Improve our compile error messages for some invalid queries

Instead of producing an overflowing trait bound error show a concrete
error message what's wrong for certain query combination. This requires
to workaround rust-lang/rust#34260 in our
single method query dsl implementations:
* `GroupByDsl`
* `BoxedDsl`
* `DistinctDsl`
* `DistinctOnDsl`
* `LockingDsl`

Author: weiznich

diesel/src/query_dsl/boxed_dsl.rs

@@ -1,5 +1,10 @@
+use crate::dsl;
+use crate::expression::TypedExpressionType;
+use crate::expression::ValidGrouping;
 use crate::query_builder::AsQuery;
+use crate::query_builder::SelectStatement;
 use crate::query_source::Table;
+use crate::Expression;
 
 /// The `into_boxed` method
 ///
@@ -13,15 +18,17 @@ pub trait BoxedDsl<'a, DB> {
     type Output;
 
     /// See the trait documentation.
-    fn internal_into_boxed(self) -> Self::Output;
+    fn internal_into_boxed(self) -> dsl::IntoBoxed<'a, Self, DB>;
 }
 
 impl<'a, T, DB> BoxedDsl<'a, DB> for T
 where
-    T: Table + AsQuery,
-    T::Query: BoxedDsl<'a, DB>,
+    T: Table + AsQuery<Query = SelectStatement<T>>,
+    SelectStatement<T>: BoxedDsl<'a, DB>,
+    T::DefaultSelection: Expression<SqlType = T::SqlType> + ValidGrouping<()>,
+    T::SqlType: TypedExpressionType,
 {
-    type Output = <T::Query as BoxedDsl<'a, DB>>::Output;
+    type Output = dsl::IntoBoxed<'a, SelectStatement<T>, DB>;
 
     fn internal_into_boxed(self) -> Self::Output {
         self.as_query().internal_into_boxed()

diesel/src/query_dsl/distinct_dsl.rs

@@ -1,6 +1,12 @@
+use crate::dsl;
 #[cfg(feature = "postgres")]
 use crate::expression::SelectableExpression;
+use crate::expression::TypedExpressionType;
+use crate::expression::ValidGrouping;
+use crate::query_builder::AsQuery;
+use crate::query_builder::SelectStatement;
 use crate::query_source::Table;
+use crate::Expression;
 
 /// The `distinct` method
 ///
@@ -14,17 +20,18 @@ pub trait DistinctDsl {
     type Output;
 
     /// See the trait documentation.
-    fn distinct(self) -> Self::Output;
+    fn distinct(self) -> dsl::Distinct<Self>;
 }
 
 impl<T> DistinctDsl for T
 where
-    T: Table,
-    T::Query: DistinctDsl,
+    T: Table + AsQuery<Query = SelectStatement<T>>,
+    T::DefaultSelection: Expression<SqlType = T::SqlType> + ValidGrouping<()>,
+    T::SqlType: TypedExpressionType,
 {
-    type Output = <T::Query as DistinctDsl>::Output;
+    type Output = dsl::Distinct<SelectStatement<T>>;
 
-    fn distinct(self) -> Self::Output {
+    fn distinct(self) -> dsl::Distinct<SelectStatement<T>> {
         self.as_query().distinct()
     }
 }
@@ -42,19 +49,20 @@ pub trait DistinctOnDsl<Selection> {
     type Output;
 
     /// See the trait documentation
-    fn distinct_on(self, selection: Selection) -> Self::Output;
+    fn distinct_on(self, selection: Selection) -> dsl::DistinctOn<Self, Selection>;
 }
 
 #[cfg(feature = "postgres")]
 impl<T, Selection> DistinctOnDsl<Selection> for T
 where
     Selection: SelectableExpression<T>,
-    T: Table,
-    T::Query: DistinctOnDsl<Selection>,
+    T: Table + AsQuery<Query = SelectStatement<T>>,
+    T::DefaultSelection: Expression<SqlType = T::SqlType> + ValidGrouping<()>,
+    T::SqlType: TypedExpressionType,
 {
-    type Output = <T::Query as DistinctOnDsl<Selection>>::Output;
+    type Output = dsl::DistinctOn<SelectStatement<T>, Selection>;
 
-    fn distinct_on(self, selection: Selection) -> Self::Output {
+    fn distinct_on(self, selection: Selection) -> dsl::DistinctOn<Self, Selection> {
         self.as_query().distinct_on(selection)
     }
 }

diesel/src/query_dsl/group_by_dsl.rs

@@ -1,5 +1,8 @@
+use crate::dsl;
 use crate::expression::Expression;
-use crate::query_builder::AsQuery;
+use crate::expression::TypedExpressionType;
+use crate::expression::ValidGrouping;
+use crate::query_builder::{AsQuery, SelectStatement};
 use crate::query_source::Table;
 
 /// The `group_by` method
@@ -14,18 +17,19 @@ pub trait GroupByDsl<Expr: Expression> {
     type Output;
 
     /// See the trait documentation.
-    fn group_by(self, expr: Expr) -> Self::Output;
+    fn group_by(self, expr: Expr) -> dsl::GroupBy<Self, Expr>;
 }
 
 impl<T, Expr> GroupByDsl<Expr> for T
 where
     Expr: Expression,
-    T: Table + AsQuery,
-    T::Query: GroupByDsl<Expr>,
+    T: Table + AsQuery<Query = SelectStatement<T>>,
+    T::DefaultSelection: Expression<SqlType = T::SqlType> + ValidGrouping<()>,
+    T::SqlType: TypedExpressionType,
 {
-    type Output = <T::Query as GroupByDsl<Expr>>::Output;
+    type Output = dsl::GroupBy<SelectStatement<T>, Expr>;
 
-    fn group_by(self, expr: Expr) -> Self::Output {
+    fn group_by(self, expr: Expr) -> dsl::GroupBy<Self, Expr> {
         self.as_query().group_by(expr)
     }
 }

diesel/src/query_dsl/locking_dsl.rs

@@ -1,5 +1,9 @@
+use crate::expression::TypedExpressionType;
+use crate::expression::ValidGrouping;
 use crate::query_builder::AsQuery;
+use crate::query_builder::SelectStatement;
 use crate::query_source::Table;
+use crate::Expression;
 
 /// Methods related to locking select statements
 ///
@@ -21,10 +25,11 @@ pub trait LockingDsl<Lock> {
 
 impl<T, Lock> LockingDsl<Lock> for T
 where
-    T: Table + AsQuery,
-    T::Query: LockingDsl<Lock>,
+    T: Table + AsQuery<Query = SelectStatement<T>>,
+    T::DefaultSelection: Expression<SqlType = T::SqlType> + ValidGrouping<()>,
+    T::SqlType: TypedExpressionType,
 {
-    type Output = <T::Query as LockingDsl<Lock>>::Output;
+    type Output = <SelectStatement<T> as LockingDsl<Lock>>::Output;
 
     fn with_lock(self, lock: Lock) -> Self::Output {
         self.as_query().with_lock(lock)

diesel/src/query_dsl/mod.rs

@@ -803,6 +803,7 @@ pub trait QueryDsl: Sized {
     /// let data = users::table.inner_join(posts::table)
     ///     .group_by(users::id)
     ///     .select((users::name, count(posts::id)))
+    /// #   .order_by(users::id.asc())
     ///     .load::<(String, i64)>(&connection)?;
     ///
     /// assert_eq!(vec![(String::from("Sean"), 2), (String::from("Tess"), 1)], data);

diesel_compile_tests/tests/compile-fail/boxed_queries_and_group_by.rs

@@ -65,14 +65,6 @@ fn main() {
         .into_boxed();
     //~^ ERROR BoxedDsl
 
-    // you cannot call group by after boxing
-    users::table
-        .into_boxed()
-        .group_by(users::id)
-        //~^ ERROR no method named `group_by` found
-        .select(users::name)
-        .load::<String>(&conn);
-
     users::table
         .group_by(users::name)
         .select(users::name)
@@ -95,4 +87,14 @@ fn main() {
     // this is a different type now
     a = users::table.group_by(users::id).into_boxed();
     //~^ ERROR mismatched types
+
+    // you cannot call group by after boxing
+    users::table
+        .into_boxed()
+        .group_by(users::id)
+        //~^ ERROR type mismatch
+        //~| ERROR Table
+        //~| ERROR GroupByDsl
+        .select(users::name)
+        .load::<String>(&conn);
 }

diesel_compile_tests/tests/compile-fail/select_for_update_cannot_be_mixed_with_some_clauses.rs

@@ -12,22 +12,35 @@ table! {
 fn main() {
     use self::users::dsl::*;
 
-    // FIXME: Overflows because of https://github.com/rust-lang/rust/issues/34260
-    // should be E0277
-    //users.for_update().distinct();
-    // FIXME: Overflows because of https://github.com/rust-lang/rust/issues/34260
-    // should be E0277
-    // users.distinct().for_update();
+    users.for_update().distinct();
+    //~^ ERROR: E0271
+    //~| ERROR: E0277
+    //~| ERROR: E0277
+    users.distinct().for_update();
+    //~^ ERROR: E0271
+    //~| ERROR: E0277
+    users.for_update().distinct_on(id);
+    //~^ ERROR: E0271
+    //~| ERROR: E0277
+    //~| ERROR: E0277
+    //~| ERROR: E0277
+    users.distinct_on(id).for_update();
+    //~^ ERROR: E0271
+    //~| ERROR: E0277
 
     users.for_update().group_by(id);
-    //~^ ERROR: E0599
-    // FIXME: Overflows because of https://github.com/rust-lang/rust/issues/34260
-    // should be E0277
-    // users.group_by(id).for_update();
+    //~^ ERROR: E0271
+    //~| ERROR: E0277
+    //~| ERROR: E0277
+    users.group_by(id).for_update();
+    //~^ ERROR: E0271
+    //~| ERROR: E0277
 
-    // FIXME: Overflows because of https://github.com/rust-lang/rust/issues/34260
-    // should be E0277
-    // users.into_boxed().for_update();
+    users.into_boxed().for_update();
+    //~^ ERROR: E0271
+    //~| ERROR: E0277
     users.for_update().into_boxed();
-    //~^ ERROR: E0275
+    //~^ ERROR: E0271
+    //~| ERROR: E0277
+    //~| ERROR: E0277
 }