use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
use super::{Parser, Restrictions, TokenType};
+use crate::errors::PathSingleColon;
use crate::{errors, maybe_whole};
use rustc_ast::ptr::P;
use rustc_ast::token::{self, Delimiter, Token, TokenKind};
AssocConstraintKind, BlockCheckMode, GenericArg, GenericArgs, Generics, ParenthesizedArgs,
Path, PathSegment, QSelf,
};
-use rustc_errors::{pluralize, Applicability, PResult};
+use rustc_errors::{Applicability, IntoDiagnostic, PResult};
use rustc_span::source_map::{BytePos, Span};
use rustc_span::symbol::{kw, sym, Ident};
use std::mem;
/// In all such contexts the non-path interpretation is preferred by default for practical
/// reasons, but the path interpretation can be forced by the disambiguator `::`, e.g.
/// `x<y>` - comparisons, `x::<y>` - unambiguously a path.
+ ///
+ /// Also, a path may never be followed by a `:`. This means that we can eagerly recover if
+ /// we encounter it.
Expr,
+ /// The same as `Expr`, but may be followed by a `:`.
+ /// For example, this code:
+ /// ```rust
+ /// struct S;
+ ///
+ /// let S: S;
+ /// // ^ Followed by a `:`
+ /// ```
+ Pat,
/// In other contexts, notably in types, no ambiguity exists and paths can be written
/// without the disambiguator, e.g., `x<y>` - unambiguously a path.
/// Paths with disambiguators are still accepted, `x::<Y>` - unambiguously a path too.
Mod,
}
+impl PathStyle {
+ fn has_generic_ambiguity(&self) -> bool {
+ matches!(self, Self::Expr | Self::Pat)
+ }
+}
+
impl<'a> Parser<'a> {
/// Parses a qualified path.
/// Assumes that the leading `<` has been parsed already.
//
if style == PathStyle::Mod && path.segments.iter().any(|segment| segment.args.is_some())
{
- parser
- .struct_span_err(
- path.segments
- .iter()
- .filter_map(|segment| segment.args.as_ref())
- .map(|arg| arg.span())
- .collect::<Vec<_>>(),
- "unexpected generic arguments in path",
- )
- .emit();
+ let span = path
+ .segments
+ .iter()
+ .filter_map(|segment| segment.args.as_ref())
+ .map(|arg| arg.span())
+ .collect::<Vec<_>>();
+ parser.sess.emit_err(errors::GenericsInPath { span });
}
};
segments.push(PathSegment::path_root(lo.shrink_to_lo().with_ctxt(mod_sep_ctxt)));
}
self.parse_path_segments(&mut segments, style, ty_generics)?;
-
Ok(Path { segments, span: lo.to(self.prev_token.span), tokens: None })
}
) -> PResult<'a, ()> {
loop {
let segment = self.parse_path_segment(style, ty_generics)?;
- if style == PathStyle::Expr {
+ if style.has_generic_ambiguity() {
// In order to check for trailing angle brackets, we must have finished
// recursing (`parse_path_segment` can indirectly call this function),
// that is, the next token must be the highlighted part of the below example:
segments.push(segment);
if self.is_import_coupler() || !self.eat(&token::ModSep) {
+ if style == PathStyle::Expr
+ && self.may_recover()
+ && self.token == token::Colon
+ && self.look_ahead(1, |token| token.is_ident() && !token.is_reserved_ident())
+ {
+ // Emit a special error message for `a::b:c` to help users
+ // otherwise, `a: c` might have meant to introduce a new binding
+ if self.token.span.lo() == self.prev_token.span.hi()
+ && self.look_ahead(1, |token| self.token.span.hi() == token.span.lo())
+ {
+ self.bump(); // bump past the colon
+ self.sess.emit_err(PathSingleColon {
+ span: self.prev_token.span,
+ type_ascription: self
+ .sess
+ .unstable_features
+ .is_nightly_build()
+ .then_some(()),
+ });
+ }
+ continue;
+ }
+
return Ok(());
}
}
ty_generics,
)?;
self.expect_gt().map_err(|mut err| {
+ // Try to recover a `:` into a `::`
+ if self.token == token::Colon
+ && self.look_ahead(1, |token| {
+ token.is_ident() && !token.is_reserved_ident()
+ })
+ {
+ err.cancel();
+ err = PathSingleColon {
+ span: self.token.span,
+ type_ascription: self
+ .sess
+ .unstable_features
+ .is_nightly_build()
+ .then_some(()),
+ }
+ .into_diagnostic(self.diagnostic());
+ }
// Attempt to find places where a missing `>` might belong.
- if let Some(arg) = args
+ else if let Some(arg) = args
.iter()
.rev()
.find(|arg| !matches!(arg, AngleBracketedArg::Constraint(_)))
// i.e. no multibyte characters, in this range.
let span =
lo.with_hi(lo.lo() + BytePos(snapshot.unmatched_angle_bracket_count));
- self.struct_span_err(
+ self.sess.emit_err(errors::UnmatchedAngle {
span,
- &format!(
- "unmatched angle bracket{}",
- pluralize!(snapshot.unmatched_angle_bracket_count)
- ),
- )
- .span_suggestion(
- span,
- &format!(
- "remove extra angle bracket{}",
- pluralize!(snapshot.unmatched_angle_bracket_count)
- ),
- "",
- Applicability::MachineApplicable,
- )
- .emit();
+ plural: snapshot.unmatched_angle_bracket_count > 1,
+ });
// Try again without unmatched angle bracket characters.
self.parse_angle_args(ty_generics)
let kind = if self.eat(&token::Colon) {
// Parse associated type constraint bound.
- let bounds = self.parse_generic_bounds(Some(self.prev_token.span))?;
+ let bounds = self.parse_generic_bounds()?;
AssocConstraintKind::Bound { bounds }
} else if self.eat(&token::Eq) {
self.parse_assoc_equality_term(ident, self.prev_token.span)?
c.into()
}
Some(GenericArg::Lifetime(lt)) => {
- self.struct_span_err(span, "associated lifetimes are not supported")
- .span_label(lt.ident.span, "the lifetime is given here")
- .help("if you meant to specify a trait object, write `dyn Trait + 'lifetime`")
- .emit();
+ self.sess.emit_err(errors::AssocLifetime { span, lifetime: lt.ident.span });
self.mk_ty(span, ast::TyKind::Err).into()
}
None => {
);
err.span_suggestion(
eq.to(before_next),
- &format!("remove the `=` if `{}` is a type", ident),
+ format!("remove the `=` if `{}` is a type", ident),
"",
Applicability::MaybeIncorrect,
)
} else {
err.span_label(
self.token.span,
- &format!("expected type, found {}", super::token_descr(&self.token)),
+ format!("expected type, found {}", super::token_descr(&self.token)),
)
};
return Err(err);
projects / rustc.git / blobdiff