Fix to #7499 - Where() on derived property fails with undefined property on base class exception

Problem was that we were not taking type differences and expression converts in various places during compilation. We sometimes remove converts when processing expressions, but then not accounting for them when we re-assemble the visited expression.
This caused many scenarios involving casts (e.g. accessing properties/navigations on derived types) to fail.

Fix is to start compensating for those where necessary. Created helper methods for EF.Property method call, member access and assignment and using them instead of regular Expression APIs.

Also fixed unrelated issue in the SqlTranslatingExpressionVisitor - when trying to translate MethodCall expression, we would force client evaluation, if arguments to the function was a subquery - this is not ideal, since we can translate some of the subqueries (ones that return single result).

Author: maumar

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

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Extensions.Internal;
 using Microsoft.EntityFrameworkCore.Internal;
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Query.Expressions;
@@ -106,7 +107,7 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
                 return methodCallExpression;
             }
 
-            if (EntityQueryModelVisitor.IsPropertyMethod(methodCallExpression.Method))
+            if (methodCallExpression.Method.IsEFPropertyMethod())
             {
                 var newArg0 = Visit(methodCallExpression.Arguments[0]);
 

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

@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Extensions.Internal;
 using Microsoft.EntityFrameworkCore.Internal;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Query.Expressions;
@@ -375,7 +376,7 @@ private void AnalyzeTestExpression(Expression expression)
                 }
 
                 if (expression is MethodCallExpression methodCallExpression
-                    && EntityQueryModelVisitor.IsPropertyMethod(methodCallExpression.Method))
+                    && methodCallExpression.Method.IsEFPropertyMethod())
                 {
                     if (methodCallExpression.Arguments[0] is QuerySourceReferenceExpression querySourceCaller)
                     {
@@ -421,7 +422,7 @@ protected override Expression VisitMember(MemberExpression node)
 
             protected override Expression VisitMethodCall(MethodCallExpression node)
             {
-                if (EntityQueryModelVisitor.IsPropertyMethod(node.Method))
+                if (node.Method.IsEFPropertyMethod())
                 {
                     if (node.Arguments[1] is ConstantExpression propertyNameExpression && (string)propertyNameExpression.Value == _propertyName)
                     {
@@ -579,9 +580,9 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
             {
                 var arguments
                     = methodCallExpression.Arguments
-                        .Where(e => !(e is QuerySourceReferenceExpression)
-                                    && !(e is SubQueryExpression))
-                        .Select(e => (e as ConstantExpression)?.Value is Array || e.Type == typeof(DbFunctions)
+                        .Where(e => !(e.RemoveConvert() is QuerySourceReferenceExpression)
+                                && !IsNonTranslatableSubquery(e.RemoveConvert()))
+                        .Select(e => (e.RemoveConvert() as ConstantExpression)?.Value is Array || e.RemoveConvert().Type == typeof(DbFunctions)
                             ? e
                             : Visit(e))
                         .Where(e => e != null)
@@ -625,6 +626,12 @@ var projectionIndex
                 ?? _queryModelVisitor.BindMethodToOuterQueryParameter(methodCallExpression);
         }
 
+        private bool IsNonTranslatableSubquery(Expression expression)
+            => expression is SubQueryExpression subQueryExpression
+            && !(subQueryExpression.QueryModel.GetOutputDataInfo() is StreamedScalarValueInfo 
+                || subQueryExpression.QueryModel.GetOutputDataInfo() is StreamedSingleValueInfo streamedSingleValueInfo
+                    && IsStreamedSingleValueSupportedType(streamedSingleValueInfo));
+
         /// <summary>
         ///     Visit a member expression.
         /// </summary>
@@ -636,8 +643,8 @@ protected override Expression VisitMember(MemberExpression memberExpression)
         {
             Check.NotNull(memberExpression, nameof(memberExpression));
 
-            if (!(memberExpression.Expression is QuerySourceReferenceExpression)
-                && !(memberExpression.Expression is SubQueryExpression))
+            if (!(memberExpression.Expression.RemoveConvert() is QuerySourceReferenceExpression)
+                && !(memberExpression.Expression.RemoveConvert() is SubQueryExpression))
             {
                 var newExpression = Visit(memberExpression.Expression);
 
@@ -842,18 +849,9 @@ protected override Expression VisitSubQuery(SubQueryExpression expression)
             }
             else if (!(subQueryOutputDataInfo is StreamedSequenceInfo))
             {
-                var streamedSingleValueInfo = subQueryOutputDataInfo as StreamedSingleValueInfo;
-
-                var streamedSingleValueSupportedType
-                    = streamedSingleValueInfo != null
-                      && _relationalTypeMapper.FindMapping(
-                          streamedSingleValueInfo.DataType
-                              .UnwrapNullableType()
-                              .UnwrapEnumType()) != null;
-
                 if (_inProjection
                     && !(subQueryOutputDataInfo is StreamedScalarValueInfo)
-                    && !streamedSingleValueSupportedType)
+                    && !IsStreamedSingleValueSupportedType(subQueryOutputDataInfo))
                 {
                     return null;
                 }
@@ -901,6 +899,13 @@ var queriesProjectionCountMapping
             return null;
         }
 
+        private bool IsStreamedSingleValueSupportedType(IStreamedDataInfo outputDataInfo)
+            => outputDataInfo is StreamedSingleValueInfo streamedSingleValueInfo
+               && _relationalTypeMapper.FindMapping(
+                   streamedSingleValueInfo.DataType
+                       .UnwrapNullableType()
+                       .UnwrapEnumType()) != null;
+
         /// <summary>
         ///     Visits a constant expression.
         /// </summary>
@@ -1023,8 +1028,8 @@ var entityType
                     if (entityType != null)
                     {
                         return Visit(
-                            EntityQueryModelVisitor.CreatePropertyExpression(
-                                expression, entityType.FindPrimaryKey().Properties[0]));
+                            expression.CreateEFPropertyExpression(
+                                entityType.FindPrimaryKey().Properties[0]));
                     }
 
                     return null;

src/EFCore.Relational/Query/RelationalQueryModelVisitor.cs

@@ -1048,7 +1048,8 @@ var concreteEntityTypes
                     var discriminatorProperty
                         = _relationalAnnotationProvider.For(concreteEntityTypes[0]).DiscriminatorProperty;
 
-                    var discriminatorPropertyExpression = CreatePropertyExpression(typeBinaryExpression.Expression, discriminatorProperty);
+                    var discriminatorPropertyExpression
+                        = typeBinaryExpression.Expression.CreateEFPropertyExpression(discriminatorProperty);
 
                     var discriminatorPredicate
                         = concreteEntityTypes
@@ -1839,8 +1840,8 @@ var parameterWithSamePrefixCount
 
                     var querySourceReference = new QuerySourceReferenceExpression(querySource);
                     var propertyExpression = isMemberExpression
-                        ? Expression.Property(querySourceReference, property.PropertyInfo)
-                        : CreatePropertyExpression(querySourceReference, property);
+                        ? querySourceReference.CreateEFPropertyExpression(property.PropertyInfo)
+                        : querySourceReference.CreateEFPropertyExpression(property);
 
                     if (propertyExpression.Type.GetTypeInfo().IsValueType)
                     {

src/EFCore.Specification.Tests/GearsOfWarQueryFixtureBase.cs

@@ -46,6 +46,15 @@ protected virtual void OnModelCreating(ModelBuilder modelBuilder)
                     b.HasOne(sm => sm.Mission).WithMany(m => m.ParticipatingSquads).HasForeignKey(sm => sm.MissionId);
                     b.HasOne(sm => sm.Squad).WithMany(s => s.Missions).HasForeignKey(sm => sm.SquadId);
                 });
+
+            modelBuilder.Entity<Faction>().HasKey(f => f.Id);
+            modelBuilder.Entity<LocustHorde>().HasBaseType<Faction>();
+            modelBuilder.Entity<LocustHorde>().HasMany(h => h.Leaders).WithOne();
+            modelBuilder.Entity<LocustHorde>().HasOne(h => h.Commander).WithOne(c => c.CommandingFaction);
+
+            modelBuilder.Entity<LocustLeader>().HasKey(l => l.Name);
+            modelBuilder.Entity<LocustCommander>().HasBaseType<LocustLeader>();
+            modelBuilder.Entity<LocustCommander>().HasOne(c => c.DefeatedBy).WithOne().HasForeignKey<LocustCommander>(c => new { c.DefeatedByNickname, c.DefeatedBySquadId });
         }
     }
 }