---

yaml
---
r: 64768
b: refs/heads/snap-stage3
c: 4a85b08
h: refs/heads/master
v: v3

Author: luqmana

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 413446c85b44a7d9269a0723ed043e16d09e2324
+refs/heads/snap-stage3: 4a85b08e08456920f07cf8bb583064f84c23575d
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/driver/driver.rs

@@ -28,15 +28,15 @@ use back::link::{mangle_exported_name};
 use back::{link, abi};
 use driver::session;
 use driver::session::Session;
-use driver::driver::{CrateAnalysis, CrateTranslation};
-use lib::llvm::{ModuleRef, ValueRef, BasicBlockRef};
+use lib::llvm::{ContextRef, ModuleRef, ValueRef, BasicBlockRef};
 use lib::llvm::{llvm, True};
 use lib;
 use metadata::common::LinkMeta;
 use metadata::{csearch, cstore, encoder};
 use middle::astencode;
 use middle::lang_items::{LangItem, ExchangeMallocFnLangItem, StartFnLangItem};
 use middle::lang_items::{MallocFnLangItem, ClosureExchangeMallocFnLangItem};
+use middle::resolve;
 use middle::trans::_match;
 use middle::trans::adt;
 use middle::trans::base;
@@ -66,7 +66,7 @@ use util::ppaux::{Repr, ty_to_str};
 use middle::trans::type_::Type;
 
 use std::hash;
-use std::hashmap::HashMap;
+use std::hashmap::{HashMap, HashSet};
 use std::io;
 use std::libc::c_uint;
 use std::uint;
@@ -2957,8 +2957,12 @@ pub fn write_abi_version(ccx: &mut CrateContext) {
 
 pub fn trans_crate(sess: session::Session,
                    crate: &ast::Crate,
-                   analysis: &CrateAnalysis,
-                   output: &Path) -> CrateTranslation {
+                   tcx: ty::ctxt,
+                   output: &Path,
+                   emap2: resolve::ExportMap2,
+                   reachable_map: @mut HashSet<ast::node_id>,
+                   maps: astencode::Maps)
+                   -> (ContextRef, ModuleRef, LinkMeta) {
     // Before we touch LLVM, make sure that multithreading is enabled.
     if unsafe { !llvm::LLVMRustStartMultithreading() } {
         //sess.bug("couldn't enable multi-threaded LLVM");
@@ -2979,12 +2983,12 @@ pub fn trans_crate(sess: session::Session,
 
     let ccx = @mut CrateContext::new(sess,
                                      llmod_id,
-                                     analysis.ty_cx,
-                                     analysis.exp_map2,
-                                     analysis.maps,
+                                     tcx,
+                                     emap2,
+                                     maps,
                                      symbol_hasher,
                                      link_meta,
-                                     analysis.reachable);
+                                     reachable_map);
 
     {
         let _icx = push_ctxt("data");
@@ -3039,9 +3043,5 @@ pub fn trans_crate(sess: session::Session,
     let link_meta = ccx.link_meta;
     let llmod = ccx.llmod;
 
-    return CrateTranslation {
-        context: llcx,
-        module: llmod,
-        link: link_meta
-    };
+    return (llcx, llmod, link_meta);
 }

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -211,11 +211,16 @@ pub fn const_expr(cx: @mut CrateContext, e: @ast::expr) -> ValueRef {
                         }
                         ty::AutoBorrowVec(ty::re_static, m) => {
                             assert!(m != ast::m_mutbl);
-                            let size = machine::llsize_of(cx,
-                                                          val_ty(llconst));
                             assert_eq!(abi::slice_elt_base, 0);
                             assert_eq!(abi::slice_elt_len, 1);
-                            llconst = C_struct([llptr, size]);
+
+                            match ty::get(ty).sty {
+                                ty::ty_evec(_, ty::vstore_fixed(*)) => {
+                                    let size = machine::llsize_of(cx, val_ty(llconst));
+                                    llconst = C_struct([llptr, size]);
+                                }
+                                _ => {}
+                            }
                         }
                         _ => {
                             cx.sess.span_bug(e.span,

branches/snap-stage3/src/librustc/middle/trans/consts.rs

@@ -223,15 +223,13 @@ fn run(mut program: ~Program, binary: ~str, lib_search_paths: ~[~str],
     debug!("testing with ^^^^^^ %?", (||{ println(test) })());
     let dinput = driver::str_input(test.to_managed());
     let cfg = driver::build_configuration(sess, binary, &dinput);
-
-    let crate = driver::phase_1_parse_input(sess, cfg.clone(), &dinput);
-    let expanded_crate = driver::phase_2_configure_and_expand(sess, cfg, crate);
-    let analysis = driver::phase_3_run_analysis_passes(sess, expanded_crate);
-
+    let outputs = driver::build_output_filenames(&dinput, &None, &None, [], sess);
+    let (crate, tcx) = driver::compile_upto(sess, cfg.clone(), &dinput,
+                                            driver::cu_typeck, Some(outputs));
     // Once we're typechecked, record the types of all local variables defined
     // in this input
-    do find_main(crate, sess) |blk| {
-        program.register_new_vars(blk, analysis.ty_cx);
+    do find_main(crate.expect("crate after cu_typeck"), sess) |blk| {
+        program.register_new_vars(blk, tcx.expect("tcx after cu_typeck"));
     }
 
     //
@@ -244,12 +242,8 @@ fn run(mut program: ~Program, binary: ~str, lib_search_paths: ~[~str],
     let cfg = driver::build_configuration(sess, binary, &input);
     let outputs = driver::build_output_filenames(&input, &None, &None, [], sess);
     let sess = driver::build_session(options, diagnostic::emit);
-
-    let crate = driver::phase_1_parse_input(sess, cfg.clone(), &input);
-    let expanded_crate = driver::phase_2_configure_and_expand(sess, cfg, crate);
-    let analysis = driver::phase_3_run_analysis_passes(sess, expanded_crate);
-    let trans = driver::phase_4_translate_to_llvm(sess, expanded_crate, &analysis, outputs);
-    driver::phase_5_run_llvm_passes(sess, &trans, outputs);
+    driver::compile_upto(sess, cfg, &input, driver::cu_everything,
+                         Some(outputs));
 
     //
     // Stage 4: Inform the program that computation is done so it can update all
@@ -271,7 +265,10 @@ fn run(mut program: ~Program, binary: ~str, lib_search_paths: ~[~str],
         let code = fmt!("fn main() {\n %s \n}", input);
         let input = driver::str_input(code.to_managed());
         let cfg = driver::build_configuration(sess, binary, &input);
-        driver::phase_1_parse_input(sess, cfg.clone(), &input)
+        let outputs = driver::build_output_filenames(&input, &None, &None, [], sess);
+        let (crate, _) = driver::compile_upto(sess, cfg, &input,
+                                              driver::cu_parse, Some(outputs));
+        crate.expect("parsing should return a crate")
     }
 
     fn find_main(crate: @ast::Crate, sess: session::Session,
@@ -337,12 +334,9 @@ fn compile_crate(src_filename: ~str, binary: ~str) -> Option<bool> {
             None => { },
         }
         if (should_compile) {
-            println(fmt!("compiling %s...", src_filename));
-            let crate = driver::phase_1_parse_input(sess, cfg.clone(), &input);
-            let expanded_crate = driver::phase_2_configure_and_expand(sess, cfg, crate);
-            let analysis = driver::phase_3_run_analysis_passes(sess, expanded_crate);
-            let trans = driver::phase_4_translate_to_llvm(sess, expanded_crate, &analysis, outputs);
-            driver::phase_5_run_llvm_passes(sess, &trans, outputs);
+            printfln!("compiling %s...", src_filename);
+            driver::compile_upto(sess, cfg, &input, driver::cu_everything,
+                                 Some(outputs));
             true
         } else { false }
     } {

branches/snap-stage3/src/librusti/rusti.rs

@@ -109,8 +109,7 @@ impl<'self> PkgScript<'self> {
         let input = driver::file_input(script);
         let sess = driver::build_session(options, diagnostic::emit);
         let cfg = driver::build_configuration(sess, binary, &input);
-        let crate = driver::phase_1_parse_input(sess, cfg.clone(), &input);
-        let crate = driver::phase_2_configure_and_expand(sess, cfg.clone(), crate);
+        let (crate, _) = driver::compile_upto(sess, cfg.clone(), &input, driver::cu_parse, None);
         let work_dir = build_pkg_id_in_workspace(id, workspace);
 
         debug!("Returning package script with id %?", id);
@@ -120,7 +119,7 @@ impl<'self> PkgScript<'self> {
             input: input,
             sess: sess,
             cfg: cfg,
-            crate: crate,
+            crate: crate.unwrap(),
             build_dir: work_dir
         }
     }
@@ -143,10 +142,14 @@ impl<'self> PkgScript<'self> {
                 let root = r.pop().pop().pop().pop(); // :-\
                 debug!("Root is %s, calling compile_rest", root.to_str());
                 let exe = self.build_dir.push(~"pkg" + util::exe_suffix());
+                let binary = os::args()[0].to_managed();
                 util::compile_crate_from_input(&self.input,
                                                &self.build_dir,
                                                sess,
-                                               crate);
+                                               crate,
+                                               driver::build_configuration(sess,
+                                                                           binary, &self.input),
+                                               driver::cu_parse);
                 debug!("Running program: %s %s %s %s", exe.to_str(),
                        sysroot.to_str(), root.to_str(), "install");
                 // FIXME #7401 should support commands besides `install`

branches/snap-stage3/src/librustpkg/rustpkg.rs

@@ -18,6 +18,7 @@ use syntax::ext::base::ExtCtxt;
 use syntax::{ast, attr, codemap, diagnostic, fold};
 use syntax::attr::AttrMetaMethods;
 use rustc::back::link::output_type_exe;
+use rustc::driver::driver::compile_upto;
 use rustc::driver::session::{lib_crate, bin_crate};
 use context::Ctx;
 use package_id::PkgId;
@@ -219,8 +220,12 @@ pub fn compile_input(ctxt: &Ctx,
     // Infer dependencies that rustpkg needs to build, by scanning for
     // `extern mod` directives.
     let cfg = driver::build_configuration(sess, binary, &input);
-    let mut crate = driver::phase_1_parse_input(sess, cfg.clone(), &input);
-    crate = driver::phase_2_configure_and_expand(sess, cfg, crate);
+    let (crate_opt, _) = driver::compile_upto(sess, cfg.clone(), &input, driver::cu_expand, None);
+
+    let mut crate = match crate_opt {
+        Some(c) => c,
+        None => fail!("compile_input expected...")
+    };
 
     // Not really right. Should search other workspaces too, and the installed
     // database (which doesn't exist yet)
@@ -252,7 +257,7 @@ pub fn compile_input(ctxt: &Ctx,
 
     debug!("calling compile_crate_from_input, out_dir = %s,
            building_library = %?", out_dir.to_str(), sess.building_library);
-    compile_crate_from_input(&input, out_dir, sess, crate);
+    compile_crate_from_input(&input, out_dir, sess, crate, cfg.clone(), driver::cu_expand);
     true
 }
 
@@ -264,7 +269,9 @@ pub fn compile_input(ctxt: &Ctx,
 pub fn compile_crate_from_input(input: &driver::input,
                                 build_dir: &Path,
                                 sess: session::Session,
-                                crate: @ast::Crate) {
+                                crate: @ast::Crate,
+                                cfg: ast::CrateConfig,
+                                compile_from: driver::compile_phase) {
     debug!("Calling build_output_filenames with %s, building library? %?",
            build_dir.to_str(), sess.building_library);
 
@@ -277,13 +284,15 @@ pub fn compile_crate_from_input(input: &driver::input,
     for sess.opts.addl_lib_search_paths.iter().advance |lib| {
         debug!("an additional library: %s", lib.to_str());
     }
-    let analysis = driver::phase_3_run_analysis_passes(sess, crate);
-    let translation = driver::phase_4_translate_to_llvm(sess, crate,
-                                                        &analysis,
-                                                        outputs);
-    driver::phase_5_run_llvm_passes(sess, &translation, outputs);
-    if driver::stop_after_phase_5(sess) { return; }
-    driver::phase_6_link_output(sess, &translation, outputs);
+
+    driver::compile_rest(sess,
+                         cfg,
+                         compile_upto {
+                             from: compile_from,
+                             to: driver::cu_everything
+                         },
+                         Some(outputs),
+                         Some(crate));
 }
 
 #[cfg(windows)]

branches/snap-stage3/src/librustpkg/util.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 // xfail-fast
+// xfail-win32 #7999
 
 use std::comm;
 use std::task;

branches/snap-stage3/src/test/run-pass/issue-3168.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 // xfail-fast
+// xfail-win32 #7999
 
 use std::comm::{Select2, Selectable};
 use std::comm;

branches/snap-stage3/src/test/run-pass/issue-3176.rs

@@ -11,6 +11,7 @@
 // except according to those terms.
 
 // xfail-test needs sleep
+// xfail-win32 #7999
 
 extern mod extra;
 

branches/snap-stage3/src/test/run-pass/pipe-sleep.rs

@@ -10,6 +10,7 @@
 
 // Make sure the destructor is run for unit-like structs.
 // xfail-fast
+// xfail-win32 #7999
 
 use std::task;