---

yaml
---
r: 139390
b: refs/heads/try2
c: 91cb668
h: refs/heads/master
v: v3

Author: thestinger

[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: d31053277aa8ced6778334d49de150b1393073eb
+refs/heads/try2: 91cb6687a8869fa14aef8d978fb13e330c711cd3
 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/cmp.rs

@@ -45,62 +45,31 @@ pub trait TotalOrd {
     fn cmp(&self, other: &Self) -> Ordering;
 }
 
-#[inline(always)]
-fn icmp<T: Ord>(a: &T, b: &T) -> Ordering {
-    if *a < *b { Less }
-    else if *a > *b { Greater }
-    else { Equal }
-}
-
-impl TotalOrd for u8 {
-    #[inline(always)]
-    fn cmp(&self, other: &u8) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for u16 {
-    #[inline(always)]
-    fn cmp(&self, other: &u16) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for u32 {
-    #[inline(always)]
-    fn cmp(&self, other: &u32) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for u64 {
-    #[inline(always)]
-    fn cmp(&self, other: &u64) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for i8 {
-    #[inline(always)]
-    fn cmp(&self, other: &i8) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for i16 {
-    #[inline(always)]
-    fn cmp(&self, other: &i16) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for i32 {
-    #[inline(always)]
-    fn cmp(&self, other: &i32) -> Ordering { icmp(self, other) }
-}
+macro_rules! totalord_impl(
+    ($t:ty) => {
+        impl TotalOrd for $t {
+            #[inline(always)]
+            fn cmp(&self, other: &$t) -> Ordering {
+                if *self < *other { Less }
+                else if *self > *other { Greater }
+                else { Equal }
+            }
+        }
+    }
+)
 
-impl TotalOrd for i64 {
-    #[inline(always)]
-    fn cmp(&self, other: &i64) -> Ordering { icmp(self, other) }
-}
+totalord_impl!(u8)
+totalord_impl!(u16)
+totalord_impl!(u32)
+totalord_impl!(u64)
 
-impl TotalOrd for int {
-    #[inline(always)]
-    fn cmp(&self, other: &int) -> Ordering { icmp(self, other) }
-}
+totalord_impl!(i8)
+totalord_impl!(i16)
+totalord_impl!(i32)
+totalord_impl!(i64)
 
-impl TotalOrd for uint {
-    #[inline(always)]
-    fn cmp(&self, other: &uint) -> Ordering { icmp(self, other) }
-}
+totalord_impl!(int)
+totalord_impl!(uint)
 
 /**
 * Trait for values that can be compared for a sort-order.

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/libcore/rt/context.rs

@@ -126,7 +126,7 @@ fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp:
 type Registers = [uint, ..22];
 
 #[cfg(target_arch = "x86_64")]
-fn new_regs() -> ~Registers { ~([0, .. 22]) }
+fn new_regs() -> ~Registers { ~[0, .. 22] }
 
 #[cfg(target_arch = "x86_64")]
 fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {

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 |