---

yaml
---
r: 139389
b: refs/heads/try2
c: d310532
h: refs/heads/master
i:
  139387: 896cb4d
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: e5dda811a9818a3289a3a1354f98731e46730bd9
+refs/heads/try2: d31053277aa8ced6778334d49de150b1393073eb
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/RELEASES.txt

@@ -62,6 +62,8 @@ Version 0.6 (March 2013)
       * Pattern matching over vectors improved and expanded
       * Typechecking of closure types has been overhauled to
         improve inference and eliminate unsoundness
+      * Macros leave scope at the end of modules, unless that module is
+        tagged with #[macro_escape]
 
    * Libraries
       * Added big integers to `std::bigint`

branches/try2/configure

@@ -308,8 +308,6 @@ case $CFG_OSTYPE in
 esac
 
 
-if [ -z "$CFG_CPUTYPE" ]
-then
 case $CFG_CPUTYPE in
 
     i386 | i486 | i686 | i786 | x86)
@@ -327,7 +325,6 @@ case $CFG_CPUTYPE in
     *)
         err "unknown CPU type: $CFG_CPUTYPE"
 esac
-fi
 
 # Detect 64 bit linux systems with 32 bit userland and force 32 bit compilation
 if [ $CFG_OSTYPE = unknown-linux-gnu -a $CFG_CPUTYPE = x86_64 ]
@@ -575,7 +572,7 @@ fi
 CFG_PREFIX=${CFG_PREFIX%/}
 CFG_HOST_TRIPLES="$(echo $CFG_HOST_TRIPLES | tr ',' ' ')"
 CFG_TARGET_TRIPLES="$(echo $CFG_TARGET_TRIPLES | tr ',' ' ')"
-CFG_SUPPORTED_TARGET_TRIPLES="$(grep ^CC_*=* $CFG_SRC_DIR/mk/platform.mk | sed 's,^[^_]*_,,' | sed 's/\([^=]*\).*/\1/' | xargs)"
+CFG_SUPPORTED_TARGET_TRIPLES="$(grep ^CC_*=* $CFG_SRC_DIR/mk/platform.mk | sed -e 's/^CC_//' -e 's/\([^=]*\).*/\1/' | xargs)"
 
 # copy host-triples to target-triples so that hosts are a subset of targets
 V_TEMP=""

branches/try2/src/libcore/hashmap.rs

@@ -8,7 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Sendable hash maps.
+//! An unordered map and set type implemented as hash tables
+//!
+//! The tables use a keyed hash with new random keys generated for each container, so the ordering
+//! of a set of keys in a hash table is randomized.
 
 /// Open addressing with linear probing.
 pub mod linear {

branches/try2/src/libcore/ops.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Core operators
+//! Traits for the built-in operators
 
 #[lang="drop"]
 pub trait Drop {
@@ -77,5 +77,5 @@ pub trait Shr<RHS,Result> {
 
 #[lang="index"]
 pub trait Index<Index,Result> {
-    fn index(&self, index: Index) -> Result;
+    fn index(&self, index: &Index) -> Result;
 }

branches/try2/src/librustc/metadata/decoder.rs

@@ -630,7 +630,6 @@ fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ {
     let self_ty_kind = string[0];
     match self_ty_kind as char {
         's' => { return ast::sty_static; }
-        'r' => { return ast::sty_by_ref; }
         'v' => { return ast::sty_value; }
         '@' => { return ast::sty_box(get_mutability(string[1])); }
         '~' => { return ast::sty_uniq(get_mutability(string[1])); }

branches/try2/src/librustc/metadata/encoder.rs

@@ -410,9 +410,6 @@ fn encode_self_type(ebml_w: writer::Encoder, self_type: ast::self_ty_) {
         sty_static => {
             ebml_w.writer.write(&[ 's' as u8 ]);
         }
-        sty_by_ref => {
-            ebml_w.writer.write(&[ 'r' as u8 ]);
-        }
         sty_value => {
             ebml_w.writer.write(&[ 'v' as u8 ]);
         }

branches/try2/src/librustc/metadata/tydecode.rs

@@ -24,6 +24,7 @@ use core::vec;
 use syntax::ast;
 use syntax::ast::*;
 use syntax::codemap::{respan, dummy_sp};
+use syntax::opt_vec;
 
 // Compact string representation for ty::t values. API ty_str &
 // parse_from_str. Extra parameters are for converting to/from def_ids in the
@@ -479,7 +480,9 @@ fn parse_sig(st: @mut PState, conv: conv_did) -> ty::FnSig {
     }
     st.pos += 1u; // eat the ']'
     let ret_ty = parse_ty(st, conv);
-    ty::FnSig {inputs: inputs, output: ret_ty}
+    ty::FnSig {bound_lifetime_names: opt_vec::Empty, // FIXME(#4846)
+               inputs: inputs,
+               output: ret_ty}
 }
 
 // Rust metadata parsing

branches/try2/src/librustc/middle/astencode.rs

@@ -342,7 +342,7 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
 }
 
 fn decode_ast(par_doc: ebml::Doc) -> ast::inlined_item {
-    let chi_doc = par_doc[c::tag_tree as uint];
+    let chi_doc = par_doc.get(c::tag_tree as uint);
     let d = &reader::Decoder(chi_doc);
     Decodable::decode(d)
 }
@@ -681,6 +681,7 @@ impl vtable_decoder_helpers for reader::Decoder {
         @self.read_to_vec(|| self.read_vtable_origin(xcx) )
     }
 
+    #[cfg(stage0)]
     fn read_vtable_origin(&self, xcx: @ExtendedDecodeContext)
         -> typeck::vtable_origin {
         do self.read_enum(~"vtable_origin") {
@@ -715,6 +716,44 @@ impl vtable_decoder_helpers for reader::Decoder {
             }
         }
     }
+
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
+    fn read_vtable_origin(&self, xcx: @ExtendedDecodeContext)
+        -> typeck::vtable_origin {
+        do self.read_enum("vtable_origin") {
+            do self.read_enum_variant(["vtable_static", "vtable_param"]) |i| {
+                match i {
+                  0 => {
+                    typeck::vtable_static(
+                        do self.read_enum_variant_arg(0u) {
+                            self.read_def_id(xcx)
+                        },
+                        do self.read_enum_variant_arg(1u) {
+                            self.read_tys(xcx)
+                        },
+                        do self.read_enum_variant_arg(2u) {
+                            self.read_vtable_res(xcx)
+                        }
+                    )
+                  }
+                  1 => {
+                    typeck::vtable_param(
+                        do self.read_enum_variant_arg(0u) {
+                            self.read_uint()
+                        },
+                        do self.read_enum_variant_arg(1u) {
+                            self.read_uint()
+                        }
+                    )
+                  }
+                  // hard to avoid - user input
+                  _ => fail!(~"bad enum variant")
+                }
+            }
+        }
+    }
 }
 
 // ______________________________________________________________________
@@ -1089,9 +1128,9 @@ impl ebml_decoder_decoder_helpers for reader::Decoder {
 fn decode_side_tables(xcx: @ExtendedDecodeContext,
                       ast_doc: ebml::Doc) {
     let dcx = xcx.dcx;
-    let tbl_doc = ast_doc[c::tag_table as uint];
+    let tbl_doc = ast_doc.get(c::tag_table as uint);
     for reader::docs(tbl_doc) |tag, entry_doc| {
-        let id0 = entry_doc[c::tag_table_id as uint].as_int();
+        let id0 = entry_doc.get(c::tag_table_id as uint).as_int();
         let id = xcx.tr_id(id0);
 
         debug!(">> Side table document with tag 0x%x \
@@ -1103,7 +1142,7 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext,
         } else if tag == (c::tag_table_moves_map as uint) {
             dcx.maps.moves_map.insert(id);
         } else {
-            let val_doc = entry_doc[c::tag_table_val as uint];
+            let val_doc = entry_doc.get(c::tag_table_val as uint);
             let val_dsr = &reader::Decoder(val_doc);
             if tag == (c::tag_table_def as uint) {
                 let def = decode_def(xcx, val_doc);
@@ -1172,7 +1211,7 @@ fn encode_item_ast(ebml_w: writer::Encoder, item: @ast::item) {
 
 #[cfg(test)]
 fn decode_item_ast(par_doc: ebml::Doc) -> @ast::item {
-    let chi_doc = par_doc[c::tag_tree as uint];
+    let chi_doc = par_doc.get(c::tag_tree as uint);
     let d = &reader::Decoder(chi_doc);
     @Decodable::decode(d)
 }

branches/try2/src/librustc/middle/borrowck/gather_loans.rs

@@ -180,21 +180,6 @@ fn req_loans_in_expr(ex: @ast::expr,
             }
         }
 
-        match self.bccx.method_map.find(&ex.id) {
-            Some(ref method_map_entry) => {
-                match (*method_map_entry).explicit_self {
-                    ast::sty_by_ref => {
-                        let rcvr_cmt = self.bccx.cat_expr(rcvr);
-                        self.guarantee_valid(rcvr_cmt, m_imm, scope_r);
-                    }
-                    _ => {} // Nothing to do.
-                }
-            }
-            None => {
-                self.tcx().sess.span_bug(ex.span, ~"no method map entry");
-            }
-        }
-
         visit::visit_expr(ex, self, vt);
       }
 

branches/try2/src/librustc/middle/check_const.rs

@@ -156,7 +156,6 @@ pub fn check_expr(sess: Session,
           expr_paren(e) => { check_expr(sess, def_map, method_map,
                                          tcx, e, is_const, v); }
           expr_vstore(_, expr_vstore_slice) |
-          expr_vstore(_, expr_vstore_fixed(_)) |
           expr_vec(_, m_imm) |
           expr_addr_of(m_imm, _) |
           expr_field(*) |

branches/try2/src/librustc/middle/const_eval.rs

@@ -110,7 +110,6 @@ pub fn classify(e: @expr,
 
               ast::expr_vstore(e, vstore) => {
                   match vstore {
-                      ast::expr_vstore_fixed(_) |
                       ast::expr_vstore_slice => classify(e, tcx),
                       ast::expr_vstore_uniq |
                       ast::expr_vstore_box |

branches/try2/src/librustc/middle/liveness.rs

@@ -111,7 +111,6 @@ use middle::typeck;
 use middle::moves;
 use util::ppaux::ty_to_str;
 
-use core::cmp;
 use core::hashmap::linear::LinearMap;
 use core::io::WriterUtil;
 use core::io;
@@ -137,58 +136,19 @@ use syntax::{visit, ast_util};
 // if it detects an outstanding loan (that is, the addr is taken).
 pub type last_use_map = @mut LinearMap<node_id, @mut ~[node_id]>;
 
+#[deriving(Eq)]
 struct Variable(uint);
+#[deriving(Eq)]
 struct LiveNode(uint);
 
-impl cmp::Eq for Variable {
-    fn eq(&self, other: &Variable) -> bool { *(*self) == *(*other) }
-    fn ne(&self, other: &Variable) -> bool { *(*self) != *(*other) }
-}
-
-impl cmp::Eq for LiveNode {
-    fn eq(&self, other: &LiveNode) -> bool { *(*self) == *(*other) }
-    fn ne(&self, other: &LiveNode) -> bool { *(*self) != *(*other) }
-}
-
+#[deriving(Eq)]
 enum LiveNodeKind {
     FreeVarNode(span),
     ExprNode(span),
     VarDefNode(span),
     ExitNode
 }
 
-impl cmp::Eq for LiveNodeKind {
-    fn eq(&self, other: &LiveNodeKind) -> bool {
-        match (*self) {
-            FreeVarNode(e0a) => {
-                match (*other) {
-                    FreeVarNode(e0b) => e0a == e0b,
-                    _ => false
-                }
-            }
-            ExprNode(e0a) => {
-                match (*other) {
-                    ExprNode(e0b) => e0a == e0b,
-                    _ => false
-                }
-            }
-            VarDefNode(e0a) => {
-                match (*other) {
-                    VarDefNode(e0b) => e0a == e0b,
-                    _ => false
-                }
-            }
-            ExitNode => {
-                match (*other) {
-                    ExitNode => true,
-                    _ => false
-                }
-            }
-        }
-    }
-    fn ne(&self, other: &LiveNodeKind) -> bool { !(*self).eq(other) }
-}
-
 fn live_node_kind_to_str(lnk: LiveNodeKind, cx: ty::ctxt) -> ~str {
     let cm = cx.sess.codemap;
     match lnk {
@@ -467,11 +427,6 @@ fn visit_fn(fk: &visit::fn_kind,
     match *fk {
         fk_method(_, _, method) => {
             match method.self_ty.node {
-                sty_by_ref => {
-                    fn_maps.add_variable(Arg(method.self_id,
-                                             special_idents::self_,
-                                             by_ref));
-                }
                 sty_value | sty_region(*) | sty_box(_) | sty_uniq(_) => {
                     fn_maps.add_variable(Arg(method.self_id,
                                              special_idents::self_,
@@ -1335,7 +1290,7 @@ pub impl Liveness {
             self.propagate_through_expr(l, ln)
           }
 
-          expr_log(_, l, r) |
+          expr_log(l, r) |
           expr_index(l, r) |
           expr_binary(_, l, r) => {
             self.propagate_through_exprs(~[l, r], succ)