From e839b2ec849246ec5efe5069c8d874dbef289462 Mon Sep 17 00:00:00 2001 From: Mazdak Farrokhzad Date: Thu, 30 Jan 2020 02:42:33 +0100 Subject: [PATCH 01/13] Constness -> enum Const { Yes(Span), No } Same idea for `Unsafety` & use new span for better diagnostics. --- src/librustc/traits/auto_trait.rs | 3 +- src/librustc/traits/error_reporting/mod.rs | 2 +- src/librustc/traits/select.rs | 8 +- src/librustc/ty/fold.rs | 3 +- src/librustc/ty/mod.rs | 4 +- src/librustc/ty/print/pretty.rs | 2 +- src/librustc/ty/structural_impls.rs | 4 +- src/librustc_ast_lowering/item.rs | 30 ++++++-- src/librustc_ast_lowering/lib.rs | 2 +- src/librustc_ast_passes/ast_validation.rs | 30 ++++---- src/librustc_ast_passes/feature_gate.rs | 3 +- src/librustc_ast_pretty/pprust.rs | 20 ++--- .../deriving/generic/mod.rs | 6 +- src/librustc_builtin_macros/deriving/mod.rs | 4 +- .../global_allocator.rs | 4 +- src/librustc_builtin_macros/test.rs | 6 +- src/librustc_hir/hir.rs | 48 ++++++++---- src/librustc_hir/print.rs | 2 +- src/librustc_interface/util.rs | 2 +- src/librustc_lint/builtin.rs | 6 +- .../borrow_check/type_check/mod.rs | 5 +- .../transform/qualify_min_const_fn.rs | 3 +- src/librustc_parse/parser/item.rs | 77 ++++++++----------- src/librustc_parse/parser/mod.rs | 12 ++- src/librustc_save_analysis/sig.rs | 16 ++-- src/librustc_typeck/astconv.rs | 6 +- src/librustc_typeck/check/mod.rs | 4 +- src/librustc_typeck/collect.rs | 10 +-- src/librustc_typeck/lib.rs | 2 +- src/librustdoc/doctree.rs | 2 +- src/libsyntax/ast.rs | 68 +++++----------- .../coherence-negative-impls-safe.stderr | 4 +- .../const-fn-with-const-param.stderr | 6 +- src/test/ui/error-codes/E0197.stderr | 4 +- src/test/ui/error-codes/E0198.stderr | 4 +- .../feature-gate.gated.stderr | 4 +- .../feature-gate.stock.stderr | 4 +- .../inherent-impl.stderr | 16 +++- src/test/ui/syntax-trait-polarity.stderr | 8 +- .../traits/trait-safety-inherent-impl.stderr | 6 +- 40 files changed, 238 insertions(+), 212 deletions(-) diff --git a/src/librustc/traits/auto_trait.rs b/src/librustc/traits/auto_trait.rs index 1255728de37b1..3ab87ce8eb4a3 100644 --- a/src/librustc/traits/auto_trait.rs +++ b/src/librustc/traits/auto_trait.rs @@ -9,7 +9,6 @@ use crate::ty::fold::TypeFolder; use crate::ty::{Region, RegionVid}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use syntax::ast; use std::collections::hash_map::Entry; use std::collections::VecDeque; @@ -350,7 +349,7 @@ impl AutoTraitFinder<'tcx> { already_visited.remove(&pred); self.add_user_pred( &mut user_computed_preds, - ty::Predicate::Trait(pred, ast::Constness::NotConst), + ty::Predicate::Trait(pred, hir::Constness::NotConst), ); predicates.push_back(pred); } else { diff --git a/src/librustc/traits/error_reporting/mod.rs b/src/librustc/traits/error_reporting/mod.rs index a7a2b578b82da..c25b392ec239a 100644 --- a/src/librustc/traits/error_reporting/mod.rs +++ b/src/librustc/traits/error_reporting/mod.rs @@ -695,7 +695,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { let unit_obligation = Obligation { predicate: ty::Predicate::Trait( predicate, - ast::Constness::NotConst, + hir::Constness::NotConst, ), ..obligation.clone() }; diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs index bf82d743c2b04..1fe8ab58d152c 100644 --- a/src/librustc/traits/select.rs +++ b/src/librustc/traits/select.rs @@ -40,19 +40,19 @@ use crate::ty::fast_reject; use crate::ty::relate::TypeRelation; use crate::ty::subst::{Subst, SubstsRef}; use crate::ty::{self, ToPolyTraitRef, ToPredicate, Ty, TyCtxt, TypeFoldable, WithConstness}; -use rustc_hir::def_id::DefId; - use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_hir as hir; +use rustc_hir::def_id::DefId; use rustc_index::bit_set::GrowableBitSet; use rustc_span::symbol::sym; use rustc_target::spec::abi::Abi; +use syntax::attr; + use std::cell::{Cell, RefCell}; use std::cmp; use std::fmt::{self, Display}; use std::iter; use std::rc::Rc; -use syntax::{ast, attr}; pub use rustc::traits::types::select::*; @@ -677,7 +677,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // if the regions match exactly. let cycle = stack.iter().skip(1).take_while(|s| s.depth >= cycle_depth); let cycle = cycle.map(|stack| { - ty::Predicate::Trait(stack.obligation.predicate, ast::Constness::NotConst) + ty::Predicate::Trait(stack.obligation.predicate, hir::Constness::NotConst) }); if self.coinductive_match(cycle) { debug!("evaluate_stack({:?}) --> recursive, coinductive", stack.fresh_trait_ref); diff --git a/src/librustc/ty/fold.rs b/src/librustc/ty/fold.rs index 0dddca98c6257..1f007b970b0ca 100644 --- a/src/librustc/ty/fold.rs +++ b/src/librustc/ty/fold.rs @@ -32,6 +32,7 @@ //! looking for, and does not need to visit anything else. use crate::ty::{self, flags::FlagComputation, Binder, Ty, TyCtxt, TypeFlags}; +use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_data_structures::fx::FxHashSet; @@ -150,7 +151,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone { } } -impl TypeFoldable<'tcx> for syntax::ast::Constness { +impl TypeFoldable<'tcx> for hir::Constness { fn super_fold_with>(&self, _: &mut F) -> Self { *self } diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 393d49a4e4b05..2bda99e6d20fc 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -35,7 +35,7 @@ use rustc_data_structures::sync::{self, par_iter, Lrc, ParallelIterator}; use rustc_hir as hir; use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res}; use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE}; -use rustc_hir::{GlobMap, Node, TraitMap}; +use rustc_hir::{Constness, GlobMap, Node, TraitMap}; use rustc_index::vec::{Idx, IndexVec}; use rustc_macros::HashStable; use rustc_serialize::{self, Encodable, Encoder}; @@ -43,7 +43,7 @@ use rustc_span::hygiene::ExpnId; use rustc_span::symbol::{kw, sym, Symbol}; use rustc_span::Span; use rustc_target::abi::Align; -use syntax::ast::{self, Constness, Ident, Name}; +use syntax::ast::{self, Ident, Name}; use syntax::node_id::{NodeId, NodeMap, NodeSet}; use std::cell::RefCell; diff --git a/src/librustc/ty/print/pretty.rs b/src/librustc/ty/print/pretty.rs index 274482cba64cc..384422956367a 100644 --- a/src/librustc/ty/print/pretty.rs +++ b/src/librustc/ty/print/pretty.rs @@ -1818,7 +1818,7 @@ define_print_and_forward_display! { ty::Predicate<'tcx> { match *self { ty::Predicate::Trait(ref data, constness) => { - if let ast::Constness::Const = constness { + if let hir::Constness::Const = constness { p!(write("const ")); } p!(print(data)) diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs index acd6c9597518d..59dd41e9d56c9 100644 --- a/src/librustc/ty/structural_impls.rs +++ b/src/librustc/ty/structural_impls.rs @@ -7,6 +7,7 @@ use crate::mir::ProjectionKind; use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; use crate::ty::print::{FmtPrinter, Printer}; use crate::ty::{self, InferConst, Lift, Ty, TyCtxt}; +use rustc_hir as hir; use rustc_hir::def::Namespace; use rustc_hir::def_id::CRATE_DEF_INDEX; use rustc_index::vec::{Idx, IndexVec}; @@ -15,7 +16,6 @@ use smallvec::SmallVec; use std::fmt; use std::rc::Rc; use std::sync::Arc; -use syntax::ast; impl fmt::Debug for ty::GenericParamDef { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { @@ -236,7 +236,7 @@ impl fmt::Debug for ty::Predicate<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match *self { ty::Predicate::Trait(ref a, constness) => { - if let ast::Constness::Const = constness { + if let hir::Constness::Const = constness { write!(f, "const ")?; } a.fmt(f) diff --git a/src/librustc_ast_lowering/item.rs b/src/librustc_ast_lowering/item.rs index dab950e23f618..8cc3479dd1ba3 100644 --- a/src/librustc_ast_lowering/item.rs +++ b/src/librustc_ast_lowering/item.rs @@ -67,10 +67,12 @@ impl<'a> Visitor<'a> for ItemLowerer<'a, '_, '_> { self.lctx.with_parent_item_lifetime_defs(hir_id, |this| { let this = &mut ItemLowerer { lctx: this }; if let ItemKind::Impl { constness, ref of_trait, .. } = item.kind { - if constness == Constness::Const { + if let Const::Yes(span) = constness { this.lctx .diagnostic() - .span_err(item.span, "const trait impls are not yet implemented"); + .struct_span_err(item.span, "const trait impls are not yet implemented") + .span_label(span, "const because of this") + .emit(); } this.with_trait_impl_ref(of_trait, |this| visit::walk_item(this, item)); @@ -413,10 +415,10 @@ impl<'hir> LoweringContext<'_, 'hir> { }); hir::ItemKind::Impl { - unsafety, + unsafety: self.lower_unsafety(unsafety), polarity, defaultness: self.lower_defaultness(defaultness, true /* [1] */), - constness, + constness: self.lower_constness(constness), generics, of_trait: trait_ref, self_ty: lowered_ty, @@ -430,7 +432,7 @@ impl<'hir> LoweringContext<'_, 'hir> { .alloc_from_iter(items.iter().map(|item| self.lower_trait_item_ref(item))); hir::ItemKind::Trait( is_auto, - unsafety, + self.lower_unsafety(unsafety), self.lower_generics(generics, ImplTraitContext::disallowed()), bounds, items, @@ -1245,9 +1247,9 @@ impl<'hir> LoweringContext<'_, 'hir> { fn lower_fn_header(&mut self, h: FnHeader) -> hir::FnHeader { hir::FnHeader { - unsafety: h.unsafety, + unsafety: self.lower_unsafety(h.unsafety), asyncness: self.lower_asyncness(h.asyncness.node), - constness: h.constness.node, + constness: self.lower_constness(h.constness), abi: self.lower_extern(h.ext), } } @@ -1281,6 +1283,20 @@ impl<'hir> LoweringContext<'_, 'hir> { } } + fn lower_constness(&mut self, c: Const) -> hir::Constness { + match c { + Const::Yes(_) => hir::Constness::Const, + Const::No => hir::Constness::NotConst, + } + } + + pub(super) fn lower_unsafety(&mut self, u: Unsafe) -> hir::Unsafety { + match u { + Unsafe::Yes(_) => hir::Unsafety::Unsafe, + Unsafe::No => hir::Unsafety::Normal, + } + } + pub(super) fn lower_generics_mut( &mut self, generics: &Generics, diff --git a/src/librustc_ast_lowering/lib.rs b/src/librustc_ast_lowering/lib.rs index 5816a64fca52c..618b1e7964b95 100644 --- a/src/librustc_ast_lowering/lib.rs +++ b/src/librustc_ast_lowering/lib.rs @@ -1196,7 +1196,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { &NodeMap::default(), ImplTraitContext::disallowed(), ), - unsafety: f.unsafety, + unsafety: this.lower_unsafety(f.unsafety), abi: this.lower_extern(f.ext), decl: this.lower_fn_decl(&f.decl, None, false, None), param_names: this.lower_fn_params_to_names(&f.decl), diff --git a/src/librustc_ast_passes/ast_validation.rs b/src/librustc_ast_passes/ast_validation.rs index 057acec959801..de4f092dbf011 100644 --- a/src/librustc_ast_passes/ast_validation.rs +++ b/src/librustc_ast_passes/ast_validation.rs @@ -13,7 +13,6 @@ use rustc_parse::validate_attr; use rustc_session::lint::builtin::PATTERNS_IN_FNS_WITHOUT_BODY; use rustc_session::lint::LintBuffer; use rustc_session::Session; -use rustc_span::source_map::Spanned; use rustc_span::symbol::{kw, sym}; use rustc_span::Span; use std::mem; @@ -234,16 +233,11 @@ impl<'a> AstValidator<'a> { } } - fn check_trait_fn_not_const(&self, constness: Spanned) { - if constness.node == Constness::Const { - struct_span_err!( - self.session, - constness.span, - E0379, - "trait fns cannot be declared const" - ) - .span_label(constness.span, "trait fns cannot be const") - .emit(); + fn check_trait_fn_not_const(&self, constness: Const) { + if let Const::Yes(span) = constness { + struct_span_err!(self.session, span, E0379, "trait fns cannot be declared const") + .span_label(span, "trait fns cannot be const") + .emit(); } } @@ -487,7 +481,7 @@ impl<'a> AstValidator<'a> { (Some(FnCtxt::Foreign), _) => return, (Some(FnCtxt::Free), Some(header)) => match header.ext { Extern::Explicit(StrLit { symbol_unescaped: sym::C, .. }) | Extern::Implicit - if header.unsafety == Unsafety::Unsafe => + if matches!(header.unsafety, Unsafe::Yes(_)) => { return; } @@ -514,12 +508,13 @@ impl<'a> AstValidator<'a> { /// FIXME(const_generics): Is this really true / necessary? Discuss with @varkor. /// At any rate, the restriction feels too syntactic. Consider moving it to e.g. typeck. fn check_const_fn_const_generic(&self, span: Span, sig: &FnSig, generics: &Generics) { - if sig.header.constness.node == Constness::Const { + if let Const::Yes(const_span) = sig.header.constness { // Look for const generics and error if we find any. for param in &generics.params { if let GenericParamKind::Const { .. } = param.kind { self.err_handler() .struct_span_err(span, "const parameters are not permitted in `const fn`") + .span_label(const_span, "`const fn` because of this") .emit(); } } @@ -754,13 +749,14 @@ impl<'a> Visitor<'a> for AstValidator<'a> { .help("use `auto trait Trait {}` instead") .emit(); } - if unsafety == Unsafety::Unsafe && polarity == ImplPolarity::Negative { + if let (Unsafe::Yes(span), ImplPolarity::Negative) = (unsafety, polarity) { struct_span_err!( this.session, item.span, E0198, "negative impls cannot be unsafe" ) + .span_label(span, "unsafe because of this") .emit(); } @@ -782,13 +778,14 @@ impl<'a> Visitor<'a> for AstValidator<'a> { &item.vis, Some("place qualifiers on individual impl items instead"), ); - if unsafety == Unsafety::Unsafe { + if let Unsafe::Yes(span) = unsafety { struct_span_err!( self.session, item.span, E0197, "inherent impls cannot be unsafe" ) + .span_label(span, "unsafe because of this") .emit(); } if polarity == ImplPolarity::Negative { @@ -800,9 +797,10 @@ impl<'a> Visitor<'a> for AstValidator<'a> { .note("only trait implementations may be annotated with default") .emit(); } - if constness == Constness::Const { + if let Const::Yes(span) = constness { self.err_handler() .struct_span_err(item.span, "inherent impls cannot be `const`") + .span_label(span, "`const` because of this") .note("only trait implementations may be annotated with `const`") .emit(); } diff --git a/src/librustc_ast_passes/feature_gate.rs b/src/librustc_ast_passes/feature_gate.rs index a10ac94d8942b..cfab54925b161 100644 --- a/src/librustc_ast_passes/feature_gate.rs +++ b/src/librustc_ast_passes/feature_gate.rs @@ -538,8 +538,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { match i.kind { ast::AssocItemKind::Fn(ref sig, _) => { - let constness = sig.header.constness.node; - if let (ast::Constness::Const, AssocCtxt::Trait) = (constness, ctxt) { + if let (ast::Const::Yes(_), AssocCtxt::Trait) = (sig.header.constness, ctxt) { gate_feature_post!(&self, const_fn, i.span, "const fn is unstable"); } } diff --git a/src/librustc_ast_pretty/pprust.rs b/src/librustc_ast_pretty/pprust.rs index 78bf149f0e01a..633964683dcc6 100644 --- a/src/librustc_ast_pretty/pprust.rs +++ b/src/librustc_ast_pretty/pprust.rs @@ -2686,7 +2686,7 @@ impl<'a> State<'a> { crate fn print_ty_fn( &mut self, ext: ast::Extern, - unsafety: ast::Unsafety, + unsafety: ast::Unsafe, decl: &ast::FnDecl, name: Option, generic_params: &[ast::GenericParam], @@ -2733,11 +2733,7 @@ impl<'a> State<'a> { crate fn print_fn_header_info(&mut self, header: ast::FnHeader, vis: &ast::Visibility) { self.s.word(visibility_qualified(vis, "")); - match header.constness.node { - ast::Constness::NotConst => {} - ast::Constness::Const => self.word_nbsp("const"), - } - + self.print_constness(header.constness); self.print_asyncness(header.asyncness.node); self.print_unsafety(header.unsafety); @@ -2756,17 +2752,17 @@ impl<'a> State<'a> { self.s.word("fn") } - crate fn print_unsafety(&mut self, s: ast::Unsafety) { + crate fn print_unsafety(&mut self, s: ast::Unsafe) { match s { - ast::Unsafety::Normal => {} - ast::Unsafety::Unsafe => self.word_nbsp("unsafe"), + ast::Unsafe::No => {} + ast::Unsafe::Yes(_) => self.word_nbsp("unsafe"), } } - crate fn print_constness(&mut self, s: ast::Constness) { + crate fn print_constness(&mut self, s: ast::Const) { match s { - ast::Constness::Const => self.word_nbsp("const"), - ast::Constness::NotConst => {} + ast::Const::No => {} + ast::Const::Yes(_) => self.word_nbsp("const"), } } diff --git a/src/librustc_builtin_macros/deriving/generic/mod.rs b/src/librustc_builtin_macros/deriving/generic/mod.rs index f99008a6d5c14..5cf233e222e7c 100644 --- a/src/librustc_builtin_macros/deriving/generic/mod.rs +++ b/src/librustc_builtin_macros/deriving/generic/mod.rs @@ -700,7 +700,7 @@ impl<'a> TraitDef<'a> { let mut a = vec![attr, unused_qual]; a.extend(self.attributes.iter().cloned()); - let unsafety = if self.is_unsafe { ast::Unsafety::Unsafe } else { ast::Unsafety::Normal }; + let unsafety = if self.is_unsafe { ast::Unsafe::Yes(self.span) } else { ast::Unsafe::No }; cx.item( self.span, @@ -710,7 +710,7 @@ impl<'a> TraitDef<'a> { unsafety, polarity: ast::ImplPolarity::Positive, defaultness: ast::Defaultness::Final, - constness: ast::Constness::NotConst, + constness: ast::Const::No, generics: trait_generics, of_trait: opt_trait_ref, self_ty: self_type, @@ -960,7 +960,7 @@ impl<'a> MethodDef<'a> { let fn_decl = cx.fn_decl(args, ast::FunctionRetTy::Ty(ret_type)); let body_block = cx.block_expr(body); - let unsafety = if self.is_unsafe { ast::Unsafety::Unsafe } else { ast::Unsafety::Normal }; + let unsafety = if self.is_unsafe { ast::Unsafe::Yes(trait_.span) } else { ast::Unsafe::No }; let trait_lo_sp = trait_.span.shrink_to_lo(); diff --git a/src/librustc_builtin_macros/deriving/mod.rs b/src/librustc_builtin_macros/deriving/mod.rs index 914dcdf196921..63cd03527e15c 100644 --- a/src/librustc_builtin_macros/deriving/mod.rs +++ b/src/librustc_builtin_macros/deriving/mod.rs @@ -157,10 +157,10 @@ fn inject_impl_of_structural_trait( ast::Ident::invalid(), attrs, ItemKind::Impl { - unsafety: ast::Unsafety::Normal, + unsafety: ast::Unsafe::No, polarity: ast::ImplPolarity::Positive, defaultness: ast::Defaultness::Final, - constness: ast::Constness::NotConst, + constness: ast::Const::No, generics, of_trait: Some(trait_ref), self_ty: self_type, diff --git a/src/librustc_builtin_macros/global_allocator.rs b/src/librustc_builtin_macros/global_allocator.rs index ec0d55b38a73d..52f033e8b1404 100644 --- a/src/librustc_builtin_macros/global_allocator.rs +++ b/src/librustc_builtin_macros/global_allocator.rs @@ -4,7 +4,7 @@ use rustc_expand::base::{Annotatable, ExtCtxt}; use rustc_span::symbol::{kw, sym, Symbol}; use rustc_span::Span; use syntax::ast::{self, Attribute, Expr, FnHeader, FnSig, Generics, Ident, Param}; -use syntax::ast::{ItemKind, Mutability, Stmt, Ty, TyKind, Unsafety}; +use syntax::ast::{ItemKind, Mutability, Stmt, Ty, TyKind, Unsafe}; use syntax::expand::allocator::{AllocatorKind, AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS}; use syntax::ptr::P; @@ -64,7 +64,7 @@ impl AllocFnFactory<'_, '_> { let result = self.call_allocator(method.name, args); let (output_ty, output_expr) = self.ret_ty(&method.output, result); let decl = self.cx.fn_decl(abi_args, ast::FunctionRetTy::Ty(output_ty)); - let header = FnHeader { unsafety: Unsafety::Unsafe, ..FnHeader::default() }; + let header = FnHeader { unsafety: Unsafe::Yes(self.span), ..FnHeader::default() }; let sig = FnSig { decl, header }; let kind = ItemKind::Fn(sig, Generics::default(), Some(self.cx.block_expr(output_expr))); let item = self.cx.item( diff --git a/src/librustc_builtin_macros/test.rs b/src/librustc_builtin_macros/test.rs index 2d6ff81aea8b8..dd93596b3cfce 100644 --- a/src/librustc_builtin_macros/test.rs +++ b/src/librustc_builtin_macros/test.rs @@ -375,8 +375,10 @@ fn has_test_signature(cx: &ExtCtxt<'_>, i: &ast::Item) -> bool { let has_should_panic_attr = attr::contains_name(&i.attrs, sym::should_panic); let ref sd = cx.parse_sess.span_diagnostic; if let ast::ItemKind::Fn(ref sig, ref generics, _) = i.kind { - if sig.header.unsafety == ast::Unsafety::Unsafe { - sd.span_err(i.span, "unsafe functions cannot be used for tests"); + if let ast::Unsafe::Yes(span) = sig.header.unsafety { + sd.struct_span_err(i.span, "unsafe functions cannot be used for tests") + .span_label(span, "unsafe because of this") + .emit(); return false; } if sig.header.asyncness.node.is_async() { diff --git a/src/librustc_hir/hir.rs b/src/librustc_hir/hir.rs index 27bca1625c1c1..c2ddaf7df316a 100644 --- a/src/librustc_hir/hir.rs +++ b/src/librustc_hir/hir.rs @@ -19,7 +19,7 @@ use rustc_target::spec::abi::Abi; use syntax::ast::{self, AsmDialect, CrateSugar, Ident, Name, NodeId}; use syntax::ast::{AttrVec, Attribute, FloatTy, IntTy, Label, LitKind, StrStyle, UintTy}; pub use syntax::ast::{BorrowKind, ImplPolarity, IsAuto}; -pub use syntax::ast::{CaptureBy, Constness, Movability, Mutability, Unsafety}; +pub use syntax::ast::{CaptureBy, Movability, Mutability}; use syntax::node_id::NodeMap; use syntax::tokenstream::TokenStream; use syntax::util::parser::ExprPrecedence; @@ -2109,18 +2109,8 @@ impl ImplicitSelfKind { } } -#[derive( - Copy, - Clone, - PartialEq, - Eq, - PartialOrd, - HashStable_Generic, - Ord, - RustcEncodable, - RustcDecodable, - Debug -)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Debug)] +#[derive(HashStable_Generic)] pub enum IsAsync { Async, NotAsync, @@ -2389,6 +2379,38 @@ pub struct Item<'hir> { pub span: Span, } +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] +#[derive(RustcEncodable, RustcDecodable, HashStable_Generic)] +pub enum Unsafety { + Unsafe, + Normal, +} + +impl Unsafety { + pub fn prefix_str(&self) -> &'static str { + match self { + Self::Unsafe => "unsafe ", + Self::Normal => "", + } + } +} + +impl fmt::Display for Unsafety { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(match *self { + Self::Unsafe => "unsafe", + Self::Normal => "normal", + }) + } +} + +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] +#[derive(RustcEncodable, RustcDecodable, HashStable_Generic)] +pub enum Constness { + Const, + NotConst, +} + #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] pub struct FnHeader { pub unsafety: Unsafety, diff --git a/src/librustc_hir/print.rs b/src/librustc_hir/print.rs index 071c3de4b1c2c..b31b814d67be6 100644 --- a/src/librustc_hir/print.rs +++ b/src/librustc_hir/print.rs @@ -648,7 +648,7 @@ impl<'a> State<'a> { self.s.space(); } - if constness == ast::Constness::Const { + if let hir::Constness::Const = constness { self.word_nbsp("const"); } diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs index 3052c9fc26f08..659323d1c2555 100644 --- a/src/librustc_interface/util.rs +++ b/src/librustc_interface/util.rs @@ -668,7 +668,7 @@ impl<'a, 'b> ReplaceBodyWithLoop<'a, 'b> { } fn is_sig_const(sig: &ast::FnSig) -> bool { - sig.header.constness.node == ast::Constness::Const + matches!(sig.header.constness, ast::Const::Yes(_)) || ReplaceBodyWithLoop::should_ignore_fn(&sig.decl.output) } } diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index c827a7f3d5283..93fca43d67c1f 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -258,13 +258,13 @@ impl EarlyLintPass for UnsafeCode { fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) { match it.kind { - ast::ItemKind::Trait(_, ast::Unsafety::Unsafe, ..) => { + ast::ItemKind::Trait(_, ast::Unsafe::Yes(_), ..) => { self.report_unsafe(cx, it.span, |lint| { lint.build("declaration of an `unsafe` trait").emit() }) } - ast::ItemKind::Impl { unsafety: ast::Unsafety::Unsafe, .. } => { + ast::ItemKind::Impl { unsafety: ast::Unsafe::Yes(_), .. } => { self.report_unsafe(cx, it.span, |lint| { lint.build("implementation of an `unsafe` trait").emit() }) @@ -278,7 +278,7 @@ impl EarlyLintPass for UnsafeCode { if let FnKind::Fn( ctxt, _, - ast::FnSig { header: ast::FnHeader { unsafety: ast::Unsafety::Unsafe, .. }, .. }, + ast::FnSig { header: ast::FnHeader { unsafety: ast::Unsafe::Yes(_), .. }, .. }, _, body, ) = fk diff --git a/src/librustc_mir/borrow_check/type_check/mod.rs b/src/librustc_mir/borrow_check/type_check/mod.rs index 100fd7dc48d0e..4cbe41455894b 100644 --- a/src/librustc_mir/borrow_check/type_check/mod.rs +++ b/src/librustc_mir/borrow_check/type_check/mod.rs @@ -32,7 +32,6 @@ use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_index::vec::{Idx, IndexVec}; use rustc_span::{Span, DUMMY_SP}; -use syntax::ast; use crate::dataflow::generic::ResultsCursor; use crate::dataflow::move_paths::MoveData; @@ -1938,7 +1937,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { tcx.mk_substs_trait(ty, &[]), ), }), - ast::Constness::NotConst, + hir::Constness::NotConst, ), ), &traits::SelectionError::Unimplemented, @@ -2579,7 +2578,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { self.prove_predicates( Some(ty::Predicate::Trait( trait_ref.to_poly_trait_ref().to_poly_trait_predicate(), - ast::Constness::NotConst, + hir::Constness::NotConst, )), locations, category, diff --git a/src/librustc_mir/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs index 6a68ccdddffdc..b12f4ce32698f 100644 --- a/src/librustc_mir/transform/qualify_min_const_fn.rs +++ b/src/librustc_mir/transform/qualify_min_const_fn.rs @@ -6,7 +6,6 @@ use rustc_hir::def_id::DefId; use rustc_span::symbol::{sym, Symbol}; use rustc_span::Span; use std::borrow::Cow; -use syntax::ast; type McfResult = Result<(), (Span, Cow<'static, str>)>; @@ -35,7 +34,7 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>) - match pred.skip_binder().self_ty().kind { ty::Param(ref p) => { // Allow `T: ?const Trait` - if *constness == ast::Constness::NotConst + if *constness == hir::Constness::NotConst && feature_allowed(tcx, def_id, sym::const_trait_bound_opt_out) { continue; diff --git a/src/librustc_parse/parser/item.rs b/src/librustc_parse/parser/item.rs index 07d8bae4725bd..a66a85b2b830f 100644 --- a/src/librustc_parse/parser/item.rs +++ b/src/librustc_parse/parser/item.rs @@ -12,7 +12,7 @@ use rustc_span::BytePos; use syntax::ast::{self, AttrKind, AttrStyle, AttrVec, Attribute, Ident, DUMMY_NODE_ID}; use syntax::ast::{AssocItem, AssocItemKind, Item, ItemKind, UseTree, UseTreeKind}; use syntax::ast::{BindingMode, Block, FnDecl, FnSig, Mac, MacArgs, MacDelimiter, Param, SelfKind}; -use syntax::ast::{Constness, Defaultness, Extern, IsAsync, IsAuto, PathSegment, StrLit, Unsafety}; +use syntax::ast::{Const, Defaultness, Extern, IsAsync, IsAuto, PathSegment, StrLit, Unsafe}; use syntax::ast::{EnumDef, Generics, StructField, TraitRef, Ty, TyKind, Variant, VariantData}; use syntax::ast::{FnHeader, ForeignItem, ForeignItemKind, Mutability, Visibility, VisibilityKind}; use syntax::ptr::P; @@ -107,9 +107,9 @@ impl<'a> Parser<'a> { // EXTERN FUNCTION ITEM let fn_span = self.prev_span; let header = FnHeader { - unsafety: Unsafety::Normal, + unsafety: Unsafe::No, asyncness: respan(fn_span, IsAsync::NotAsync), - constness: respan(fn_span, Constness::NotConst), + constness: Const::No, ext: Extern::from_abi(abi), }; return self.parse_item_fn(lo, vis, attrs, header); @@ -128,8 +128,8 @@ impl<'a> Parser<'a> { return self.mk_item_with_info(attrs, lo, vis, info); } - if self.eat_keyword(kw::Const) { - let const_span = self.prev_span; + let constness = self.parse_constness(); + if let Const::Yes(const_span) = constness { if [kw::Fn, kw::Unsafe, kw::Extern].iter().any(|k| self.check_keyword(*k)) { // CONST FUNCTION ITEM let unsafety = self.parse_unsafety(); @@ -143,7 +143,7 @@ impl<'a> Parser<'a> { let header = FnHeader { unsafety, asyncness: respan(const_span, IsAsync::NotAsync), - constness: respan(const_span, Constness::Const), + constness, ext, }; return self.parse_item_fn(lo, vis, attrs, header); @@ -175,7 +175,6 @@ impl<'a> Parser<'a> { self.bump(); // `async` let unsafety = self.parse_unsafety(); // `unsafe`? self.expect_keyword(kw::Fn)?; // `fn` - let fn_span = self.prev_span; let asyncness = respan( async_span, IsAsync::Async { @@ -184,20 +183,16 @@ impl<'a> Parser<'a> { }, ); self.ban_async_in_2015(async_span); - let header = FnHeader { - unsafety, - asyncness, - constness: respan(fn_span, Constness::NotConst), - ext: Extern::None, - }; + let header = + FnHeader { unsafety, asyncness, constness: Const::No, ext: Extern::None }; return self.parse_item_fn(lo, vis, attrs, header); } } if self.check_keyword(kw::Unsafe) && self.is_keyword_ahead(1, &[kw::Trait, kw::Auto]) { // UNSAFE TRAIT ITEM - self.bump(); // `unsafe` - let info = self.parse_item_trait(lo, Unsafety::Unsafe)?; + let unsafety = self.parse_unsafety(); + let info = self.parse_item_trait(lo, unsafety)?; return self.mk_item_with_info(attrs, lo, vis, info); } @@ -218,9 +213,9 @@ impl<'a> Parser<'a> { self.bump(); let fn_span = self.prev_span; let header = FnHeader { - unsafety: Unsafety::Normal, + unsafety: Unsafe::No, asyncness: respan(fn_span, IsAsync::NotAsync), - constness: respan(fn_span, Constness::NotConst), + constness: Const::No, ext: Extern::None, }; return self.parse_item_fn(lo, vis, attrs, header); @@ -230,16 +225,16 @@ impl<'a> Parser<'a> { && self.look_ahead(1, |t| *t != token::OpenDelim(token::Brace)) { // UNSAFE FUNCTION ITEM - self.bump(); // `unsafe` + let unsafety = self.parse_unsafety(); // `{` is also expected after `unsafe`; in case of error, include it in the diagnostic. self.check(&token::OpenDelim(token::Brace)); let ext = self.parse_extern()?; self.expect_keyword(kw::Fn)?; let fn_span = self.prev_span; let header = FnHeader { - unsafety: Unsafety::Unsafe, + unsafety, asyncness: respan(fn_span, IsAsync::NotAsync), - constness: respan(fn_span, Constness::NotConst), + constness: Const::No, ext, }; return self.parse_item_fn(lo, vis, attrs, header); @@ -268,7 +263,7 @@ impl<'a> Parser<'a> { || (self.check_keyword(kw::Auto) && self.is_keyword_ahead(1, &[kw::Trait])) { // TRAIT ITEM - let info = self.parse_item_trait(lo, Unsafety::Normal)?; + let info = self.parse_item_trait(lo, Unsafe::No)?; return self.mk_item_with_info(attrs, lo, vis, info); } @@ -547,7 +542,7 @@ impl<'a> Parser<'a> { /// `impl` GENERICS `const`? `!`? TYPE (`where` PREDICATES)? `{` BODY `}` fn parse_item_impl( &mut self, - unsafety: Unsafety, + unsafety: Unsafe, defaultness: Defaultness, ) -> PResult<'a, ItemInfo> { // First, parse generic parameters if necessary. @@ -561,13 +556,10 @@ impl<'a> Parser<'a> { generics }; - let constness = if self.eat_keyword(kw::Const) { - let span = self.prev_span; + let constness = self.parse_constness(); + if let Const::Yes(span) = constness { self.sess.gated_spans.gate(sym::const_trait_impl, span); - Constness::Const - } else { - Constness::NotConst - }; + } // Disambiguate `impl !Trait for Type { ... }` and `impl ! { ... }` for the never type. let polarity = if self.check(&token::Not) && self.look_ahead(1, |t| t.can_begin_type()) { @@ -707,7 +699,7 @@ impl<'a> Parser<'a> { } /// Parses `auto? trait Foo { ... }` or `trait Foo = Bar;`. - fn parse_item_trait(&mut self, lo: Span, unsafety: Unsafety) -> PResult<'a, ItemInfo> { + fn parse_item_trait(&mut self, lo: Span, unsafety: Unsafe) -> PResult<'a, ItemInfo> { // Parse optional `auto` prefix. let is_auto = if self.eat_keyword(kw::Auto) { IsAuto::Yes } else { IsAuto::No }; @@ -734,11 +726,11 @@ impl<'a> Parser<'a> { self.expect_semi()?; let whole_span = lo.to(self.prev_span); - if is_auto == IsAuto::Yes { + if let IsAuto::Yes = is_auto { let msg = "trait aliases cannot be `auto`"; self.struct_span_err(whole_span, msg).span_label(whole_span, msg).emit(); } - if unsafety != Unsafety::Normal { + if let Unsafe::Yes(_) = unsafety { let msg = "trait aliases cannot be `unsafe`"; self.struct_span_err(whole_span, msg).span_label(whole_span, msg).emit(); } @@ -1785,28 +1777,27 @@ impl<'a> Parser<'a> { Ok(body) } - /// Parses all the "front matter" for a `fn` declaration, up to - /// and including the `fn` keyword: + /// Parses all the "front matter" (or "qualifiers") for a `fn` declaration, + /// up to and including the `fn` keyword. The formal grammar is: /// - /// - `const fn` - /// - `unsafe fn` - /// - `const unsafe fn` - /// - `extern fn` - /// - etc. + /// ``` + /// Extern = "extern" StringLit ; + /// FnQual = "const"? "async"? "unsafe"? Extern? ; + /// FnFrontMatter = FnQual? "fn" ; + /// ``` fn parse_fn_front_matter(&mut self) -> PResult<'a, FnHeader> { - let is_const_fn = self.eat_keyword(kw::Const); - let const_span = self.prev_span; + let constness = self.parse_constness(); let asyncness = self.parse_asyncness(); if let IsAsync::Async { .. } = asyncness { self.ban_async_in_2015(self.prev_span); } let asyncness = respan(self.prev_span, asyncness); let unsafety = self.parse_unsafety(); - let (constness, unsafety, ext) = if is_const_fn { - (respan(const_span, Constness::Const), unsafety, Extern::None) + let (constness, unsafety, ext) = if let Const::Yes(_) = constness { + (constness, unsafety, Extern::None) } else { let ext = self.parse_extern()?; - (respan(self.prev_span, Constness::NotConst), unsafety, ext) + (Const::No, unsafety, ext) }; if !self.eat_keyword(kw::Fn) { // It is possible for `expect_one_of` to recover given the contents of diff --git a/src/librustc_parse/parser/mod.rs b/src/librustc_parse/parser/mod.rs index e1461dbb8e763..bccf5968118b4 100644 --- a/src/librustc_parse/parser/mod.rs +++ b/src/librustc_parse/parser/mod.rs @@ -22,7 +22,8 @@ use rustc_session::parse::ParseSess; use rustc_span::source_map::respan; use rustc_span::symbol::{kw, sym, Symbol}; use rustc_span::{FileName, Span, DUMMY_SP}; -use syntax::ast::{self, AttrStyle, AttrVec, CrateSugar, Extern, Ident, Unsafety, DUMMY_NODE_ID}; +use syntax::ast::DUMMY_NODE_ID; +use syntax::ast::{self, AttrStyle, AttrVec, Const, CrateSugar, Extern, Ident, Unsafe}; use syntax::ast::{IsAsync, MacArgs, MacDelimiter, Mutability, StrLit, Visibility, VisibilityKind}; use syntax::ptr::P; use syntax::token::{self, DelimToken, Token, TokenKind}; @@ -962,8 +963,13 @@ impl<'a> Parser<'a> { } /// Parses unsafety: `unsafe` or nothing. - fn parse_unsafety(&mut self) -> Unsafety { - if self.eat_keyword(kw::Unsafe) { Unsafety::Unsafe } else { Unsafety::Normal } + fn parse_unsafety(&mut self) -> Unsafe { + if self.eat_keyword(kw::Unsafe) { Unsafe::Yes(self.prev_span) } else { Unsafe::No } + } + + /// Parses constness: `const` or nothing. + fn parse_constness(&mut self) -> Const { + if self.eat_keyword(kw::Const) { Const::Yes(self.prev_span) } else { Const::No } } /// Parses mutability (`mut` or nothing). diff --git a/src/librustc_save_analysis/sig.rs b/src/librustc_save_analysis/sig.rs index 6401cabdcd5c1..820202c85ab87 100644 --- a/src/librustc_save_analysis/sig.rs +++ b/src/librustc_save_analysis/sig.rs @@ -225,7 +225,7 @@ impl Sig for ast::Ty { text.push('>'); } - if f.unsafety == ast::Unsafety::Unsafe { + if let ast::Unsafe::Yes(_) = f.unsafety { text.push_str("unsafe "); } push_extern(&mut text, f.ext); @@ -365,13 +365,13 @@ impl Sig for ast::Item { } ast::ItemKind::Fn(ast::FnSig { ref decl, header }, ref generics, _) => { let mut text = String::new(); - if header.constness.node == ast::Constness::Const { + if let ast::Const::Yes(_) = header.constness { text.push_str("const "); } if header.asyncness.node.is_async() { text.push_str("async "); } - if header.unsafety == ast::Unsafety::Unsafe { + if let ast::Unsafe::Yes(_) = header.unsafety { text.push_str("unsafe "); } push_extern(&mut text, header.ext); @@ -453,7 +453,7 @@ impl Sig for ast::Item { text.push_str("auto "); } - if unsafety == ast::Unsafety::Unsafe { + if let ast::Unsafe::Yes(_) = unsafety { text.push_str("unsafe "); } text.push_str("trait "); @@ -496,11 +496,11 @@ impl Sig for ast::Item { if let ast::Defaultness::Default = defaultness { text.push_str("default "); } - if unsafety == ast::Unsafety::Unsafe { + if let ast::Unsafe::Yes(_) = unsafety { text.push_str("unsafe "); } text.push_str("impl"); - if constness == ast::Constness::Const { + if let ast::Const::Yes(_) = constness { text.push_str(" const"); } @@ -884,13 +884,13 @@ fn make_method_signature( ) -> Result { // FIXME code dup with function signature let mut text = String::new(); - if m.header.constness.node == ast::Constness::Const { + if let ast::Const::Yes(_) = m.header.constness { text.push_str("const "); } if m.header.asyncness.node.is_async() { text.push_str("async "); } - if m.header.unsafety == ast::Unsafety::Unsafe { + if let ast::Unsafe::Yes(_) = m.header.unsafety { text.push_str("unsafe "); } push_extern(&mut text, m.header.ext); diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index c26b47c313023..0e7c10541cad7 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -28,12 +28,12 @@ use rustc_hir::def::{CtorOf, DefKind, Res}; use rustc_hir::def_id::DefId; use rustc_hir::intravisit::Visitor; use rustc_hir::print; -use rustc_hir::{ExprKind, GenericArg, GenericArgs}; +use rustc_hir::{Constness, ExprKind, GenericArg, GenericArgs}; use rustc_span::symbol::sym; use rustc_span::{MultiSpan, Span, DUMMY_SP}; use rustc_target::spec::abi; use smallvec::SmallVec; -use syntax::ast::{self, Constness}; +use syntax::ast; use syntax::util::lev_distance::find_best_match_for_name; use std::collections::BTreeSet; @@ -1502,7 +1502,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { .filter(|(trait_ref, _, _)| !tcx.trait_is_auto(trait_ref.def_id())); for (base_trait_ref, span, constness) in regular_traits_refs_spans { - assert_eq!(constness, ast::Constness::NotConst); + assert_eq!(constness, Constness::NotConst); for trait_ref in traits::elaborate_trait_ref(tcx, base_trait_ref) { debug!( diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index fd0c994a6eadf..a825856e38aa0 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -2693,13 +2693,13 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> { None } - fn default_constness_for_trait_bounds(&self) -> ast::Constness { + fn default_constness_for_trait_bounds(&self) -> hir::Constness { // FIXME: refactor this into a method let node = self.tcx.hir().get(self.body_id); if let Some(fn_like) = FnLikeNode::from_node(node) { fn_like.constness() } else { - ast::Constness::NotConst + hir::Constness::NotConst } } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index f3a1f412d0d59..5349c324ad8a7 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -300,11 +300,11 @@ impl AstConv<'tcx> for ItemCtxt<'tcx> { Some(self.item_def_id) } - fn default_constness_for_trait_bounds(&self) -> ast::Constness { + fn default_constness_for_trait_bounds(&self) -> hir::Constness { if let Some(fn_like) = FnLikeNode::from_node(self.node()) { fn_like.constness() } else { - ast::Constness::NotConst + hir::Constness::NotConst } } @@ -2429,7 +2429,7 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat match bound { &hir::GenericBound::Trait(ref poly_trait_ref, modifier) => { let constness = match modifier { - hir::TraitBoundModifier::MaybeConst => ast::Constness::NotConst, + hir::TraitBoundModifier::MaybeConst => hir::Constness::NotConst, hir::TraitBoundModifier::None => constness, hir::TraitBoundModifier::Maybe => bug!("this wasn't handled"), }; @@ -2617,13 +2617,13 @@ fn predicates_from_bound<'tcx>( astconv: &dyn AstConv<'tcx>, param_ty: Ty<'tcx>, bound: &'tcx hir::GenericBound<'tcx>, - constness: ast::Constness, + constness: hir::Constness, ) -> Vec<(ty::Predicate<'tcx>, Span)> { match *bound { hir::GenericBound::Trait(ref tr, modifier) => { let constness = match modifier { hir::TraitBoundModifier::Maybe => return vec![], - hir::TraitBoundModifier::MaybeConst => ast::Constness::NotConst, + hir::TraitBoundModifier::MaybeConst => hir::Constness::NotConst, hir::TraitBoundModifier::None => constness, }; diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 474868f0dd6c4..067b33c144742 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -377,7 +377,7 @@ pub fn hir_trait_to_predicates<'tcx>( &item_cx, hir_trait, DUMMY_SP, - syntax::ast::Constness::NotConst, + hir::Constness::NotConst, tcx.types.err, &mut bounds, true, diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index 218674b757f39..744201a00500b 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -203,7 +203,7 @@ pub struct Impl<'hir> { pub unsafety: hir::Unsafety, pub polarity: hir::ImplPolarity, pub defaultness: hir::Defaultness, - pub constness: ast::Constness, + pub constness: hir::Constness, pub generics: &'hir hir::Generics<'hir>, pub trait_: &'hir Option>, pub for_: &'hir hir::Ty<'hir>, diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index b22406124e098..a7142dfda8593 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1863,7 +1863,7 @@ pub struct Ty { #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct BareFnTy { - pub unsafety: Unsafety, + pub unsafety: Unsafe, pub ext: Extern, pub generic_params: Vec, pub decl: P, @@ -2101,43 +2101,11 @@ pub enum IsAuto { No, } -#[derive( - Copy, - Clone, - PartialEq, - Eq, - PartialOrd, - Ord, - Hash, - RustcEncodable, - RustcDecodable, - Debug, - HashStable_Generic -)] -pub enum Unsafety { - Unsafe, - Normal, -} - -impl Unsafety { - pub fn prefix_str(&self) -> &'static str { - match self { - Unsafety::Unsafe => "unsafe ", - Unsafety::Normal => "", - } - } -} - -impl fmt::Display for Unsafety { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - fmt::Display::fmt( - match *self { - Unsafety::Normal => "normal", - Unsafety::Unsafe => "unsafe", - }, - f, - ) - } +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Debug)] +#[derive(HashStable_Generic)] +pub enum Unsafe { + Yes(Span), + No, } #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug)] @@ -2162,9 +2130,9 @@ impl IsAsync { #[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)] #[derive(HashStable_Generic)] -pub enum Constness { - Const, - NotConst, +pub enum Const { + Yes(Span), + No, } /// Item defaultness. @@ -2527,9 +2495,9 @@ impl Extern { /// included in this struct (e.g., `async unsafe fn` or `const extern "C" fn`). #[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug)] pub struct FnHeader { - pub unsafety: Unsafety, + pub unsafety: Unsafe, pub asyncness: Spanned, - pub constness: Spanned, + pub constness: Const, pub ext: Extern, } @@ -2537,9 +2505,9 @@ impl FnHeader { /// Does this function header have any qualifiers or is it empty? pub fn has_qualifiers(&self) -> bool { let Self { unsafety, asyncness, constness, ext } = self; - matches!(unsafety, Unsafety::Unsafe) + matches!(unsafety, Unsafe::Yes(_)) || asyncness.node.is_async() - || matches!(constness.node, Constness::Const) + || matches!(constness, Const::Yes(_)) || !matches!(ext, Extern::None) } } @@ -2547,9 +2515,9 @@ impl FnHeader { impl Default for FnHeader { fn default() -> FnHeader { FnHeader { - unsafety: Unsafety::Normal, + unsafety: Unsafe::No, asyncness: dummy_spanned(IsAsync::NotAsync), - constness: dummy_spanned(Constness::NotConst), + constness: Const::No, ext: Extern::None, } } @@ -2606,7 +2574,7 @@ pub enum ItemKind { /// A trait declaration (`trait`). /// /// E.g., `trait Foo { .. }`, `trait Foo { .. }` or `auto trait Foo {}`. - Trait(IsAuto, Unsafety, Generics, GenericBounds, Vec>), + Trait(IsAuto, Unsafe, Generics, GenericBounds, Vec>), /// Trait alias /// /// E.g., `trait Foo = Bar + Quux;`. @@ -2615,10 +2583,10 @@ pub enum ItemKind { /// /// E.g., `impl Foo { .. }` or `impl Trait for Foo { .. }`. Impl { - unsafety: Unsafety, + unsafety: Unsafe, polarity: ImplPolarity, defaultness: Defaultness, - constness: Constness, + constness: Const, generics: Generics, /// The trait being implemented, if any. diff --git a/src/test/ui/coherence/coherence-negative-impls-safe.stderr b/src/test/ui/coherence/coherence-negative-impls-safe.stderr index c47c9d25e3614..4db66af6783ca 100644 --- a/src/test/ui/coherence/coherence-negative-impls-safe.stderr +++ b/src/test/ui/coherence/coherence-negative-impls-safe.stderr @@ -2,7 +2,9 @@ error[E0198]: negative impls cannot be unsafe --> $DIR/coherence-negative-impls-safe.rs:7:1 | LL | unsafe impl !Send for TestType {} - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ------^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | unsafe because of this error: aborting due to previous error diff --git a/src/test/ui/const-generics/const-fn-with-const-param.stderr b/src/test/ui/const-generics/const-fn-with-const-param.stderr index 3437ed33d0c6f..68670963f8e5e 100644 --- a/src/test/ui/const-generics/const-fn-with-const-param.stderr +++ b/src/test/ui/const-generics/const-fn-with-const-param.stderr @@ -1,7 +1,11 @@ error: const parameters are not permitted in `const fn` --> $DIR/const-fn-with-const-param.rs:4:1 | -LL | / const fn const_u32_identity() -> u32 { +LL | const fn const_u32_identity() -> u32 { + | ^---- + | | + | _`const fn` because of this + | | LL | | LL | | X LL | | } diff --git a/src/test/ui/error-codes/E0197.stderr b/src/test/ui/error-codes/E0197.stderr index bb7b6474d3e38..51ed9c83bc999 100644 --- a/src/test/ui/error-codes/E0197.stderr +++ b/src/test/ui/error-codes/E0197.stderr @@ -2,7 +2,9 @@ error[E0197]: inherent impls cannot be unsafe --> $DIR/E0197.rs:3:1 | LL | unsafe impl Foo { } - | ^^^^^^^^^^^^^^^^^^^ + | ------^^^^^^^^^^^^^ + | | + | unsafe because of this error: aborting due to previous error diff --git a/src/test/ui/error-codes/E0198.stderr b/src/test/ui/error-codes/E0198.stderr index 0d3706336a9ca..90e8b4abd1296 100644 --- a/src/test/ui/error-codes/E0198.stderr +++ b/src/test/ui/error-codes/E0198.stderr @@ -2,7 +2,9 @@ error[E0198]: negative impls cannot be unsafe --> $DIR/E0198.rs:5:1 | LL | unsafe impl !Send for Foo { } - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ------^^^^^^^^^^^^^^^^^^^^^^^ + | | + | unsafe because of this error: aborting due to previous error diff --git a/src/test/ui/rfc-2632-const-trait-impl/feature-gate.gated.stderr b/src/test/ui/rfc-2632-const-trait-impl/feature-gate.gated.stderr index b196f9ef57380..061af3c94b44d 100644 --- a/src/test/ui/rfc-2632-const-trait-impl/feature-gate.gated.stderr +++ b/src/test/ui/rfc-2632-const-trait-impl/feature-gate.gated.stderr @@ -2,7 +2,9 @@ error: const trait impls are not yet implemented --> $DIR/feature-gate.rs:9:1 | LL | impl const T for S {} - | ^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^-----^^^^^^^^^^^ + | | + | const because of this error: aborting due to previous error diff --git a/src/test/ui/rfc-2632-const-trait-impl/feature-gate.stock.stderr b/src/test/ui/rfc-2632-const-trait-impl/feature-gate.stock.stderr index 6e1cdde084396..cfe226ea7a7ce 100644 --- a/src/test/ui/rfc-2632-const-trait-impl/feature-gate.stock.stderr +++ b/src/test/ui/rfc-2632-const-trait-impl/feature-gate.stock.stderr @@ -11,7 +11,9 @@ error: const trait impls are not yet implemented --> $DIR/feature-gate.rs:9:1 | LL | impl const T for S {} - | ^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^-----^^^^^^^^^^^ + | | + | const because of this error: aborting due to 2 previous errors diff --git a/src/test/ui/rfc-2632-const-trait-impl/inherent-impl.stderr b/src/test/ui/rfc-2632-const-trait-impl/inherent-impl.stderr index 508c6f4c747e1..bdc95ff2a57b5 100644 --- a/src/test/ui/rfc-2632-const-trait-impl/inherent-impl.stderr +++ b/src/test/ui/rfc-2632-const-trait-impl/inherent-impl.stderr @@ -2,7 +2,9 @@ error: inherent impls cannot be `const` --> $DIR/inherent-impl.rs:9:1 | LL | impl const S {} - | ^^^^^^^^^^^^^^^ + | ^^^^^-----^^^^^ + | | + | `const` because of this | = note: only trait implementations may be annotated with `const` @@ -10,7 +12,9 @@ error: inherent impls cannot be `const` --> $DIR/inherent-impl.rs:13:1 | LL | impl const T {} - | ^^^^^^^^^^^^^^^ + | ^^^^^-----^^^^^ + | | + | `const` because of this | = note: only trait implementations may be annotated with `const` @@ -18,13 +22,17 @@ error: const trait impls are not yet implemented --> $DIR/inherent-impl.rs:9:1 | LL | impl const S {} - | ^^^^^^^^^^^^^^^ + | ^^^^^-----^^^^^ + | | + | const because of this error: const trait impls are not yet implemented --> $DIR/inherent-impl.rs:13:1 | LL | impl const T {} - | ^^^^^^^^^^^^^^^ + | ^^^^^-----^^^^^ + | | + | const because of this error: aborting due to 4 previous errors diff --git a/src/test/ui/syntax-trait-polarity.stderr b/src/test/ui/syntax-trait-polarity.stderr index b66db9feedbdc..fef3a65088855 100644 --- a/src/test/ui/syntax-trait-polarity.stderr +++ b/src/test/ui/syntax-trait-polarity.stderr @@ -8,7 +8,9 @@ error[E0198]: negative impls cannot be unsafe --> $DIR/syntax-trait-polarity.rs:12:1 | LL | unsafe impl !Send for TestType {} - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ------^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | unsafe because of this error: inherent impls cannot be negative --> $DIR/syntax-trait-polarity.rs:19:1 @@ -20,7 +22,9 @@ error[E0198]: negative impls cannot be unsafe --> $DIR/syntax-trait-polarity.rs:22:1 | LL | unsafe impl !Send for TestType2 {} - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | unsafe because of this error[E0192]: negative impls are only allowed for auto traits (e.g., `Send` and `Sync`) --> $DIR/syntax-trait-polarity.rs:14:1 diff --git a/src/test/ui/traits/trait-safety-inherent-impl.stderr b/src/test/ui/traits/trait-safety-inherent-impl.stderr index 3911261083ecc..c398785d3949e 100644 --- a/src/test/ui/traits/trait-safety-inherent-impl.stderr +++ b/src/test/ui/traits/trait-safety-inherent-impl.stderr @@ -1,7 +1,11 @@ error[E0197]: inherent impls cannot be unsafe --> $DIR/trait-safety-inherent-impl.rs:5:1 | -LL | / unsafe impl SomeStruct { +LL | unsafe impl SomeStruct { + | ^----- + | | + | _unsafe because of this + | | LL | | fn foo(self) { } LL | | } | |_^ From c30f068dc8b2ef58678b9846ba834dd6dea3fe44 Mon Sep 17 00:00:00 2001 From: Mazdak Farrokhzad Date: Thu, 30 Jan 2020 05:31:04 +0100 Subject: [PATCH 02/13] IsAsync -> enum Async { Yes { span: Span, .. }, No } use new span for better diagnostics. --- src/librustc_ast_lowering/expr.rs | 2 +- src/librustc_ast_lowering/item.rs | 27 +++++------- src/librustc_ast_passes/ast_validation.rs | 12 ++--- src/librustc_ast_pretty/pprust.rs | 4 +- src/librustc_builtin_macros/test.rs | 6 ++- src/librustc_expand/build.rs | 4 +- src/librustc_parse/parser/expr.rs | 4 +- src/librustc_parse/parser/item.rs | 44 ++++--------------- src/librustc_parse/parser/mod.rs | 9 ++-- src/librustc_resolve/def_collector.rs | 12 ++--- src/librustc_resolve/late.rs | 2 +- src/librustc_save_analysis/dump_visitor.rs | 8 ++-- src/librustc_save_analysis/sig.rs | 4 +- src/libsyntax/ast.rs | 26 +++++------ src/libsyntax/mut_visit.rs | 10 ++--- src/test/ui-fulldeps/pprust-expr-roundtrip.rs | 2 +- src/test/ui/async-await/async-trait-fn.stderr | 8 +++- .../edition-deny-async-fns-2015.stderr | 4 +- .../ui/parser/fn-header-semantic-fail.stderr | 16 +++++-- 19 files changed, 96 insertions(+), 108 deletions(-) diff --git a/src/librustc_ast_lowering/expr.rs b/src/librustc_ast_lowering/expr.rs index dd3316979f6a2..b51d476558312 100644 --- a/src/librustc_ast_lowering/expr.rs +++ b/src/librustc_ast_lowering/expr.rs @@ -106,7 +106,7 @@ impl<'hir> LoweringContext<'_, 'hir> { ref body, fn_decl_span, ) => { - if let IsAsync::Async { closure_id, .. } = asyncness { + if let Async::Yes { closure_id, .. } = asyncness { self.lower_expr_async_closure( capture_clause, closure_id, diff --git a/src/librustc_ast_lowering/item.rs b/src/librustc_ast_lowering/item.rs index 8cc3479dd1ba3..73a25620b5a04 100644 --- a/src/librustc_ast_lowering/item.rs +++ b/src/librustc_ast_lowering/item.rs @@ -299,7 +299,7 @@ impl<'hir> LoweringContext<'_, 'hir> { // `impl Future` here because lower_body // only cares about the input argument patterns in the function // declaration (decl), not the return types. - let asyncness = header.asyncness.node; + let asyncness = header.asyncness; let body_id = this.lower_maybe_async_body(span, &decl, asyncness, body.as_deref()); @@ -836,19 +836,16 @@ impl<'hir> LoweringContext<'_, 'hir> { } AssocItemKind::Fn(ref sig, ref body) => { self.current_item = Some(i.span); - let body_id = self.lower_maybe_async_body( - i.span, - &sig.decl, - sig.header.asyncness.node, - body.as_deref(), - ); + let asyncness = sig.header.asyncness; + let body_id = + self.lower_maybe_async_body(i.span, &sig.decl, asyncness, body.as_deref()); let impl_trait_return_allow = !self.is_in_trait_impl; let (generics, sig) = self.lower_method_sig( &i.generics, sig, impl_item_def_id, impl_trait_return_allow, - sig.header.asyncness.node.opt_return_id(), + asyncness.opt_return_id(), ); (generics, hir::ImplItemKind::Method(sig, body_id)) @@ -1033,12 +1030,12 @@ impl<'hir> LoweringContext<'_, 'hir> { &mut self, span: Span, decl: &FnDecl, - asyncness: IsAsync, + asyncness: Async, body: Option<&Block>, ) -> hir::BodyId { let closure_id = match asyncness { - IsAsync::Async { closure_id, .. } => closure_id, - IsAsync::NotAsync => return self.lower_fn_body_block(span, decl, body), + Async::Yes { closure_id, .. } => closure_id, + Async::No => return self.lower_fn_body_block(span, decl, body), }; self.lower_body(|this| { @@ -1248,7 +1245,7 @@ impl<'hir> LoweringContext<'_, 'hir> { fn lower_fn_header(&mut self, h: FnHeader) -> hir::FnHeader { hir::FnHeader { unsafety: self.lower_unsafety(h.unsafety), - asyncness: self.lower_asyncness(h.asyncness.node), + asyncness: self.lower_asyncness(h.asyncness), constness: self.lower_constness(h.constness), abi: self.lower_extern(h.ext), } @@ -1276,10 +1273,10 @@ impl<'hir> LoweringContext<'_, 'hir> { .emit(); } - fn lower_asyncness(&mut self, a: IsAsync) -> hir::IsAsync { + fn lower_asyncness(&mut self, a: Async) -> hir::IsAsync { match a { - IsAsync::Async { .. } => hir::IsAsync::Async, - IsAsync::NotAsync => hir::IsAsync::NotAsync, + Async::Yes { .. } => hir::IsAsync::Async, + Async::No => hir::IsAsync::NotAsync, } } diff --git a/src/librustc_ast_passes/ast_validation.rs b/src/librustc_ast_passes/ast_validation.rs index de4f092dbf011..e0217de1d3b8d 100644 --- a/src/librustc_ast_passes/ast_validation.rs +++ b/src/librustc_ast_passes/ast_validation.rs @@ -221,13 +221,13 @@ impl<'a> AstValidator<'a> { } } - fn check_trait_fn_not_async(&self, span: Span, asyncness: IsAsync) { - if asyncness.is_async() { - struct_span_err!(self.session, span, E0706, "trait fns cannot be declared `async`") + fn check_trait_fn_not_async(&self, fn_span: Span, asyncness: Async) { + if let Async::Yes { span, .. } = asyncness { + struct_span_err!(self.session, fn_span, E0706, "trait fns cannot be declared `async`") + .span_label(span, "`async` because of this") .note("`async` trait functions are not currently supported") .note( - "consider using the `async-trait` crate: \ - https://crates.io/crates/async-trait", + "consider using the `async-trait` crate: https://crates.io/crates/async-trait", ) .emit(); } @@ -1144,7 +1144,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> { self.invalid_visibility(&item.vis, None); if let AssocItemKind::Fn(sig, _) = &item.kind { self.check_trait_fn_not_const(sig.header.constness); - self.check_trait_fn_not_async(item.span, sig.header.asyncness.node); + self.check_trait_fn_not_async(item.span, sig.header.asyncness); } } diff --git a/src/librustc_ast_pretty/pprust.rs b/src/librustc_ast_pretty/pprust.rs index 633964683dcc6..b1fa818d0a8cf 100644 --- a/src/librustc_ast_pretty/pprust.rs +++ b/src/librustc_ast_pretty/pprust.rs @@ -2449,7 +2449,7 @@ impl<'a> State<'a> { } } - crate fn print_asyncness(&mut self, asyncness: ast::IsAsync) { + crate fn print_asyncness(&mut self, asyncness: ast::Async) { if asyncness.is_async() { self.word_nbsp("async"); } @@ -2734,7 +2734,7 @@ impl<'a> State<'a> { self.s.word(visibility_qualified(vis, "")); self.print_constness(header.constness); - self.print_asyncness(header.asyncness.node); + self.print_asyncness(header.asyncness); self.print_unsafety(header.unsafety); match header.ext { diff --git a/src/librustc_builtin_macros/test.rs b/src/librustc_builtin_macros/test.rs index dd93596b3cfce..a246e11495345 100644 --- a/src/librustc_builtin_macros/test.rs +++ b/src/librustc_builtin_macros/test.rs @@ -381,8 +381,10 @@ fn has_test_signature(cx: &ExtCtxt<'_>, i: &ast::Item) -> bool { .emit(); return false; } - if sig.header.asyncness.node.is_async() { - sd.span_err(i.span, "async functions cannot be used for tests"); + if let ast::Async::Yes { span, .. } = sig.header.asyncness { + sd.struct_span_err(i.span, "async functions cannot be used for tests") + .span_label(span, "async because of this") + .emit(); return false; } diff --git a/src/librustc_expand/build.rs b/src/librustc_expand/build.rs index 11f94ab2e6279..af22e46eb6afa 100644 --- a/src/librustc_expand/build.rs +++ b/src/librustc_expand/build.rs @@ -507,7 +507,7 @@ impl<'a> ExtCtxt<'a> { span, ast::ExprKind::Closure( ast::CaptureBy::Ref, - ast::IsAsync::NotAsync, + ast::Async::No, ast::Movability::Movable, fn_decl, body, @@ -530,7 +530,7 @@ impl<'a> ExtCtxt<'a> { span, ast::ExprKind::Closure( ast::CaptureBy::Ref, - ast::IsAsync::NotAsync, + ast::Async::No, ast::Movability::Movable, fn_decl, body, diff --git a/src/librustc_parse/parser/expr.rs b/src/librustc_parse/parser/expr.rs index 77748d16653a7..5a4225ece65aa 100644 --- a/src/librustc_parse/parser/expr.rs +++ b/src/librustc_parse/parser/expr.rs @@ -13,7 +13,7 @@ use syntax::ast::{self, AttrStyle, AttrVec, CaptureBy, Field, Ident, Lit, DUMMY_ use syntax::ast::{ AnonConst, BinOp, BinOpKind, FnDecl, FunctionRetTy, Mac, Param, Ty, TyKind, UnOp, }; -use syntax::ast::{Arm, BlockCheckMode, Expr, ExprKind, IsAsync, Label, Movability, RangeLimits}; +use syntax::ast::{Arm, Async, BlockCheckMode, Expr, ExprKind, Label, Movability, RangeLimits}; use syntax::ptr::P; use syntax::token::{self, Token, TokenKind}; use syntax::util::classify; @@ -1348,7 +1348,7 @@ impl<'a> Parser<'a> { if self.eat_keyword(kw::Static) { Movability::Static } else { Movability::Movable }; let asyncness = - if self.token.span.rust_2018() { self.parse_asyncness() } else { IsAsync::NotAsync }; + if self.token.span.rust_2018() { self.parse_asyncness() } else { Async::No }; if asyncness.is_async() { // Feature-gate `async ||` closures. self.sess.gated_spans.gate(sym::async_closure, self.prev_span); diff --git a/src/librustc_parse/parser/item.rs b/src/librustc_parse/parser/item.rs index a66a85b2b830f..aa43c15e286ed 100644 --- a/src/librustc_parse/parser/item.rs +++ b/src/librustc_parse/parser/item.rs @@ -6,13 +6,13 @@ use crate::maybe_whole; use rustc_ast_pretty::pprust; use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, PResult, StashKey}; -use rustc_span::source_map::{self, respan, Span}; +use rustc_span::source_map::{self, Span}; use rustc_span::symbol::{kw, sym, Symbol}; use rustc_span::BytePos; use syntax::ast::{self, AttrKind, AttrStyle, AttrVec, Attribute, Ident, DUMMY_NODE_ID}; use syntax::ast::{AssocItem, AssocItemKind, Item, ItemKind, UseTree, UseTreeKind}; +use syntax::ast::{Async, Const, Defaultness, Extern, IsAuto, PathSegment, StrLit, Unsafe}; use syntax::ast::{BindingMode, Block, FnDecl, FnSig, Mac, MacArgs, MacDelimiter, Param, SelfKind}; -use syntax::ast::{Const, Defaultness, Extern, IsAsync, IsAuto, PathSegment, StrLit, Unsafe}; use syntax::ast::{EnumDef, Generics, StructField, TraitRef, Ty, TyKind, Variant, VariantData}; use syntax::ast::{FnHeader, ForeignItem, ForeignItemKind, Mutability, Visibility, VisibilityKind}; use syntax::ptr::P; @@ -105,10 +105,9 @@ impl<'a> Parser<'a> { if self.eat_keyword(kw::Fn) { // EXTERN FUNCTION ITEM - let fn_span = self.prev_span; let header = FnHeader { unsafety: Unsafe::No, - asyncness: respan(fn_span, IsAsync::NotAsync), + asyncness: Async::No, constness: Const::No, ext: Extern::from_abi(abi), }; @@ -140,12 +139,7 @@ impl<'a> Parser<'a> { let ext = self.parse_extern()?; self.expect_keyword(kw::Fn)?; - let header = FnHeader { - unsafety, - asyncness: respan(const_span, IsAsync::NotAsync), - constness, - ext, - }; + let header = FnHeader { unsafety, asyncness: Async::No, constness, ext }; return self.parse_item_fn(lo, vis, attrs, header); } @@ -172,16 +166,9 @@ impl<'a> Parser<'a> { let async_span = self.token.span; if self.is_keyword_ahead(1, &[kw::Fn]) || self.is_keyword_ahead(2, &[kw::Fn]) { // ASYNC FUNCTION ITEM - self.bump(); // `async` + let asyncness = self.parse_asyncness(); // `async` let unsafety = self.parse_unsafety(); // `unsafe`? self.expect_keyword(kw::Fn)?; // `fn` - let asyncness = respan( - async_span, - IsAsync::Async { - closure_id: DUMMY_NODE_ID, - return_impl_trait_id: DUMMY_NODE_ID, - }, - ); self.ban_async_in_2015(async_span); let header = FnHeader { unsafety, asyncness, constness: Const::No, ext: Extern::None }; @@ -211,13 +198,7 @@ impl<'a> Parser<'a> { if self.check_keyword(kw::Fn) { // FUNCTION ITEM self.bump(); - let fn_span = self.prev_span; - let header = FnHeader { - unsafety: Unsafe::No, - asyncness: respan(fn_span, IsAsync::NotAsync), - constness: Const::No, - ext: Extern::None, - }; + let header = FnHeader::default(); return self.parse_item_fn(lo, vis, attrs, header); } @@ -230,13 +211,7 @@ impl<'a> Parser<'a> { self.check(&token::OpenDelim(token::Brace)); let ext = self.parse_extern()?; self.expect_keyword(kw::Fn)?; - let fn_span = self.prev_span; - let header = FnHeader { - unsafety, - asyncness: respan(fn_span, IsAsync::NotAsync), - constness: Const::No, - ext, - }; + let header = FnHeader { unsafety, asyncness: Async::No, constness: Const::No, ext }; return self.parse_item_fn(lo, vis, attrs, header); } @@ -1788,10 +1763,9 @@ impl<'a> Parser<'a> { fn parse_fn_front_matter(&mut self) -> PResult<'a, FnHeader> { let constness = self.parse_constness(); let asyncness = self.parse_asyncness(); - if let IsAsync::Async { .. } = asyncness { - self.ban_async_in_2015(self.prev_span); + if let Async::Yes { span, .. } = asyncness { + self.ban_async_in_2015(span); } - let asyncness = respan(self.prev_span, asyncness); let unsafety = self.parse_unsafety(); let (constness, unsafety, ext) = if let Const::Yes(_) = constness { (constness, unsafety, Extern::None) diff --git a/src/librustc_parse/parser/mod.rs b/src/librustc_parse/parser/mod.rs index bccf5968118b4..2f2f2f8f176e5 100644 --- a/src/librustc_parse/parser/mod.rs +++ b/src/librustc_parse/parser/mod.rs @@ -24,7 +24,7 @@ use rustc_span::symbol::{kw, sym, Symbol}; use rustc_span::{FileName, Span, DUMMY_SP}; use syntax::ast::DUMMY_NODE_ID; use syntax::ast::{self, AttrStyle, AttrVec, Const, CrateSugar, Extern, Ident, Unsafe}; -use syntax::ast::{IsAsync, MacArgs, MacDelimiter, Mutability, StrLit, Visibility, VisibilityKind}; +use syntax::ast::{Async, MacArgs, MacDelimiter, Mutability, StrLit, Visibility, VisibilityKind}; use syntax::ptr::P; use syntax::token::{self, DelimToken, Token, TokenKind}; use syntax::tokenstream::{self, DelimSpan, TokenStream, TokenTree, TreeAndJoint}; @@ -954,11 +954,12 @@ impl<'a> Parser<'a> { } /// Parses asyncness: `async` or nothing. - fn parse_asyncness(&mut self) -> IsAsync { + fn parse_asyncness(&mut self) -> Async { if self.eat_keyword(kw::Async) { - IsAsync::Async { closure_id: DUMMY_NODE_ID, return_impl_trait_id: DUMMY_NODE_ID } + let span = self.prev_span; + Async::Yes { span, closure_id: DUMMY_NODE_ID, return_impl_trait_id: DUMMY_NODE_ID } } else { - IsAsync::NotAsync + Async::No } } diff --git a/src/librustc_resolve/def_collector.rs b/src/librustc_resolve/def_collector.rs index 3a26197c1607a..fe80dec513cfe 100644 --- a/src/librustc_resolve/def_collector.rs +++ b/src/librustc_resolve/def_collector.rs @@ -48,8 +48,8 @@ impl<'a> DefCollector<'a> { decl: &'a FnDecl, body: Option<&'a Block>, ) { - let (closure_id, return_impl_trait_id) = match header.asyncness.node { - IsAsync::Async { closure_id, return_impl_trait_id } => { + let (closure_id, return_impl_trait_id) = match header.asyncness { + Async::Yes { span: _, closure_id, return_impl_trait_id } => { (closure_id, return_impl_trait_id) } _ => unreachable!(), @@ -117,7 +117,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { | ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) | ItemKind::TyAlias(..) => DefPathData::TypeNs(i.ident.name), - ItemKind::Fn(sig, generics, body) if sig.header.asyncness.node.is_async() => { + ItemKind::Fn(sig, generics, body) if sig.header.asyncness.is_async() => { return self.visit_async_fn( i.id, i.ident.name, @@ -215,7 +215,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { fn visit_assoc_item(&mut self, i: &'a AssocItem, ctxt: visit::AssocCtxt) { let def_data = match &i.kind { - AssocItemKind::Fn(FnSig { header, decl }, body) if header.asyncness.node.is_async() => { + AssocItemKind::Fn(FnSig { header, decl }, body) if header.asyncness.is_async() => { return self.visit_async_fn( i.id, i.ident.name, @@ -255,10 +255,10 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> { // we must create two defs. let closure_def = self.create_def(expr.id, DefPathData::ClosureExpr, expr.span); match asyncness { - IsAsync::Async { closure_id, .. } => { + Async::Yes { closure_id, .. } => { self.create_def(closure_id, DefPathData::ClosureExpr, expr.span) } - IsAsync::NotAsync => closure_def, + Async::No => closure_def, } } ExprKind::Async(_, async_id, _) => { diff --git a/src/librustc_resolve/late.rs b/src/librustc_resolve/late.rs index 01a0e568137b2..58ff7f447890c 100644 --- a/src/librustc_resolve/late.rs +++ b/src/librustc_resolve/late.rs @@ -2030,7 +2030,7 @@ impl<'a, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> { // `async |x| ...` gets desugared to `|x| future_from_generator(|| ...)`, so we need to // resolve the arguments within the proper scopes so that usages of them inside the // closure are detected as upvars rather than normal closure arg usages. - ExprKind::Closure(_, IsAsync::Async { .. }, _, ref fn_decl, ref body, _span) => { + ExprKind::Closure(_, Async::Yes { .. }, _, ref fn_decl, ref body, _span) => { self.with_rib(ValueNS, NormalRibKind, |this| { // Resolve arguments: this.resolve_params(&fn_decl.inputs); diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs index 5ce81c104e17c..01e3e3f368529 100644 --- a/src/librustc_save_analysis/dump_visitor.rs +++ b/src/librustc_save_analysis/dump_visitor.rs @@ -290,8 +290,8 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> { // as an `impl Trait` existential type. Because of this, to match // the definition paths when resolving nested types we need to // start walking from the newly-created definition. - match sig.header.asyncness.node { - ast::IsAsync::Async { return_impl_trait_id, .. } => { + match sig.header.asyncness { + ast::Async::Yes { return_impl_trait_id, .. } => { v.nest_tables(return_impl_trait_id, |v| v.visit_ty(ret_ty)) } _ => v.visit_ty(ret_ty), @@ -383,8 +383,8 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> { // as an `impl Trait` existential type. Because of this, to match // the definition paths when resolving nested types we need to // start walking from the newly-created definition. - match header.asyncness.node { - ast::IsAsync::Async { return_impl_trait_id, .. } => { + match header.asyncness { + ast::Async::Yes { return_impl_trait_id, .. } => { v.nest_tables(return_impl_trait_id, |v| v.visit_ty(ret_ty)) } _ => v.visit_ty(ret_ty), diff --git a/src/librustc_save_analysis/sig.rs b/src/librustc_save_analysis/sig.rs index 820202c85ab87..d3c4d6d5723b9 100644 --- a/src/librustc_save_analysis/sig.rs +++ b/src/librustc_save_analysis/sig.rs @@ -368,7 +368,7 @@ impl Sig for ast::Item { if let ast::Const::Yes(_) = header.constness { text.push_str("const "); } - if header.asyncness.node.is_async() { + if header.asyncness.is_async() { text.push_str("async "); } if let ast::Unsafe::Yes(_) = header.unsafety { @@ -887,7 +887,7 @@ fn make_method_signature( if let ast::Const::Yes(_) = m.header.constness { text.push_str("const "); } - if m.header.asyncness.node.is_async() { + if m.header.asyncness.is_async() { text.push_str("async "); } if let ast::Unsafe::Yes(_) = m.header.unsafety { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index a7142dfda8593..72430fa9c17e4 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -34,7 +34,7 @@ use rustc_data_structures::thin_vec::ThinVec; use rustc_index::vec::Idx; use rustc_macros::HashStable_Generic; use rustc_serialize::{self, Decoder, Encoder}; -use rustc_span::source_map::{dummy_spanned, respan, Spanned}; +use rustc_span::source_map::{respan, Spanned}; use rustc_span::symbol::{kw, sym, Symbol}; use rustc_span::{Span, DUMMY_SP}; @@ -1198,14 +1198,14 @@ pub enum ExprKind { /// A closure (e.g., `move |a, b, c| a + b + c`). /// /// The final span is the span of the argument block `|...|`. - Closure(CaptureBy, IsAsync, Movability, P, P, Span), + Closure(CaptureBy, Async, Movability, P, P, Span), /// A block (`'label: { ... }`). Block(P, Option