diff options
Diffstat (limited to 'compiler/rustc_parse/src/parser/ty.rs')
| -rw-r--r-- | compiler/rustc_parse/src/parser/ty.rs | 36 |
1 files changed, 18 insertions, 18 deletions
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs index 2bd25adda7e..42ab23d6292 100644 --- a/compiler/rustc_parse/src/parser/ty.rs +++ b/compiler/rustc_parse/src/parser/ty.rs @@ -213,7 +213,7 @@ impl<'a> Parser<'a> { // Don't `eat` to prevent `=>` from being added as an expected token which isn't // actually expected and could only confuse users self.bump(); - self.sess.emit_err(ReturnTypesUseThinArrow { span: self.prev_token.span }); + self.dcx().emit_err(ReturnTypesUseThinArrow { span: self.prev_token.span }); let ty = self.parse_ty_common( allow_plus, AllowCVariadic::No, @@ -288,7 +288,7 @@ impl<'a> Parser<'a> { let parse_plus = allow_plus == AllowPlus::Yes && self.check_plus(); let kind = self.parse_remaining_bounds_path(lifetime_defs, path, lo, parse_plus)?; - let mut err = self.sess.create_err(errors::TransposeDynOrImpl { + let mut err = self.dcx().create_err(errors::TransposeDynOrImpl { span: kw.span, kw: kw.name.as_str(), sugg: errors::TransposeDynOrImplSugg { @@ -335,7 +335,7 @@ impl<'a> Parser<'a> { AllowCVariadic::No => { // FIXME(Centril): Should we just allow `...` syntactically // anywhere in a type and use semantic restrictions instead? - self.sess.emit_err(NestedCVariadicType { span: lo.to(self.prev_token.span) }); + self.dcx().emit_err(NestedCVariadicType { span: lo.to(self.prev_token.span) }); TyKind::Err } } @@ -426,7 +426,7 @@ impl<'a> Parser<'a> { let lt_no_plus = self.check_lifetime() && !self.look_ahead(1, |t| t.is_like_plus()); let bounds = self.parse_generic_bounds_common(allow_plus)?; if lt_no_plus { - self.sess.emit_err(NeedPlusAfterTraitObjectLifetime { span: lo }); + self.dcx().emit_err(NeedPlusAfterTraitObjectLifetime { span: lo }); } Ok(TyKind::TraitObject(bounds, TraitObjectSyntax::None)) } @@ -460,7 +460,7 @@ impl<'a> Parser<'a> { fn parse_ty_ptr(&mut self) -> PResult<'a, TyKind> { let mutbl = self.parse_const_or_mut().unwrap_or_else(|| { let span = self.prev_token.span; - self.sess.emit_err(ExpectedMutOrConstInRawPointerType { + self.dcx().emit_err(ExpectedMutOrConstInRawPointerType { span, after_asterisk: span.shrink_to_hi(), }); @@ -523,7 +523,7 @@ impl<'a> Parser<'a> { } else { (None, String::new()) }; - self.sess.emit_err(LifetimeAfterMut { span, suggest_lifetime, snippet }); + self.dcx().emit_err(LifetimeAfterMut { span, suggest_lifetime, snippet }); opt_lifetime = Some(self.expect_lifetime()); } @@ -533,7 +533,7 @@ impl<'a> Parser<'a> { { // We have `&dyn mut ...`, which is invalid and should be `&mut dyn ...`. let span = and_span.to(self.look_ahead(1, |t| t.span)); - self.sess.emit_err(DynAfterMut { span }); + self.dcx().emit_err(DynAfterMut { span }); // Recovery mutbl = Mutability::Mut; @@ -587,10 +587,10 @@ impl<'a> Parser<'a> { // If we ever start to allow `const fn()`, then update // feature gating for `#![feature(const_extern_fn)]` to // cover it. - self.sess.emit_err(FnPointerCannotBeConst { span: whole_span, qualifier: span }); + self.dcx().emit_err(FnPointerCannotBeConst { span: whole_span, qualifier: span }); } if let Some(ast::CoroutineKind::Async { span, .. }) = coroutine_kind { - self.sess.emit_err(FnPointerCannotBeAsync { span: whole_span, qualifier: span }); + self.dcx().emit_err(FnPointerCannotBeAsync { span: whole_span, qualifier: span }); } // FIXME(gen_blocks): emit a similar error for `gen fn()` let decl_span = span_start.to(self.token.span); @@ -634,7 +634,7 @@ impl<'a> Parser<'a> { None }; - self.sess.emit_err(FnPtrWithGenerics { span: generics.span, sugg }); + self.dcx().emit_err(FnPtrWithGenerics { span: generics.span, sugg }); params.append(&mut lifetimes); Ok(()) } @@ -647,7 +647,7 @@ impl<'a> Parser<'a> { if let token::Ident(sym, _) = t.kind { // parse pattern with "'a Sized" we're supposed to give suggestion like // "'a + Sized" - self.sess.emit_err(errors::MissingPlusBounds { + self.dcx().emit_err(errors::MissingPlusBounds { span: self.token.span, hi: self.token.span.shrink_to_hi(), sym, @@ -739,7 +739,7 @@ impl<'a> Parser<'a> { { if self.token.is_keyword(kw::Dyn) { // Account for `&dyn Trait + dyn Other`. - self.sess.emit_err(InvalidDynKeyword { span: self.token.span }); + self.dcx().emit_err(InvalidDynKeyword { span: self.token.span }); self.bump(); } bounds.push(self.parse_generic_bound()?); @@ -813,14 +813,14 @@ impl<'a> Parser<'a> { match modifiers.constness { BoundConstness::Never => {} BoundConstness::Maybe(span) => { - self.sess.emit_err(errors::TildeConstLifetime { span }); + self.dcx().emit_err(errors::TildeConstLifetime { span }); } } match modifiers.polarity { BoundPolarity::Positive => {} BoundPolarity::Negative(span) | BoundPolarity::Maybe(span) => { - self.sess.emit_err(errors::ModifierLifetime { + self.dcx().emit_err(errors::ModifierLifetime { span, sigil: modifiers.polarity.as_str(), }); @@ -839,7 +839,7 @@ impl<'a> Parser<'a> { (None, String::new()) }; - self.sess.emit_err(errors::ParenthesizedLifetime { span, sugg, snippet }); + self.dcx().emit_err(errors::ParenthesizedLifetime { span, sugg, snippet }); Ok(()) } @@ -860,7 +860,7 @@ impl<'a> Parser<'a> { } else if self.eat_keyword(kw::Const) { let span = self.prev_token.span; self.sess.gated_spans.gate(sym::const_trait_impl, span); - self.sess.emit_err(errors::ConstMissingTilde { span, start: span.shrink_to_lo() }); + self.dcx().emit_err(errors::ConstMissingTilde { span, start: span.shrink_to_lo() }); BoundConstness::Maybe(span) } else { @@ -960,7 +960,7 @@ impl<'a> Parser<'a> { let bounds = vec![]; self.parse_remaining_bounds(bounds, true)?; self.expect(&token::CloseDelim(Delimiter::Parenthesis))?; - self.sess.emit_err(errors::IncorrectParensTraitBounds { + self.dcx().emit_err(errors::IncorrectParensTraitBounds { span: vec![lo, self.prev_token.span], sugg: errors::IncorrectParensTraitBoundsSugg { wrong_span: leading_token.span.shrink_to_hi().to(lo), @@ -984,7 +984,7 @@ impl<'a> Parser<'a> { let snapshot = self.create_snapshot_for_diagnostic(); match self.parse_fn_decl(|_| false, AllowPlus::No, RecoverReturnSign::OnlyFatArrow) { Ok(decl) => { - self.sess.emit_err(ExpectedFnPathFoundFnKeyword { fn_token_span }); + self.dcx().emit_err(ExpectedFnPathFoundFnKeyword { fn_token_span }); Some(ast::Path { span: fn_token_span.to(self.prev_token.span), segments: thin_vec![ast::PathSegment { |