Change 'iface' to 'trait' internally; parse `trait` as `iface` synonym

7 files changed, 40 insertions, 38 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 9419b9f647e..676c713f8e5 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -62,7 +62,7 @@ enum ty_param_bound {
     bound_copy,
     bound_send,
     bound_const,
-    bound_iface(@ty),
+    bound_trait(@ty),
 }
 
 #[auto_serialize]
@@ -657,11 +657,11 @@ enum attr_style { attr_outer, attr_inner, }
 type attribute_ = {style: attr_style, value: meta_item, is_sugared_doc: bool};
 
 /*
-  iface_refs appear in both impls and in classes that implement ifaces.
-  resolve maps each iface_ref's id to its defining iface.
+  trait_refs appear in both impls and in classes that implement traits.
+  resolve maps each trait_ref's id to its defining trait.
  */
 #[auto_serialize]
-type iface_ref = {path: @path, id: node_id};
+type trait_ref = {path: @path, id: node_id};
 
 #[auto_serialize]
 enum visibility { public, private }
@@ -686,7 +686,7 @@ enum item_ {
     item_ty(@ty, ~[ty_param], region_param),
     item_enum(~[variant], ~[ty_param], region_param),
     item_class(~[ty_param], /* ty params for class */
-               ~[@iface_ref],   /* ifaces this class implements */
+               ~[@trait_ref],   /* traits this class implements */
                ~[@class_member], /* methods, etc. */
                                /* (not including ctor or dtor) */
                class_ctor,
@@ -694,8 +694,8 @@ enum item_ {
                option<class_dtor>,
                region_param
                ),
-    item_iface(~[ty_param], region_param, ~[ty_method]),
-    item_impl(~[ty_param], region_param, option<@iface_ref> /* iface */,
+    item_trait(~[ty_param], region_param, ~[ty_method]),
+    item_impl(~[ty_param], region_param, option<@trait_ref> /* trait */,
               @ty /* self */, ~[@method]),
 }
 
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 4974b07503e..79d6691caf1 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -214,11 +214,11 @@ fn map_item(i: @item, cx: ctx, v: vt) {
                                            extend(cx, i.ident)));
         }
       }
-      item_class(tps, ifces, items, ctor, dtor, _) {
+      item_class(tps, traits, items, ctor, dtor, _) {
           let (_, ms) = ast_util::split_class_items(items);
-          // Map iface refs to their parent classes. This is
+          // Map trait refs to their parent classes. This is
           // so we can find the self_ty
-          do vec::iter(ifces) |p| { cx.map.insert(p.id,
+          do vec::iter(traits) |p| { cx.map.insert(p.id,
                                   node_item(i, item_path)); };
           let d_id = ast_util::local_def(i.id);
           let p = extend(cx, i.ident);
diff --git a/src/libsyntax/ext/auto_serialize.rs b/src/libsyntax/ext/auto_serialize.rs
index d2d685f8f7d..a1e6aa06d59 100644
--- a/src/libsyntax/ext/auto_serialize.rs
+++ b/src/libsyntax/ext/auto_serialize.rs
@@ -530,7 +530,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
     }
 
     let ser_bnds = @~[
-        ast::bound_iface(cx.ty_path(span,
+        ast::bound_trait(cx.ty_path(span,
                                     ~[@"std", @"serialization",
                                      @"serializer"],
                                     ~[]))];
@@ -736,7 +736,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
     }
 
     let deser_bnds = @~[
-        ast::bound_iface(cx.ty_path(
+        ast::bound_trait(cx.ty_path(
             span,
             ~[@"std", @"serialization", @"deserializer"],
             ~[]))];
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index c949c2e17aa..ad55c85496b 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -142,7 +142,7 @@ fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
 fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
     alt tpb {
       bound_copy | bound_send | bound_const { tpb }
-      bound_iface(ty) { bound_iface(fld.fold_ty(ty)) }
+      bound_trait(ty) { bound_trait(fld.fold_ty(ty)) }
     }
 }
 
@@ -252,7 +252,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
                       fold_ty_params(typms, fld),
                       r)
           }
-          item_class(typms, ifaces, items, ctor, m_dtor, rp) {
+          item_class(typms, traits, items, ctor, m_dtor, rp) {
               let ctor_body = fld.fold_block(ctor.node.body);
               let ctor_decl = fold_fn_decl(ctor.node.dec, fld);
               let ctor_id   = fld.new_id(ctor.node.id);
@@ -264,7 +264,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
                     with dtor}};
               item_class(
                   /* FIXME (#2543) */ copy typms,
-                  vec::map(ifaces, |p| fold_iface_ref(p, fld)),
+                  vec::map(traits, |p| fold_trait_ref(p, fld)),
                   vec::map(items, fld.fold_class_item),
                   {node: {body: ctor_body,
                           dec: ctor_decl,
@@ -274,19 +274,19 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
           item_impl(tps, rp, ifce, ty, methods) {
               item_impl(fold_ty_params(tps, fld),
                         rp,
-                        ifce.map(|p| fold_iface_ref(p, fld)),
+                        ifce.map(|p| fold_trait_ref(p, fld)),
                         fld.fold_ty(ty),
                         vec::map(methods, fld.fold_method))
           }
-          item_iface(tps, rp, methods) {
-            item_iface(fold_ty_params(tps, fld),
+          item_trait(tps, rp, methods) {
+            item_trait(fold_ty_params(tps, fld),
                        rp,
                        /* FIXME (#2543) */ copy methods)
           }
         };
 }
 
-fn fold_iface_ref(&&p: @iface_ref, fld: ast_fold) -> @iface_ref {
+fn fold_trait_ref(&&p: @trait_ref, fld: ast_fold) -> @trait_ref {
     @{path: fld.fold_path(p.path), id: fld.new_id(p.id)}
 }
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index c9292308810..bec58354137 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1892,7 +1892,7 @@ class parser {
                 else if self.eat_keyword("const") {
                     push(bounds, bound_const)
                 }
-                else { push(bounds, bound_iface(self.parse_ty(false))); }
+                else { push(bounds, bound_trait(self.parse_ty(false))); }
             }
         }
         ret {ident: ident, id: self.get_id(), bounds: @bounds};
@@ -2008,12 +2008,12 @@ class parser {
           self_id: self.get_id(), vis: pr}
     }
 
-    fn parse_item_iface() -> item_info {
+    fn parse_item_trait() -> item_info {
         let ident = self.parse_ident();
         let rp = self.parse_region_param();
         let tps = self.parse_ty_params();
         let meths = self.parse_ty_methods();
-        (ident, item_iface(tps, rp, meths), none)
+        (ident, item_trait(tps, rp, meths), none)
     }
 
     // Parses three variants (with the region/type params always optional):
@@ -2082,15 +2082,15 @@ class parser {
          }
     }
 
-    fn parse_iface_ref() -> @iface_ref {
+    fn parse_trait_ref() -> @trait_ref {
         @{path: self.parse_path_with_tps(false),
           id: self.get_id()}
     }
 
-    fn parse_iface_ref_list() -> ~[@iface_ref] {
+    fn parse_trait_ref_list() -> ~[@trait_ref] {
         self.parse_seq_to_before_end(
             token::LBRACE, seq_sep_trailing_disallowed(token::COMMA),
-            |p| p.parse_iface_ref())
+            |p| p.parse_trait_ref())
     }
 
     fn parse_item_class() -> item_info {
@@ -2098,8 +2098,8 @@ class parser {
         let rp = self.parse_region_param();
         let ty_params = self.parse_ty_params();
         let class_path = self.ident_to_path_tys(class_name, rp, ty_params);
-        let ifaces : ~[@iface_ref] = if self.eat(token::COLON)
-            { self.parse_iface_ref_list() }
+        let traits : ~[@trait_ref] = if self.eat(token::COLON)
+            { self.parse_trait_ref_list() }
         else { ~[] };
         self.expect(token::LBRACE);
         let mut ms: ~[@class_member] = ~[];
@@ -2127,7 +2127,7 @@ class parser {
         alt the_ctor {
           some((ct_d, ct_b, ct_s)) {
             (class_name,
-             item_class(ty_params, ifaces, ms, {
+             item_class(ty_params, traits, ms, {
                  node: {id: ctor_id,
                         self_id: self.get_id(),
                         dec: ct_d,
@@ -2462,7 +2462,9 @@ class parser {
         } else if self.eat_keyword("enum") {
             self.parse_item_enum(vis)
         } else if self.eat_keyword("iface") {
-            self.parse_item_iface()
+            self.parse_item_trait()
+        } else if self.eat_keyword("trait") {
+            self.parse_item_trait()
         } else if self.eat_keyword("impl") {
             self.parse_item_impl()
         } else if self.eat_keyword("class") {
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 5f2aada9fc6..8e85de17613 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -494,14 +494,14 @@ fn print_item(s: ps, &&item: @ast::item) {
             bclose(s, item.span);
         }
       }
-      ast::item_class(tps, ifaces, items, ctor, m_dtor, rp) {
+      ast::item_class(tps, traits, items, ctor, m_dtor, rp) {
           head(s, "class");
           word_nbsp(s, *item.ident);
           print_region_param(s, rp);
           print_type_params(s, tps);
-          if vec::len(ifaces) != 0u {
+          if vec::len(traits) != 0u {
               word_space(s, ":");
-              commasep(s, inconsistent, ifaces, |s, p|
+              commasep(s, inconsistent, traits, |s, p|
                   print_path(s, p.path, false));
           }
           bopen(s);
@@ -579,7 +579,7 @@ fn print_item(s: ps, &&item: @ast::item) {
         }
         bclose(s, item.span);
       }
-      ast::item_iface(tps, rp, methods) {
+      ast::item_trait(tps, rp, methods) {
         head(s, "iface");
         word(s.s, *item.ident);
         print_region_param(s, rp);
@@ -1350,7 +1350,7 @@ fn print_bounds(s: ps, bounds: @~[ast::ty_param_bound]) {
               ast::bound_copy { word(s.s, "copy"); }
               ast::bound_send { word(s.s, "send"); }
               ast::bound_const { word(s.s, "const"); }
-              ast::bound_iface(t) { print_type(s, t); }
+              ast::bound_trait(t) { print_type(s, t); }
             }
         }
     }
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 48f2e57de1c..25c61535fcf 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -143,19 +143,19 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
             visit_method_helper(m, e, v)
         }
       }
-      item_class(tps, ifaces, members, ctor, m_dtor, _) {
+      item_class(tps, traits, members, ctor, m_dtor, _) {
           v.visit_ty_params(tps, e, v);
           for members.each |m| {
              v.visit_class_item(m, e, v);
           }
-          for ifaces.each |p| { visit_path(p.path, e, v); }
+          for traits.each |p| { visit_path(p.path, e, v); }
           visit_class_ctor_helper(ctor, i.ident, tps,
                                   ast_util::local_def(i.id), e, v);
           do option::iter(m_dtor) |dtor| {
                   visit_class_dtor_helper(dtor, tps,
                      ast_util::local_def(i.id), e, v)};
       }
-      item_iface(tps, _rp, methods) {
+      item_trait(tps, _rp, methods) {
         v.visit_ty_params(tps, e, v);
         for methods.each |m| {
             for m.decl.inputs.each |a| { v.visit_ty(a.ty, e, v); }
@@ -260,7 +260,7 @@ fn visit_ty_params<E>(tps: ~[ty_param], e: E, v: vt<E>) {
     for tps.each |tp| {
         for vec::each(*tp.bounds) |bound| {
             alt bound {
-              bound_iface(t) { v.visit_ty(t, e, v); }
+              bound_trait(t) { v.visit_ty(t, e, v); }
               bound_copy | bound_send | bound_const { }
             }
         }