[WIP] Concating null with not null string resulting in null

src/EFCore.Relational/Query/ExpressionVisitors/SqlTranslatingExpressionVisitor.cs

@@ -203,8 +203,10 @@ var structuralComparisonExpression
                         ? Expression.AndAlso(left, right)
                         : null;
 
-                case ExpressionType.OrElse:
                 case ExpressionType.Add:
+                    return ProcessAddExpression(expression);
+
+                case ExpressionType.OrElse:
                 case ExpressionType.Subtract:
                 case ExpressionType.Multiply:
                 case ExpressionType.Divide:
@@ -575,6 +577,38 @@ var nullExpression
                 : null;
         }
 
+        private Expression ProcessAddExpression(BinaryExpression addExpression)
+        {
+            var leftExpression = Visit(addExpression.Left);
+            var rightExpression = Visit(addExpression.Right);
+
+            if (leftExpression != null && rightExpression != null)
+            {
+                if (leftExpression.Type == typeof(string)
+                    && leftExpression.RemoveConvert() is ColumnExpression leftColumnExpression
+                    && leftColumnExpression.Property.IsNullable)
+                {
+                    leftExpression = Expression.Coalesce(leftExpression, Expression.Constant(string.Empty));
+                }
+
+                if (rightExpression.Type == typeof(string)
+                    && rightExpression.RemoveConvert() is ColumnExpression rightColumnExpression
+                    && rightColumnExpression.Property.IsNullable)
+                {
+                    rightExpression = Expression.Coalesce(rightExpression, Expression.Constant(string.Empty));
+                }
+
+                return Expression.MakeBinary(
+                    addExpression.NodeType,
+                    leftExpression,
+                    rightExpression,
+                    addExpression.IsLiftedToNull,
+                    addExpression.Method);
+            }
+
+            return null;
+        }
+
         private static Expression TransformNullComparison(
             Expression left, Expression right, ExpressionType expressionType)
         {

test/EFCore.Specification.Tests/Query/SimpleQueryTestBase.cs

@@ -3743,6 +3743,17 @@ public virtual Task Environment_newline_is_funcletized(bool isAsync)
                 cs => cs.Where(c => c.CustomerID.Contains(Environment.NewLine)));
         }
 
+        [ConditionalFact]
+        public virtual void String_concat_with_null_produces_string()
+        {
+            using (var context = CreateContext())
+            {
+                var query = context.Customers.Select(c => new { c.City, c.Region, Concat = c.City + " " + c.Region }).ToList();
+
+                Assert.All(query, t => Assert.Equal(t.City + " " + t.Region, t.Concat));
+            }
+        }
+
         [ConditionalTheory]
         [MemberData(nameof(IsAsyncData))]
         public virtual Task String_concat_with_navigation1(bool isAsync)

test/EFCore.SqlServer.FunctionalTests/Query/SimpleQuerySqlServerTest.cs

@@ -2809,6 +2809,15 @@ public override void Random_next_is_not_funcletized_6()
 FROM [Orders] AS [o]");
         }
 
+        public override void String_concat_with_null_produces_string()
+        {
+            base.String_concat_with_null_produces_string();
+
+            AssertSql(
+                @"SELECT [c].[City], [c].[Region], (COALESCE([c].[City], N'') + N' ') + COALESCE([c].[Region], N'') AS [Concat]
+FROM [Customers] AS [c]");
+        }
+
         public override async Task Environment_newline_is_funcletized(bool isAsync)
         {
             await base.Environment_newline_is_funcletized(isAsync);

test/EFCore.Sqlite.FunctionalTests/Query/SimpleQuerySqliteTest.cs

@@ -291,6 +291,15 @@ public override async Task String_Contains_MethodCall(bool isAsync)
 WHERE instr(""c"".""ContactName"", 'M') > 0");
         }
 
+        public override void String_concat_with_null_produces_string()
+        {
+            base.String_concat_with_null_produces_string();
+
+            AssertSql(
+                @"SELECT ""c"".""City"", ""c"".""Region"", (COALESCE(""c"".""City"", '') || ' ') || COALESCE(""c"".""Region"", '') AS ""Concat""
+FROM ""Customers"" AS ""c""");
+        }
+
         public override async Task IsNullOrWhiteSpace_in_predicate(bool isAsync)
         {
             await base.IsNullOrWhiteSpace_in_predicate(isAsync);