---

yaml
---
r: 139384
b: refs/heads/try2
c: ab5346d
h: refs/heads/master
v: v3

Author: huonw

[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: 84ddff3909b5920228642649b7f5cc011c0b900a
+refs/heads/try2: ab5346d119b6ac3ba9e9d67df929fdf546865d0a
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/RELEASES.txt

@@ -62,8 +62,6 @@ 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,6 +308,8 @@ case $CFG_OSTYPE in
 esac
 
 
+if [ -z "$CFG_CPUTYPE" ]
+then
 case $CFG_CPUTYPE in
 
     i386 | i486 | i686 | i786 | x86)
@@ -325,6 +327,7 @@ 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 ]
@@ -572,7 +575,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 -e 's/^CC_//' -e 's/\([^=]*\).*/\1/' | xargs)"
+CFG_SUPPORTED_TARGET_TRIPLES="$(grep ^CC_*=* $CFG_SRC_DIR/mk/platform.mk | sed 's,^[^_]*_,,' | sed '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,10 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! 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.
+//! Sendable hash maps.
 
 /// 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.
 
-//! Traits for the built-in operators
+// Core 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,6 +630,7 @@ 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,6 +410,9 @@ 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,7 +24,6 @@ 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
@@ -480,9 +479,7 @@ 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 {bound_lifetime_names: opt_vec::Empty, // FIXME(#4846)
-               inputs: inputs,
-               output: ret_ty}
+    ty::FnSig {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.get(c::tag_tree as uint);
+    let chi_doc = par_doc[c::tag_tree as uint];
     let d = &reader::Decoder(chi_doc);
     Decodable::decode(d)
 }
@@ -681,7 +681,6 @@ 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") {
@@ -716,44 +715,6 @@ 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")
-                }
-            }
-        }
-    }
 }
 
 // ______________________________________________________________________
@@ -1128,9 +1089,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.get(c::tag_table as uint);
+    let tbl_doc = ast_doc[c::tag_table as uint];
     for reader::docs(tbl_doc) |tag, entry_doc| {
-        let id0 = entry_doc.get(c::tag_table_id as uint).as_int();
+        let id0 = entry_doc[c::tag_table_id as uint].as_int();
         let id = xcx.tr_id(id0);
 
         debug!(">> Side table document with tag 0x%x \
@@ -1142,7 +1103,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.get(c::tag_table_val as uint);
+            let val_doc = entry_doc[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);
@@ -1211,7 +1172,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.get(c::tag_tree as uint);
+    let chi_doc = par_doc[c::tag_tree as uint];
     let d = &reader::Decoder(chi_doc);
     @Decodable::decode(d)
 }

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

@@ -180,6 +180,21 @@ 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,6 +156,7 @@ 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,6 +110,7 @@ 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,6 +111,7 @@ 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;
@@ -136,19 +137,58 @@ 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);
 
-#[deriving(Eq)]
+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) }
+}
+
 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 {
@@ -427,6 +467,11 @@ 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_,
@@ -1290,7 +1335,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)