Add several new analyzers (#603)

* Add VSMEF004 for missing ImportingConstructor

* Add codefix for VSMEF004

* Add copilot-instructions.md

* Add VSMEF005 for multiple importing constructors

* Add VSMEF006 to align nullable and AllowDefault

* Use file-scoped namespace

* Extract duplicated util code

* Test missing attribute on primary constructors

* Formatting

* Documentation updates

* Add VSMEF007 for duplicated imports

* Merge duplicate fields

* Adjust whitespace

* A few touch-ups

* Simplify analyzer verification tests

* Code fix simplifies names and formats

* Use explicit type name instead of var

Matches configured code style and addresses diagnostic.

* Test code fixer's addition of parameterless ctor

Addresses TODO. Small change in code fix to put this constructor first, and apply formatting.

* Fix VSMEF007 when ctor params not attributes

Add a bunch more test cases.

Also some pattern matching and other clean up.

* Better notes in AnalyzerReleases.Unshipped.md

* Handle value types correctly in VSMEF006

Don't warn about nullable value types (int?) or AllowDefault on value types, since these have different semantics than nullable reference types.

* Allow VSMEF005 to work with structs

* Document that contract name is an approximation

* Don't set Name on ExportCodeFixProviderAttribute

* Fix broken link

* Move analyzer docs to new folder (post merge)

* Codefix adds `= null!` to property initializer

* Handle attributes derived from known MEF attributes

* Handle InheritedExportAttribute

---------

Co-authored-by: Andrew Arnott <[email protected]>

Author: drewnoakes

docfx/analyzers/VSMEF004.md

@@ -0,0 +1,191 @@
+# VSMEF004 Exported type missing importing constructor
+
+A class that exports itself or has exported members must be instantiable by MEF. If the class defines non-default constructors, it must have either:
+
+1. A parameterless constructor, or
+2. A constructor annotated with `[ImportingConstructor]`
+
+The following class definition would produce a diagnostic from this rule:
+
+```cs
+[Export]
+class Foo
+{
+    public Foo(string parameter)
+    {
+        // Non-default constructor without [ImportingConstructor]
+    }
+}
+```
+
+This class exports itself but only has a non-default constructor that is not annotated with `[ImportingConstructor]`. MEF cannot instantiate this class because it doesn't know how to provide the required `string` parameter.
+
+## Fixing the diagnostic
+
+There are several ways to fix this diagnostic:
+
+### Option 1: Add a parameterless constructor
+
+```cs
+[Export]
+class Foo
+{
+    public Foo()
+    {
+        // Default constructor for MEF
+    }
+
+    public Foo(string parameter)
+    {
+        // Non-default constructor for other uses
+    }
+}
+```
+
+### Option 2: Annotate a constructor with [ImportingConstructor]
+
+```cs
+[Export]
+class Foo
+{
+    [ImportingConstructor]
+    public Foo(string parameter)
+    {
+        // MEF will satisfy the 'parameter' import
+    }
+}
+```
+
+### Option 3: Use importing constructor with MEF imports
+
+```cs
+[Export]
+class Foo
+{
+    [ImportingConstructor]
+    public Foo([Import] IService service)
+    {
+        // MEF will inject the required IService
+    }
+}
+```
+
+## Examples that trigger this rule
+
+### Class-level export with non-default constructor
+
+```cs
+[Export]
+class Service
+{
+    public Service(string connectionString)  // ❌ Error: missing [ImportingConstructor]
+    {
+    }
+}
+```
+
+### Class with exported members and non-default constructor
+
+```cs
+class ServiceProvider
+{
+    [Export]
+    public IService GetService() => new Service();
+
+    public ServiceProvider(string config)  // ❌ Error: missing [ImportingConstructor]
+    {
+    }
+}
+```
+
+### Mixed static and instance exports
+
+```cs
+class MixedExports
+{
+    [Export]
+    public static string StaticValue = "test";  // ✅ OK: static export
+
+    [Export]
+    public string InstanceValue { get; set; }  // ❌ Requires instantiation
+
+    public MixedExports(string parameter)  // ❌ Error: missing [ImportingConstructor]
+    {
+    }
+}
+```
+
+## Examples that do NOT trigger this rule
+
+### Class with only static exports
+
+```cs
+class StaticOnlyExports
+{
+    [Export]
+    public static IService Service { get; } = new Service();
+
+    public StaticOnlyExports(string parameter)  // ✅ OK: no instance exports
+    {
+    }
+}
+```
+
+### Class with default constructor
+
+```cs
+[Export]
+class Service
+{
+    public Service()  // ✅ OK: default constructor
+    {
+    }
+}
+```
+
+### Class with importing constructor
+
+```cs
+[Export]
+class Service
+{
+    [ImportingConstructor]
+    public Service(string connectionString)  // ✅ OK: has [ImportingConstructor]
+    {
+    }
+}
+```
+
+### Abstract class
+
+```cs
+[Export]
+abstract class ServiceBase
+{
+    public ServiceBase(string parameter)  // ✅ OK: abstract classes are not instantiated
+    {
+    }
+}
+```
+
+## Applies to both MEF versions
+
+This rule applies to both MEF v1 (`System.ComponentModel.Composition`) and MEF v2 (`System.Composition`) attributes:
+
+```cs
+// MEF v1
+[System.ComponentModel.Composition.Export]
+class Service
+{
+    [System.ComponentModel.Composition.ImportingConstructor]
+    public Service(string parameter) { }
+}
+
+// MEF v2
+[System.Composition.Export]
+class Service
+{
+    [System.Composition.ImportingConstructor]
+    public Service(string parameter) { }
+}
+```

docfx/analyzers/VSMEF005.md

@@ -0,0 +1,89 @@
+# VSMEF005 Multiple importing constructors
+
+A class that exports itself or has exported members can only have one constructor marked with `[ImportingConstructor]`. MEF requires exactly one importing constructor per type to know how to instantiate the class.
+
+The following class definition would produce a diagnostic from this rule:
+
+```cs
+[Export]
+class Foo
+{
+    [ImportingConstructor]
+    public Foo()
+    {
+    }
+
+    [ImportingConstructor]
+    public Foo(string parameter)
+    {
+    }
+}
+```
+
+This class has two constructors both marked with `[ImportingConstructor]`, which creates ambiguity for MEF about which constructor to use for instantiation.
+
+## Fixing the diagnostic
+
+Remove the `[ImportingConstructor]` attribute from all but one constructor. The remaining importing constructor will be used by MEF to create instances of the class.
+
+```cs
+[Export]
+class Foo
+{
+    public Foo()
+    {
+    }
+
+    [ImportingConstructor]
+    public Foo(string parameter)
+    {
+    }
+}
+```
+
+In this corrected version, only one constructor is marked as the importing constructor, and MEF will use it to instantiate the class, providing the required `string` parameter through dependency injection.
+
+## Alternative solutions
+
+If you need multiple constructors for different scenarios:
+
+### Option 1: Use only one importing constructor
+
+Keep only one constructor marked with `[ImportingConstructor]` and use that for MEF instantiation:
+
+```cs
+[Export]
+class Foo
+{
+    // Regular constructor for manual instantiation
+    public Foo()
+    {
+    }
+
+    // MEF importing constructor
+    [ImportingConstructor]
+    public Foo(IService service)
+    {
+        // Initialize with injected dependencies
+    }
+}
+```
+
+### Option 2: Use factory pattern
+
+If you need complex instantiation logic, consider using a factory pattern:
+
+```cs
+[Export]
+class FooFactory
+{
+    [ImportingConstructor]
+    public FooFactory(IService service)
+    {
+        this.service = service;
+    }
+
+    public Foo CreateFoo() => new Foo();
+    public Foo CreateFoo(string parameter) => new Foo(parameter, this.service);
+}
+```