Added possibility to declare properties as unmapped.

Author: oliverhanappi

README.md

@@ -22,15 +22,19 @@ Declare a method as a mapping method by decorating it with `MappingMethodAttribu
 
 The analyzer will report errors for any property with a public setter that is not assigned within the mapping method.
 
-In the example below the analyzer will report that the method `MapToModel` does not map the property `PersonModel.LastName`.
+You can exclude properties by adding one or more instances of `UnmappedPropertyAttribute` to the mapping method and passing the property name to it.
+
+In the example below the analyzer will report that the method `MapToModel` does not map the property `PersonModel.LastName`. The property `PersonModel.Tag` is not reported because it is declared as unmapped property.
 
 ```csharp
 using ManualMappingGuard;
 
 public class Person
 {
+    public int Id { get; set; }
     public string FirstName { get; set; }
     public string LastName { get; set; }
+    public string FullName => $"{FirstName} {LastName}";
 }
 
 public class PersonModel
@@ -42,11 +46,18 @@ public class PersonModel
 public static class Mapper
 {
     [MappingMethod]
-    public static PersonModel MapToModel(Person person)
+    [UnmappedProperty(nameof(Person.Id))]
+    public static Person Map(PersonModel model)
     {
-        return new PersonModel { FirstName = person.FirstName };
+        return new Person { FirstName = model.FirstName };
     }
 }
+
+/*
+  MSBuild Output:
+
+  Program.cs(19, 4): [MMG1001] Property LastName is not mapped.
+*/
 ```
 
 #### Limitations

src/Analyzers/MappingAnalyzer.cs

@@ -54,10 +54,20 @@ private void OnMethodDeclaration(SyntaxNodeAnalysisContext context)
           mappedProperties.Add(targetProperty);
       }
 
-      var unmappedProperties = mappingTargetProperties.Except(mappedProperties, new RootPropertyEqualityComparer());
-      foreach (var unmappedProperty in unmappedProperties.OrderBy(p => p.Name))
+      var excludedPropertyNames = method.GetAttributes()
+        .Where(a => a.AttributeClass.Name == "UnmappedPropertyAttribute")
+        .Select(a => (string) a.ConstructorArguments[0].Value)
+        .ToList();
+
+      var unmappedPropertyNames = mappingTargetProperties
+        .Except(mappedProperties, new RootPropertyEqualityComparer())
+        .Select(p => p.Name)
+        .Except(excludedPropertyNames)
+        .OrderBy(n => n);
+
+      foreach (var unmappedPropertyName in unmappedPropertyNames)
       {
-        var diagnostic = Diagnostic.Create(Diagnostics.UnmappedProperty, location, unmappedProperty.Name);
+        var diagnostic = Diagnostic.Create(Diagnostics.UnmappedProperty, location, unmappedPropertyName);
         context.ReportDiagnostic(diagnostic);
       }
     }

src/Common.props

@@ -2,6 +2,6 @@
   <PropertyGroup>
     <LangVersion>8</LangVersion>
     <Nullable>enable</Nullable>
-    <WarningsAsErrors>CS8600;CS8602;CS8603;CS8604;CS8618</WarningsAsErrors>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
   </PropertyGroup>
 </Project>

src/Core/UnmappedPropertyAttribute.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace ManualMappingGuard
+{
+  [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+  public class UnmappedPropertyAttribute : Attribute
+  {
+    public string PropertyName { get; }
+
+    public UnmappedPropertyAttribute(string propertyName)
+    {
+      PropertyName = propertyName ?? throw new ArgumentNullException(nameof(propertyName));
+    }
+  }
+}

src/Tests/Analyzers/MappingAnalyzerTests.cs

@@ -137,6 +137,61 @@ public Person Map()
       AssertNoUnmappedProperties(diagnostics);
     }
 
+    [Test]
+    public async Task UnmappedProperty_Excluded_DoesNotReportMissingProperty()
+    {
+      var diagnostics = await Analyze(@"
+        public class Person
+        {
+          public int Id { get; set; }
+          public string FirstName { get; set; }
+          public string LastName { get; set; }
+        }
+
+        [MappingMethod]
+        [UnmappedProperty(nameof(Person.Id))]
+        public Person Map() => new Person { FirstName = ""Test"" };
+      ");
+
+      AssertUnmappedProperties(diagnostics, "LastName");
+    }
+
+    [Test]
+    public async Task UnmappedProperty_MultipleExcluded_DoesNotReportMissingProperties()
+    {
+      var diagnostics = await Analyze(@"
+        public class Person
+        {
+          public const string IdPropertyName = ""Id"";
+
+          public int Id { get; set; }
+          public string FirstName { get; set; }
+          public string LastName { get; set; }
+        }
+
+        [MappingMethod]
+        [UnmappedProperty(Person.IdPropertyName)]
+        [UnmappedProperty(""LastName"")]
+        public Person Map() => new Person { FirstName = ""Test"" };
+      ");
+
+      AssertNoUnmappedProperties(diagnostics);
+    }
+
+    [Test]
+    public async Task NonExistingExcludedProperty_DoesNotFail()
+    {
+      var diagnostics = await Analyze(@"
+        public class Person { }
+
+        [MappingMethod]
+        [UnmappedProperty(""NotExisting"")]
+        public Person Map() => new Person();
+      ");
+
+      Assert.That(diagnostics, Is.Empty);
+    }
+
     private void AssertMissingMappingTargetType(ImmutableArray<Diagnostic> diagnostics)
     {
       var expectedMessages = new[]

src/Tests/Analyzers/TestInfrastructure/CompilationUtility.cs

@@ -20,6 +20,7 @@ private static IEnumerable<Type> GetReferencedTypes()
       yield return typeof(object);
       yield return typeof(MappingMethodAttribute);
       yield return typeof(MappingTargetAttribute);
+      yield return typeof(UnmappedPropertyAttribute);
     }
 
     private static IReadOnlyCollection<MetadataReference> CreateMetadataReferences()

src/Tests/Core/UnmappedPropertyAttributeTests.cs

@@ -0,0 +1,14 @@
+using NUnit.Framework;
+
+namespace ManualMappingGuard.Core
+{
+  [TestFixture]
+  public class UnmappedPropertyAttributeTests
+  {
+    [Test]
+    public void NullPropertyName_ThrowsException()
+    {
+      Assert.That(() => new UnmappedPropertyAttribute(null!), Throws.ArgumentNullException);
+    }
+  }
+}