---

yaml
---
r: 7379
b: refs/heads/master
c: 93be00f
h: refs/heads/master
i:
  7377: 9d9b920
  7375: 145a80b
v: v3

Author: rtanglao

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 4ac44492c4cbd0ed2523e43ea816caf2754da421
+refs/heads/master: 93be00f99594464fc753796395ce0cfb8ee790ea

trunk/configure

@@ -363,16 +363,6 @@ then
     err "either clang or gcc is required"
 fi
 
-if [ ! -z "$CFG_PERF" ]
-then
-    HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 | grep 'unknown option'`
-    if [ -z "$HAVE_PERF_LOGFD" ];
-    then
-        CFG_PERF_WITH_LOGFD=1
-        putvar CFG_PERF_WITH_LOGFD
-    fi
-fi
-
 step_msg "making directories"
 
 for i in \

trunk/mk/platform.mk

@@ -58,11 +58,7 @@ ifneq ($(findstring linux,$(CFG_OSTYPE)),)
   CFG_LDENV := LD_LIBRARY_PATH
   CFG_DEF_SUFFIX := .linux.def
   ifdef CFG_PERF
-    ifneq ($(CFG_PERF_WITH_LOGFD),)
-        CFG_PERF_TOOL := $(CFG_PERF) stat -r 3 --log-fd 2
-    else
-        CFG_PERF_TOOL := $(CFG_PERF) stat -r 3
-    endif
+	CFG_PERF_TOOL := $(CFG_PERF) stat -r 3
   else
     ifdef CFG_VALGRIND
       CFG_PERF_TOOL :=\

trunk/src/comp/back/link.rs

@@ -445,10 +445,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: str,
                 let name =
                     {
                         let os = str::split(fs::basename(output), '.' as u8);
-                        if (vec::len(os) < 2u) {
-                            sess.fatal(#fmt("Output file name %s doesn't\
-                              appear to have an extension", output));
-                        }
+                        assert (vec::len(os) >= 2u);
                         vec::pop(os);
                         str::connect(os, ".")
                     };

trunk/src/comp/back/upcall.rs

@@ -16,7 +16,6 @@ type upcalls =
      free: ValueRef,
      shared_malloc: ValueRef,
      shared_free: ValueRef,
-     memset: ValueRef,
      mark: ValueRef,
      create_shared_type_desc: ValueRef,
      free_shared_type_desc: ValueRef,
@@ -65,7 +64,6 @@ fn declare_upcalls(targ_cfg: @session::config,
                 T_ptr(T_i8())),
           shared_free:
               dv("shared_free", [T_ptr(T_i8())]),
-          memset: dv("memset", [T_ptr(T_i8()), T_i8(), T_i32(), T_i32()]),
           mark:
               d("mark", [T_ptr(T_i8())], int_t),
           create_shared_type_desc:

trunk/src/comp/driver/driver.rs

@@ -20,7 +20,7 @@ import back::{x86, x86_64};
 
 tag pp_mode { ppm_normal; ppm_expanded; ppm_typed; ppm_identified; }
 
-fn default_configuration(sess: session, argv0: str, input: str) ->
+fn default_configuration(sess: session::session, argv0: str, input: str) ->
    ast::crate_cfg {
     let libc =
         alt sess.targ_cfg.os {
@@ -48,7 +48,7 @@ fn default_configuration(sess: session, argv0: str, input: str) ->
          mk("build_input", input)];
 }
 
-fn build_configuration(sess: session, argv0: str, input: str) ->
+fn build_configuration(sess: session::session, argv0: str, input: str) ->
    ast::crate_cfg {
     // Combine the configuration requested by the session (command line) with
     // some default and generated configuration items
@@ -76,27 +76,31 @@ fn parse_cfgspecs(cfgspecs: [str]) -> ast::crate_cfg {
 
 fn input_is_stdin(filename: str) -> bool { filename == "-" }
 
-fn parse_input(sess: session, cfg: ast::crate_cfg, input: str)
-    -> {crate: @ast::crate, src: str} {
-    let src = get_input_str(sess, input);
-    let crate = if !input_is_stdin(input) {
+fn parse_input(sess: session::session, cfg: ast::crate_cfg, input: str) ->
+   @ast::crate {
+    if !input_is_stdin(input) {
         parser::parse_crate_from_file(input, cfg, sess.parse_sess)
-    } else {
-        parser::parse_crate_from_source_str(input, src, cfg, sess.parse_sess)
-    };
-    {crate: crate, src: src}
+    } else { parse_input_src(sess, cfg, input).crate }
 }
 
-fn get_input_str(sess: session, infile: str) -> str {
-    let stream = if !input_is_stdin(infile) {
+fn parse_input_src(sess: session::session, cfg: ast::crate_cfg, infile: str)
+   -> {crate: @ast::crate, src: str} {
+    let src_stream = if infile != "-" {
         alt io::file_reader(infile) {
           result::ok(reader) { reader }
           result::err(e) {
             sess.fatal(e)
           }
         }
-    } else { io::stdin() };
-    str::unsafe_from_bytes(stream.read_whole_stream())
+    } else {
+        io::stdin()
+    };
+    let srcbytes = src_stream.read_whole_stream();
+    let src = str::unsafe_from_bytes(srcbytes);
+    let crate =
+        parser::parse_crate_from_source_str(infile, src, cfg,
+                                            sess.parse_sess);
+    ret {crate: crate, src: src};
 }
 
 fn time<T>(do_it: bool, what: str, thunk: fn@() -> T) -> T {
@@ -109,7 +113,7 @@ fn time<T>(do_it: bool, what: str, thunk: fn@() -> T) -> T {
     ret rv;
 }
 
-fn inject_libcore_reference(sess: session,
+fn inject_libcore_reference(sess: session::session,
                             crate: @ast::crate) -> @ast::crate {
 
     fn spanned<T: copy>(x: T) -> @ast::spanned<T> {
@@ -130,22 +134,14 @@ fn inject_libcore_reference(sess: session,
                  with crate.node} with *crate }
 }
 
-enum compile_upto {
-    cu_parse;
-    cu_expand;
-    cu_typeck;
-    cu_no_trans;
-    cu_everything;
-}
 
-fn compile_upto(sess: session, cfg: ast::crate_cfg,
-                input: str, upto: compile_upto,
-                outputs: option::t<output_filenames>)
-    -> {crate: @ast::crate, tcx: option::t<ty::ctxt>, src: str} {
+fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str,
+                 outdir: option::t<str>, output: option::t<str>) {
+
     let time_passes = sess.opts.time_passes;
-    let {crate, src} =
+    let crate =
         time(time_passes, "parsing", bind parse_input(sess, cfg, input));
-    if upto == cu_parse { ret {crate: crate, tcx: none, src: src}; }
+    if sess.opts.parse_only { ret; }
 
     sess.building_library =
         session::building_library(sess.opts.crate_type, crate);
@@ -160,7 +156,6 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
         time(time_passes, "expansion",
              bind syntax::ext::expand::expand_crate(sess, crate));
 
-    if upto == cu_expand { ret {crate: crate, tcx: none, src: src}; }
     if sess.opts.libcore {
         crate = inject_libcore_reference(sess, crate);
     }
@@ -182,9 +177,6 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
     let (method_map, dict_map) =
         time(time_passes, "typechecking",
              bind typeck::check_crate(ty_cx, impl_map, crate));
-
-    if upto == cu_typeck { ret {crate: crate, tcx: some(ty_cx), src: src}; }
-
     time(time_passes, "block-use checking",
          bind middle::block_use::check_crate(ty_cx, crate));
     time(time_passes, "function usage",
@@ -203,9 +195,9 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
         bind last_use::find_last_uses(crate, def_map, ref_map, ty_cx));
     time(time_passes, "kind checking",
          bind kind::check_crate(ty_cx, method_map, last_uses, crate));
+    if sess.opts.no_trans { ret; }
 
-    if upto == cu_no_trans { ret {crate: crate, tcx: some(ty_cx), src: src}; }
-    let outputs = option::get(outputs);
+    let outputs = build_output_filenames(input, outdir, output, sess);
 
     let (llmod, link_meta) =
         time(time_passes, "translation",
@@ -220,25 +212,14 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
         sess.opts.output_type != link::output_type_exe ||
             sess.opts.static && sess.building_library;
 
-    if stop_after_codegen { ret {crate: crate, tcx: some(ty_cx), src: src}; }
+    if stop_after_codegen { ret; }
 
     time(time_passes, "Linking",
          bind link::link_binary(sess, outputs.obj_filename,
                                 outputs.out_filename, link_meta));
-    ret {crate: crate, tcx: some(ty_cx), src: src};
 }
 
-fn compile_input(sess: session, cfg: ast::crate_cfg, input: str,
-                 outdir: option::t<str>, output: option::t<str>) {
-
-    let upto = if sess.opts.parse_only { cu_parse }
-               else if sess.opts.no_trans { cu_no_trans }
-               else { cu_everything };
-    let outputs = build_output_filenames(input, outdir, output, sess);
-    compile_upto(sess, cfg, input, upto, some(outputs));
-}
-
-fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: str,
+fn pretty_print_input(sess: session::session, cfg: ast::crate_cfg, input: str,
                       ppm: pp_mode) {
     fn ann_paren_for_expr(node: pprust::ann_node) {
         alt node { pprust::node_expr(s, expr) { pprust::popen(s); } _ { } }
@@ -279,23 +260,30 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: str,
     // to collect comments and literals, and we need to support reading
     // from stdin, we're going to just suck the source into a string
     // so both the parser and pretty-printer can use it.
-    let upto = alt ppm {
-      ppm_expanded. { cu_expand }
-      ppm_typed. { cu_typeck }
-      _ { cu_parse }
-    };
-    let {crate, tcx, src} = compile_upto(sess, cfg, input, upto, none);
+    let crate_src = parse_input_src(sess, cfg, input);
+    let crate = crate_src.crate;
+    let src = crate_src.src;
 
-    let ann: pprust::pp_ann = pprust::no_ann();
+    let ann;
     alt ppm {
+      ppm_expanded. {
+        crate = syntax::ext::expand::expand_crate(sess, crate);
+        ann = pprust::no_ann();
+      }
       ppm_typed. {
-        ann = {pre: ann_paren_for_expr,
-               post: bind ann_typed_post(option::get(tcx), _)};
+        crate = syntax::ext::expand::expand_crate(sess, crate);
+        let amap = middle::ast_map::map_crate(*crate);
+        let {def_map, impl_map, _} =
+            resolve::resolve_crate(sess, amap, crate);
+        let freevars = freevars::annotate_freevars(def_map, crate);
+        let ty_cx = ty::mk_ctxt(sess, def_map, amap, freevars);
+        typeck::check_crate(ty_cx, impl_map, crate);
+        ann = {pre: ann_paren_for_expr, post: bind ann_typed_post(ty_cx, _)};
       }
       ppm_identified. {
         ann = {pre: ann_paren_for_expr, post: ann_identified_post};
       }
-      ppm_expanded. | ppm_normal. {}
+      ppm_normal. { ann = pprust::no_ann(); }
     }
     pprust::print_crate(sess.codemap, sess.diagnostic, crate, input,
                         io::string_reader(src), io::stdout(), ann);
@@ -465,7 +453,7 @@ fn build_session_options(match: getopts::match,
 }
 
 fn build_session(sopts: @session::options, input: str,
-                 demitter: diagnostic::emitter) -> session {
+                 demitter: diagnostic::emitter) -> session::session {
     let target_cfg = build_target_config(sopts, demitter);
     let cstore = cstore::mk_cstore();
     let filesearch = filesearch::mk_filesearch(
@@ -492,7 +480,7 @@ fn build_session(sopts: @session::options, input: str,
       working_dir: fs::dirname(input)}
 }
 
-fn parse_pretty(sess: session, &&name: str) -> pp_mode {
+fn parse_pretty(sess: session::session, &&name: str) -> pp_mode {
     if str::eq(name, "normal") {
         ret ppm_normal;
     } else if str::eq(name, "expanded") {
@@ -521,13 +509,11 @@ fn opts() -> [getopts::opt] {
          optflag("warn-unused-imports")];
 }
 
-type output_filenames = @{out_filename: str, obj_filename:str};
-
 fn build_output_filenames(ifile: str,
                           odir: option::t<str>,
                           ofile: option::t<str>,
-                          sess: session)
-        -> output_filenames {
+                          sess: session::session)
+        -> @{out_filename: str, obj_filename:str} {
     let obj_path = "";
     let out_path: str = "";
     let sopts = sess.opts;
@@ -613,7 +599,7 @@ fn early_error(emitter: diagnostic::emitter, msg: str) -> ! {
     fail;
 }
 
-fn list_metadata(sess: session, path: str, out: io::writer) {
+fn list_metadata(sess: session::session, path: str, out: io::writer) {
     metadata::creader::list_file_metadata(sess, path, out);
 }
 

trunk/src/comp/front/attr.rs

@@ -20,9 +20,6 @@ export get_meta_item_name;
 export get_meta_item_value_str;
 export get_meta_item_value_str_by_name;
 export get_meta_item_list;
-export meta_item_value_from_list;
-export meta_item_list_from_list;
-export name_value_str_pair;
 export mk_name_value_item_str;
 export mk_name_value_item;
 export mk_list_item;
@@ -220,53 +217,6 @@ fn native_abi(attrs: [ast::attribute]) -> either::t<str, ast::native_abi> {
     };
 }
 
-fn meta_item_from_list(
-    items: [@ast::meta_item],
-    name: str
-) -> option<@ast::meta_item> {
-    let items = attr::find_meta_items_by_name(items, name);
-    vec::last(items)
-}
-
-fn meta_item_value_from_list(
-    items: [@ast::meta_item],
-    name: str
-) -> option<str> {
-    alt meta_item_from_list(items, name) {
-      some(item) {
-        alt attr::get_meta_item_value_str(item) {
-          some(value) { some(value) }
-          none. { none }
-        }
-      }
-      none. { none }
-    }
-}
-
-fn meta_item_list_from_list(
-    items: [@ast::meta_item],
-    name: str
-) -> option<[@ast::meta_item]> {
-    alt meta_item_from_list(items, name) {
-      some(item) {
-        attr::get_meta_item_list(item)
-      }
-      none. { none }
-    }
-}
-
-fn name_value_str_pair(
-    item: @ast::meta_item
-) -> option<(str, str)> {
-    alt attr::get_meta_item_value_str(item) {
-      some(value) {
-        let name = attr::get_meta_item_name(item);
-        some((name, value))
-      }
-      none. { none }
-    }
-}
-
 fn span<T: copy>(item: T) -> ast::spanned<T> {
     ret {node: item, span: ast_util::dummy_sp()};
 }

trunk/src/comp/metadata/decoder.rs

@@ -246,7 +246,6 @@ fn get_tag_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
     for did: ast::def_id in variant_ids {
         let item = find_item(did.node, items);
         let ctor_ty = item_type(item, tcx, cdata);
-        let name = item_name(item);
         let arg_tys: [ty::t] = [];
         alt ty::struct(tcx, ctor_ty) {
           ty::ty_fn(f) {
@@ -258,8 +257,8 @@ fn get_tag_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
           some(val) { disr_val = val; }
           _         { /* empty */ }
         }
-        infos += [@{args: arg_tys, ctor_ty: ctor_ty, name: name,
-                    id: did, disr_val: disr_val}];
+        infos += [@{args: arg_tys, ctor_ty: ctor_ty, id: did,
+                    disr_val: disr_val}];
         disr_val += 1;
     }
     ret infos;

trunk/src/comp/metadata/encoder.rs

@@ -239,7 +239,6 @@ fn encode_tag_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(variant.node.id));
         encode_family(ebml_w, 'v' as u8);
-        encode_name(ebml_w, variant.node.name);
         encode_tag_id(ebml_w, local_def(id));
         encode_type(ecx, ebml_w,
                     node_id_to_monotype(ecx.ccx.tcx, variant.node.id));