Make ast::Visibility non-copyable

jseyfried · jseyfried · commit bc355244df5a · 2016-04-02T20:21:41.000Z
diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs
@@ -761,7 +761,7 @@ pub fn lower_impl_item(lctx: &LoweringContext, i: &ImplItem) -> hir::ImplItem {
         id: i.id,
         name: i.ident.name,
         attrs: lower_attrs(lctx, &i.attrs),
-        vis: lower_visibility(lctx, i.vis),
+        vis: lower_visibility(lctx, &i.vis),
         defaultness: lower_defaultness(lctx, i.defaultness),
         node: match i.node {
             ImplItemKind::Const(ref ty, ref expr) => {
@@ -839,7 +839,7 @@ pub fn lower_item(lctx: &LoweringContext, i: &Item) -> hir::Item {
         name: i.ident.name,
         attrs: lower_attrs(lctx, &i.attrs),
         node: node,
-        vis: lower_visibility(lctx, i.vis),
+        vis: lower_visibility(lctx, &i.vis),
         span: i.span,
     }
 }
@@ -857,7 +857,7 @@ pub fn lower_foreign_item(lctx: &LoweringContext, i: &ForeignItem) -> hir::Forei
                 hir::ForeignItemStatic(lower_ty(lctx, t), m)
             }
         },
-        vis: lower_visibility(lctx, i.vis),
+        vis: lower_visibility(lctx, &i.vis),
         span: i.span,
     }
 }
@@ -1706,8 +1706,8 @@ pub fn lower_capture_clause(_lctx: &LoweringContext, c: CaptureBy) -> hir::Captu
     }
 }
 
-pub fn lower_visibility(_lctx: &LoweringContext, v: Visibility) -> hir::Visibility {
-    match v {
+pub fn lower_visibility(_lctx: &LoweringContext, v: &Visibility) -> hir::Visibility {
+    match *v {
         Visibility::Public => hir::Public,
         Visibility::Inherited => hir::Inherited,
     }
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -1868,7 +1868,7 @@ pub struct PolyTraitRef {
     pub span: Span,
 }
 
-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub enum Visibility {
     Public,
     Inherited,
@@ -1893,7 +1893,7 @@ impl StructField_ {
 
 pub type StructField = Spanned<StructField_>;
 
-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub enum StructFieldKind {
     NamedField(Ident, Visibility),
     /// Element of a tuple-like struct
@@ -1908,9 +1908,9 @@ impl StructFieldKind {
         }
     }
 
-    pub fn visibility(&self) -> Visibility {
+    pub fn visibility(&self) -> &Visibility {
         match *self {
-            NamedField(_, vis) | UnnamedField(vis) => vis
+            NamedField(_, ref vis) | UnnamedField(ref vis) => vis
         }
     }
 }
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
@@ -247,7 +247,7 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {
             FnKind::ItemFn(_, generics, _, _, _, _) => {
                 self.visit_generics_helper(generics)
             }
-            FnKind::Method(_, sig, _) => {
+            FnKind::Method(_, ref sig, _) => {
                 self.visit_generics_helper(&sig.generics)
             }
             FnKind::Closure => {}
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -4952,7 +4952,7 @@ impl<'a> Parser<'a> {
             self.commit_expr_expecting(&expr, token::Semi)?;
             (name, ast::ImplItemKind::Const(typ, expr))
         } else {
-            let (name, inner_attrs, node) = self.parse_impl_method(vis)?;
+            let (name, inner_attrs, node) = self.parse_impl_method(&vis)?;
             attrs.extend(inner_attrs);
             (name, node)
         };
@@ -4968,8 +4968,8 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn complain_if_pub_macro(&mut self, visa: Visibility, span: Span) {
-        match visa {
+    fn complain_if_pub_macro(&mut self, visa: &Visibility, span: Span) {
+        match *visa {
             Visibility::Public => {
                 let is_macro_rules: bool = match self.token {
                     token::Ident(sid, _) => sid.name == intern("macro_rules"),
@@ -4993,7 +4993,7 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse a method or a macro invocation in a trait impl.
-    fn parse_impl_method(&mut self, vis: Visibility)
+    fn parse_impl_method(&mut self, vis: &Visibility)
                          -> PResult<'a, (Ident, Vec<ast::Attribute>, ast::ImplItemKind)> {
         // code copied from parse_macro_use_or_failure... abstraction!
         if !self.token.is_any_keyword()
@@ -5003,7 +5003,7 @@ impl<'a> Parser<'a> {
             // method macro.
 
             let last_span = self.last_span;
-            self.complain_if_pub_macro(vis, last_span);
+            self.complain_if_pub_macro(&vis, last_span);
 
             let lo = self.span.lo;
             let pth = self.parse_path(NoTypesAllowed)?;
@@ -6045,7 +6045,7 @@ impl<'a> Parser<'a> {
             // MACRO INVOCATION ITEM
 
             let last_span = self.last_span;
-            self.complain_if_pub_macro(visibility, last_span);
+            self.complain_if_pub_macro(&visibility, last_span);
 
             let mac_lo = self.span.lo;
 
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -388,7 +388,7 @@ pub fn fun_to_string(decl: &ast::FnDecl,
     to_string(|s| {
         s.head("")?;
         s.print_fn(decl, unsafety, constness, Abi::Rust, Some(name),
-                   generics, opt_explicit_self, ast::Visibility::Inherited)?;
+                   generics, opt_explicit_self, &ast::Visibility::Inherited)?;
         s.end()?; // Close the head box
         s.end() // Close the outer box
     })
@@ -432,8 +432,8 @@ pub fn mac_to_string(arg: &ast::Mac) -> String {
     to_string(|s| s.print_mac(arg, ::parse::token::Paren))
 }
 
-pub fn visibility_qualified(vis: ast::Visibility, s: &str) -> String {
-    match vis {
+pub fn visibility_qualified(vis: &ast::Visibility, s: &str) -> String {
+    match *vis {
         ast::Visibility::Public => format!("pub {}", s),
         ast::Visibility::Inherited => s.to_string()
     }
@@ -1052,13 +1052,13 @@ impl<'a> State<'a> {
                 self.print_fn(decl, ast::Unsafety::Normal,
                               ast::Constness::NotConst,
                               Abi::Rust, Some(item.ident),
-                              generics, None, item.vis)?;
+                              generics, None, &item.vis)?;
                 self.end()?; // end head-ibox
                 word(&mut self.s, ";")?;
                 self.end() // end the outer fn box
             }
             ast::ForeignItemKind::Static(ref t, m) => {
-                self.head(&visibility_qualified(item.vis, "static"))?;
+                self.head(&visibility_qualified(&item.vis, "static"))?;
                 if m {
                     self.word_space("mut")?;
                 }
@@ -1076,7 +1076,7 @@ impl<'a> State<'a> {
                               ident: ast::Ident,
                               ty: &ast::Ty,
                               default: Option<&ast::Expr>,
-                              vis: ast::Visibility)
+                              vis: &ast::Visibility)
                               -> io::Result<()>
     {
         word(&mut self.s, &visibility_qualified(vis, ""))?;
@@ -1118,7 +1118,7 @@ impl<'a> State<'a> {
         self.ann.pre(self, NodeItem(item))?;
         match item.node {
             ast::ItemKind::ExternCrate(ref optional_path) => {
-                self.head(&visibility_qualified(item.vis, "extern crate"))?;
+                self.head(&visibility_qualified(&item.vis, "extern crate"))?;
                 if let Some(p) = *optional_path {
                     let val = p.as_str();
                     if val.contains("-") {
@@ -1136,14 +1136,14 @@ impl<'a> State<'a> {
                 self.end()?; // end outer head-block
             }
             ast::ItemKind::Use(ref vp) => {
-                self.head(&visibility_qualified(item.vis, "use"))?;
+                self.head(&visibility_qualified(&item.vis, "use"))?;
                 self.print_view_path(&vp)?;
                 word(&mut self.s, ";")?;
                 self.end()?; // end inner head-block
                 self.end()?; // end outer head-block
             }
             ast::ItemKind::Static(ref ty, m, ref expr) => {
-                self.head(&visibility_qualified(item.vis, "static"))?;
+                self.head(&visibility_qualified(&item.vis, "static"))?;
                 if m == ast::Mutability::Mutable {
                     self.word_space("mut")?;
                 }
@@ -1159,7 +1159,7 @@ impl<'a> State<'a> {
                 self.end()?; // end the outer cbox
             }
             ast::ItemKind::Const(ref ty, ref expr) => {
-                self.head(&visibility_qualified(item.vis, "const"))?;
+                self.head(&visibility_qualified(&item.vis, "const"))?;
                 self.print_ident(item.ident)?;
                 self.word_space(":")?;
                 self.print_type(&ty)?;
@@ -1181,13 +1181,13 @@ impl<'a> State<'a> {
                     Some(item.ident),
                     typarams,
                     None,
-                    item.vis
+                    &item.vis
                 )?;
                 word(&mut self.s, " ")?;
                 self.print_block_with_attrs(&body, &item.attrs)?;
             }
             ast::ItemKind::Mod(ref _mod) => {
-                self.head(&visibility_qualified(item.vis, "mod"))?;
+                self.head(&visibility_qualified(&item.vis, "mod"))?;
                 self.print_ident(item.ident)?;
                 self.nbsp()?;
                 self.bopen()?;
@@ -1204,7 +1204,7 @@ impl<'a> State<'a> {
             ast::ItemKind::Ty(ref ty, ref params) => {
                 self.ibox(INDENT_UNIT)?;
                 self.ibox(0)?;
-                self.word_nbsp(&visibility_qualified(item.vis, "type"))?;
+                self.word_nbsp(&visibility_qualified(&item.vis, "type"))?;
                 self.print_ident(item.ident)?;
                 self.print_generics(params)?;
                 self.end()?; // end the inner ibox
@@ -1222,17 +1222,17 @@ impl<'a> State<'a> {
                     params,
                     item.ident,
                     item.span,
-                    item.vis
+                    &item.vis
                 )?;
             }
             ast::ItemKind::Struct(ref struct_def, ref generics) => {
-                self.head(&visibility_qualified(item.vis,"struct"))?;
+                self.head(&visibility_qualified(&item.vis, "struct"))?;
                 self.print_struct(&struct_def, generics, item.ident, item.span, true)?;
             }
 
             ast::ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
                 self.head("")?;
-                self.print_visibility(item.vis)?;
+                self.print_visibility(&item.vis)?;
                 self.print_unsafety(unsafety)?;
                 self.word_nbsp("impl")?;
                 self.print_trait_ref(trait_ref)?;
@@ -1249,7 +1249,7 @@ impl<'a> State<'a> {
                           ref ty,
                           ref impl_items) => {
                 self.head("")?;
-                self.print_visibility(item.vis)?;
+                self.print_visibility(&item.vis)?;
                 self.print_unsafety(unsafety)?;
                 self.word_nbsp("impl")?;
 
@@ -1287,7 +1287,7 @@ impl<'a> State<'a> {
             }
             ast::ItemKind::Trait(unsafety, ref generics, ref bounds, ref trait_items) => {
                 self.head("")?;
-                self.print_visibility(item.vis)?;
+                self.print_visibility(&item.vis)?;
                 self.print_unsafety(unsafety)?;
                 self.word_nbsp("trait")?;
                 self.print_ident(item.ident)?;
@@ -1312,7 +1312,7 @@ impl<'a> State<'a> {
                 self.bclose(item.span)?;
             }
             ast::ItemKind::Mac(codemap::Spanned { ref node, .. }) => {
-                self.print_visibility(item.vis)?;
+                self.print_visibility(&item.vis)?;
                 self.print_path(&node.path, false, 0)?;
                 word(&mut self.s, "! ")?;
                 self.print_ident(item.ident)?;
@@ -1355,7 +1355,7 @@ impl<'a> State<'a> {
     pub fn print_enum_def(&mut self, enum_definition: &ast::EnumDef,
                           generics: &ast::Generics, ident: ast::Ident,
                           span: codemap::Span,
-                          visibility: ast::Visibility) -> io::Result<()> {
+                          visibility: &ast::Visibility) -> io::Result<()> {
         self.head(&visibility_qualified(visibility, "enum"))?;
         self.print_ident(ident)?;
         self.print_generics(generics)?;
@@ -1381,8 +1381,8 @@ impl<'a> State<'a> {
         self.bclose(span)
     }
 
-    pub fn print_visibility(&mut self, vis: ast::Visibility) -> io::Result<()> {
-        match vis {
+    pub fn print_visibility(&mut self, vis: &ast::Visibility) -> io::Result<()> {
+        match *vis {
             ast::Visibility::Public => self.word_nbsp("pub"),
             ast::Visibility::Inherited => Ok(())
         }
@@ -1404,7 +1404,7 @@ impl<'a> State<'a> {
                     |s, field| {
                         match field.node.kind {
                             ast::NamedField(..) => panic!("unexpected named field"),
-                            ast::UnnamedField(vis) => {
+                            ast::UnnamedField(ref vis) => {
                                 s.print_visibility(vis)?;
                                 s.maybe_print_comment(field.span.lo)?;
                                 s.print_type(&field.node.ty)
@@ -1429,7 +1429,7 @@ impl<'a> State<'a> {
             for field in struct_def.fields() {
                 match field.node.kind {
                     ast::UnnamedField(..) => panic!("unexpected unnamed field"),
-                    ast::NamedField(ident, visibility) => {
+                    ast::NamedField(ident, ref visibility) => {
                         self.hardbreak_if_not_bol()?;
                         self.maybe_print_comment(field.span.lo)?;
                         self.print_outer_attributes(&field.node.attrs)?;
@@ -1528,7 +1528,7 @@ impl<'a> State<'a> {
     pub fn print_method_sig(&mut self,
                             ident: ast::Ident,
                             m: &ast::MethodSig,
-                            vis: ast::Visibility)
+                            vis: &ast::Visibility)
                             -> io::Result<()> {
         self.print_fn(&m.decl,
                       m.unsafety,
@@ -1550,13 +1550,13 @@ impl<'a> State<'a> {
             ast::TraitItemKind::Const(ref ty, ref default) => {
                 self.print_associated_const(ti.ident, &ty,
                                             default.as_ref().map(|expr| &**expr),
-                                            ast::Visibility::Inherited)?;
+                                            &ast::Visibility::Inherited)?;
             }
             ast::TraitItemKind::Method(ref sig, ref body) => {
                 if body.is_some() {
                     self.head("")?;
                 }
-                self.print_method_sig(ti.ident, sig, ast::Visibility::Inherited)?;
+                self.print_method_sig(ti.ident, sig, &ast::Visibility::Inherited)?;
                 if let Some(ref body) = *body {
                     self.nbsp()?;
                     self.print_block_with_attrs(body, &ti.attrs)?;
@@ -1582,11 +1582,11 @@ impl<'a> State<'a> {
         }
         match ii.node {
             ast::ImplItemKind::Const(ref ty, ref expr) => {
-                self.print_associated_const(ii.ident, &ty, Some(&expr), ii.vis)?;
+                self.print_associated_const(ii.ident, &ty, Some(&expr), &ii.vis)?;
             }
             ast::ImplItemKind::Method(ref sig, ref body) => {
                 self.head("")?;
-                self.print_method_sig(ii.ident, sig, ii.vis)?;
+                self.print_method_sig(ii.ident, sig, &ii.vis)?;
                 self.nbsp()?;
                 self.print_block_with_attrs(body, &ii.attrs)?;
             }
@@ -2655,7 +2655,7 @@ impl<'a> State<'a> {
                     name: Option<ast::Ident>,
                     generics: &ast::Generics,
                     opt_explicit_self: Option<&ast::SelfKind>,
-                    vis: ast::Visibility) -> io::Result<()> {
+                    vis: &ast::Visibility) -> io::Result<()> {
         self.print_fn_header_info(unsafety, constness, abi, vis)?;
 
         if let Some(name) = name {
@@ -3037,7 +3037,7 @@ impl<'a> State<'a> {
                       name,
                       &generics,
                       opt_explicit_self,
-                      ast::Visibility::Inherited)?;
+                      &ast::Visibility::Inherited)?;
         self.end()
     }
 
@@ -3112,7 +3112,7 @@ impl<'a> State<'a> {
                                 unsafety: ast::Unsafety,
                                 constness: ast::Constness,
                                 abi: Abi,
-                                vis: ast::Visibility) -> io::Result<()> {
+                                vis: &ast::Visibility) -> io::Result<()> {
         word(&mut self.s, &visibility_qualified(vis, ""))?;
 
         match constness {
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs

Original file line number	Diff line number	Diff line change
`@@ -761,7 +761,7 @@ pub fn lower_impl_item(lctx: &LoweringContext, i: &ImplItem) -> hir::ImplItem {`
`761`	`761`	`id: i.id,`
`762`	`762`	`name: i.ident.name,`
`763`	`763`	`attrs: lower_attrs(lctx, &i.attrs),`
`764`		`- vis: lower_visibility(lctx, i.vis),`
	`764`	`+ vis: lower_visibility(lctx, &i.vis),`
`765`	`765`	`defaultness: lower_defaultness(lctx, i.defaultness),`
`766`	`766`	`node: match i.node {`
`767`	`767`	`ImplItemKind::Const(ref ty, ref expr) => {`
`@@ -839,7 +839,7 @@ pub fn lower_item(lctx: &LoweringContext, i: &Item) -> hir::Item {`
`839`	`839`	`name: i.ident.name,`
`840`	`840`	`attrs: lower_attrs(lctx, &i.attrs),`
`841`	`841`	`node: node,`
`842`		`- vis: lower_visibility(lctx, i.vis),`
	`842`	`+ vis: lower_visibility(lctx, &i.vis),`
`843`	`843`	`span: i.span,`
`844`	`844`	`}`
`845`	`845`	`}`
`@@ -857,7 +857,7 @@ pub fn lower_foreign_item(lctx: &LoweringContext, i: &ForeignItem) -> hir::Forei`
`857`	`857`	`hir::ForeignItemStatic(lower_ty(lctx, t), m)`
`858`	`858`	`}`
`859`	`859`	`},`
`860`		`- vis: lower_visibility(lctx, i.vis),`
	`860`	`+ vis: lower_visibility(lctx, &i.vis),`
`861`	`861`	`span: i.span,`
`862`	`862`	`}`
`863`	`863`	`}`
`@@ -1706,8 +1706,8 @@ pub fn lower_capture_clause(_lctx: &LoweringContext, c: CaptureBy) -> hir::Captu`
`1706`	`1706`	`}`
`1707`	`1707`	`}`
`1708`	`1708`
`1709`		`-pub fn lower_visibility(_lctx: &LoweringContext, v: Visibility) -> hir::Visibility {`
`1710`		`- match v {`
	`1709`	`+pub fn lower_visibility(_lctx: &LoweringContext, v: &Visibility) -> hir::Visibility {`
	`1710`	`+ match *v {`
`1711`	`1711`	`Visibility::Public => hir::Public,`
`1712`	`1712`	`Visibility::Inherited => hir::Inherited,`
`1713`	`1713`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1868,7 +1868,7 @@ pub struct PolyTraitRef {`
`1868`	`1868`	`pub span: Span,`
`1869`	`1869`	`}`
`1870`	`1870`
`1871`		`-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]`
	`1871`	`+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]`
`1872`	`1872`	`pub enum Visibility {`
`1873`	`1873`	`Public,`
`1874`	`1874`	`Inherited,`
`@@ -1893,7 +1893,7 @@ impl StructField_ {`
`1893`	`1893`
`1894`	`1894`	`pub type StructField = Spanned<StructField_>;`
`1895`	`1895`
`1896`		`-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]`
	`1896`	`+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]`
`1897`	`1897`	`pub enum StructFieldKind {`
`1898`	`1898`	`NamedField(Ident, Visibility),`
`1899`	`1899`	`/// Element of a tuple-like struct`
`@@ -1908,9 +1908,9 @@ impl StructFieldKind {`
`1908`	`1908`	`}`
`1909`	`1909`	`}`
`1910`	`1910`
`1911`		`- pub fn visibility(&self) -> Visibility {`
	`1911`	`+ pub fn visibility(&self) -> &Visibility {`
`1912`	`1912`	`match *self {`
`1913`		`- NamedField(_, vis) \| UnnamedField(vis) => vis`
	`1913`	`+ NamedField(_, ref vis) \| UnnamedField(ref vis) => vis`
`1914`	`1914`	`}`
`1915`	`1915`	`}`
`1916`	`1916`	`}`
Original file line number	Diff line number	Diff line change
`@@ -247,7 +247,7 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {`
`247`	`247`	`FnKind::ItemFn(_, generics, _, _, _, _) => {`
`248`	`248`	`self.visit_generics_helper(generics)`
`249`	`249`	`}`
`250`		`- FnKind::Method(_, sig, _) => {`
	`250`	`+ FnKind::Method(_, ref sig, _) => {`
`251`	`251`	`self.visit_generics_helper(&sig.generics)`
`252`	`252`	`}`
`253`	`253`	`FnKind::Closure => {}`