Properly serialize is_last_use values

They were all normalized to the same thing by the serializer.

Author: marijnh

src/etc/gen-astencode

@@ -17,7 +17,7 @@ function msg {
 M=src/rustc/metadata
 GEN_TYPES="syntax::ast::item syntax::ast::def middle::typeck::method_origin \
            middle::freevars::freevar_entry syntax::ast::def_id
-           syntax::ast::inlined_item"
+           syntax::ast::inlined_item middle::last_use::is_last_use"
 
 BUILD_DIR=$1
 if test $BUILD_DIR == ""; then

src/rustc/metadata/astencode.rs

@@ -471,6 +471,10 @@ impl helper for serialization::ebml_deserializer {
         let fv = astencode_gen::deserialize_middle_typeck_method_origin(self);
         fv.tr(xcx)
     }
+    fn read_is_last_use(xcx: extended_decode_ctxt) -> last_use::is_last_use {
+        let lu = astencode_gen::deserialize_middle_last_use_is_last_use(self);
+        lu.tr(xcx)
+    }
 }
 
 impl of tr for method_origin {
@@ -489,6 +493,17 @@ impl of tr for method_origin {
     }
 }
 
+impl of tr for last_use::is_last_use {
+    fn tr(xcx: extended_decode_ctxt) -> last_use::is_last_use {
+        alt self {
+          last_use::is_last_use | last_use::has_last_use { self }
+          last_use::closes_over(ids) {
+            last_use::closes_over(vec::map(ids, {|id| xcx.tr_id(id)}))
+          }
+        }
+    }
+}
+
 // ______________________________________________________________________
 // Encoding and decoding dict_res
 
@@ -743,9 +758,12 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         }
     }
 
-    option::may(ccx.maps.last_uses.find(id)) {|_m|
+    option::may(ccx.maps.last_uses.find(id)) {|m|
         ebml_w.tag(c::tag_table_last_use) {||
             ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val) {||
+               astencode_gen::serialize_middle_last_use_is_last_use(ebml_w, m)
+            }
         }
     }
 
@@ -830,8 +848,6 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
             dcx.maps.mutbl_map.insert(id, ());
         } else if tag == (c::tag_table_copy as uint) {
             dcx.maps.copy_map.insert(id, ());
-        } else if tag == (c::tag_table_last_use as uint) {
-            dcx.maps.last_uses.insert(id, last_use::is_last_use);
         } else {
             let val_doc = entry_doc[c::tag_table_val];
             let val_dsr = serialization::mk_ebml_deserializer(val_doc);
@@ -856,6 +872,8 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
             } else if tag == (c::tag_table_param_bounds as uint) {
                 let bounds = val_dsr.read_bounds(xcx);
                 dcx.tcx.ty_param_bounds.insert(id, bounds);
+            } else if tag == (c::tag_table_last_use as uint) {
+                dcx.maps.last_uses.insert(id, val_dsr.read_is_last_use(xcx));
             } else if tag == (c::tag_table_method_map as uint) {
                 dcx.maps.method_map.insert(id,
                                            val_dsr.read_method_origin(xcx));

src/rustc/metadata/astencode_gen.rs

@@ -8984,3 +8984,101 @@ fn deserialize_syntax_ast_inlined_item<S: std::serialization::deserializer>(s:
    -> syntax::ast::inlined_item {
     deserialize_171(s)
 }
+/*[syntax::ast::node_id]*/
+fn serialize_172<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [syntax::ast::node_id]) {
+    s.emit_vec(vec::len(v), /*syntax::ast::node_id*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_27(s, e) })
+                              })
+               });
+}
+/*middle::last_use::is_last_use*/
+fn serialize_173<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        middle::last_use::is_last_use) {
+    s.emit_enum("middle::last_use::is_last_use",
+
+
+                /*[syntax::ast::node_id]*/
+                {||
+                    alt v {
+                      middle::last_use::is_last_use {
+                        s.emit_enum_variant("middle::last_use::is_last_use",
+                                            0u, 0u, {|| })
+                      }
+                      middle::last_use::has_last_use {
+                        s.emit_enum_variant("middle::last_use::has_last_use",
+                                            1u, 0u, {|| })
+                      }
+                      middle::last_use::closes_over(v0) {
+                        s.emit_enum_variant("middle::last_use::closes_over",
+                                            2u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_172(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+fn serialize_middle_last_use_is_last_use<S: std::serialization::serializer>(s:
+                                                                                S,
+                                                                            v:
+                                                                                middle::last_use::is_last_use) {
+    serialize_173(s, v);
+}
+/*[syntax::ast::node_id]*/
+fn deserialize_172<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::node_id] {
+    s.read_vec(
+
+               /*syntax::ast::node_id*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_27(s) })
+                                })
+               })
+}
+/*middle::last_use::is_last_use*/
+fn deserialize_173<S: std::serialization::deserializer>(s: S) ->
+   middle::last_use::is_last_use {
+    s.read_enum("middle::last_use::is_last_use",
+
+
+
+
+                /*[syntax::ast::node_id]*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                middle::last_use::is_last_use
+                                              }
+                                              1u {
+                                                middle::last_use::has_last_use
+                                              }
+                                              2u {
+                                                middle::last_use::closes_over(s.read_enum_variant_arg(0u,
+                                                                                                      {||
+                                                                                                          deserialize_172(s)
+                                                                                                      }))
+                                              }
+                                            }
+                                        })
+                })
+}
+fn deserialize_middle_last_use_is_last_use<S: std::serialization::deserializer>(s:
+                                                                                    S)
+   -> middle::last_use::is_last_use {
+    deserialize_173(s)
+}