---

yaml
---
r: 93748
b: refs/heads/try
c: ab7fe9d
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: 68024eb4eb55ee6bca1279fc755a0b9bc6ec58cd
+refs/heads/try: ab7fe9dd06e93986f6b11512031c891059474653
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libextra/time.rs

@@ -21,8 +21,8 @@ pub mod rustrt {
     use super::Tm;
 
     extern {
-        pub fn get_time(sec: &mut i64, nsec: &mut i32);
-        pub fn precise_time_ns(ns: &mut u64);
+        pub fn rust_get_time(sec: &mut i64, nsec: &mut i32);
+        pub fn rust_precise_time_ns(ns: &mut u64);
         pub fn rust_tzset();
         pub fn rust_gmtime(sec: i64, nsec: i32, result: &mut Tm);
         pub fn rust_localtime(sec: i64, nsec: i32, result: &mut Tm);
@@ -66,7 +66,7 @@ pub fn get_time() -> Timespec {
     unsafe {
         let mut sec = 0i64;
         let mut nsec = 0i32;
-        rustrt::get_time(&mut sec, &mut nsec);
+        rustrt::rust_get_time(&mut sec, &mut nsec);
         return Timespec::new(sec, nsec);
     }
 }
@@ -79,7 +79,7 @@ pub fn get_time() -> Timespec {
 pub fn precise_time_ns() -> u64 {
     unsafe {
         let mut ns = 0u64;
-        rustrt::precise_time_ns(&mut ns);
+        rustrt::rust_precise_time_ns(&mut ns);
         ns
     }
 }

branches/try/src/librustc/middle/cfg/construct.rs

@@ -97,7 +97,7 @@ impl CFGBuilder {
             ast::PatEnum(_, None) |
             ast::PatLit(*) |
             ast::PatRange(*) |
-            ast::PatWild => {
+            ast::PatWild | ast::PatWildMulti => {
                 self.add_node(pat.id, [pred])
             }
 

branches/try/src/librustc/middle/check_match.rs

@@ -333,7 +333,7 @@ fn is_useful_specialized(cx: &MatchCheckCtxt,
 fn pat_ctor_id(cx: &MatchCheckCtxt, p: @Pat) -> Option<ctor> {
     let pat = raw_pat(p);
     match pat.node {
-      PatWild => { None }
+      PatWild | PatWildMulti => { None }
       PatIdent(_, _, _) | PatEnum(_, _) => {
         match cx.tcx.def_map.find(&pat.id) {
           Some(&DefVariant(_, id, _)) => Some(variant(id)),
@@ -369,7 +369,7 @@ fn pat_ctor_id(cx: &MatchCheckCtxt, p: @Pat) -> Option<ctor> {
 fn is_wild(cx: &MatchCheckCtxt, p: @Pat) -> bool {
     let pat = raw_pat(p);
     match pat.node {
-      PatWild => { true }
+      PatWild | PatWildMulti => { true }
       PatIdent(_, _, _) => {
         match cx.tcx.def_map.find(&pat.id) {
           Some(&DefVariant(_, _, _)) | Some(&DefStatic(*)) => { false }
@@ -532,6 +532,10 @@ fn wild() -> @Pat {
     @Pat {id: 0, node: PatWild, span: dummy_sp()}
 }
 
+fn wild_multi() -> @Pat {
+    @Pat {id: 0, node: PatWildMulti, span: dummy_sp()}
+}
+
 fn specialize(cx: &MatchCheckCtxt,
                   r: &[@Pat],
                   ctor_id: &ctor,
@@ -546,6 +550,9 @@ fn specialize(cx: &MatchCheckCtxt,
             PatWild => {
                 Some(vec::append(vec::from_elem(arity, wild()), r.tail()))
             }
+            PatWildMulti => {
+                Some(vec::append(vec::from_elem(arity, wild_multi()), r.tail()))
+            }
             PatIdent(_, _, _) => {
                 match cx.tcx.def_map.find(&pat_id) {
                     Some(&DefVariant(_, id, _)) => {
@@ -849,7 +856,7 @@ fn is_refutable(cx: &MatchCheckCtxt, pat: &Pat) -> bool {
       PatIdent(_, _, Some(sub)) => {
         is_refutable(cx, sub)
       }
-      PatWild | PatIdent(_, _, None) => { false }
+      PatWild | PatWildMulti | PatIdent(_, _, None) => { false }
       PatLit(@Expr {node: ExprLit(@Spanned { node: lit_nil, _}), _}) => {
         // "()"
         false

branches/try/src/librustc/middle/mem_categorization.rs

@@ -876,7 +876,7 @@ impl mem_categorization_ctxt {
         op(cmt, pat);
 
         match pat.node {
-          ast::PatWild => {
+          ast::PatWild | ast::PatWildMulti => {
             // _
           }
 

branches/try/src/librustc/middle/pat_util.rs

@@ -65,7 +65,7 @@ pub fn pat_is_binding(dm: resolve::DefMap, pat: @Pat) -> bool {
 pub fn pat_is_binding_or_wild(dm: resolve::DefMap, pat: @Pat) -> bool {
     match pat.node {
         PatIdent(*) => pat_is_binding(dm, pat),
-        PatWild => true,
+        PatWild | PatWildMulti => true,
         _ => false
     }
 }

branches/try/src/librustc/middle/trans/_match.rs

@@ -545,7 +545,7 @@ fn enter_default<'r>(bcx: @mut Block,
     // Collect all of the matches that can match against anything.
     let matches = do enter_match(bcx, dm, m, col, val) |p| {
         match p.node {
-          ast::PatWild | ast::PatTup(_) => Some(~[]),
+          ast::PatWild | ast::PatWildMulti | ast::PatTup(_) => Some(~[]),
           ast::PatIdent(_, _, None) if pat_is_binding(dm, p) => Some(~[]),
           _ => None
         }
@@ -2234,7 +2234,7 @@ fn bind_irrefutable_pat(bcx: @mut Block,
                 pat.span,
                 format!("vector patterns are never irrefutable!"));
         }
-        ast::PatWild | ast::PatLit(_) | ast::PatRange(_, _) => ()
+        ast::PatWild | ast::PatWildMulti | ast::PatLit(_) | ast::PatRange(_, _) => ()
     }
     return bcx;
 }

branches/try/src/librustc/middle/trans/controlflow.rs

@@ -14,6 +14,7 @@ use middle::trans::base::*;
 use middle::trans::build::*;
 use middle::trans::callee;
 use middle::trans::common::*;
+use middle::trans::debuginfo;
 use middle::trans::expr;
 use middle::ty;
 use util::common::indenter;
@@ -75,6 +76,7 @@ pub fn trans_if(bcx: @mut Block,
             // if true { .. } [else { .. }]
             return do with_scope(bcx, thn.info(), "if_true_then") |bcx| {
                 let bcx_out = trans_block(bcx, thn, dest);
+                debuginfo::clear_source_location(bcx.fcx);
                 trans_block_cleanups(bcx_out, block_cleanups(bcx))
             }
         } else {
@@ -86,6 +88,7 @@ pub fn trans_if(bcx: @mut Block,
                 Some(elexpr) => {
                     return do with_scope(bcx, elexpr.info(), "if_false_then") |bcx| {
                         let bcx_out = trans_if_else(bcx, elexpr, dest);
+                        debuginfo::clear_source_location(bcx.fcx);
                         trans_block_cleanups(bcx_out, block_cleanups(bcx))
                     }
                 }
@@ -98,6 +101,8 @@ pub fn trans_if(bcx: @mut Block,
     let then_bcx_in = scope_block(bcx, thn.info(), "then");
 
     let then_bcx_out = trans_block(then_bcx_in, thn, dest);
+
+    debuginfo::clear_source_location(bcx.fcx);
     let then_bcx_out = trans_block_cleanups(then_bcx_out,
                                             block_cleanups(then_bcx_in));
 
@@ -122,6 +127,9 @@ pub fn trans_if(bcx: @mut Block,
     debug!("then_bcx_in={}, else_bcx_in={}",
            then_bcx_in.to_str(), else_bcx_in.to_str());
 
+    // Clear the source location because it is still set to whatever has been translated
+    // right before.
+    debuginfo::clear_source_location(else_bcx_in.fcx);
     CondBr(bcx, cond_val, then_bcx_in.llbb, else_bcx_in.llbb);
     return next_bcx;
 
@@ -139,6 +147,7 @@ pub fn trans_if(bcx: @mut Block,
             // would be nice to have a constraint on ifs
             _ => else_bcx_in.tcx().sess.bug("strange alternative in if")
         };
+        debuginfo::clear_source_location(else_bcx_in.fcx);
         trans_block_cleanups(else_bcx_out, block_cleanups(else_bcx_in))
     }
 }

branches/try/src/librustc/middle/trans/debuginfo.rs

@@ -509,6 +509,17 @@ pub fn set_source_location(fcx: &FunctionContext,
     }
 }
 
+/// Clears the current debug location.
+///
+/// Instructions generated hereafter won't be assigned a source location.
+pub fn clear_source_location(fcx: &FunctionContext) {
+    if fn_should_be_ignored(fcx) {
+        return;
+    }
+
+    set_debug_location(fcx.ccx, UnknownLocation);
+}
+
 /// Enables emitting source locations for the given functions.
 ///
 /// Since we don't want source locations to be emitted for the function prelude, they are disabled
@@ -2418,7 +2429,7 @@ fn populate_scope_map(cx: &mut CrateContext,
                 }
             }
 
-            ast::PatWild => {
+            ast::PatWild | ast::PatWildMulti => {
                 scope_map.insert(pat.id, scope_stack.last().scope_metadata);
             }
 

branches/try/src/librustc/middle/typeck/check/_match.rs

@@ -414,7 +414,7 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::Pat, expected: ty::t) {
     let tcx = pcx.fcx.ccx.tcx;
 
     match pat.node {
-      ast::PatWild => {
+      ast::PatWild | ast::PatWildMulti => {
         fcx.write_ty(pat.id, expected);
       }
       ast::PatLit(lt) => {

branches/try/src/librustc/middle/typeck/check/regionck.rs

@@ -1219,7 +1219,7 @@ pub mod guarantor {
                rcx.fcx.pat_to_str(pat), guarantor);
 
         match pat.node {
-            ast::PatWild => {}
+            ast::PatWild | ast::PatWildMulti => {}
             ast::PatIdent(ast::BindByRef(_), _, opt_p) => {
                 link(rcx, pat.span, pat.id, guarantor);
 

branches/try/src/librustdoc/clean.rs

@@ -1137,6 +1137,7 @@ fn name_from_pat(p: &ast::Pat) -> ~str {
     use syntax::ast::*;
     match p.node {
         PatWild => ~"_",
+        PatWildMulti => ~"..",
         PatIdent(_, ref p, _) => path_to_str(p),
         PatEnum(ref p, _) => path_to_str(p),
         PatStruct(*) => fail!("tried to get argument name from pat_struct, \

branches/try/src/libstd/rt/basic.rs

@@ -241,11 +241,11 @@ impl Drop for BasicPausible {
 
 fn time() -> Time {
     extern {
-        fn get_time(sec: &mut i64, nsec: &mut i32);
+        fn rust_get_time(sec: &mut i64, nsec: &mut i32);
     }
     let mut sec = 0;
     let mut nsec = 0;
-    unsafe { get_time(&mut sec, &mut nsec) }
+    unsafe { rust_get_time(&mut sec, &mut nsec) }
 
     Time { sec: sec as u64, nsec: nsec as u64 }
 }

branches/try/src/libstd/rt/context.rs

@@ -59,7 +59,7 @@ impl Context {
         // which we will then modify to call the given function when restored
         let mut regs = new_regs();
         unsafe {
-            swap_registers(transmute_mut_region(&mut *regs), transmute_region(&*regs));
+            rust_swap_registers(transmute_mut_region(&mut *regs), transmute_region(&*regs));
         };
 
         initialize_call_frame(&mut *regs, fp, argp, sp);
@@ -104,22 +104,22 @@ impl Context {
             // stack limit in the OS-specified TLS slot. This also  means that
             // we cannot call any more rust functions after record_stack_bounds
             // returns because they would all likely fail due to the limit being
-            // invalid for the current task. Lucky for us `swap_registers` is a
-            // C function so we don't have to worry about that!
+            // invalid for the current task. Lucky for us `rust_swap_registers`
+            // is a C function so we don't have to worry about that!
             match in_context.stack_bounds {
                 Some((lo, hi)) => record_stack_bounds(lo, hi),
                 // If we're going back to one of the original contexts or
                 // something that's possibly not a "normal task", then reset
                 // the stack limit to 0 to make morestack never fail
                 None => record_stack_bounds(0, uint::max_value),
             }
-            swap_registers(out_regs, in_regs)
+            rust_swap_registers(out_regs, in_regs)
         }
     }
 }
 
 extern {
-    fn swap_registers(out_regs: *mut Registers, in_regs: *Registers);
+    fn rust_swap_registers(out_regs: *mut Registers, in_regs: *Registers);
 }
 
 // Register contexts used in various architectures
@@ -142,7 +142,7 @@ extern {
 //
 // These structures/functions are roughly in-sync with the source files inside
 // of src/rt/arch/$arch. The only currently used function from those folders is
-// the `swap_registers` function, but that's only because for now segmented
+// the `rust_swap_registers` function, but that's only because for now segmented
 // stacks are disabled.
 
 #[cfg(target_arch = "x86")]

branches/try/src/libsyntax/ast.rs

@@ -337,6 +337,7 @@ pub enum BindingMode {
 #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
 pub enum Pat_ {
     PatWild,
+    PatWildMulti,
     // A pat_ident may either be a new bound variable,
     // or a nullary enum (in which case the second field
     // is None).

branches/try/src/libsyntax/ast_util.rs

@@ -657,7 +657,7 @@ pub fn walk_pat(pat: @Pat, it: &fn(@Pat) -> bool) -> bool {
                 slice.iter().advance(|&p| walk_pat(p, |p| it(p))) &&
                 after.iter().advance(|&p| walk_pat(p, |p| it(p)))
         }
-        PatWild | PatLit(_) | PatRange(_, _) | PatIdent(_, _, _) |
+        PatWild | PatWildMulti | PatLit(_) | PatRange(_, _) | PatIdent(_, _, _) |
         PatEnum(_, _) => {
             true
         }

branches/try/src/libsyntax/fold.rs

@@ -174,6 +174,7 @@ pub trait ast_fold {
     fn fold_pat(&self, p: @Pat) -> @Pat {
         let node = match p.node {
             PatWild => PatWild,
+            PatWildMulti => PatWildMulti,
             PatIdent(binding_mode, ref pth, ref sub) => {
                 PatIdent(binding_mode,
                          self.fold_path(pth),

branches/try/src/libsyntax/parse/obsolete.rs

@@ -39,6 +39,9 @@ pub enum ObsoleteSyntax {
     ObsoleteConstPointer,
     ObsoleteEmptyImpl,
     ObsoleteLoopAsContinue,
+    ObsoleteEnumWildcard,
+    ObsoleteStructWildcard,
+    ObsoleteVecDotDotWildcard
 }
 
 impl to_bytes::IterBytes for ObsoleteSyntax {
@@ -113,6 +116,18 @@ impl ParserObsoleteMethods for Parser {
                 "`loop` is now only used for loops and `continue` is used for \
                  skipping iterations"
             ),
+            ObsoleteEnumWildcard => (
+                "enum wildcard",
+                "use `..` instead of `*` for matching all enum fields"
+            ),
+            ObsoleteStructWildcard => (
+                "struct wildcard",
+                "use `..` instead of `_` for matching trailing struct fields"
+            ),
+            ObsoleteVecDotDotWildcard => (
+                "vec slice wildcard",
+                "use `..` instead of `.._` for matching slices"
+            ),
         };
 
         self.report(sp, kind, kind_str, desc);