ast: Remove one @ and fix the fallout

Blei · Blei · commit 47ce9819033d · 2013-12-01T11:24:58.000+01:00
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
@@ -730,7 +730,7 @@ fn encode_provided_source(ebml_w: &mut writer::Encoder,
 fn encode_info_for_struct(ecx: &EncodeContext,
                           ebml_w: &mut writer::Encoder,
                           path: &[ast_map::path_elt],
-                          fields: &[@struct_field],
+                          fields: &[struct_field],
                           global_index: @mut ~[entry<i64>])
                           -> ~[entry<i64>] {
     /* Each class has its own index, since different classes
diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
@@ -1310,7 +1310,7 @@ impl<'self> Visitor<()> for Context<'self> {
         self.cur_struct_def_id = old_id;
     }
 
-    fn visit_struct_field(&mut self, s: @ast::struct_field, _: ()) {
+    fn visit_struct_field(&mut self, s: &ast::struct_field, _: ()) {
         self.with_lint_attrs(s.node.attrs, |cx| {
             check_missing_doc_struct_field(cx, s);
             check_attrs_usage(cx, s.node.attrs);
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
@@ -3876,9 +3876,9 @@ impl Resolver {
     fn resolve_struct(&mut self,
                           id: NodeId,
                           generics: &Generics,
-                          fields: &[@struct_field]) {
-        let mut ident_map: HashMap<ast::Ident,@struct_field> = HashMap::new();
-        for &field in fields.iter() {
+                          fields: &[struct_field]) {
+        let mut ident_map: HashMap<ast::Ident, &struct_field> = HashMap::new();
+        for field in fields.iter() {
             match field.node.kind {
                 named_field(ident, _) => {
                     match ident_map.find(&ident) {
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
@@ -2037,7 +2037,7 @@ pub fn trans_enum_variant(ccx: @mut CrateContext,
 }
 
 pub fn trans_tuple_struct(ccx: @mut CrateContext,
-                          fields: &[@ast::struct_field],
+                          fields: &[ast::struct_field],
                           ctor_id: ast::NodeId,
                           param_substs: Option<@param_substs>,
                           llfndecl: ValueRef) {
@@ -2062,7 +2062,7 @@ impl IdAndTy for ast::variant_arg {
     fn ty<'a>(&'a self) -> &'a ast::Ty { &self.ty }
 }
 
-impl IdAndTy for @ast::struct_field {
+impl IdAndTy for ast::struct_field {
     fn id(&self) -> ast::NodeId { self.node.id }
     fn ty<'a>(&'a self) -> &'a ast::Ty { &self.node.ty }
 }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -3693,7 +3693,7 @@ impl VariantInfo {
             },
             ast::struct_variant_kind(ref struct_def) => {
 
-                let fields: &[@struct_field] = struct_def.fields;
+                let fields: &[struct_field] = struct_def.fields;
 
                 assert!(fields.len() > 0);
 
@@ -4082,7 +4082,7 @@ pub fn lookup_struct_field(cx: ctxt,
     }
 }
 
-fn struct_field_tys(fields: &[@struct_field]) -> ~[field_ty] {
+fn struct_field_tys(fields: &[struct_field]) -> ~[field_ty] {
     fields.map(|field| {
         match field.node.kind {
             named_field(ident, visibility) => {
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
@@ -620,7 +620,7 @@ pub fn convert_struct(ccx: &CrateCtxt,
 
     // Write the type of each of the members
     for f in struct_def.fields.iter() {
-       convert_field(ccx, &tpt.generics, *f);
+       convert_field(ccx, &tpt.generics, f);
     }
     let substs = mk_item_substs(ccx, &tpt.generics, None);
     let selfty = ty::mk_struct(tcx, local_def(id), substs);
diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs
@@ -80,7 +80,7 @@ pub struct Struct {
     name: Ident,
     generics: ast::Generics,
     attrs: ~[ast::Attribute],
-    fields: ~[@ast::struct_field],
+    fields: ~[ast::struct_field],
     where: Span,
 }
 
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
@@ -46,7 +46,7 @@ impl RustdocVisitor {
                 vis: item.vis,
                 attrs: item.attrs.clone(),
                 generics: generics.clone(),
-                fields: sd.fields.iter().map(|x| (*x).clone()).to_owned_vec(),
+                fields: sd.fields.clone(),
                 where: item.span
             }
         }
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -1098,7 +1098,7 @@ impl visibility {
     }
 }
 
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
 pub struct struct_field_ {
     kind: struct_field_kind,
     id: NodeId,
@@ -1108,15 +1108,15 @@ pub struct struct_field_ {
 
 pub type struct_field = Spanned<struct_field_>;
 
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
 pub enum struct_field_kind {
     named_field(Ident, visibility),
     unnamed_field   // element of a tuple-like struct
 }
 
 #[deriving(Eq, Encodable, Decodable,IterBytes)]
 pub struct struct_def {
-    fields: ~[@struct_field], /* fields, not including ctor */
+    fields: ~[struct_field], /* fields, not including ctor */
     /* ID of the constructor. This is only used for tuple- or enum-like
      * structs. */
     ctor_id: Option<NodeId>
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
@@ -576,7 +576,7 @@ impl<'self, O: IdVisitingOperation> Visitor<()> for IdVisitor<'self, O> {
         }
     }
 
-    fn visit_struct_field(&mut self, struct_field: @struct_field, env: ()) {
+    fn visit_struct_field(&mut self, struct_field: &struct_field, env: ()) {
         self.operation.visit_id(struct_field.node.id);
         visit::walk_struct_field(self, struct_field, env)
     }
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -118,10 +118,10 @@ pub trait ast_fold {
         noop_fold_item(i, self)
     }
 
-    fn fold_struct_field(&self, sf: @struct_field) -> @struct_field {
+    fn fold_struct_field(&self, sf: &struct_field) -> struct_field {
         let fold_attribute = |x| fold_attribute_(x, self);
 
-        @Spanned {
+        Spanned {
             node: ast::struct_field_ {
                 kind: sf.node.kind,
                 id: self.new_id(sf.node.id),
@@ -312,7 +312,7 @@ pub trait ast_fold {
             struct_variant_kind(ref struct_def) => {
                 kind = struct_variant_kind(@ast::struct_def {
                     fields: struct_def.fields.iter()
-                        .map(|f| self.fold_struct_field(*f)).collect(),
+                        .map(|f| self.fold_struct_field(f)).collect(),
                     ctor_id: struct_def.ctor_id.map(|c| self.new_id(c))
                 })
             }
@@ -536,7 +536,7 @@ pub fn fold_generics<T:ast_fold>(generics: &Generics, fld: &T) -> Generics {
 fn fold_struct_def<T:ast_fold>(struct_def: @ast::struct_def, fld: &T)
                                -> @ast::struct_def {
     @ast::struct_def {
-        fields: struct_def.fields.map(|f| fold_struct_field(*f, fld)),
+        fields: struct_def.fields.map(|f| fold_struct_field(f, fld)),
         ctor_id: struct_def.ctor_id.map(|cid| fld.new_id(cid)),
     }
 }
@@ -562,8 +562,8 @@ fn fold_trait_ref<T:ast_fold>(p: &trait_ref, fld: &T) -> trait_ref {
     }
 }
 
-fn fold_struct_field<T:ast_fold>(f: @struct_field, fld: &T) -> @struct_field {
-    @Spanned {
+fn fold_struct_field<T:ast_fold>(f: &struct_field, fld: &T) -> struct_field {
+    Spanned {
         node: ast::struct_field_ {
             kind: f.node.kind,
             id: fld.new_id(f.node.id),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -3162,15 +3162,15 @@ impl Parser {
     // parse a structure field
     fn parse_name_and_ty(&self,
                          pr: visibility,
-                         attrs: ~[Attribute]) -> @struct_field {
+                         attrs: ~[Attribute]) -> struct_field {
         let lo = self.span.lo;
         if !is_plain_ident(&*self.token) {
             self.fatal("expected ident");
         }
         let name = self.parse_ident();
         self.expect(&token::COLON);
         let ty = self.parse_ty(false);
-        @spanned(lo, self.last_span.hi, ast::struct_field_ {
+        spanned(lo, self.last_span.hi, ast::struct_field_ {
             kind: named_field(name, pr),
             id: ast::DUMMY_NODE_ID,
             ty: ty,
@@ -4006,7 +4006,7 @@ impl Parser {
         let class_name = self.parse_ident();
         let generics = self.parse_generics();
 
-        let mut fields: ~[@struct_field];
+        let mut fields: ~[struct_field];
         let is_tuple_like;
 
         if self.eat(&token::LBRACE) {
@@ -4037,7 +4037,7 @@ impl Parser {
                     ty: p.parse_ty(false),
                     attrs: attrs,
                 };
-                @spanned(lo, p.span.hi, struct_field_)
+                spanned(lo, p.span.hi, struct_field_)
             });
             self.expect(&token::SEMI);
         } else if self.eat(&token::SEMI) {
@@ -4075,7 +4075,7 @@ impl Parser {
     pub fn parse_single_struct_field(&self,
                                      vis: visibility,
                                      attrs: ~[Attribute])
-                                     -> @struct_field {
+                                     -> struct_field {
         let a_var = self.parse_name_and_ty(vis, attrs);
         match *self.token {
             token::COMMA => {
@@ -4092,7 +4092,7 @@ impl Parser {
     }
 
     // parse an element of a struct definition
-    fn parse_struct_decl_field(&self) -> @struct_field {
+    fn parse_struct_decl_field(&self) -> struct_field {
 
         let attrs = self.parse_outer_attributes();
 
@@ -4454,7 +4454,7 @@ impl Parser {
     // parse a structure-like enum variant definition
     // this should probably be renamed or refactored...
     fn parse_struct_def(&self) -> @struct_def {
-        let mut fields: ~[@struct_field] = ~[];
+        let mut fields: ~[struct_field] = ~[];
         while *self.token != token::RBRACE {
             fields.push(self.parse_struct_decl_field());
         }
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
@@ -92,7 +92,7 @@ pub trait Visitor<E:Clone> {
     fn visit_struct_def(&mut self, s:@struct_def, i:Ident, g:&Generics, n:NodeId, e:E) {
         walk_struct_def(self, s, i, g, n, e)
     }
-    fn visit_struct_field(&mut self, s:@struct_field, e:E) { walk_struct_field(self, s, e) }
+    fn visit_struct_field(&mut self, s:&struct_field, e:E) { walk_struct_field(self, s, e) }
     fn visit_variant(&mut self, v:&variant, g:&Generics, e:E) { walk_variant(self, v, g, e) }
     fn visit_opt_lifetime_ref(&mut self,
                               _span: Span,
@@ -538,7 +538,7 @@ pub fn walk_struct_def<E:Clone, V:Visitor<E>>(visitor: &mut V,
                                  _: NodeId,
                                  env: E) {
     for field in struct_definition.fields.iter() {
-        visitor.visit_struct_field(*field, env.clone())
+        visitor.visit_struct_field(field, env.clone())
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1310,7 +1310,7 @@ impl<'self> Visitor<()> for Context<'self> {`
`1310`	`1310`	`self.cur_struct_def_id = old_id;`
`1311`	`1311`	`}`
`1312`	`1312`
`1313`		`- fn visit_struct_field(&mut self, s: @ast::struct_field, _: ()) {`
	`1313`	`+ fn visit_struct_field(&mut self, s: &ast::struct_field, _: ()) {`
`1314`	`1314`	`self.with_lint_attrs(s.node.attrs, \|cx\| {`
`1315`	`1315`	`check_missing_doc_struct_field(cx, s);`
`1316`	`1316`	`check_attrs_usage(cx, s.node.attrs);`
Original file line number	Diff line number	Diff line change
`@@ -2037,7 +2037,7 @@ pub fn trans_enum_variant(ccx: @mut CrateContext,`
`2037`	`2037`	`}`
`2038`	`2038`
`2039`	`2039`	`pub fn trans_tuple_struct(ccx: @mut CrateContext,`
`2040`		`- fields: &[@ast::struct_field],`
	`2040`	`+ fields: &[ast::struct_field],`
`2041`	`2041`	`ctor_id: ast::NodeId,`
`2042`	`2042`	`param_substs: Option<@param_substs>,`
`2043`	`2043`	`llfndecl: ValueRef) {`
`@@ -2062,7 +2062,7 @@ impl IdAndTy for ast::variant_arg {`
`2062`	`2062`	`fn ty<'a>(&'a self) -> &'a ast::Ty { &self.ty }`
`2063`	`2063`	`}`
`2064`	`2064`
`2065`		`-impl IdAndTy for @ast::struct_field {`
	`2065`	`+impl IdAndTy for ast::struct_field {`
`2066`	`2066`	`fn id(&self) -> ast::NodeId { self.node.id }`
`2067`	`2067`	`fn ty<'a>(&'a self) -> &'a ast::Ty { &self.node.ty }`
`2068`	`2068`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3693,7 +3693,7 @@ impl VariantInfo {`
`3693`	`3693`	`},`
`3694`	`3694`	`ast::struct_variant_kind(ref struct_def) => {`
`3695`	`3695`
`3696`		`- let fields: &[@struct_field] = struct_def.fields;`
	`3696`	`+ let fields: &[struct_field] = struct_def.fields;`
`3697`	`3697`
`3698`	`3698`	`assert!(fields.len() > 0);`
`3699`	`3699`
`@@ -4082,7 +4082,7 @@ pub fn lookup_struct_field(cx: ctxt,`
`4082`	`4082`	`}`
`4083`	`4083`	`}`
`4084`	`4084`
`4085`		`-fn struct_field_tys(fields: &[@struct_field]) -> ~[field_ty] {`
	`4085`	`+fn struct_field_tys(fields: &[struct_field]) -> ~[field_ty] {`
`4086`	`4086`	`fields.map(\|field\| {`
`4087`	`4087`	`match field.node.kind {`
`4088`	`4088`	`named_field(ident, visibility) => {`
Original file line number	Diff line number	Diff line change
`@@ -620,7 +620,7 @@ pub fn convert_struct(ccx: &CrateCtxt,`
`620`	`620`
`621`	`621`	`// Write the type of each of the members`
`622`	`622`	`for f in struct_def.fields.iter() {`
`623`		`- convert_field(ccx, &tpt.generics, *f);`
	`623`	`+ convert_field(ccx, &tpt.generics, f);`
`624`	`624`	`}`
`625`	`625`	`let substs = mk_item_substs(ccx, &tpt.generics, None);`
`626`	`626`	`let selfty = ty::mk_struct(tcx, local_def(id), substs);`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ pub struct Struct {`
`80`	`80`	`name: Ident,`
`81`	`81`	`generics: ast::Generics,`
`82`	`82`	`attrs: ~[ast::Attribute],`
`83`		`- fields: ~[@ast::struct_field],`
	`83`	`+ fields: ~[ast::struct_field],`
`84`	`84`	`where: Span,`
`85`	`85`	`}`
`86`	`86`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ impl RustdocVisitor {`
`46`	`46`	`vis: item.vis,`
`47`	`47`	`attrs: item.attrs.clone(),`
`48`	`48`	`generics: generics.clone(),`
`49`		`- fields: sd.fields.iter().map(\|x\| (*x).clone()).to_owned_vec(),`
	`49`	`+ fields: sd.fields.clone(),`
`50`	`50`	`where: item.span`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -576,7 +576,7 @@ impl<'self, O: IdVisitingOperation> Visitor<()> for IdVisitor<'self, O> {`
`576`	`576`	`}`
`577`	`577`	`}`
`578`	`578`
`579`		`- fn visit_struct_field(&mut self, struct_field: @struct_field, env: ()) {`
	`579`	`+ fn visit_struct_field(&mut self, struct_field: &struct_field, env: ()) {`
`580`	`580`	`self.operation.visit_id(struct_field.node.id);`
`581`	`581`	`visit::walk_struct_field(self, struct_field, env)`
`582`	`582`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ pub trait Visitor<E:Clone> {`
`92`	`92`	`fn visit_struct_def(&mut self, s:@struct_def, i:Ident, g:&Generics, n:NodeId, e:E) {`
`93`	`93`	`walk_struct_def(self, s, i, g, n, e)`
`94`	`94`	`}`
`95`		`- fn visit_struct_field(&mut self, s:@struct_field, e:E) { walk_struct_field(self, s, e) }`
	`95`	`+ fn visit_struct_field(&mut self, s:&struct_field, e:E) { walk_struct_field(self, s, e) }`
`96`	`96`	`fn visit_variant(&mut self, v:&variant, g:&Generics, e:E) { walk_variant(self, v, g, e) }`
`97`	`97`	`fn visit_opt_lifetime_ref(&mut self,`
`98`	`98`	`_span: Span,`
`@@ -538,7 +538,7 @@ pub fn walk_struct_def<E:Clone, V:Visitor<E>>(visitor: &mut V,`
`538`	`538`	`_: NodeId,`
`539`	`539`	`env: E) {`
`540`	`540`	`for field in struct_definition.fields.iter() {`
`541`		`- visitor.visit_struct_field(*field, env.clone())`
	`541`	`+ visitor.visit_struct_field(field, env.clone())`
`542`	`542`	`}`
`543`	`543`	`}`
`544`	`544`