Change Constness to Spanned<Constness>

KiChjang · KiChjang · commit aa5c4bb05d1d · 2016-08-27T22:43:51.000-07:00
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -809,8 +809,8 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_constness(&mut self, c: Constness) -> hir::Constness {
-        match c {
+    fn lower_constness(&mut self, c: Spanned<Constness>) -> hir::Constness {
+        match c.node {
             Constness::Const => hir::Constness::Const,
             Constness::NotConst => hir::Constness::NotConst,
         }
diff --git a/src/librustc/hir/map/blocks.rs b/src/librustc/hir/map/blocks.rs
@@ -23,13 +23,13 @@
 
 pub use self::Code::*;
 
+use hir as ast;
 use hir::map::{self, Node};
-use syntax::abi;
 use hir::{Block, FnDecl};
+use hir::intravisit::FnKind;
+use syntax::abi;
 use syntax::ast::{Attribute, Name, NodeId};
-use hir as ast;
 use syntax_pos::Span;
-use hir::intravisit::FnKind;
 
 /// An FnLikeNode is a Node that is like a fn, in that it has a decl
 /// and a body (as well as a NodeId, a span, etc).
diff --git a/src/librustc/infer/error_reporting.rs b/src/librustc/infer/error_reporting.rs
@@ -1030,7 +1030,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                                     = node_inner.expect("expect item fn");
         let rebuilder = Rebuilder::new(self.tcx, fn_decl, generics, same_regions, &life_giver);
         let (fn_decl, generics) = rebuilder.rebuild();
-        self.give_expl_lifetime_param(err, &fn_decl, unsafety, constness, name, &generics, span);
+        self.give_expl_lifetime_param(
+            err, &fn_decl, unsafety, constness, name, &generics, span);
     }
 
     pub fn issue_32330_warnings(&self, span: Span, issue32330s: &[ty::Issue32330]) {
diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs
@@ -20,6 +20,7 @@ use rustc::lint;
 use rustc::session::Session;
 use syntax::ast::*;
 use syntax::attr;
+use syntax::codemap::Spanned;
 use syntax::parse::token::{self, keywords};
 use syntax::visit::{self, Visitor};
 use syntax_pos::Span;
@@ -70,11 +71,12 @@ impl<'a> AstValidator<'a> {
         }
     }
 
-    fn check_trait_fn_not_const(&self, span: Span, constness: Constness) {
-        match constness {
+    fn check_trait_fn_not_const(&self, constness: Spanned<Constness>) {
+        match constness.node {
             Constness::Const => {
-                struct_span_err!(self.session, span, E0379, "trait fns cannot be declared const")
-                    .span_label(span, &format!("trait fns cannot be const"))
+                struct_span_err!(self.session, constness.span, E0379,
+                                 "trait fns cannot be declared const")
+                    .span_label(constness.span, &format!("trait fns cannot be const"))
                     .emit();
             }
             _ => {}
@@ -158,7 +160,7 @@ impl<'a> Visitor for AstValidator<'a> {
                 for impl_item in impl_items {
                     self.invalid_visibility(&impl_item.vis, impl_item.span, None);
                     if let ImplItemKind::Method(ref sig, _) = impl_item.node {
-                        self.check_trait_fn_not_const(impl_item.span, sig.constness);
+                        self.check_trait_fn_not_const(sig.constness);
                     }
                 }
             }
@@ -186,7 +188,7 @@ impl<'a> Visitor for AstValidator<'a> {
             ItemKind::Trait(_, _, _, ref trait_items) => {
                 for trait_item in trait_items {
                     if let TraitItemKind::Method(ref sig, _) = trait_item.node {
-                        self.check_trait_fn_not_const(trait_item.span, sig.constness);
+                        self.check_trait_fn_not_const(sig.constness);
                     }
                 }
             }
diff --git a/src/librustc_passes/consts.rs b/src/librustc_passes/consts.rs
@@ -147,7 +147,8 @@ impl<'a, 'gcx> CheckCrateVisitor<'a, 'gcx> {
         }
 
         let mode = match fk {
-            FnKind::ItemFn(_, _, _, hir::Constness::Const, _, _, _) => Mode::ConstFn,
+            FnKind::ItemFn(_, _, _, hir::Constness::Const, _, _, _)
+                => Mode::ConstFn,
             FnKind::Method(_, m, _, _) => {
                 if m.constness == hir::Constness::Const {
                     Mode::ConstFn
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -1120,7 +1120,7 @@ pub struct MutTy {
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct MethodSig {
     pub unsafety: Unsafety,
-    pub constness: Constness,
+    pub constness: Spanned<Constness>,
     pub abi: Abi,
     pub decl: P<FnDecl>,
     pub generics: Generics,
@@ -1846,7 +1846,7 @@ pub enum ItemKind {
     /// A function declaration (`fn` or `pub fn`).
     ///
     /// E.g. `fn foo(bar: usize) -> usize { .. }`
-    Fn(P<FnDecl>, Unsafety, Constness, Abi, Generics, P<Block>),
+    Fn(P<FnDecl>, Unsafety, Spanned<Constness>, Abi, Generics, P<Block>),
     /// A module declaration (`mod` or `pub mod`).
     ///
     /// E.g. `mod foo;` or `mod foo { .. }`
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
@@ -12,7 +12,7 @@ use abi::Abi;
 use ast::{self, Ident, Generics, Expr, BlockCheckMode, UnOp, PatKind};
 use attr;
 use syntax_pos::{Span, DUMMY_SP, Pos};
-use codemap::{respan, Spanned};
+use codemap::{dummy_spanned, respan, Spanned};
 use ext::base::ExtCtxt;
 use parse::token::{self, keywords, InternedString};
 use ptr::P;
@@ -1016,7 +1016,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                   Vec::new(),
                   ast::ItemKind::Fn(self.fn_decl(inputs, output),
                               ast::Unsafety::Normal,
-                              ast::Constness::NotConst,
+                              dummy_spanned(ast::Constness::NotConst),
                               Abi::Rust,
                               generics,
                               body))
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
@@ -30,7 +30,7 @@ use ast::{NodeId, PatKind};
 use ast;
 use attr;
 use attr::AttrMetaMethods;
-use codemap::CodeMap;
+use codemap::{CodeMap, Spanned};
 use syntax_pos::Span;
 use errors::Handler;
 use visit::{self, FnKind, Visitor};
@@ -1046,7 +1046,7 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {
                 _node_id: NodeId) {
         // check for const fn declarations
         match fn_kind {
-            FnKind::ItemFn(_, _, _, ast::Constness::Const, _, _) => {
+            FnKind::ItemFn(_, _, _, Spanned { node: ast::Constness::Const, .. }, _, _) => {
                 gate_feature_post!(&self, const_fn, span, "const fn is unstable");
             }
             _ => {
@@ -1078,7 +1078,7 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {
                 if block.is_none() {
                     self.check_abi(sig.abi, ti.span);
                 }
-                if sig.constness == ast::Constness::Const {
+                if sig.constness.node == ast::Constness::Const {
                     gate_feature_post!(&self, const_fn, ti.span, "const fn is unstable");
                 }
             }
@@ -1105,7 +1105,7 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {
                                   "associated constants are experimental")
             }
             ast::ImplItemKind::Method(ref sig, _) => {
-                if sig.constness == ast::Constness::Const {
+                if sig.constness.node == ast::Constness::Const {
                     gate_feature_post!(&self, const_fn, ii.span, "const fn is unstable");
                 }
             }
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
@@ -937,7 +937,10 @@ mod tests {
                                 variadic: false
                             }),
                                     ast::Unsafety::Normal,
-                                    ast::Constness::NotConst,
+                                    Spanned {
+                                        span: sp(0,2),
+                                        node: ast::Constness::NotConst,
+                                    },
                                     Abi::Rust,
                                     ast::Generics{ // no idea on either of these:
                                         lifetimes: Vec::new(),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -39,7 +39,7 @@ use ast::{ViewPath, ViewPathGlob, ViewPathList, ViewPathSimple};
 use ast::{Visibility, WhereClause};
 use ast::{BinOpKind, UnOp};
 use ast;
-use codemap::{self, CodeMap, Spanned, spanned};
+use codemap::{self, CodeMap, Spanned, spanned, respan};
 use syntax_pos::{self, Span, BytePos, mk_sp};
 use errors::{self, DiagnosticBuilder};
 use ext::tt::macro_parser;
@@ -4768,7 +4768,7 @@ impl<'a> Parser<'a> {
     /// Parse an item-position function declaration.
     fn parse_item_fn(&mut self,
                      unsafety: Unsafety,
-                     constness: Constness,
+                     constness: Spanned<Constness>,
                      abi: abi::Abi)
                      -> PResult<'a, ItemInfo> {
         let (ident, mut generics) = self.parse_fn_header()?;
@@ -4794,18 +4794,21 @@ impl<'a> Parser<'a> {
     /// - `extern fn`
     /// - etc
     pub fn parse_fn_front_matter(&mut self)
-                                 -> PResult<'a, (ast::Constness, ast::Unsafety, abi::Abi)> {
+                                 -> PResult<'a, (Spanned<ast::Constness>,
+                                                ast::Unsafety,
+                                                abi::Abi)> {
         let is_const_fn = self.eat_keyword(keywords::Const);
+        let const_span = self.last_span;
         let unsafety = self.parse_unsafety()?;
         let (constness, unsafety, abi) = if is_const_fn {
-            (Constness::Const, unsafety, Abi::Rust)
+            (respan(const_span, Constness::Const), unsafety, Abi::Rust)
         } else {
             let abi = if self.eat_keyword(keywords::Extern) {
                 self.parse_opt_abi()?.unwrap_or(Abi::C)
             } else {
                 Abi::Rust
             };
-            (Constness::NotConst, unsafety, abi)
+            (respan(self.last_span, Constness::NotConst), unsafety, abi)
         };
         self.expect_keyword(keywords::Fn)?;
         Ok((constness, unsafety, abi))
@@ -5704,9 +5707,12 @@ impl<'a> Parser<'a> {
 
             if self.eat_keyword(keywords::Fn) {
                 // EXTERN FUNCTION ITEM
+                let fn_span = self.last_span;
                 let abi = opt_abi.unwrap_or(Abi::C);
                 let (ident, item_, extra_attrs) =
-                    self.parse_item_fn(Unsafety::Normal, Constness::NotConst, abi)?;
+                    self.parse_item_fn(Unsafety::Normal,
+                                       respan(fn_span, Constness::NotConst),
+                                       abi)?;
                 let last_span = self.last_span;
                 let item = self.mk_item(lo,
                                         last_span.hi,
@@ -5740,6 +5746,7 @@ impl<'a> Parser<'a> {
             return Ok(Some(item));
         }
         if self.eat_keyword(keywords::Const) {
+            let const_span = self.last_span;
             if self.check_keyword(keywords::Fn)
                 || (self.check_keyword(keywords::Unsafe)
                     && self.look_ahead(1, |t| t.is_keyword(keywords::Fn))) {
@@ -5751,7 +5758,9 @@ impl<'a> Parser<'a> {
                 };
                 self.bump();
                 let (ident, item_, extra_attrs) =
-                    self.parse_item_fn(unsafety, Constness::Const, Abi::Rust)?;
+                    self.parse_item_fn(unsafety,
+                                       respan(const_span, Constness::Const),
+                                       Abi::Rust)?;
                 let last_span = self.last_span;
                 let item = self.mk_item(lo,
                                         last_span.hi,
@@ -5815,8 +5824,11 @@ impl<'a> Parser<'a> {
         if self.check_keyword(keywords::Fn) {
             // FUNCTION ITEM
             self.bump();
+            let fn_span = self.last_span;
             let (ident, item_, extra_attrs) =
-                self.parse_item_fn(Unsafety::Normal, Constness::NotConst, Abi::Rust)?;
+                self.parse_item_fn(Unsafety::Normal,
+                                   respan(fn_span, Constness::NotConst),
+                                   Abi::Rust)?;
             let last_span = self.last_span;
             let item = self.mk_item(lo,
                                     last_span.hi,
@@ -5836,8 +5848,11 @@ impl<'a> Parser<'a> {
                 Abi::Rust
             };
             self.expect_keyword(keywords::Fn)?;
+            let fn_span = self.last_span;
             let (ident, item_, extra_attrs) =
-                self.parse_item_fn(Unsafety::Unsafe, Constness::NotConst, abi)?;
+                self.parse_item_fn(Unsafety::Unsafe,
+                                   respan(fn_span, Constness::NotConst),
+                                   abi)?;
             let last_span = self.last_span;
             let item = self.mk_item(lo,
                                     last_span.hi,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -1184,7 +1184,7 @@ impl<'a> State<'a> {
                 try!(self.print_fn(
                     decl,
                     unsafety,
-                    constness,
+                    constness.node,
                     abi,
                     Some(item.ident),
                     typarams,
@@ -1518,7 +1518,7 @@ impl<'a> State<'a> {
                             -> io::Result<()> {
         self.print_fn(&m.decl,
                       m.unsafety,
-                      m.constness,
+                      m.constness.node,
                       m.abi,
                       Some(ident),
                       &m.generics,
diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
@@ -24,7 +24,7 @@ use attr;
 use syntax_pos::{self, DUMMY_SP, NO_EXPANSION, Span, FileMap, BytePos};
 use std::rc::Rc;
 
-use codemap::{self, CodeMap, ExpnInfo, NameAndSpan, MacroAttribute};
+use codemap::{self, CodeMap, ExpnInfo, NameAndSpan, MacroAttribute, dummy_spanned};
 use errors;
 use errors::snippet::{SnippetData};
 use config;
@@ -485,7 +485,7 @@ fn mk_main(cx: &mut TestCtxt) -> P<ast::Item> {
     let main_body = ecx.block(sp, vec![call_test_main]);
     let main = ast::ItemKind::Fn(ecx.fn_decl(vec![], main_ret_ty),
                            ast::Unsafety::Normal,
-                           ast::Constness::NotConst,
+                           dummy_spanned(ast::Constness::NotConst),
                            ::abi::Abi::Rust, ast::Generics::default(), main_body);
     let main = P(ast::Item {
         ident: token::str_to_ident("main"),
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
@@ -31,7 +31,7 @@ use codemap::Spanned;
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum FnKind<'a> {
     /// fn foo() or extern "Abi" fn foo()
-    ItemFn(Ident, &'a Generics, Unsafety, Constness, Abi, &'a Visibility),
+    ItemFn(Ident, &'a Generics, Unsafety, Spanned<Constness>, Abi, &'a Visibility),
 
     /// fn foo(&self)
     Method(Ident, &'a MethodSig, Option<&'a Visibility>),
diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
@@ -197,7 +197,7 @@ use syntax::attr;
 use syntax::attr::AttrMetaMethods;
 use syntax::ext::base::{Annotatable, ExtCtxt};
 use syntax::ext::build::AstBuilder;
-use syntax::codemap::{self, respan};
+use syntax::codemap::{self, dummy_spanned, respan};
 use syntax::util::move_map::MoveMap;
 use syntax::parse::token::{InternedString, keywords};
 use syntax::ptr::P;
@@ -901,7 +901,8 @@ impl<'a> MethodDef<'a> {
                                                 generics: fn_generics,
                                                 abi: abi,
                                                 unsafety: unsafety,
-                                                constness: ast::Constness::NotConst,
+                                                constness:
+                                                    dummy_spanned(ast::Constness::NotConst),
                                                 decl: fn_decl,
                                             },
                                             body_block),

Original file line number	Diff line number	Diff line change
`@@ -809,8 +809,8 @@ impl<'a> LoweringContext<'a> {`
`809`	`809`	`}`
`810`	`810`	`}`
`811`	`811`
`812`		`- fn lower_constness(&mut self, c: Constness) -> hir::Constness {`
`813`		`- match c {`
	`812`	`+ fn lower_constness(&mut self, c: Spanned<Constness>) -> hir::Constness {`
	`813`	`+ match c.node {`
`814`	`814`	`Constness::Const => hir::Constness::Const,`
`815`	`815`	`Constness::NotConst => hir::Constness::NotConst,`
`816`	`816`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1030,7 +1030,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {`
`1030`	`1030`	`= node_inner.expect("expect item fn");`
`1031`	`1031`	`let rebuilder = Rebuilder::new(self.tcx, fn_decl, generics, same_regions, &life_giver);`
`1032`	`1032`	`let (fn_decl, generics) = rebuilder.rebuild();`
`1033`		`- self.give_expl_lifetime_param(err, &fn_decl, unsafety, constness, name, &generics, span);`
	`1033`	`+ self.give_expl_lifetime_param(`
	`1034`	`+ err, &fn_decl, unsafety, constness, name, &generics, span);`
`1034`	`1035`	`}`
`1035`	`1036`
`1036`	`1037`	`pub fn issue_32330_warnings(&self, span: Span, issue32330s: &[ty::Issue32330]) {`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ use rustc::lint;`
`20`	`20`	`use rustc::session::Session;`
`21`	`21`	`use syntax::ast::*;`
`22`	`22`	`use syntax::attr;`
	`23`	`+use syntax::codemap::Spanned;`
`23`	`24`	`use syntax::parse::token::{self, keywords};`
`24`	`25`	`use syntax::visit::{self, Visitor};`
`25`	`26`	`use syntax_pos::Span;`
`@@ -70,11 +71,12 @@ impl<'a> AstValidator<'a> {`
`70`	`71`	`}`
`71`	`72`	`}`
`72`	`73`
`73`		`- fn check_trait_fn_not_const(&self, span: Span, constness: Constness) {`
`74`		`- match constness {`
	`74`	`+ fn check_trait_fn_not_const(&self, constness: Spanned<Constness>) {`
	`75`	`+ match constness.node {`
`75`	`76`	`Constness::Const => {`
`76`		`- struct_span_err!(self.session, span, E0379, "trait fns cannot be declared const")`
`77`		`- .span_label(span, &format!("trait fns cannot be const"))`
	`77`	`+ struct_span_err!(self.session, constness.span, E0379,`
	`78`	`+ "trait fns cannot be declared const")`
	`79`	`+ .span_label(constness.span, &format!("trait fns cannot be const"))`
`78`	`80`	`.emit();`
`79`	`81`	`}`
`80`	`82`	`_ => {}`
`@@ -158,7 +160,7 @@ impl<'a> Visitor for AstValidator<'a> {`
`158`	`160`	`for impl_item in impl_items {`
`159`	`161`	`self.invalid_visibility(&impl_item.vis, impl_item.span, None);`
`160`	`162`	`if let ImplItemKind::Method(ref sig, _) = impl_item.node {`
`161`		`- self.check_trait_fn_not_const(impl_item.span, sig.constness);`
	`163`	`+ self.check_trait_fn_not_const(sig.constness);`
`162`	`164`	`}`
`163`	`165`	`}`
`164`	`166`	`}`
`@@ -186,7 +188,7 @@ impl<'a> Visitor for AstValidator<'a> {`
`186`	`188`	`ItemKind::Trait(_, _, _, ref trait_items) => {`
`187`	`189`	`for trait_item in trait_items {`
`188`	`190`	`if let TraitItemKind::Method(ref sig, _) = trait_item.node {`
`189`		`- self.check_trait_fn_not_const(trait_item.span, sig.constness);`
	`191`	`+ self.check_trait_fn_not_const(sig.constness);`
`190`	`192`	`}`
`191`	`193`	`}`
`192`	`194`	`}`
Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,8 @@ impl<'a, 'gcx> CheckCrateVisitor<'a, 'gcx> {`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`let mode = match fk {`
`150`		`- FnKind::ItemFn(_, _, _, hir::Constness::Const, _, _, _) => Mode::ConstFn,`
	`150`	`+ FnKind::ItemFn(_, _, _, hir::Constness::Const, _, _, _)`
	`151`	`+ => Mode::ConstFn,`
`151`	`152`	`FnKind::Method(_, m, _, _) => {`
`152`	`153`	`if m.constness == hir::Constness::Const {`
`153`	`154`	`Mode::ConstFn`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ use ast::{NodeId, PatKind};`
`30`	`30`	`use ast;`
`31`	`31`	`use attr;`
`32`	`32`	`use attr::AttrMetaMethods;`
`33`		`-use codemap::CodeMap;`
	`33`	`+use codemap::{CodeMap, Spanned};`
`34`	`34`	`use syntax_pos::Span;`
`35`	`35`	`use errors::Handler;`
`36`	`36`	`use visit::{self, FnKind, Visitor};`
`@@ -1046,7 +1046,7 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {`
`1046`	`1046`	`_node_id: NodeId) {`
`1047`	`1047`	`// check for const fn declarations`
`1048`	`1048`	`match fn_kind {`
`1049`		`- FnKind::ItemFn(_, _, _, ast::Constness::Const, _, _) => {`
	`1049`	`+ FnKind::ItemFn(_, _, _, Spanned { node: ast::Constness::Const, .. }, _, _) => {`
`1050`	`1050`	`gate_feature_post!(&self, const_fn, span, "const fn is unstable");`
`1051`	`1051`	`}`
`1052`	`1052`	`_ => {`
`@@ -1078,7 +1078,7 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {`
`1078`	`1078`	`if block.is_none() {`
`1079`	`1079`	`self.check_abi(sig.abi, ti.span);`
`1080`	`1080`	`}`
`1081`		`- if sig.constness == ast::Constness::Const {`
	`1081`	`+ if sig.constness.node == ast::Constness::Const {`
`1082`	`1082`	`gate_feature_post!(&self, const_fn, ti.span, "const fn is unstable");`
`1083`	`1083`	`}`
`1084`	`1084`	`}`
`@@ -1105,7 +1105,7 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {`
`1105`	`1105`	`"associated constants are experimental")`
`1106`	`1106`	`}`
`1107`	`1107`	`ast::ImplItemKind::Method(ref sig, _) => {`
`1108`		`- if sig.constness == ast::Constness::Const {`
	`1108`	`+ if sig.constness.node == ast::Constness::Const {`
`1109`	`1109`	`gate_feature_post!(&self, const_fn, ii.span, "const fn is unstable");`
`1110`	`1110`	`}`
`1111`	`1111`	`}`