---

yaml
---
r: 14581
b: refs/heads/try
c: def72bd
h: refs/heads/master
i:
  14579: 7678dca
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: 12c68bcd6df325cc369adce018c07dfe3e2b767a
+refs/heads/try: def72bda47977b3bc36143eba9692bff12a8303c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

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

@@ -31,6 +31,8 @@ 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,
@@ -49,49 +51,125 @@ iface tr {
 }
 
 // ______________________________________________________________________
-// Enumerating the IDs which appear in an AST
+// 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) {
+
     #debug["> Encoding inlined item: %s::%s (%u)",
            ast_map::path_to_str(path),
-           item.ident,
+           ifn.ident,
            ebml_w.writer.tell()];
-    let id_range = compute_id_range(item);
+
+    let id_range = compute_id_range(ifn);
     ebml_w.wr_tag(c::tag_ast as uint) {||
         encode_id_range(ebml_w, id_range);
-        encode_ast(ebml_w, item);
-        encode_side_tables_for_item(ecx, ebml_w, item);
+        encode_ast(ebml_w, ifn);
+        encode_side_tables_for_ifn(ecx, ebml_w, ifn);
     }
-    #debug["< Encoded inlined item: %s (%u)",
+
+    #debug["< Encoded inlined fn: %s::%s (%u)",
            ast_map::path_to_str(path),
+           ifn.ident,
            ebml_w.writer.tell()];
 }
 
-fn decode_inlined_item(cdata: cstore::crate_metadata,
-                       tcx: ty::ctxt,
-                       maps: maps,
-                       path: ast_map::path,
-                       par_doc: ebml::doc) -> option<@ast::item> {
+// 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> {
     let dcx = @{cdata: cdata, tcx: tcx, maps: maps};
     alt par_doc.opt_child(c::tag_ast) {
       none { none }
       some(ast_doc) {
-        #debug["> Decoding inlined item: %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_item = decode_ast(ast_doc);
-        let item = renumber_ast(xcx, raw_item);
-        #debug[">> Item named: %s", item.ident];
-        ast_map::map_decoded_item(dcx.tcx.items, path, item);
+        let raw_ifn = decode_ast(ast_doc);
+        let ifn = renumber_ast(xcx, raw_ifn);
+        #debug["Fn named: %s", ifn.ident];
         decode_side_tables(xcx, ast_doc);
-        #debug["< Decoded inlined item: %s", ast_map::path_to_str(path)];
-        some(item)
+        #debug["< Decoded inlined fn: %s::%s",
+               ast_map::path_to_str(path),
+               ifn.ident];
+        some(ifn)
       }
     }
 }
@@ -105,7 +183,7 @@ fn empty(range: id_range) -> bool {
     range.min >= range.max
 }
 
-fn visit_ids(item: @ast::item, vfn: fn@(ast::node_id)) {
+fn visit_ids(ifn: inline_fn, 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)
@@ -214,13 +292,13 @@ fn visit_ids(item: @ast::item, vfn: fn@(ast::node_id)) {
         }
     });
 
-    visitor.visit_item(item, (), visitor);
+    visit::visit_method_helper(*ifn, (), visitor);
 }
 
-fn compute_id_range(item: @ast::item) -> id_range {
+fn compute_id_range(ifn: inline_fn) -> id_range {
     let min = @mutable int::max_value;
     let max = @mutable int::min_value;
-    visit_ids(item) {|id|
+    visit_ids(ifn) {|id|
         *min = int::min(*min, id);
         *max = int::max(*max, id + 1);
     }
@@ -317,25 +395,25 @@ 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, item: @ast::item) {
+fn encode_ast(ebml_w: ebml::writer, ifn: inline_fn) {
     ebml_w.wr_tag(c::tag_tree as uint) {||
-        astencode_gen::serialize_syntax_ast_item(ebml_w, *item);
+        astencode_gen::serialize_syntax_ast_method(ebml_w, **ifn)
     }
 }
 
-fn decode_ast(par_doc: ebml::doc) -> @ast::item {
+fn decode_ast(par_doc: ebml::doc) -> inline_fn {
     let chi_doc = par_doc[c::tag_tree];
     let d = serialization::mk_ebml_deserializer(chi_doc);
-    @astencode_gen::deserialize_syntax_ast_item(d)
+    inline_fn(@astencode_gen::deserialize_syntax_ast_method(d))
 }
 
-fn renumber_ast(xcx: extended_decode_ctxt, item: @ast::item) -> @ast::item {
+fn renumber_ast(xcx: extended_decode_ctxt, ifn: inline_fn) -> inline_fn {
     let fld = fold::make_fold({
         new_id: xcx.tr_id(_),
         new_span: xcx.tr_span(_)
         with *fold::default_ast_fold()
     });
-    fld.fold_item(item)
+    inline_fn(fld.fold_method(*ifn))
 }
 
 // ______________________________________________________________________
@@ -586,11 +664,11 @@ impl writer for ebml::writer {
     }
 }
 
-fn encode_side_tables_for_item(ecx: @e::encode_ctxt,
-                               ebml_w: ebml::writer,
-                               item: @ast::item) {
+fn encode_side_tables_for_ifn(ecx: @e::encode_ctxt,
+                              ebml_w: ebml::writer,
+                              ifn: inline_fn) {
     ebml_w.wr_tag(c::tag_table as uint) {||
-        visit_ids(item, fn@(id: ast::node_id) {
+        visit_ids(ifn, 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.
@@ -820,7 +898,21 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
 }
 
 // ______________________________________________________________________
-// Testing
+// Testing of astencode_gen
+
+#[cfg(test)]
+fn encode_item_ast(ebml_w: ebml::writer, item: @ast::item) {
+    ebml_w.wr_tag(c::tag_tree as uint) {||
+        astencode_gen::serialize_syntax_ast_item(ebml_w, *item);
+    }
+}
+
+#[cfg(test)]
+fn decode_item_ast(par_doc: ebml::doc) -> @ast::item {
+    let chi_doc = par_doc[c::tag_tree];
+    let d = serialization::mk_ebml_deserializer(chi_doc);
+    @astencode_gen::deserialize_syntax_ast_item(d)
+}
 
 #[cfg(test)]
 fn new_parse_sess() -> parser::parse_sess {
@@ -864,9 +956,9 @@ fn roundtrip(in_item: @ast::item) {
     #debug["in_item = %s", pprust::item_to_str(in_item)];
     let mbuf = io::mk_mem_buffer();
     let ebml_w = ebml::mk_writer(io::mem_buffer_writer(mbuf));
-    encode_ast(ebml_w, in_item);
+    encode_item_ast(ebml_w, in_item);
     let ebml_doc = ebml::new_doc(@io::mem_buffer_buf(mbuf));
-    let out_item = decode_ast(ebml_doc);
+    let out_item = decode_item_ast(ebml_doc);
     #debug["out_item = %s", pprust::item_to_str(out_item)];
     assert in_item == out_item;
 }

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

@@ -8748,3 +8748,12 @@ 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);
+}
+fn deserialize_syntax_ast_method<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::method {
+    deserialize_160(s)
+}

branches/try/src/comp/middle/ast_map.rs

@@ -73,6 +73,15 @@ fn map_decoded_item(map: map, path: path, i: @item) {
     v.visit_item(i, cx, v);
 }
 
+fn map_decoded_method(map: map, path: path, m: @method) {
+    // As above.
+    let cx = {map: map,
+              mutable path: path,
+              mutable local_id: 0u};
+    let v = mk_ast_map_visitor();
+    visit::visit_method_helper(m, cx, v);
+}
+
 fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
           sp: codemap::span, id: node_id, cx: ctx, v: vt) {
     for a in decl.inputs {

branches/try/src/comp/syntax/visit.rs

@@ -130,8 +130,7 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
         alt ifce { some(ty) { v.visit_ty(ty, e, v); } _ {} }
         v.visit_ty(ty, e, v);
         for m in methods {
-            v.visit_fn(fk_method(m.ident, m.tps), m.decl, m.body, m.span,
-                       m.id, e, v);
+            visit_method_helper(m, e, v)
         }
       }
       item_class(tps, members, _, ctor_decl, ctor_blk) {
@@ -252,6 +251,15 @@ fn visit_fn_decl<E>(fd: fn_decl, e: E, v: vt<E>) {
     v.visit_ty(fd.output, e, v);
 }
 
+// Note: there is no visit_method() method in the visitor, instead override
+// visit_fn() and check for fk_method().  I named this visit_method_helper()
+// because it is not a default impl of any method, though I doubt that really
+// clarifies anything. - Niko
+fn visit_method_helper<E>(m: @method, e: E, v: vt<E>) {
+    v.visit_fn(fk_method(m.ident, m.tps), m.decl, m.body, m.span,
+               m.id, e, v);
+}
+
 fn visit_fn<E>(fk: fn_kind, decl: fn_decl, body: blk, _sp: span,
                _id: node_id, e: E, v: vt<E>) {
     visit_fn_decl(decl, e, v);

branches/try/src/compiletest/runtest.rs

@@ -289,10 +289,15 @@ fn compile_test(config: config, props: test_props,
                 testfile: str) -> procres {
     vec::iter(props.aux_builds) {|rel_ab|
         let abs_ab = fs::connect(config.aux_base, rel_ab);
-        compose_and_run(config, abs_ab,
-                        make_compile_args(_, props, ["--lib"],
-                                          make_lib_name, _),
-                        config.compile_lib_path, option::none);
+        let auxres = compose_and_run(config, abs_ab,
+                                     make_compile_args(_, props, ["--lib"],
+                                                       make_lib_name, _),
+                                     config.compile_lib_path, option::none);
+        if auxres.status != 0 {
+            fatal_procres(
+                #fmt["auxiliary build of %s failed to compile: ", abs_ab],
+                auxres);
+        }
     }
 
     compose_and_run(config, testfile,

branches/try/src/etc/gen-astencode

@@ -16,7 +16,8 @@ function msg {
 
 M=src/comp/metadata
 GEN_TYPES="syntax::ast::item syntax::ast::def middle::typeck::method_origin \
-           middle::freevars::freevar_entry syntax::ast::def_id"
+           middle::freevars::freevar_entry syntax::ast::def_id
+           syntax::ast::method"
 
 # Find serializer tool:
 for S in build/*/stage1/bin/serializer; do

branches/try/src/libcore/sys.rs

@@ -20,12 +20,15 @@ native mod rustrt {
     fn unsupervise();
     fn shape_log_str<T>(t: *sys::type_desc, data: T) -> str;
     fn rust_set_exit_status(code: ctypes::intptr_t);
-    fn rust_frame_address() -> ctypes::uintptr_t;
 }
 
 #[abi = "rust-intrinsic"]
 native mod rusti {
     fn get_type_desc<T>() -> *type_desc;
+
+    // Invokes __builtin_frame_address().
+    // See <http://gcc.gnu.org/onlinedocs/gcc/Return-Address.html>.
+    fn frame_address(n: ctypes::c_uint) -> ctypes::uintptr_t;
 }
 
 /*
@@ -78,10 +81,6 @@ fn log_str<T>(t: T) -> str {
     rustrt::shape_log_str(get_type_desc::<T>(), t)
 }
 
-fn frame_address() -> uint {
-    rustrt::rust_frame_address()
-}
-
 #[doc(
     brief = "Sets the process exit code",
     desc = "Sets the exit code returned by the process if all supervised \

branches/try/src/rt/intrinsics/intrinsics.cpp

@@ -166,3 +166,9 @@ upcall_vec_push(rust_vec** vp,
 		type_desc* elt_ty, void* elt) {
   upcall_intrinsic_vec_push(vp, elt_ty, elt);
 }
+
+extern "C" CDECL void
+rust_intrinsic_frame_address(void **p, unsigned n) {
+    *p = __builtin_frame_address(n);
+}
+