Fix minor parser problems

Author: varkor

src/librustdoc/clean/mod.rs

@@ -1089,9 +1089,9 @@ fn external_generic_args(cx: &DocContext, trait_did: Option<DefId>, has_self: bo
  match trait_did {
  // Attempt to sugar an external path like Fn<(A, B,), C> to Fn(A, B) -> C
  Some(did) if cx.tcx.lang_items().fn_trait_kind(did).is_some() => {
- assert_eq!(types.len(), 1);
- let inputs = match types[0].sty {
- ty::Tuple(ref tys) => tys.iter().map(|t| t.clean(cx)).collect(),
+ assert!(first_ty_sty.is_some());
+ let inputs = match first_ty_sty {
+ Some(ty::Tuple(ref tys)) => tys.iter().map(|t| t.clean(cx)).collect(),
  _ => return GenericArgs::AngleBracketed { args, bindings },
  };
  let output = None;

src/libsyntax/parse/parser.rs

@@ -5067,6 +5067,7 @@ impl<'a> Parser<'a> {
  crate fn parse_generic_params(&mut self) -> PResult<'a, Vec<ast::GenericParam>> {
  let mut params = vec![];
  let mut max_param = None;
+ // TODO(const_generics): move parameter order enforcement to AST.
  fn enforce_param_order(parser: &Parser,
  max_param: &mut Option<ParamKindOrd>,
  param_ord: ParamKindOrd) {
@@ -5111,9 +5112,6 @@ impl<'a> Parser<'a> {
  if let Some(max_param) = max_param {
  self.span_err(attrs[0].span,
  &format!("trailing attribute after {} parameters", max_param));
- } else {
- self.span_err(attrs[0].span,
- "leading attribute before generic parameters");
  }
  }
  break
@@ -5202,7 +5200,7 @@ impl<'a> Parser<'a> {
  let lit = self.parse_lit()?;
  self.mk_expr(lit.span, ExprKind::Lit(P(lit)), ThinVec::new())
  } else {
- unreachable!()
+ unreachable!() // TODO(const_generics): handle this case
  };
  debug!("const arg: expr={:?}", expr);
  let value = AnonConst {
@@ -5253,7 +5251,7 @@ impl<'a> Parser<'a> {
  // We are considering adding generics to the `where` keyword as an alternative higher-rank
  // parameter syntax (as in `where<'a>` or `where<T>`. To avoid that being a breaking
  // change we parse those generics now, but report an error.
- if self.choose_generics_over_qpath(false) {
+ if self.choose_generics_over_qpath() {
  let generics = self.parse_generics()?;
  self.span_err(generics.span,
  "generic parameters on `where` clauses are reserved for future use");
@@ -5827,7 +5825,7 @@ impl<'a> Parser<'a> {
  }
  }
 
- fn choose_generics_over_qpath(&self, param: bool) -> bool {
+ fn choose_generics_over_qpath(&self) -> bool {
  // There's an ambiguity between generic parameters and qualified paths in impls.
  // If we see `<` it may start both, so we have to inspect some following tokens.
  // The following combinations can only start generics,
@@ -5849,8 +5847,7 @@ impl<'a> Parser<'a> {
  self.look_ahead(1, |t| t.is_lifetime() || t.is_ident()) &&
  self.look_ahead(2, |t| t == &token::Gt || t == &token::Comma ||
  t == &token::Colon || t == &token::Eq) ||
- param && self.look_ahead(1, |t| t.is_keyword(keywords::Const) &&
- self.look_ahead(2, |t| t.is_ident())))
+ self.look_ahead(1, |t| t.is_keyword(keywords::Const)))
  }
 
  fn parse_impl_body(&mut self) -> PResult<'a, (Vec<ImplItem>, Vec<Attribute>)> {
@@ -5883,7 +5880,7 @@ impl<'a> Parser<'a> {
  fn parse_item_impl(&mut self, unsafety: Unsafety, defaultness: Defaultness)
  -> PResult<'a, ItemInfo> {
  // First, parse generic parameters if necessary.
- let mut generics = if self.choose_generics_over_qpath(true) {
+ let mut generics = if self.choose_generics_over_qpath() {
  self.parse_generics()?
  } else {
  ast::Generics::default()

src/libsyntax/parse/token.rs

@@ -284,6 +284,12 @@ impl Token {
  pub fn can_begin_const_arg(&self) -> bool {
  match self {
  OpenDelim(Brace) => true,
+ Interpolated(ref nt) => match nt.0 {
+ NtExpr(..) => true,
+ NtBlock(..) => true,
+ NtLiteral(..) => true,
+ _ => false,
+ }
  _ => self.can_begin_literal_or_bool(),
  }
  }