---

yaml
---
r: 130735
b: refs/heads/master
c: 1ee099d
h: refs/heads/master
i:
  130733: 0f86f34
  130731: 0e7a455
  130727: 73455f1
  130719: 70778b5
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 641b1980a4031f711099c5791653464f93c43ebf
+refs/heads/master: 1ee099da36f6ac647747806558e555c5fe8dcd12
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6faa4f33a42de32579e02a8d030db920d360e2b5
 refs/heads/try: a2473a89da106f7dd3be86e9d52fe23f43d5bfa5

trunk/Makefile.in

@@ -65,6 +65,7 @@
 #
 #   * `VERBOSE=1` - Print all commands. Use this to see what's going on.
 #   * `RUSTFLAGS=...` - Add compiler flags to all `rustc` invocations
+#   * `JEMALLOC_FLAGS=...` - Pass flags to jemalloc's configure script
 #
 #   * `TESTNAME=...` - Specify the name of tests to run
 #   * `CHECK_IGNORED=1` - Run normally-ignored tests

trunk/mk/main.mk

@@ -90,15 +90,19 @@ endif
 CFG_RUSTC_FLAGS := $(RUSTFLAGS)
 CFG_GCCISH_CFLAGS :=
 CFG_GCCISH_LINK_FLAGS :=
+CFG_JEMALLOC_FLAGS :=
 
 ifdef CFG_DISABLE_OPTIMIZE
   $(info cfg: disabling rustc optimization (CFG_DISABLE_OPTIMIZE))
   CFG_RUSTC_FLAGS +=
+  CFG_JEMALLOC_FLAGS += --enable-debug
 else
   # The rtopt cfg turns off runtime sanity checks
   CFG_RUSTC_FLAGS += -O --cfg rtopt
 endif
 
+CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS)
+
 ifdef CFG_DISABLE_DEBUG
   CFG_RUSTC_FLAGS += --cfg ndebug
   CFG_GCCISH_CFLAGS += -DRUST_NDEBUG

trunk/mk/rt.mk

@@ -301,7 +301,7 @@ JEMALLOC_LOCAL_$(1) := $$(JEMALLOC_BUILD_DIR_$(1))/lib/$$(JEMALLOC_REAL_NAME_$(1
 $$(JEMALLOC_LOCAL_$(1)): $$(JEMALLOC_DEPS) $$(MKFILE_DEPS)
 	@$$(call E, make: jemalloc)
 	cd "$$(JEMALLOC_BUILD_DIR_$(1))"; "$(S)src/jemalloc/configure" \
-		$$(JEMALLOC_ARGS_$(1)) --with-jemalloc-prefix=je_ \
+		$$(JEMALLOC_ARGS_$(1)) --with-jemalloc-prefix=je_ $(CFG_JEMALLOC_FLAGS) \
 		--build=$(CFG_BUILD) --host=$(1) \
 		CC="$$(CC_$(1))" \
 		AR="$$(AR_$(1))" \

trunk/src/doc/rust.md

@@ -3564,36 +3564,34 @@ let (a, b) = p;
 assert!(b != "world");
 ~~~~
 
-### Vector, Array, and Slice types
+### Vector types
 
-Rust has three different types for a list of items:
+The vector type constructor represents a homogeneous array of values of a given type.
+A vector has a fixed size.
+(Operations like `vec.push` operate solely on owned vectors.)
+A vector type can be annotated with a _definite_ size, such as `[int, ..10]`.
+Such a definite-sized vector type is a first-class type, since its size is known statically.
+A vector without such a size is said to be of _indefinite_ size,
+and is therefore not a _first-class_ type.
+An indefinite-size vector can only be instantiated through a pointer type,
+such as `&[T]` or `Vec<T>`.
+The kind of a vector type depends on the kind of its element type,
+as with other simple structural types.
 
-* `Vec<T>`, a 'vector'
-* `[T ..N]`, an 'array'
-* `&[T]`, a 'slice'.
+Expressions producing vectors of definite size cannot be evaluated in a
+context expecting a vector of indefinite size; one must copy the
+definite-sized vector contents into a distinct vector of indefinite size.
 
-A vector is a heap-allocated list of `T`. A vector has ownership over the data
-inside of it. It is also able to grow and change in size. It's important to note
-that `Vec<T>` is a library type, it's not actually part of the core language.
+An example of a vector type and its use:
 
-An array has a fixed size, and can be allocated on either the stack or the heap.
-
-A slice is a 'view' into a vector or array. It doesn't own the data it points
-to, it borrows it.
-
-An example of each kind:
-
-```{rust}
-let vec: Vec<int>  = vec![1, 2, 3];
-let arr: [int, ..3] = [1, 2, 3];
-let s: &[int]      = vec.as_slice();
-```
-
-As you can see, the `vec!` macro allows you to create a `Vec<T>` easily. The
-`vec!` macro is also part of the standard library, rather than the language.
+~~~~
+let v: &[int] = &[7, 5, 3];
+let i: int = v[2];
+assert!(i == 3);
+~~~~
 
-All in-bounds elements of vectors, arrays, and slices are always initialized,
-and access to a vector, array, or slice is always bounds-checked.
+All in-bounds elements of a vector are always initialized,
+and access to a vector is always bounds-checked.
 
 ### Structure types
 

trunk/src/libcollections/vec.rs

@@ -1618,19 +1618,6 @@ pub struct MoveItems<T> {
     iter: Items<'static, T>
 }
 
-impl<T> MoveItems<T> {
-    #[inline]
-    /// Drops all items that have not yet been moved and returns the empty vector.
-    pub fn unwrap(mut self) -> Vec<T> {
-        unsafe {
-            for _x in self { }
-            let MoveItems { allocation, cap, iter: _iter } = self;
-            mem::forget(self);
-            Vec { ptr: allocation, cap: cap, len: 0 }
-        }
-    }
-}
-
 impl<T> Iterator<T> for MoveItems<T> {
     #[inline]
     fn next<'a>(&'a mut self) -> Option<T> {
@@ -2029,18 +2016,6 @@ mod tests {
         assert_eq!(vec.swap_remove(0), None);
     }
 
-    #[test]
-    fn test_move_iter_unwrap() {
-        let mut vec: Vec<uint> = Vec::with_capacity(7);
-        vec.push(1);
-        vec.push(2);
-        let ptr = vec.as_ptr();
-        vec = vec.move_iter().unwrap();
-        assert_eq!(vec.as_ptr(), ptr);
-        assert_eq!(vec.capacity(), 7);
-        assert_eq!(vec.len(), 0);
-    }
-
     #[bench]
     fn bench_new(b: &mut Bencher) {
         b.iter(|| {

trunk/src/libnative/io/net.rs

@@ -959,7 +959,7 @@ pub fn read<T>(fd: sock_t,
             // wait for the socket to become readable again.
             let _guard = lock();
             match retry(|| read(deadline.is_some())) {
-                -1 if util::wouldblock() => {}
+                -1 if util::wouldblock() => { assert!(deadline.is_some()); }
                 -1 => return Err(os::last_error()),
                n => { ret = n; break }
             }

trunk/src/librustc/back/link.rs

@@ -28,6 +28,7 @@ use util::ppaux;
 use util::sha2::{Digest, Sha256};
 
 use std::char;
+use std::collections::HashSet;
 use std::io::{fs, TempDir, Command};
 use std::io;
 use std::mem;
@@ -569,7 +570,10 @@ fn link_binary_output(sess: &Session,
 fn archive_search_paths(sess: &Session) -> Vec<Path> {
     let mut rustpath = filesearch::rust_path();
     rustpath.push(sess.target_filesearch().get_lib_path());
-    let mut search: Vec<Path> = sess.opts.addl_lib_search_paths.borrow().clone();
+    // FIXME: Addl lib search paths are an unordered HashSet?
+    // Shouldn't this search be done in some order?
+    let addl_lib_paths: HashSet<Path> = sess.opts.addl_lib_search_paths.borrow().clone();
+    let mut search: Vec<Path> = addl_lib_paths.move_iter().collect();
     search.push_all(rustpath.as_slice());
     return search;
 }
@@ -1015,12 +1019,6 @@ fn link_args(cmd: &mut Command,
 
         // Mark all dynamic libraries and executables as compatible with ASLR
         cmd.arg("-Wl,--dynamicbase");
-
-        // Mark all dynamic libraries and executables as compatible with the larger 4GiB address
-        // space available to x86 Windows binaries on x86_64.
-        if sess.targ_cfg.arch == abi::X86 {
-            cmd.arg("-Wl,--large-address-aware");
-        }
     }
 
     if sess.targ_cfg.os == abi::OsAndroid {

trunk/src/librustc/diagnostics.rs

@@ -169,6 +169,5 @@ register_diagnostics!(
     E0157,
     E0158,
     E0159,
-    E0160,
-    E0161
+    E0160
 )

trunk/src/librustc/driver/config.rs

@@ -30,7 +30,7 @@ use syntax::diagnostic::{ColorConfig, Auto, Always, Never};
 use syntax::parse;
 use syntax::parse::token::InternedString;
 
-use std::collections::HashMap;
+use std::collections::{HashSet, HashMap};
 use getopts::{optopt, optmulti, optflag, optflagopt};
 use getopts;
 use std::cell::{RefCell};
@@ -76,7 +76,7 @@ pub struct Options {
     // This was mutable for rustpkg, which updates search paths based on the
     // parsed code. It remains mutable in case its replacements wants to use
     // this.
-    pub addl_lib_search_paths: RefCell<Vec<Path>>,
+    pub addl_lib_search_paths: RefCell<HashSet<Path>>,
     pub maybe_sysroot: Option<Path>,
     pub target_triple: String,
     // User-specified cfg meta items. The compiler itself will add additional
@@ -113,7 +113,7 @@ pub fn basic_options() -> Options {
         lint_opts: Vec::new(),
         describe_lints: false,
         output_types: Vec::new(),
-        addl_lib_search_paths: RefCell::new(Vec::new()),
+        addl_lib_search_paths: RefCell::new(HashSet::new()),
         maybe_sysroot: None,
         target_triple: driver::host_triple().to_string(),
         cfg: Vec::new(),

trunk/src/librustc/driver/driver.rs

@@ -32,7 +32,6 @@ use serialize::{json, Encodable};
 
 use std::io;
 use std::io::fs;
-use arena::TypedArena;
 use syntax::ast;
 use syntax::attr;
 use syntax::attr::{AttrMetaMethods};
@@ -87,9 +86,8 @@ pub fn compile_input(sess: Session,
 
         if stop_after_phase_2(&sess) { return; }
 
-        let type_arena = TypedArena::new();
         let analysis = phase_3_run_analysis_passes(sess, &expanded_crate,
-                                                   ast_map, &type_arena, id);
+                                                   ast_map, id);
         phase_save_analysis(&analysis.ty_cx.sess, &expanded_crate, &analysis, outdir);
         if stop_after_phase_3(&analysis.ty_cx.sess) { return; }
         let (tcx, trans) = phase_4_translate_to_llvm(expanded_crate, analysis);
@@ -301,11 +299,11 @@ pub fn phase_2_configure_and_expand(sess: &Session,
     Some((krate, map))
 }
 
-pub struct CrateAnalysis<'tcx> {
+pub struct CrateAnalysis {
     pub exp_map2: middle::resolve::ExportMap2,
     pub exported_items: middle::privacy::ExportedItems,
     pub public_items: middle::privacy::PublicItems,
-    pub ty_cx: ty::ctxt<'tcx>,
+    pub ty_cx: ty::ctxt,
     pub reachable: NodeSet,
     pub name: String,
 }
@@ -314,11 +312,10 @@ pub struct CrateAnalysis<'tcx> {
 /// Run the resolution, typechecking, region checking and other
 /// miscellaneous analysis passes on the crate. Return various
 /// structures carrying the results of the analysis.
-pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
-                                         krate: &ast::Crate,
-                                         ast_map: syntax::ast_map::Map,
-                                         type_arena: &'tcx TypedArena<ty::t_box_>,
-                                         name: String) -> CrateAnalysis<'tcx> {
+pub fn phase_3_run_analysis_passes(sess: Session,
+                                   krate: &ast::Crate,
+                                   ast_map: syntax::ast_map::Map,
+                                   name: String) -> CrateAnalysis {
     let time_passes = sess.time_passes();
 
     time(time_passes, "external crate/lib resolution", (), |_|
@@ -365,7 +362,6 @@ pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
                                stability::Index::build(krate));
 
     let ty_cx = ty::mk_ctxt(sess,
-                            type_arena,
                             def_map,
                             named_region_map,
                             ast_map,
@@ -408,9 +404,6 @@ pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
     time(time_passes, "borrow checking", (), |_|
          middle::borrowck::check_crate(&ty_cx, krate));
 
-    time(time_passes, "rvalue checking", (), |_|
-         middle::check_rvalues::check_crate(&ty_cx, krate));
-
     time(time_passes, "kind checking", (), |_|
          kind::check_crate(&ty_cx, krate));
 

trunk/src/librustc/driver/pretty.rs

@@ -33,7 +33,7 @@ use graphviz as dot;
 use std::io::{mod, MemReader};
 use std::from_str::FromStr;
 use std::option;
-use arena::TypedArena;
+
 
 #[deriving(PartialEq, Show)]
 pub enum PpSourceMode {
@@ -114,9 +114,7 @@ impl PpSourceMode {
             }
             PpmTyped => {
                 let ast_map = ast_map.expect("--pretty=typed missing ast_map");
-                let type_arena = TypedArena::new();
-                let analysis = driver::phase_3_run_analysis_passes(sess, krate, ast_map,
-                                                                   &type_arena, id);
+                let analysis = driver::phase_3_run_analysis_passes(sess, krate, ast_map, id);
                 let annotation = TypedAnnotation { analysis: analysis };
                 f(&annotation, payload)
             }
@@ -262,25 +260,25 @@ impl pprust::PpAnn for HygieneAnnotation {
 }
 
 
-struct TypedAnnotation<'tcx> {
-    analysis: CrateAnalysis<'tcx>,
+struct TypedAnnotation {
+    analysis: CrateAnalysis,
 }
 
-impl<'tcx> PrinterSupport for TypedAnnotation<'tcx> {
+impl PrinterSupport for TypedAnnotation {
     fn pp_ann<'a>(&'a self) -> &'a pprust::PpAnn { self as &pprust::PpAnn }
 }
 
-impl<'tcx> SessionCarrier for TypedAnnotation<'tcx> {
+impl SessionCarrier for TypedAnnotation {
     fn sess<'a>(&'a self) -> &'a Session { &self.analysis.ty_cx.sess }
 }
 
-impl<'tcx> AstMapCarrier for TypedAnnotation<'tcx> {
+impl AstMapCarrier for TypedAnnotation {
     fn ast_map<'a>(&'a self) -> Option<&'a ast_map::Map> {
         Some(&self.analysis.ty_cx.map)
     }
 }
 
-impl<'tcx> pprust::PpAnn for TypedAnnotation<'tcx> {
+impl pprust::PpAnn for TypedAnnotation {
     fn pre(&self,
            s: &mut pprust::State,
            node: pprust::AnnNode) -> io::IoResult<()> {
@@ -533,9 +531,8 @@ pub fn pretty_print_input(sess: Session,
             match code {
                 Some(code) => {
                     let variants = gather_flowgraph_variants(&sess);
-                    let type_arena = TypedArena::new();
                     let analysis = driver::phase_3_run_analysis_passes(sess, &krate,
-                                                                       ast_map, &type_arena, id);
+                                                                       ast_map, id);
                     print_flowgraph(variants, analysis, code, out)
                 }
                 None => {

trunk/src/librustc/lib.rs

@@ -80,7 +80,6 @@ pub mod middle {
     pub mod check_const;
     pub mod check_loop;
     pub mod check_match;
-    pub mod check_rvalues;
     pub mod check_static;
     pub mod const_eval;
     pub mod dataflow;

trunk/src/librustc/lint/builtin.rs

@@ -340,11 +340,11 @@ impl LintPass for TypeLimits {
 declare_lint!(CTYPES, Warn,
               "proper use of libc types in foreign modules")
 
-struct CTypesVisitor<'a, 'tcx: 'a> {
-    cx: &'a Context<'a, 'tcx>
+struct CTypesVisitor<'a> {
+    cx: &'a Context<'a>
 }
 
-impl<'a, 'tcx> CTypesVisitor<'a, 'tcx> {
+impl<'a> CTypesVisitor<'a> {
     fn check_def(&mut self, sp: Span, ty_id: ast::NodeId, path_id: ast::NodeId) {
         match self.cx.tcx.def_map.borrow().get_copy(&path_id) {
             def::DefPrimTy(ast::TyInt(ast::TyI)) => {
@@ -375,7 +375,7 @@ impl<'a, 'tcx> CTypesVisitor<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> Visitor<()> for CTypesVisitor<'a, 'tcx> {
+impl<'a> Visitor<()> for CTypesVisitor<'a> {
     fn visit_ty(&mut self, ty: &ast::Ty, _: ()) {
         match ty.node {
             ast::TyPath(_, _, id) => self.check_def(ty.span, ty.id, id),
@@ -505,11 +505,11 @@ impl LintPass for HeapMemory {
 declare_lint!(RAW_POINTER_DERIVING, Warn,
               "uses of #[deriving] with raw pointers are rarely correct")
 
-struct RawPtrDerivingVisitor<'a, 'tcx: 'a> {
-    cx: &'a Context<'a, 'tcx>
+struct RawPtrDerivingVisitor<'a> {
+    cx: &'a Context<'a>
 }
 
-impl<'a, 'tcx> Visitor<()> for RawPtrDerivingVisitor<'a, 'tcx> {
+impl<'a> Visitor<()> for RawPtrDerivingVisitor<'a> {
     fn visit_ty(&mut self, ty: &ast::Ty, _: ()) {
         static MSG: &'static str = "use of `#[deriving]` with a raw pointer";
         match ty.node {