Merge pull request #650 from drewnoakes/fix-VSMEF006

Don't fire VSMEF006 in non-nullable contexts

Author: AArnott

src/Microsoft.VisualStudio.Composition.Analyzers/VSMEF006ImportNullabilityAnalyzer.cs

@@ -104,6 +104,16 @@ static void AnalyzeMember(SymbolAnalysisContext context, ISymbol member, ITypeSy
                 return;
             }
 
+            // Skip analysis if nullable context is not enabled
+            // When nullable is disabled or not specified, non-nullable reference types have NullableAnnotation.None
+            // When nullable is enabled, non-nullable reference types have NullableAnnotation.NotAnnotated
+            // So we check: if a reference type import has None, nullable context is not enabled
+            if (type.IsReferenceType && type.NullableAnnotation == NullableAnnotation.None)
+            {
+                // Oblivious mode - nullable reference types are not enabled
+                return;
+            }
+
             bool isNullableReferenceType = IsNullableReferenceType(type);
             bool hasAllowDefault = Utils.GetAllowDefaultValue(importAttribute);
 

test/Microsoft.VisualStudio.Composition.Analyzers.Tests/VSMEF006ImportNullabilityAnalyzerTests.cs

@@ -592,4 +592,99 @@ class Foo
 
         await VerifyCS.VerifyCodeFixAsync(test, expected, fixedTest);
     }
+
+    [Fact]
+    public async Task NullableDisabledImportWithAllowDefault_NoWarning()
+    {
+        string test = """
+            #nullable disable
+            using System.ComponentModel.Composition;
+
+            class Foo
+            {
+                [Import(AllowDefault = true)]
+                public string Value { get; set; }
+            }
+            """;
+
+        await VerifyCS.VerifyAnalyzerAsync(test);
+    }
+
+    [Fact]
+    public async Task NullableUnspecifiedImportWithAllowDefault_NoWarning()
+    {
+        string test = """
+            using System.ComponentModel.Composition;
+
+            class Foo
+            {
+                [Import(AllowDefault = true)]
+                public string Value { get; set; }
+            }
+            """;
+
+        await VerifyCS.VerifyAnalyzerAsync(test);
+    }
+
+    [Fact]
+    public async Task LazyImportWithAllowDefault_LazyIsNullable()
+    {
+        string test = """
+            #nullable enable
+            using System;
+            using System.ComponentModel.Composition;
+
+            class Foo
+            {
+                [Import(AllowDefault = true)]
+                public Lazy<string>? Value { get; set; }
+            }
+            """;
+
+        await VerifyCS.VerifyAnalyzerAsync(test);
+    }
+
+    [Fact]
+    public async Task LazyImportWithAllowDefault_LazyNotNullable_Warning()
+    {
+        string test = """
+            #nullable enable
+            using System;
+            using System.ComponentModel.Composition;
+
+            class Foo
+            {
+                [Import(AllowDefault = true)]
+                public Lazy<string> {|#0:Value|} { get; set; }
+            }
+            """;
+
+        DiagnosticResult expected = VerifyCS.Diagnostic(VSMEF006ImportNullabilityAnalyzer.AllowDefaultWithoutNullableDescriptor)
+            .WithLocation(0)
+            .WithArguments("Value");
+
+        await VerifyCS.VerifyAnalyzerAsync(test, expected);
+    }
+
+    [Fact]
+    public async Task LazyImportNullable_WithoutAllowDefault_Warning()
+    {
+        string test = """
+            #nullable enable
+            using System;
+            using System.ComponentModel.Composition;
+
+            class Foo
+            {
+                [Import]
+                public Lazy<string>? {|#0:Value|} { get; set; }
+            }
+            """;
+
+        DiagnosticResult expected = VerifyCS.Diagnostic(VSMEF006ImportNullabilityAnalyzer.NullableWithoutAllowDefaultDescriptor)
+            .WithLocation(0)
+            .WithArguments("Value");
+
+        await VerifyCS.VerifyAnalyzerAsync(test, expected);
+    }
 }