Simplify checks for default values

Author: NikolayPianikov

Immutype.Tests/Integration/Tests.cs

@@ -366,7 +366,7 @@ public readonly struct Rec
         }
 
         [Fact]
-        public void ShouldCreateStructWithSingleValueWhenCS71()
+        public void ShouldCreateStructWithSingleValueWhenCs71()
         {
             // Given
             const string statements = "System.Console.WriteLine(new Rec(33).WithVal(99));";
@@ -388,27 +388,7 @@ public struct Rec
             // Then
             output.ShouldBe(new [] { "Sample.Rec" }, generatedCode);
         }
-        
-        [Fact]
-        public void ShouldCreateRecordStructWithSingleValue()
-        {
-            // Given
-            const string statements = "System.Console.WriteLine(new Rec(33).WithVal(99));";
 
-            // When
-            var output = @"
-            namespace Sample
-            {
-                using System;
-                
-                [Immutype.TargetAttribute()]
-                public record struct Rec(int Val);
-            }".Run(out var generatedCode, new RunOptions { Statements = statements });
-
-            // Then
-            output.ShouldBe(new [] { "Rec { Val = 99 }" }, generatedCode);
-        }
-        
         [Fact]
         public void ShouldCreateClassWithSingleValue()
         {

Immutype/Core/MethodAddRemoveFactory.cs

@@ -1,6 +1,5 @@
 namespace Immutype.Core
 {
-    using System;
     using System.Collections.Generic;
     using System.Linq;
     using Microsoft.CodeAnalysis.CSharp;
@@ -68,12 +67,15 @@ private IEnumerable<ArgumentSyntax> CreateArguments(string enumerableMethod, Typ
             {
                 if (parameter == currentParameter)
                 {
-                    yield return SyntaxFactory.Argument(
-                        CreateExpression(
-                            enumerableMethod,
-                            _syntaxNodeFactory.CreateTransientArgumentExpression(owner, thisParameter, currentParameter),
-                            currentParameter.Type,
-                            arrayParameter));
+                    var thisArg = _syntaxNodeFactory.CreateTransientArgumentExpression(owner, thisParameter, currentParameter);
+
+                    var expression = CreateExpression(
+                        enumerableMethod,
+                        thisArg,
+                        currentParameter.Type,
+                        arrayParameter);
+                    
+                    yield return SyntaxFactory.Argument(expression);
                 }
                 else
                 {
@@ -82,16 +84,19 @@ private IEnumerable<ArgumentSyntax> CreateArguments(string enumerableMethod, Typ
             }
         }
 
-        private ExpressionSyntax CreateExpression(string enumerableMethod, ExpressionSyntax? thisExpression, TypeSyntax? currentParameterType, ParameterSyntax arrayParameter)
+        private ExpressionSyntax CreateExpression(string enumerableMethod, ExpressionSyntax? thisExpression, TypeSyntax? currentParameterType, ParameterSyntax arrayParameter, bool addCheck = true)
         {
             ExpressionSyntax? result = default;
             if (thisExpression != default)
             {
-                var defaultExpression = CreateExpression(enumerableMethod, default, currentParameterType, arrayParameter);
-                thisExpression = SyntaxFactory.ParenthesizedExpression(SyntaxFactory.ConditionalExpression(
-                    SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, thisExpression, SyntaxFactory.DefaultExpression(currentParameterType!)),
-                    defaultExpression,
-                    thisExpression));
+                if (addCheck)
+                {
+                    var defaultExpression = CreateExpression(enumerableMethod, default, currentParameterType, arrayParameter);
+                    thisExpression = SyntaxFactory.ParenthesizedExpression(SyntaxFactory.ConditionalExpression(
+                        SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, thisExpression, SyntaxFactory.DefaultExpression(currentParameterType!)),
+                        defaultExpression,
+                        thisExpression));
+                }
 
                 result = SyntaxFactory.InvocationExpression(
                         SyntaxFactory.MemberAccessExpression(
@@ -104,18 +109,8 @@ private ExpressionSyntax CreateExpression(string enumerableMethod, ExpressionSyn
             switch (_syntaxNodeFactory.GetUnqualified(currentParameterType))
             {
                 case NullableTypeSyntax nullableTypeSyntax:
-                    var defaultExpression = CreateExpression(enumerableMethod, default, nullableTypeSyntax.ElementType, arrayParameter);
-                    if (thisExpression != default)
-                    {
-                        thisExpression = SyntaxFactory.ParenthesizedExpression(SyntaxFactory.BinaryExpression(SyntaxKind.CoalesceExpression, thisExpression!, defaultExpression));
-                    }
-                    else
-                    {
-                        thisExpression = SyntaxFactory.DefaultExpression(nullableTypeSyntax.ElementType);
-                    }
-
                     // ReSharper disable once TailRecursiveCall
-                    return CreateExpression(enumerableMethod, thisExpression, nullableTypeSyntax.ElementType, arrayParameter);
+                    return CreateExpression(enumerableMethod, thisExpression, nullableTypeSyntax.ElementType, arrayParameter, false);
 
                 case GenericNameSyntax genericNameSyntax:
                     if (_dataContainerFactory.TryCreate(genericNameSyntax, ref result, ref arrayParameter))