Explicitly select a constructor by marking it with the [Immutype.Target] attribute

Author: NikolayPianikov

Immutype.UsageScenarios.Tests/ExplicitConstructorChoice.cs

@@ -0,0 +1,66 @@
+// ReSharper disable ClassNeverInstantiated.Global
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable RedundantNameQualifier
+// ReSharper disable CheckNamespace
+namespace Immutype.UsageScenarios.Tests.ExplicitConstructorChoice
+{
+    using System.Collections.Immutable;
+    using Shouldly;
+    using Xunit;
+
+    // $visible=true
+    // $tag=1 Basics
+    // $priority=06
+    // $description=Explicit constructor choice
+    // {
+    [Immutype.Target]
+    internal readonly struct Person
+    {
+        public readonly string Name;
+        public readonly int Age;
+        public readonly IImmutableList<Person> Friends;
+
+        // You can explicitly select a constructor by marking it with the [Immutype.Target] attribute
+        [Immutype.Target]
+        public Person(
+            string name,
+            int age = 0,
+            IImmutableList<Person>? friends = default)
+        {
+            Name = name;
+            Age = age;
+            Friends = friends ?? ImmutableList<Person>.Empty;
+        }
+        
+        public Person(
+            string name,
+            int age,
+            IImmutableList<Person>? friends,
+            int someArg = 99)
+        {
+            Name = name;
+            Age = age;
+            Friends = friends ?? ImmutableList<Person>.Empty;
+        }
+    };
+
+    public class ExplicitConstructorChoice
+    {
+    // }
+        [Fact]
+    // {
+        public void Run()
+        {
+            var john = new Person("John",15)
+                .WithFriends(
+                    new Person("David").WithAge(16),
+                    new Person("James").WithAge(17))
+                .AddFriends(
+                    new Person("David").WithAge(22));
+            
+            john.Friends.Count.ShouldBe(3);
+        }
+    }
+    // }
+}

Immutype.UsageScenarios.Tests/README_TEMPLATE.md

@@ -10,6 +10,7 @@
   - [Nullable collection](#nullable-collection)
   - [Set](#set)
   - [Record with constructor](#record-with-constructor)
+  - [Explicit constructor choice](#explicit-constructor-choice)
 
 ### Sample scenario
 
@@ -281,3 +282,57 @@ public class RecordWithConstructor
 
 
 
+### Explicit constructor choice
+
+
+
+``` CSharp
+[Immutype.Target]
+internal readonly struct Person
+{
+    public readonly string Name;
+    public readonly int Age;
+    public readonly IImmutableList<Person> Friends;
+
+    // You can explicitly select a constructor by marking it with the [Immutype.Target] attribute
+    [Immutype.Target]
+    public Person(
+        string name,
+        int age = 0,
+        IImmutableList<Person>? friends = default)
+    {
+        Name = name;
+        Age = age;
+        Friends = friends ?? ImmutableList<Person>.Empty;
+    }
+    
+    public Person(
+        string name,
+        int age,
+        IImmutableList<Person>? friends,
+        int someArg = 99)
+    {
+        Name = name;
+        Age = age;
+        Friends = friends ?? ImmutableList<Person>.Empty;
+    }
+};
+
+public class ExplicitConstructorChoice
+{
+    public void Run()
+    {
+        var john = new Person("John",15)
+            .WithFriends(
+                new Person("David").WithAge(16),
+                new Person("James").WithAge(17))
+            .AddFriends(
+                new Person("David").WithAge(22));
+        
+        john.Friends.Count.ShouldBe(3);
+    }
+}
+```
+
+
+

Immutype/Components/Contracts.cs

@@ -4,6 +4,6 @@ namespace Immutype
 {
     using System;
 
-    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor, Inherited = false)]
     public class TargetAttribute: Attribute { }
 }

Immutype/Core/ISyntaxNodeFactory.cs

@@ -6,6 +6,8 @@ namespace Immutype.Core
 
     internal interface ISyntaxNodeFactory
     {
+        bool HasTargetAttribute(MemberDeclarationSyntax memberDeclarationSyntax);
+            
         TypeSyntax? GetUnqualified(TypeSyntax? typeSyntax);
 
         bool IsAccessible(IEnumerable<SyntaxToken> modifiers);

Immutype/Core/SourceBuilder.cs

@@ -16,13 +16,16 @@ internal class SourceBuilder: ISourceBuilder
     {
         private readonly ITypeSyntaxFilter _typeSyntaxFilter;
         private readonly IUnitFactory _unitFactory;
+        private readonly ISyntaxNodeFactory _syntaxNodeFactory;
 
         public SourceBuilder(
             ITypeSyntaxFilter typeSyntaxFilter,
-            IUnitFactory unitFactory)
+            IUnitFactory unitFactory,
+            ISyntaxNodeFactory syntaxNodeFactory)
         {
             _typeSyntaxFilter = typeSyntaxFilter;
             _unitFactory = unitFactory;
+            _syntaxNodeFactory = syntaxNodeFactory;
         }
 
         public IEnumerable<Source> Build(IEnumerable<SyntaxTree> trees, CancellationToken cancellationToken) =>
@@ -46,7 +49,8 @@ public IEnumerable<Source> Build(TypeDeclarationSyntax typeDeclarationSyntax, Ca
                     from ctor in typeDeclarationSyntax.Members.OfType<ConstructorDeclarationSyntax>()
                     where !cancellationToken.IsCancellationRequested
                     where ctor.ParameterList.Parameters.Count > 0 && ctor.Modifiers.Any(i => i.IsKind(SyntaxKind.PublicKeyword) || i.IsKind(SyntaxKind.InternalKeyword)) || !ctor.Modifiers.Any()
-                    orderby ctor.ParameterList.Parameters.Count descending
+                    let weight = ctor.ParameterList.Parameters.Count + (_syntaxNodeFactory.HasTargetAttribute(ctor) ? 0xffff : 0)
+                    orderby weight descending
                     select ctor)
                 .FirstOrDefault()
                 ?.ParameterList

Immutype/Core/SyntaxNodeFactory.cs

@@ -23,6 +23,12 @@ internal class SyntaxNodeFactory : ISyntaxNodeFactory
 
         private static readonly AttributeSyntax PureAttr = SyntaxFactory.Attribute(SyntaxFactory.IdentifierName(typeof(PureAttribute).FullName));
 
+        public bool HasTargetAttribute(MemberDeclarationSyntax memberDeclarationSyntax) =>
+            memberDeclarationSyntax.AttributeLists
+                .SelectMany(i => i.Attributes)
+                .Select(i => GetUnqualified(i.Name)?.ToString())
+                .Any(i => i is "Target" or "TargetAttribute");
+
         public TypeSyntax? GetUnqualified(TypeSyntax? typeSyntax) =>
             typeSyntax is QualifiedNameSyntax qualifiedType ? qualifiedType.Right : typeSyntax;
 

Immutype/Core/TypeSyntaxFilter.cs

@@ -10,10 +10,8 @@ internal class TypeSyntaxFilter : ITypeSyntaxFilter
     {
         private readonly ISyntaxNodeFactory _syntaxNodeFactory;
 
-        public TypeSyntaxFilter(ISyntaxNodeFactory syntaxNodeFactory)
-        {
+        public TypeSyntaxFilter(ISyntaxNodeFactory syntaxNodeFactory) =>
             _syntaxNodeFactory = syntaxNodeFactory;
-        }
 
         public bool IsAccepted(TypeDeclarationSyntax typeDeclarationSyntax)
         {
@@ -27,10 +25,7 @@ public bool IsAccepted(TypeDeclarationSyntax typeDeclarationSyntax)
                 return false;
             }
 
-            if (typeDeclarationSyntax.AttributeLists
-                .SelectMany(i => i.Attributes)
-                .Select(i => _syntaxNodeFactory.GetUnqualified(i.Name)?.ToString())
-                .All(i => i != "Target" && i != "TargetAttribute"))
+            if (!_syntaxNodeFactory.HasTargetAttribute(typeDeclarationSyntax))
             {
                 return false;
             }
@@ -44,5 +39,7 @@ public bool IsAccepted(TypeDeclarationSyntax typeDeclarationSyntax)
                 .OfType<ConstructorDeclarationSyntax>()
                 .Any(ctor => ctor.ParameterList.Parameters.Count > 0 && ctor.Modifiers.Any(i => i.IsKind(SyntaxKind.PublicKeyword) || i.IsKind(SyntaxKind.InternalKeyword)) || !ctor.Modifiers.Any());
         }
+
+        
     }
 }

README.md

@@ -96,6 +96,7 @@ _Immutype_ supports [IIncrementalGenerator](https://docs.microsoft.com/en-us/dot
   - [Nullable collection](#nullable-collection)
   - [Set](#set)
   - [Record with constructor](#record-with-constructor)
+  - [Explicit constructor choice](#explicit-constructor-choice)
 
 ### Sample scenario
 
@@ -367,3 +368,57 @@ public class RecordWithConstructor
 
 
 
+### Explicit constructor choice
+
+
+
+``` CSharp
+[Immutype.Target]
+internal readonly struct Person
+{
+    public readonly string Name;
+    public readonly int Age;
+    public readonly IImmutableList<Person> Friends;
+
+    // You can explicitly select a constructor by marking it with the [Immutype.Target] attribute
+    [Immutype.Target]
+    public Person(
+        string name,
+        int age = 0,
+        IImmutableList<Person>? friends = default)
+    {
+        Name = name;
+        Age = age;
+        Friends = friends ?? ImmutableList<Person>.Empty;
+    }
+    
+    public Person(
+        string name,
+        int age,
+        IImmutableList<Person>? friends,
+        int someArg = 99)
+    {
+        Name = name;
+        Age = age;
+        Friends = friends ?? ImmutableList<Person>.Empty;
+    }
+};
+
+public class ExplicitConstructorChoice
+{
+    public void Run()
+    {
+        var john = new Person("John",15)
+            .WithFriends(
+                new Person("David").WithAge(16),
+                new Person("James").WithAge(17))
+            .AddFriends(
+                new Person("David").WithAge(22));
+        
+        john.Friends.Count.ShouldBe(3);
+    }
+}
+```
+
+
+