Merge pull request #3662 from Ten0/bool_expression_helper_type_inference

Allow ~type inference on `And` and `Or` helper types

diesel/src/expression/helper_types.rs

@@ -5,6 +5,7 @@ use super::array_comparison::{AsInExpression, In, NotIn};
 use super::grouped::Grouped;
 use super::select_by::SelectBy;
 use super::{AsExpression, Expression};
+use crate::expression_methods::PreferredBoolSqlType;
 use crate::sql_types;
 
 /// The SQL type of an expression
@@ -94,12 +95,13 @@ pub type AssumeNotNull<Expr> = super::assume_not_null::AssumeNotNull<Expr>;
 
 /// The return type of
 /// [`lhs.and(rhs)`](crate::expression_methods::BoolExpressionMethods::and())
-pub type And<Lhs, Rhs, ST = sql_types::Bool> =
+pub type And<Lhs, Rhs, ST = <Rhs as PreferredBoolSqlType>::PreferredSqlType> =
     Grouped<super::operators::And<Lhs, AsExprOf<Rhs, ST>>>;
 
 /// The return type of
 /// [`lhs.or(rhs)`](crate::expression_methods::BoolExpressionMethods::or())
-pub type Or<Lhs, Rhs, ST = sql_types::Bool> = Grouped<super::operators::Or<Lhs, AsExprOf<Rhs, ST>>>;
+pub type Or<Lhs, Rhs, ST = <Rhs as PreferredBoolSqlType>::PreferredSqlType> =
+    Grouped<super::operators::Or<Lhs, AsExprOf<Rhs, ST>>>;
 
 /// The return type of
 /// [`lhs.escape('x')`](crate::expression_methods::EscapeExpressionMethods::escape())

diesel/src/expression_methods/bool_expression_methods.rs

@@ -2,7 +2,7 @@ use crate::dsl;
 use crate::expression::grouped::Grouped;
 use crate::expression::operators::{And, Or};
 use crate::expression::{AsExpression, Expression, TypedExpressionType};
-use crate::sql_types::{BoolOrNullableBool, SqlType};
+use crate::sql_types::{self, BoolOrNullableBool, SqlType};
 
 /// Methods present on boolean expressions
 pub trait BoolExpressionMethods: Expression + Sized {
@@ -103,3 +103,59 @@ where
     T::SqlType: BoolOrNullableBool,
 {
 }
+
+/// Allow ~type inference on [And](crate::helper_types::And) and [Or](crate::helper_types::Or)
+/// helper types
+///
+/// This is used to be statistically correct as last generic parameter of `dsl::And` and `dsl::Or`
+/// without having to specify an additional type parameter.
+///
+/// It works with types that are [Expression]s and have a [`SqlType`](Expression::SqlType) that is
+/// either [`Bool`](sql_types::Bool) or [`Nullable<Bool>`](sql_types::Nullable), and with [`bool`]
+/// (and `Option<bool>` and references to those).
+///
+/// Cases where an additional type parameter would still have to be specified in the helper type
+/// generic parameters are:
+/// - If this trait isn't implemented for the `other` parameter of the expression
+///   (in that case the user (you?) probably wants to implement it)
+/// - If the user actually was using the not-preferred implementation of `AsExpression`
+///   (e.g. towards `Nullable<Bool>` instead of `Bool`)
+pub trait PreferredBoolSqlType {
+    /// The preferred `Bool` SQL type for this AsExpression implementation.
+    ///
+    /// That should be either `Bool` or `Nullable<Bool>`.
+    type PreferredSqlType;
+}
+
+impl<E: Expression> PreferredBoolSqlType for E
+where
+    E::SqlType: BoolOrNullableBool,
+{
+    type PreferredSqlType = <E as Expression>::SqlType;
+}
+
+/// This impl has to live in Diesel because otherwise it would conflict with the blanket impl above
+/// because "diesel might add an implementation of Expression for bool"
+impl PreferredBoolSqlType for bool {
+    type PreferredSqlType = sql_types::Bool;
+}
+
+impl PreferredBoolSqlType for &bool {
+    type PreferredSqlType = sql_types::Bool;
+}
+
+impl PreferredBoolSqlType for &&bool {
+    type PreferredSqlType = sql_types::Bool;
+}
+
+impl PreferredBoolSqlType for Option<bool> {
+    type PreferredSqlType = sql_types::Nullable<sql_types::Bool>;
+}
+
+impl PreferredBoolSqlType for &Option<bool> {
+    type PreferredSqlType = sql_types::Nullable<sql_types::Bool>;
+}
+
+impl PreferredBoolSqlType for &&Option<bool> {
+    type PreferredSqlType = sql_types::Nullable<sql_types::Bool>;
+}

diesel/src/expression_methods/mod.rs

@@ -11,7 +11,7 @@ mod global_expression_methods;
 mod text_expression_methods;
 
 #[doc(inline)]
-pub use self::bool_expression_methods::BoolExpressionMethods;
+pub use self::bool_expression_methods::{BoolExpressionMethods, PreferredBoolSqlType};
 #[doc(hidden)]
 pub use self::eq_all::EqAll;
 #[doc(inline)]