Auto merge of #39158 - petrochenkov:bounds, r=nikomatsakis

Bounds parsing refactoring 2

See #37511 for previous discussion.
cc @matklad

Relaxed parsing rules:
 - zero bounds after `:` are allowed in all contexts.
 - zero predicates are allowed after `where`.
- trailing separator `,` is allowed after predicates in `where` clauses not followed by `{`.

Other parsing rules:
 - trailing separator `+` is still allowed in all bound lists.

Code is also cleaned up and tests added.

I haven't touched parsing of trait object types yet, I'll do it later.

Author: bors

src/librustc_passes/ast_validation.rs

@@ -146,6 +146,12 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
             TyKind::TraitObject(ref bounds) => {
                 self.no_questions_in_bounds(bounds, "trait object types", false);
             }
+            TyKind::ImplTrait(ref bounds) => {
+                if !bounds.iter()
+                          .any(|b| if let TraitTyParamBound(..) = *b { true } else { false }) {
+                    self.err_handler().span_err(ty.span, "at least one trait must be specified");
+                }
+            }
             _ => {}
         }
 
@@ -284,6 +290,26 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
 
         visit::walk_vis(self, vis)
     }
+
+    fn visit_generics(&mut self, g: &'a Generics) {
+        let mut seen_default = None;
+        for ty_param in &g.ty_params {
+            if ty_param.default.is_some() {
+                seen_default = Some(ty_param.span);
+            } else if let Some(span) = seen_default {
+                self.err_handler()
+                    .span_err(span, "type parameters with a default must be trailing");
+                break
+            }
+        }
+        for predicate in &g.where_clause.predicates {
+            if let WherePredicate::EqPredicate(ref predicate) = *predicate {
+                self.err_handler().span_err(predicate.span, "equality constraints are not yet \
+                                                             supported in where clauses (#20041)");
+            }
+        }
+        visit::walk_generics(self, g)
+    }
 }
 
 pub fn check_crate(session: &Session, krate: &Crate) {

src/librustc_typeck/collect.rs

@@ -1833,11 +1833,8 @@ fn ty_generic_predicates<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>,
                 }
             }
 
-            &hir::WherePredicate::EqPredicate(ref eq_pred) => {
+            &hir::WherePredicate::EqPredicate(..) => {
                 // FIXME(#20041)
-                span_bug!(eq_pred.span,
-                         "Equality constraints are not yet \
-                          implemented (#20041)")
             }
         }
     }

src/librustdoc/clean/mod.rs

@@ -842,8 +842,11 @@ impl Clean<WherePredicate> for hir::WherePredicate {
                 }
             }
 
-            hir::WherePredicate::EqPredicate(_) => {
-                unimplemented!() // FIXME(#20041)
+            hir::WherePredicate::EqPredicate(ref wrp) => {
+                WherePredicate::EqPredicate {
+                    lhs: wrp.lhs_ty.clean(cx),
+                    rhs: wrp.rhs_ty.clean(cx)
+                }
             }
         }
     }