Move ast_map::map to LinearMap

Author: alexcrichton

src/librustc/metadata/encoder.rs

@@ -1026,7 +1026,7 @@ fn encode_info_for_items(ecx: @EncodeContext, ebml_w: writer::Encoder,
             let ebml_w = copy ebml_w;
             |i, cx, v| {
                 visit::visit_item(i, cx, v);
-                match ecx.tcx.items.get(&i.id) {
+                match *ecx.tcx.items.get(&i.id) {
                     ast_map::node_item(_, pt) => {
                         encode_info_for_item(ecx, ebml_w, i,
                                              index, *pt);
@@ -1039,7 +1039,7 @@ fn encode_info_for_items(ecx: @EncodeContext, ebml_w: writer::Encoder,
             let ebml_w = copy ebml_w;
             |ni, cx, v| {
                 visit::visit_foreign_item(ni, cx, v);
-                match ecx.tcx.items.get(&ni.id) {
+                match *ecx.tcx.items.get(&ni.id) {
                     ast_map::node_foreign_item(_, abi, _, pt) => {
                         encode_info_for_foreign_item(ecx, ebml_w, ni,
                                                      index, /*bad*/copy *pt,

src/librustc/middle/check_const.rs

@@ -240,7 +240,7 @@ pub fn check_item_recursion(sess: Session,
             match env.def_map.find(&e.id) {
               Some(&def_const(def_id)) => {
                 if ast_util::is_local(def_id) {
-                  match env.ast_map.get(&def_id.node) {
+                  match *env.ast_map.get(&def_id.node) {
                     ast_map::node_item(it, _) => {
                       (v.visit_item)(it, env, v);
                     }

src/librustc/middle/const_eval.rs

@@ -182,7 +182,7 @@ pub fn lookup_const_by_id(tcx: ty::ctxt,
     if ast_util::is_local(def_id) {
         match tcx.items.find(&def_id.node) {
             None => None,
-            Some(ast_map::node_item(it, _)) => match it.node {
+            Some(&ast_map::node_item(it, _)) => match it.node {
                 item_const(_, const_expr) => Some(const_expr),
                 _ => None
             },

src/librustc/middle/privacy.rs

@@ -113,8 +113,8 @@ pub fn check_crate(tcx: ty::ctxt,
             @fn(span: span, method_id: node_id) -> def_id =
             |span, method_id| {
         match tcx.items.find(&method_id) {
-            Some(node_method(_, impl_id, _)) => impl_id,
-            Some(node_trait_method(_, trait_id, _)) => trait_id,
+            Some(&node_method(_, impl_id, _)) => impl_id,
+            Some(&node_trait_method(_, trait_id, _)) => trait_id,
             Some(_) => {
                 tcx.sess.span_bug(span,
                                   fmt!("method was a %s?!",
@@ -148,7 +148,7 @@ pub fn check_crate(tcx: ty::ctxt,
                 }
 
                 match tcx.items.find(&container_id.node) {
-                    Some(node_item(item, _)) => {
+                    Some(&node_item(item, _)) => {
                         match item.node {
                             item_impl(_, None, _, _)
                                     if item.vis != public => {
@@ -170,10 +170,10 @@ pub fn check_crate(tcx: ty::ctxt,
         };
 
         match tcx.items.find(&method_id) {
-            Some(node_method(method, impl_id, _)) => {
+            Some(&node_method(method, impl_id, _)) => {
                 check(method.vis, impl_id)
             }
-            Some(node_trait_method(trait_method, trait_id, _)) => {
+            Some(&node_trait_method(trait_method, trait_id, _)) => {
                 match *trait_method {
                     required(_) => check(public, trait_id),
                     provided(method) => check(method.vis, trait_id),
@@ -200,16 +200,16 @@ pub fn check_crate(tcx: ty::ctxt,
         let mut f: &fn(node_id) -> bool = |_| false;
         f = |item_id| {
             match tcx.items.find(&item_id) {
-                Some(node_item(item, _)) => item.vis != public,
-                Some(node_foreign_item(_, _, vis, _)) => vis != public,
-                Some(node_method(method, impl_did, _)) => {
+                Some(&node_item(item, _)) => item.vis != public,
+                Some(&node_foreign_item(_, _, vis, _)) => vis != public,
+                Some(&node_method(method, impl_did, _)) => {
                     match method.vis {
                         private => true,
                         public => false,
                         inherited => f(impl_did.node)
                     }
                 }
-                Some(node_trait_method(_, trait_did, _)) => f(trait_did.node),
+                Some(&node_trait_method(_, trait_did, _)) => f(trait_did.node),
                 Some(_) => {
                     tcx.sess.span_bug(span,
                                       fmt!("local_item_is_private: item was \
@@ -332,7 +332,7 @@ pub fn check_crate(tcx: ty::ctxt,
             method_super(trait_id, method_num) => {
                 if trait_id.crate == local_crate {
                     match tcx.items.find(&trait_id.node) {
-                        Some(node_item(item, _)) => {
+                        Some(&node_item(item, _)) => {
                             match item.node {
                                 item_trait(_, _, ref methods) => {
                                     if method_num >= (*methods).len() {

src/librustc/middle/trans/base.rs

@@ -2065,7 +2065,7 @@ pub fn trans_enum_def(ccx: @CrateContext, enum_definition: ast::enum_def,
 
 pub fn trans_item(ccx: @CrateContext, item: ast::item) {
     let _icx = ccx.insn_ctxt("trans_item");
-    let path = match ccx.tcx.items.get(&item.id) {
+    let path = match *ccx.tcx.items.get(&item.id) {
         ast_map::node_item(_, p) => p,
         // tjc: ?
         _ => fail!(~"trans_item"),
@@ -2336,13 +2336,12 @@ pub fn fill_fn_pair(bcx: block, pair: ValueRef, llfn: ValueRef,
 }
 
 pub fn item_path(ccx: @CrateContext, i: @ast::item) -> path {
-    vec::append(
-        /*bad*/copy *match ccx.tcx.items.get(&i.id) {
-            ast_map::node_item(_, p) => p,
-                // separate map for paths?
-            _ => fail!(~"item_path")
-        },
-        ~[path_name(i.ident)])
+    let base = match *ccx.tcx.items.get(&i.id) {
+        ast_map::node_item(_, p) => p,
+            // separate map for paths?
+        _ => fail!(~"item_path")
+    };
+    vec::append(/*bad*/copy *base, ~[path_name(i.ident)])
 }
 
 /* If there's already a symbol for the dtor with <id> and substs <substs>,
@@ -2393,7 +2392,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef {
       None => {
 
         let mut exprt = false;
-        let val = match ccx.tcx.items.get(&id) {
+        let val = match *ccx.tcx.items.get(&id) {
           ast_map::node_item(i, pth) => {
             let my_path = vec::append(/*bad*/copy *pth,
                                       ~[path_name(i.ident)]);

src/librustc/middle/trans/callee.rs

@@ -268,7 +268,7 @@ pub fn trans_fn_ref_with_vtables(
             ccx.tcx.items.find(&def_id.node),
             || fmt!("local item should be in ast map"));
 
-        match map_node {
+        match *map_node {
             ast_map::node_foreign_item(_,
                                        ast::foreign_abi_rust_intrinsic,
                                        _,

src/librustc/middle/trans/consts.rs

@@ -158,7 +158,7 @@ pub fn get_const_val(cx: @CrateContext, def_id: ast::def_id) -> ValueRef {
         if !ast_util::is_local(def_id) {
             def_id = inline::maybe_instantiate_inline(cx, def_id, true);
         }
-        match cx.tcx.items.get(&def_id.node) {
+        match *cx.tcx.items.get(&def_id.node) {
             ast_map::node_item(@ast::item {
                 node: ast::item_const(_, subexpr), _
             }, _) => {

src/librustc/middle/trans/debuginfo.rs

@@ -849,7 +849,7 @@ pub fn create_function(fcx: fn_ctxt) -> @Metadata<SubProgramMetadata> {
     let sp = fcx.span.get();
     debug!("%s", cx.sess.codemap.span_to_str(sp));
 
-    let (ident, ret_ty, id) = match cx.tcx.items.get(&fcx.id) {
+    let (ident, ret_ty, id) = match *cx.tcx.items.get(&fcx.id) {
       ast_map::node_item(item, _) => {
         match item.node {
           ast::item_fn(ref decl, _, _, _) => {

src/librustc/middle/trans/foreign.rs

@@ -567,7 +567,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
             let tp_sz = machine::llbitsize_of_real(ccx, lltp_ty),
             out_sz = machine::llbitsize_of_real(ccx, llout_ty);
           if tp_sz != out_sz {
-              let sp = match ccx.tcx.items.get(&ref_id.get()) {
+              let sp = match *ccx.tcx.items.get(&ref_id.get()) {
                   ast_map::node_expr(e) => e.span,
                   _ => fail!(~"reinterpret_cast or forget has non-expr arg")
               };
@@ -1082,7 +1082,7 @@ pub fn register_foreign_fn(ccx: @CrateContext,
 fn abi_of_foreign_fn(ccx: @CrateContext, i: @ast::foreign_item)
     -> ast::foreign_abi {
     match attr::first_attr_value_str_by_name(i.attrs, ~"abi") {
-      None => match ccx.tcx.items.get(&i.id) {
+      None => match *ccx.tcx.items.get(&i.id) {
         ast_map::node_foreign_item(_, abi, _, _) => abi,
         // ??
         _ => fail!(~"abi_of_foreign_fn: not foreign")

src/librustc/middle/trans/meth.rs

@@ -306,7 +306,7 @@ pub fn trans_static_method_callee(bcx: block,
     };
 
     let mname = if method_id.crate == ast::local_crate {
-        match bcx.tcx().items.get(&method_id.node) {
+        match *bcx.tcx().items.get(&method_id.node) {
             ast_map::node_trait_method(trait_method, _, _) => {
                 ast_util::trait_method_to_ty_method(trait_method).ident
             }
@@ -361,7 +361,7 @@ pub fn method_from_methods(ms: &[@ast::method], name: ast::ident)
 pub fn method_with_name(ccx: @CrateContext, impl_id: ast::def_id,
                         name: ast::ident) -> ast::def_id {
     if impl_id.crate == ast::local_crate {
-        match ccx.tcx.items.get(&impl_id.node) {
+        match *ccx.tcx.items.get(&impl_id.node) {
           ast_map::node_item(@ast::item {
                 node: ast::item_impl(_, _, _, ref ms),
                 _
@@ -378,7 +378,7 @@ pub fn method_with_name(ccx: @CrateContext, impl_id: ast::def_id,
 pub fn method_with_name_or_default(ccx: @CrateContext, impl_id: ast::def_id,
                                    name: ast::ident) -> ast::def_id {
     if impl_id.crate == ast::local_crate {
-        match ccx.tcx.items.get(&impl_id.node) {
+        match *ccx.tcx.items.get(&impl_id.node) {
           ast_map::node_item(@ast::item {
                 node: ast::item_impl(_, _, _, ref ms), _
           }, _) => {
@@ -414,7 +414,7 @@ pub fn method_ty_param_count(ccx: @CrateContext, m_id: ast::def_id,
     debug!("method_ty_param_count: m_id: %?, i_id: %?", m_id, i_id);
     if m_id.crate == ast::local_crate {
         match ccx.tcx.items.find(&m_id.node) {
-            Some(ast_map::node_method(m, _, _)) => m.generics.ty_params.len(),
+            Some(&ast_map::node_method(m, _, _)) => m.generics.ty_params.len(),
             None => {
                 match ccx.tcx.provided_method_sources.find(&m_id) {
                     Some(source) => {
@@ -424,7 +424,7 @@ pub fn method_ty_param_count(ccx: @CrateContext, m_id: ast::def_id,
                     None => fail!()
                 }
             }
-            Some(ast_map::node_trait_method(@ast::provided(@ref m),
+            Some(&ast_map::node_trait_method(@ast::provided(@ref m),
                                             _, _)) => {
                 m.generics.ty_params.len()
             }

src/librustc/middle/trans/monomorphize.rs

@@ -93,7 +93,7 @@ pub fn monomorphic_fn(ccx: @CrateContext,
         (may have attempted to monomorphize an item defined in a different \
         crate?)", fn_id));
     // Get the path so that we can create a symbol
-    let (pt, name, span) = match map_node {
+    let (pt, name, span) = match *map_node {
       ast_map::node_item(i, pt) => (pt, i.ident, i.span),
       ast_map::node_variant(ref v, enm, pt) => (pt, (*v).node.name, enm.span),
       ast_map::node_method(m, _, pt) => (pt, m.ident, m.span),
@@ -172,7 +172,7 @@ pub fn monomorphic_fn(ccx: @CrateContext,
         self_ty: impl_ty_opt
     });
 
-    let lldecl = match map_node {
+    let lldecl = match *map_node {
       ast_map::node_item(i@@ast::item {
                 // XXX: Bad copy.
                 node: ast::item_fn(ref decl, _, _, ref body),

src/librustc/middle/trans/reachable.rs

@@ -71,20 +71,17 @@ fn traverse_exports(cx: ctx, mod_id: node_id) -> bool {
 
 fn traverse_def_id(cx: ctx, did: def_id) {
     if did.crate != local_crate { return; }
-    let n = match cx.tcx.items.find(&did.node) {
-        None => return, // This can happen for self, for example
-        Some(ref n) => (/*bad*/copy *n)
-    };
-    match n {
-      ast_map::node_item(item, _) => traverse_public_item(cx, item),
-      ast_map::node_method(_, impl_id, _) => traverse_def_id(cx, impl_id),
-      ast_map::node_foreign_item(item, _, _, _) => {
-        cx.rmap.insert(item.id);
-      }
-      ast_map::node_variant(ref v, _, _) => {
-        cx.rmap.insert(v.node.id);
-      }
-      _ => ()
+    match cx.tcx.items.find(&did.node) {
+        None => (), // This can happen for self, for example
+        Some(&ast_map::node_item(item, _)) => traverse_public_item(cx, item),
+        Some(&ast_map::node_method(_, impl_id, _)) => traverse_def_id(cx, impl_id),
+        Some(&ast_map::node_foreign_item(item, _, _, _)) => {
+            cx.rmap.insert(item.id);
+        }
+        Some(&ast_map::node_variant(ref v, _, _)) => {
+            cx.rmap.insert(v.node.id);
+        }
+        _ => ()
     }
 }
 

src/librustc/middle/trans/type_use.rs

@@ -98,7 +98,7 @@ pub fn type_uses_for(ccx: @CrateContext, fn_id: def_id, n_tps: uint)
         return uses;
     }
     let map_node = match ccx.tcx.items.find(&fn_id_loc.node) {
-        Some(ref x) => (/*bad*/copy *x),
+        Some(x) => (/*bad*/copy *x),
         None    => ccx.sess.bug(fmt!("type_uses_for: unbound item ID %?",
                                      fn_id_loc))
     };

src/librustc/middle/ty.rs

@@ -3538,7 +3538,7 @@ pub fn store_trait_methods(cx: ctxt, id: ast::node_id, ms: @~[method]) {
 pub fn provided_trait_methods(cx: ctxt, id: ast::def_id) -> ~[ast::ident] {
     if is_local(id) {
         match cx.items.find(&id.node) {
-            Some(ast_map::node_item(@ast::item {
+            Some(&ast_map::node_item(@ast::item {
                         node: item_trait(_, _, ref ms),
                         _
                     }, _)) =>
@@ -3627,7 +3627,7 @@ pub fn impl_traits(cx: ctxt, id: ast::def_id, store: TraitStore) -> ~[t] {
     if id.crate == ast::local_crate {
         debug!("(impl_traits) searching for trait impl %?", id);
         match cx.items.find(&id.node) {
-           Some(ast_map::node_item(@ast::item {
+           Some(&ast_map::node_item(@ast::item {
                         node: ast::item_impl(_, opt_trait, _, _),
                         _},
                     _)) => {
@@ -3663,7 +3663,7 @@ fn struct_ctor_id(cx: ctxt, struct_did: ast::def_id) -> Option<ast::def_id> {
     }
 
     match cx.items.find(&struct_did.node) {
-        Some(ast_map::node_item(item, _)) => {
+        Some(&ast_map::node_item(item, _)) => {
             match item.node {
                 ast::item_struct(struct_def, _) => {
                     struct_def.ctor_id.map(|ctor_id|
@@ -3735,7 +3735,7 @@ pub fn ty_dtor(cx: ctxt, struct_id: def_id) -> DtorKind {
 
     if is_local(struct_id) {
        match cx.items.find(&struct_id.node) {
-           Some(ast_map::node_item(@ast::item {
+           Some(&ast_map::node_item(@ast::item {
                node: ast::item_struct(@ast::struct_def { dtor: Some(ref dtor),
                                                          _ },
                                       _),
@@ -3762,8 +3762,12 @@ pub fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path {
     if id.crate != ast::local_crate {
         csearch::get_item_path(cx, id)
     } else {
-        let node = cx.items.get(&id.node);
-        match node {
+        // FIXME (#5521): uncomment this code and don't have a catch-all at the
+        //                end of the match statement. Favor explicitly listing
+        //                each variant.
+        // let node = cx.items.get(&id.node);
+        // match *node {
+        match *cx.items.get(&id.node) {
           ast_map::node_item(item, path) => {
             let item_elt = match item.node {
               item_mod(_) | item_foreign_mod(_) => {
@@ -3805,9 +3809,7 @@ pub fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path {
             vec::append_one(/*bad*/copy *path, ast_map::path_name(item.ident))
           }
 
-          ast_map::node_stmt(*) | ast_map::node_expr(*) |
-          ast_map::node_arg(*) | ast_map::node_local(*) |
-          ast_map::node_block(*) => {
+          ref node => {
             cx.sess.bug(fmt!("cannot find item_path for node %?", node));
           }
         }
@@ -3839,7 +3841,7 @@ pub fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[VariantInfo] {
           call eval_const_expr, it should never get called twice for the same
           expr, since check_enum_variants also updates the enum_var_cache
          */
-        match cx.items.get(&id.node) {
+        match *cx.items.get(&id.node) {
           ast_map::node_item(@ast::item {
                     node: ast::item_enum(ref enum_definition, _),
                     _
@@ -3955,15 +3957,15 @@ pub fn lookup_field_type(tcx: ctxt,
 pub fn lookup_struct_fields(cx: ctxt, did: ast::def_id) -> ~[field_ty] {
   if did.crate == ast::local_crate {
     match cx.items.find(&did.node) {
-       Some(ast_map::node_item(i,_)) => {
+       Some(&ast_map::node_item(i,_)) => {
          match i.node {
             ast::item_struct(struct_def, _) => {
                struct_field_tys(struct_def.fields)
             }
             _ => cx.sess.bug(~"struct ID bound to non-struct")
          }
        }
-       Some(ast_map::node_variant(ref variant, _, _)) => {
+       Some(&ast_map::node_variant(ref variant, _, _)) => {
           match (*variant).node.kind {
             ast::struct_variant_kind(struct_def) => {
               struct_field_tys(struct_def.fields)

src/librustc/middle/typeck/check/method.rs

@@ -1257,7 +1257,7 @@ pub impl<'self> LookupContext<'self> {
     fn report_static_candidate(&self, idx: uint, did: def_id) {
         let span = if did.crate == ast::local_crate {
             match self.tcx().items.find(&did.node) {
-              Some(ast_map::node_method(m, _, _)) => m.span,
+              Some(&ast_map::node_method(m, _, _)) => m.span,
               _ => fail!(fmt!("report_static_candidate: bad item %?", did))
             }
         } else {