---

yaml
---
r: 128825
b: refs/heads/try
c: 1c16acc
h: refs/heads/master
i:
  128823: 55a533c
v: v3

Author: pcwalton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: a8c8e3f80fd0355b2bb91337c6ad0bb0a38d5485
+refs/heads/try: 1c16accfc204b447b128ed17545e88d947144682
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/rust.md

@@ -919,7 +919,7 @@ extern crate foo = "some/where/rust-foo#foo:1.0"; // a full crate ID for externa
 ##### Use declarations
 
 ~~~~ {.ebnf .gram}
-use_decl : "pub" ? "use" [ ident '=' path
+use_decl : "pub" ? "use" [ path "as" ident
                           | path_glob ] ;
 
 path_glob : ident [ "::" [ path_glob
@@ -939,7 +939,7 @@ module item. These declarations may appear at the top of [modules](#modules) and
 
 Use declarations support a number of convenient shortcuts:
 
-  * Rebinding the target name as a new local name, using the syntax `use x = p::q::r;`.
+  * Rebinding the target name as a new local name, using the syntax `use p::q::r as x;`.
   * Simultaneously binding a list of paths differing only in their final element,
     using the glob-like brace syntax `use a::b::{c,d,e,f};`
   * Binding all paths matching a given prefix, using the asterisk wildcard syntax `use a::b::*;`

branches/try/src/librustc/front/config.rs

@@ -109,14 +109,10 @@ fn fold_foreign_mod(cx: &mut Context, nm: &ast::ForeignMod) -> ast::ForeignMod {
 
 fn fold_item_underscore(cx: &mut Context, item: &ast::Item_) -> ast::Item_ {
     let item = match *item {
-        ast::ItemImpl(ref a, ref b, c, ref impl_items) => {
-            let impl_items = impl_items.iter()
-                                       .filter(|ii| {
-                                           impl_item_in_cfg(cx, &**ii)
-                                       })
-                                       .map(|x| *x)
-                                       .collect();
-            ast::ItemImpl((*a).clone(), (*b).clone(), c, impl_items)
+        ast::ItemImpl(ref a, ref b, c, ref methods) => {
+            let methods = methods.iter().filter(|m| method_in_cfg(cx, &***m))
+                .map(|x| *x).collect();
+            ast::ItemImpl((*a).clone(), (*b).clone(), c, methods)
         }
         ast::ItemTrait(ref a, ref b, ref c, ref methods) => {
             let methods = methods.iter()
@@ -234,16 +230,14 @@ fn view_item_in_cfg(cx: &mut Context, item: &ast::ViewItem) -> bool {
     return (cx.in_cfg)(item.attrs.as_slice());
 }
 
-fn trait_method_in_cfg(cx: &mut Context, meth: &ast::TraitItem) -> bool {
-    match *meth {
-        ast::RequiredMethod(ref meth) => (cx.in_cfg)(meth.attrs.as_slice()),
-        ast::ProvidedMethod(meth) => (cx.in_cfg)(meth.attrs.as_slice())
-    }
+fn method_in_cfg(cx: &mut Context, meth: &ast::Method) -> bool {
+    return (cx.in_cfg)(meth.attrs.as_slice());
 }
 
-fn impl_item_in_cfg(cx: &mut Context, impl_item: &ast::ImplItem) -> bool {
-    match *impl_item {
-        ast::MethodImplItem(meth) => (cx.in_cfg)(meth.attrs.as_slice()),
+fn trait_method_in_cfg(cx: &mut Context, meth: &ast::TraitMethod) -> bool {
+    match *meth {
+        ast::Required(ref meth) => (cx.in_cfg)(meth.attrs.as_slice()),
+        ast::Provided(meth) => (cx.in_cfg)(meth.attrs.as_slice())
     }
 }
 

branches/try/src/librustc/lint/builtin.rs

@@ -801,19 +801,15 @@ fn method_context(cx: &Context, m: &ast::Method) -> MethodContext {
         node: m.id
     };
 
-    match cx.tcx.impl_or_trait_items.borrow().find_copy(&did) {
+    match cx.tcx.methods.borrow().find_copy(&did) {
         None => cx.sess().span_bug(m.span, "missing method descriptor?!"),
         Some(md) => {
-            match md {
-                ty::MethodTraitItem(md) => {
-                    match md.container {
-                        ty::TraitContainer(..) => TraitDefaultImpl,
-                        ty::ImplContainer(cid) => {
-                            match ty::impl_trait_ref(cx.tcx, cid) {
-                                Some(..) => TraitImpl,
-                                None => PlainImpl
-                            }
-                        }
+            match md.container {
+                ty::TraitContainer(..) => TraitDefaultImpl,
+                ty::ImplContainer(cid) => {
+                    match ty::impl_trait_ref(cx.tcx, cid) {
+                        Some(..) => TraitImpl,
+                        None => PlainImpl
                     }
                 }
             }
@@ -1474,15 +1470,7 @@ impl LintPass for Stability {
                                 trait_id: trait_id,
                                 method_num: index,
                                 ..
-                            }) => {
-                                match ty::trait_item(cx.tcx,
-                                                     trait_id,
-                                                     index) {
-                                    ty::MethodTraitItem(method) => {
-                                        method.def_id
-                                    }
-                                }
-                            }
+                            }) => ty::trait_method(cx.tcx, trait_id, index).def_id
                         }
                     }
                     None => return

branches/try/src/librustc/lint/context.rs

@@ -563,9 +563,9 @@ impl<'a> Visitor<()> for Context<'a> {
         visit::walk_generics(self, g, ());
     }
 
-    fn visit_trait_item(&mut self, m: &ast::TraitItem, _: ()) {
+    fn visit_trait_method(&mut self, m: &ast::TraitMethod, _: ()) {
         run_lints!(self, check_trait_method, m);
-        visit::walk_trait_item(self, m, ());
+        visit::walk_trait_method(self, m, ());
     }
 
     fn visit_opt_lifetime_ref(&mut self, sp: Span, lt: &Option<ast::Lifetime>, _: ()) {

branches/try/src/librustc/lint/mod.rs

@@ -141,7 +141,7 @@ pub trait LintPass {
     fn check_fn(&mut self, _: &Context,
         _: &FnKind, _: &ast::FnDecl, _: &ast::Block, _: Span, _: ast::NodeId) { }
     fn check_ty_method(&mut self, _: &Context, _: &ast::TypeMethod) { }
-    fn check_trait_method(&mut self, _: &Context, _: &ast::TraitItem) { }
+    fn check_trait_method(&mut self, _: &Context, _: &ast::TraitMethod) { }
     fn check_struct_def(&mut self, _: &Context,
         _: &ast::StructDef, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { }
     fn check_struct_def_post(&mut self, _: &Context,

branches/try/src/librustc/metadata/common.rs

@@ -77,7 +77,7 @@ pub static tag_crate_dep_hash: uint = 0x1e;
 
 pub static tag_mod_impl: uint = 0x1f;
 
-pub static tag_item_trait_item: uint = 0x20;
+pub static tag_item_trait_method: uint = 0x20;
 
 pub static tag_item_trait_ref: uint = 0x21;
 pub static tag_item_super_trait_ref: uint = 0x22;
@@ -95,14 +95,14 @@ pub static tag_item_field_origin: uint = 0x29;
 
 pub static tag_item_variances: uint = 0x2a;
 /*
-  trait items contain tag_item_trait_item elements,
-  impl items contain tag_item_impl_item elements, and classes
+  trait items contain tag_item_trait_method elements,
+  impl items contain tag_item_impl_method elements, and classes
   have both. That's because some code treats classes like traits,
   and other code treats them like impls. Because classes can contain
-  both, tag_item_trait_item and tag_item_impl_item have to be two
+  both, tag_item_trait_method and tag_item_impl_method have to be two
   different tags.
  */
-pub static tag_item_impl_item: uint = 0x30;
+pub static tag_item_impl_method: uint = 0x30;
 pub static tag_item_trait_method_explicit_self: uint = 0x31;
 
 
@@ -154,11 +154,9 @@ impl astencode_tag {
     }
 }
 
-pub static tag_item_trait_item_sort: uint = 0x60;
+pub static tag_item_trait_method_sort: uint = 0x60;
 
-pub static tag_item_trait_parent_sort: uint = 0x61;
-
-pub static tag_item_impl_type_basename: uint = 0x62;
+pub static tag_item_impl_type_basename: uint = 0x61;
 
 pub static tag_crate_triple: uint = 0x66;
 

branches/try/src/librustc/metadata/csearch.rs

@@ -16,7 +16,6 @@ use metadata::common::*;
 use metadata::cstore;
 use metadata::decoder;
 use middle::lang_items;
-use middle::resolve;
 use middle::ty;
 use middle::typeck;
 use middle::subst::VecPerParamSpace;
@@ -122,33 +121,30 @@ pub fn get_enum_variants(tcx: &ty::ctxt, def: ast::DefId)
 }
 
 /// Returns information about the given implementation.
-pub fn get_impl_items(cstore: &cstore::CStore, impl_def_id: ast::DefId)
-                      -> Vec<ty::ImplOrTraitItemId> {
+pub fn get_impl_methods(cstore: &cstore::CStore, impl_def_id: ast::DefId)
+                        -> Vec<ast::DefId> {
     let cdata = cstore.get_crate_data(impl_def_id.krate);
-    decoder::get_impl_items(&*cdata, impl_def_id.node)
+    decoder::get_impl_methods(&*cdata, impl_def_id.node)
 }
 
-pub fn get_impl_or_trait_item(tcx: &ty::ctxt, def: ast::DefId)
-                              -> ty::ImplOrTraitItem {
+pub fn get_method(tcx: &ty::ctxt, def: ast::DefId) -> ty::Method {
     let cdata = tcx.sess.cstore.get_crate_data(def.krate);
-    decoder::get_impl_or_trait_item(tcx.sess.cstore.intr.clone(),
-                                    &*cdata,
-                                    def.node,
-                                    tcx)
+    decoder::get_method(tcx.sess.cstore.intr.clone(), &*cdata, def.node, tcx)
 }
 
-pub fn get_trait_item_name_and_kind(cstore: &cstore::CStore, def: ast::DefId)
-                                    -> (ast::Ident, resolve::TraitItemKind) {
+pub fn get_method_name_and_explicit_self(cstore: &cstore::CStore,
+                                         def: ast::DefId)
+                                         -> (ast::Ident,
+                                             ty::ExplicitSelfCategory)
+{
     let cdata = cstore.get_crate_data(def.krate);
-    decoder::get_trait_item_name_and_kind(cstore.intr.clone(),
-                                          &*cdata,
-                                          def.node)
+    decoder::get_method_name_and_explicit_self(cstore.intr.clone(), &*cdata, def.node)
 }
 
-pub fn get_trait_item_def_ids(cstore: &cstore::CStore, def: ast::DefId)
-                              -> Vec<ty::ImplOrTraitItemId> {
+pub fn get_trait_method_def_ids(cstore: &cstore::CStore,
+                                def: ast::DefId) -> Vec<ast::DefId> {
     let cdata = cstore.get_crate_data(def.krate);
-    decoder::get_trait_item_def_ids(&*cdata, def.node)
+    decoder::get_trait_method_def_ids(&*cdata, def.node)
 }
 
 pub fn get_item_variances(cstore: &cstore::CStore,
@@ -290,15 +286,15 @@ pub fn each_implementation_for_trait(cstore: &cstore::CStore,
     decoder::each_implementation_for_trait(&*cdata, def_id.node, callback)
 }
 
-/// If the given def ID describes an item belonging to a trait (either a
+/// If the given def ID describes a method belonging to a trait (either a
 /// default method or an implementation of a trait method), returns the ID of
 /// the trait that the method belongs to. Otherwise, returns `None`.
-pub fn get_trait_of_item(cstore: &cstore::CStore,
-                         def_id: ast::DefId,
-                         tcx: &ty::ctxt)
-                         -> Option<ast::DefId> {
+pub fn get_trait_of_method(cstore: &cstore::CStore,
+                           def_id: ast::DefId,
+                           tcx: &ty::ctxt)
+                           -> Option<ast::DefId> {
     let cdata = cstore.get_crate_data(def_id.krate);
-    decoder::get_trait_of_item(&*cdata, def_id.node, tcx)
+    decoder::get_trait_of_method(&*cdata, def_id.node, tcx)
 }
 
 pub fn get_tuple_struct_definition_if_ctor(cstore: &cstore::CStore,