Add Linq parameter type detection

Author: maca88

src/NHibernate.DomainModel/Northwind/Entities/User.cs

@@ -48,10 +48,16 @@ public class User : IUser, IEntity
 
         public virtual FeatureSet Features { get; set; }
 
+		public virtual User NotMappedUser => this;
+
 		public virtual EnumStoredAsString Enum1 { get; set; }
 
+		public virtual EnumStoredAsString? NullableEnum1 { get; set; }
+
 		public virtual EnumStoredAsInt32 Enum2 { get; set; }
 
+		public virtual EnumStoredAsInt32? NullableEnum2 { get; set; }
+
 		public virtual IUser CreatedBy { get; set; }
 
 		public virtual IUser ModifiedBy { get; set; }

src/NHibernate.DomainModel/Northwind/Mappings/User.hbm.xml

@@ -24,8 +24,14 @@
       <column name="Enum1" length="12" />
     </property>
 
+    <property name="NullableEnum1" type="NHibernate.DomainModel.Northwind.Entities.EnumStoredAsStringType, NHibernate.DomainModel"
+              formula="(case when Enum1 = 'Unspecified' then null else Enum1 end)" insert="false" update="false">
+    </property>
+
     <property name="Enum2" not-null="true" />
 
+    <property name="NullableEnum2" formula="(case when Enum2 = 0 then null else Enum2 end)" insert="false" update="false" />
+
     <property name="Features" not-null="true" />
 
     <many-to-one name="Role" class="Role">

src/NHibernate.Test/Async/Linq/EnumTests.cs

@@ -61,5 +61,42 @@ public async Task CanQueryOnEnumStoredAsString_Small_1Async()
 
 			Assert.AreEqual(expectedCount, query.Count);
 		}
+
+		[Test]
+		public async Task ConditionalNavigationPropertyAsync()
+		{
+			EnumStoredAsString? type = null;
+			await (db.Users.Where(o => o.Enum1 == EnumStoredAsString.Large).ToListAsync());
+			await (db.Users.Where(o => EnumStoredAsString.Large != o.Enum1).ToListAsync());
+			await (db.Users.Where(o => (o.NullableEnum1 ?? EnumStoredAsString.Large) == EnumStoredAsString.Medium).ToListAsync());
+			await (db.Users.Where(o => ((o.NullableEnum1 ?? type) ?? o.Enum1) == EnumStoredAsString.Medium).ToListAsync());
+
+			await (db.Users.Where(o => (o.NullableEnum1.HasValue ? o.Enum1 : EnumStoredAsString.Unspecified) == EnumStoredAsString.Medium).ToListAsync());
+			await (db.Users.Where(o => (o.Enum1 != EnumStoredAsString.Large
+				                    ? (o.NullableEnum1.HasValue ? o.Enum1 : EnumStoredAsString.Unspecified)
+				                    : EnumStoredAsString.Small) == EnumStoredAsString.Medium).ToListAsync());
+
+			await (db.Users.Where(o => (o.Enum1 == EnumStoredAsString.Large ? o.Role : o.Role).Name == "test").ToListAsync());
+		}
+
+		[Test]
+		public async Task CanQueryComplexExpressionOnEnumStoredAsStringAsync()
+		{
+			var type = EnumStoredAsString.Unspecified;
+			var query = await ((from user in db.Users
+			             where (user.NullableEnum1 == EnumStoredAsString.Large
+				                   ? EnumStoredAsString.Medium
+				                   : user.NullableEnum1 ?? user.Enum1
+			                   ) == type
+			             select new
+			             {
+				             user,
+				             simple = user.Enum1,
+				             condition = user.Enum1 == EnumStoredAsString.Large ? EnumStoredAsString.Medium : user.Enum1,
+				             coalesce = user.NullableEnum1 ?? EnumStoredAsString.Medium
+			             }).ToListAsync());
+
+			Assert.That(query.Count, Is.EqualTo(0));
+		}
 	}
 }

src/NHibernate.Test/Linq/ConstantTest.cs

@@ -217,12 +217,12 @@ public void ConstantInWhereDoesNotCauseManyKeys()
 			          select c);
 			var preTransformParameters = new PreTransformationParameters(QueryMode.Select, Sfi);
 			var preTransformResult = NhRelinqQueryParser.PreTransform(q1.Expression, preTransformParameters);
-			var expression = ExpressionParameterVisitor.Visit(preTransformResult, out var parameters1);
-			var k1 = ExpressionKeyVisitor.Visit(expression, parameters1);
+			var parameters1 = ExpressionParameterVisitor.Visit(preTransformResult);
+			var k1 = ExpressionKeyVisitor.Visit(preTransformResult.Expression, parameters1, Sfi);
 
 			var preTransformResult2 = NhRelinqQueryParser.PreTransform(q2.Expression, preTransformParameters);
-			var expression2 = ExpressionParameterVisitor.Visit(preTransformResult2, out var parameters2);
-			var k2 = ExpressionKeyVisitor.Visit(expression2, parameters2);
+			var parameters2 = ExpressionParameterVisitor.Visit(preTransformResult2);
+			var k2 = ExpressionKeyVisitor.Visit(preTransformResult2.Expression, parameters2, Sfi);
 
 			Assert.That(parameters1, Has.Count.GreaterThan(0), "parameters1");
 			Assert.That(parameters2, Has.Count.GreaterThan(0), "parameters2");