---

yaml
---
r: 14582
b: refs/heads/try
c: 6473a87
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: def72bda47977b3bc36143eba9692bff12a8303c
+refs/heads/try: 6473a87cec100682764f4d926541fc7eb455b00c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/comp/metadata/astencode.rs

@@ -2,6 +2,7 @@ import syntax::ast;
 import syntax::fold;
 import syntax::visit;
 import syntax::ast_util;
+import syntax::ast_util::inlined_item_methods;
 import syntax::codemap::span;
 import std::map::map;
 import std::smallintmap::map;
@@ -31,8 +32,6 @@ import syntax::print::pprust;
 
 export encode_inlined_item;
 export decode_inlined_item;
-export encode_inlined_method;
-export decode_inlined_method;
 
 type decode_ctxt = @{
     cdata: cstore::crate_metadata,
@@ -53,123 +52,49 @@ iface tr {
 // ______________________________________________________________________
 // Top-level methods.
 
-// The type inline_fn should be a type that can represent both methods
-// and top-level items. As it happens, the type ast::method is perfect
-// for this purpose, but I use this typedef just to keep clear when
-// the thing may not, in fact, be an actual method in the AST but
-// rather some sort of function.
-enum inline_fn = @ast::method;
-
 fn encode_inlined_item(ecx: @e::encode_ctxt,
                        ebml_w: ebml::writer,
                        path: ast_map::path,
-                       item: @ast::item) {
-    let ifn = inline_fn(alt item.node {
-      ast::item_fn(decl, tps, body) {
-          @{ident: item.ident,
-            attrs: item.attrs,
-            tps: tps,
-            decl: decl,
-            body: body,
-            id: item.id,
-            span: item.span}
-      }
-
-      _ {
-          ecx.ccx.sess.span_bug(item.span, "Cannot inline non-function")
-      }
-    });
-
-    encode_inlined_fn(ecx, ebml_w, path, ifn);
-}
-
-fn decode_inlined_item(cdata: cstore::crate_metadata,
-                       tcx: ty::ctxt,
-                       maps: maps,
-                       path: ast_map::path,
-                       par_doc: ebml::doc) -> option<@ast::item> {
-    let oifn = decode_inlined_fn(cdata, tcx, maps, path, par_doc);
-    option::map(oifn) {|ifn|
-        let item = @{ident: ifn.ident,
-                     attrs: ifn.attrs,
-                     id: ifn.id,
-                     node: ast::item_fn(ifn.decl, ifn.tps, ifn.body),
-                     span: ifn.span};
-        ast_map::map_decoded_item(tcx.items, path, item);
-        item
-    }
-}
-
-fn encode_inlined_method(ecx: @e::encode_ctxt,
-                         ebml_w: ebml::writer,
-                         path: ast_map::path,
-                         mthd: @ast::method) {
-    encode_inlined_fn(ecx, ebml_w, path, inline_fn(mthd))
-}
-
-fn decode_inlined_method(cdata: cstore::crate_metadata,
-                         tcx: ty::ctxt,
-                         maps: maps,
-                         path: ast_map::path,
-                         par_doc: ebml::doc) -> option<@ast::method> {
-    let oifn = decode_inlined_fn(cdata, tcx, maps, path, par_doc);
-    option::map(oifn) {|ifn|
-        ast_map::map_decoded_method(tcx.items, path, *ifn);
-        *ifn
-    }
-}
-
-fn encode_inlined_fn(ecx: @e::encode_ctxt,
-                     ebml_w: ebml::writer,
-                     path: ast_map::path,
-                     ifn: inline_fn) {
-
+                       ii: ast::inlined_item) {
     #debug["> Encoding inlined item: %s::%s (%u)",
-           ast_map::path_to_str(path),
-           ifn.ident,
+           ast_map::path_to_str(path), ii.ident(),
            ebml_w.writer.tell()];
 
-    let id_range = compute_id_range(ifn);
+    let id_range = compute_id_range(ii);
     ebml_w.wr_tag(c::tag_ast as uint) {||
         encode_id_range(ebml_w, id_range);
-        encode_ast(ebml_w, ifn);
-        encode_side_tables_for_ifn(ecx, ebml_w, ifn);
+        encode_ast(ebml_w, ii);
+        encode_side_tables_for_ii(ecx, ebml_w, ii);
     }
 
     #debug["< Encoded inlined fn: %s::%s (%u)",
-           ast_map::path_to_str(path),
-           ifn.ident,
+           ast_map::path_to_str(path), ii.ident(),
            ebml_w.writer.tell()];
 }
 
-// Decodes the inlined function and associated side tables.  Does
-// *not* insert the function into the ast_map, since the correct way
-// to do this depends on whether this is an inlined item or method;
-// therefore, you ought to be invoking decode_inlined_item() or
-// decode_inlined_method() and not this helper function.
-fn decode_inlined_fn(cdata: cstore::crate_metadata,
-                     tcx: ty::ctxt,
-                     maps: maps,
-                     path: ast_map::path,
-                     par_doc: ebml::doc) -> option<inline_fn> {
+fn decode_inlined_item(cdata: cstore::crate_metadata,
+                       tcx: ty::ctxt,
+                       maps: maps,
+                       path: ast_map::path,
+                       par_doc: ebml::doc) -> option<ast::inlined_item> {
     let dcx = @{cdata: cdata, tcx: tcx, maps: maps};
     alt par_doc.opt_child(c::tag_ast) {
       none { none }
       some(ast_doc) {
-        #debug["> Decoding inlined fn: %s", ast_map::path_to_str(path)];
+        #debug["> Decoding inlined fn: %s::?", ast_map::path_to_str(path)];
         let from_id_range = decode_id_range(ast_doc);
         let to_id_range = reserve_id_range(dcx.tcx.sess, from_id_range);
         let xcx = @{dcx: dcx,
                     from_id_range: from_id_range,
                     to_id_range: to_id_range};
-        let raw_ifn = decode_ast(ast_doc);
-        let ifn = renumber_ast(xcx, raw_ifn);
-        #debug["Fn named: %s", ifn.ident];
+        let raw_ii = decode_ast(ast_doc);
+        let ii = renumber_ast(xcx, raw_ii);
+        ast_map::map_decoded_item(dcx.tcx.items, path, ii);
+        #debug["Fn named: %s", ii.ident()];
         decode_side_tables(xcx, ast_doc);
         #debug["< Decoded inlined fn: %s::%s",
-               ast_map::path_to_str(path),
-               ifn.ident];
-        some(ifn)
+               ast_map::path_to_str(path), ii.ident()];
+        some(ii)
       }
     }
 }
@@ -183,7 +108,7 @@ fn empty(range: id_range) -> bool {
     range.min >= range.max
 }
 
-fn visit_ids(ifn: inline_fn, vfn: fn@(ast::node_id)) {
+fn visit_ids(item: ast::inlined_item, vfn: fn@(ast::node_id)) {
     let visitor = visit::mk_simple_visitor(@{
         visit_mod: fn@(_m: ast::_mod, _sp: span, id: ast::node_id) {
             vfn(id)
@@ -292,13 +217,13 @@ fn visit_ids(ifn: inline_fn, vfn: fn@(ast::node_id)) {
         }
     });
 
-    visit::visit_method_helper(*ifn, (), visitor);
+    item.accept((), visitor)
 }
 
-fn compute_id_range(ifn: inline_fn) -> id_range {
+fn compute_id_range(item: ast::inlined_item) -> id_range {
     let min = @mutable int::max_value;
     let max = @mutable int::min_value;
-    visit_ids(ifn) {|id|
+    visit_ids(item) {|id|
         *min = int::min(*min, id);
         *max = int::max(*max, id + 1);
     }
@@ -395,25 +320,34 @@ impl deserializer_helpers<D: serialization::deserializer> for D {
 // We also have to adjust the spans: for now we just insert a dummy span,
 // but eventually we should add entries to the local codemap as required.
 
-fn encode_ast(ebml_w: ebml::writer, ifn: inline_fn) {
+fn encode_ast(ebml_w: ebml::writer, item: ast::inlined_item) {
     ebml_w.wr_tag(c::tag_tree as uint) {||
-        astencode_gen::serialize_syntax_ast_method(ebml_w, **ifn)
+        astencode_gen::serialize_syntax_ast_inlined_item(ebml_w, item)
     }
 }
 
-fn decode_ast(par_doc: ebml::doc) -> inline_fn {
+fn decode_ast(par_doc: ebml::doc) -> ast::inlined_item {
     let chi_doc = par_doc[c::tag_tree];
     let d = serialization::mk_ebml_deserializer(chi_doc);
-    inline_fn(@astencode_gen::deserialize_syntax_ast_method(d))
+    astencode_gen::deserialize_syntax_ast_inlined_item(d)
 }
 
-fn renumber_ast(xcx: extended_decode_ctxt, ifn: inline_fn) -> inline_fn {
+fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
+    -> ast::inlined_item {
     let fld = fold::make_fold({
         new_id: xcx.tr_id(_),
         new_span: xcx.tr_span(_)
         with *fold::default_ast_fold()
     });
-    inline_fn(fld.fold_method(*ifn))
+
+    alt ii {
+      ast::ii_item(i) {
+        ast::ii_item(fld.fold_item(i))
+      }
+      ast::ii_method(d, m) {
+        ast::ii_method(xcx.tr_def_id(d), fld.fold_method(m))
+      }
+    }
 }
 
 // ______________________________________________________________________
@@ -664,11 +598,11 @@ impl writer for ebml::writer {
     }
 }
 
-fn encode_side_tables_for_ifn(ecx: @e::encode_ctxt,
-                              ebml_w: ebml::writer,
-                              ifn: inline_fn) {
+fn encode_side_tables_for_ii(ecx: @e::encode_ctxt,
+                             ebml_w: ebml::writer,
+                             ii: ast::inlined_item) {
     ebml_w.wr_tag(c::tag_table as uint) {||
-        visit_ids(ifn, fn@(id: ast::node_id) {
+        visit_ids(ii, fn@(id: ast::node_id) {
             // Note: this will cause a copy of ebml_w, which is bad as
             // it has mutable fields.  But I believe it's harmless since
             // we generate balanced EBML.

branches/try/src/comp/metadata/astencode_gen.rs

@@ -8748,12 +8748,84 @@ fn deserialize_syntax_ast_def_id<S: std::serialization::deserializer>(s: S) ->
    syntax::ast::def_id {
     deserialize_162(s)
 }
-fn serialize_syntax_ast_method<S: std::serialization::serializer>(s: S,
-                                                                  v:
-                                                                      syntax::ast::method) {
-    serialize_160(s, v);
+/*syntax::ast::inlined_item*/
+fn serialize_168<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::inlined_item) {
+    s.emit_enum("syntax::ast::inlined_item",
+                /*@syntax::ast::item*/
+                /*syntax::ast::def_id*//*@syntax::ast::method*/
+                {||
+                    alt v {
+                      syntax::ast::ii_item(v0) {
+                        s.emit_enum_variant("syntax::ast::ii_item", 0u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_117(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ii_method(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::ii_method", 1u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_159(s,
+                                                                                              v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
 }
-fn deserialize_syntax_ast_method<S: std::serialization::deserializer>(s: S) ->
-   syntax::ast::method {
-    deserialize_160(s)
+fn serialize_syntax_ast_inlined_item<S: std::serialization::serializer>(s: S,
+                                                                        v:
+                                                                            syntax::ast::inlined_item) {
+    serialize_168(s, v);
+}
+/*syntax::ast::inlined_item*/
+fn deserialize_168<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::inlined_item {
+    s.read_enum("syntax::ast::inlined_item",
+                /*@syntax::ast::item*/
+
+                /*syntax::ast::def_id*//*@syntax::ast::method*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::ii_item(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_117(s)
+                                                                                             }))
+                                              }
+                                              1u {
+                                                syntax::ast::ii_method(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_162(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_159(s)
+                                                                                               }))
+                                              }
+                                            }
+                                        })
+                })
+}
+fn deserialize_syntax_ast_inlined_item<S: std::serialization::deserializer>(s:
+                                                                                S)
+   -> syntax::ast::inlined_item {
+    deserialize_168(s)
 }

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

@@ -79,7 +79,7 @@ fn get_item_path(tcx: ty::ctxt, def: ast::def_id) -> ast_map::path {
 // not marked for inlining, then the AST will not be present and hence none
 // will be returned.
 fn maybe_get_item_ast(tcx: ty::ctxt, maps: maps, def: ast::def_id)
-    -> option<@ast::item> {
+    -> option<ast::inlined_item> {
     let cstore = tcx.sess.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
     decoder::maybe_get_item_ast(cdata, tcx, maps, def.node)

branches/try/src/comp/metadata/decoder.rs

@@ -264,7 +264,7 @@ fn get_item_path(cdata: cmd, id: ast::node_id) -> ast_map::path {
 }
 
 fn maybe_get_item_ast(cdata: cmd, tcx: ty::ctxt, maps: maps,
-                      id: ast::node_id) -> option<@ast::item> {
+                      id: ast::node_id) -> option<ast::inlined_item> {
     let item_doc = lookup_item(id, cdata.data);
     let path = vec::init(item_path(item_doc));
     astencode::decode_inlined_item(cdata, tcx, maps, path, item_doc)

branches/try/src/comp/metadata/encoder.rs

@@ -352,7 +352,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_symbol(ecx, ebml_w, item.id);
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
         if should_inline(path, item) {
-            astencode::encode_inlined_item(ecx, ebml_w, path, item);
+            astencode::encode_inlined_item(ecx, ebml_w, path, ii_item(item));
         }
         ebml_w.end_tag();
       }