---

yaml
---
r: 49425
b: refs/heads/master
c: 51da7d4
h: refs/heads/master
i:
  49423: bf66eb4
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a29934a61b0ade13ef799a9aa9e95c0be940e0f5
+refs/heads/master: 51da7d4bc7a100f5343bc727fb2fb87b05e35c84
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
 refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea

trunk/src/libcore/io.rs

@@ -986,7 +986,7 @@ pub trait WriterUtil {
 
 impl<T:Writer> WriterUtil for T {
     fn write_char(&self, ch: char) {
-        if (ch as uint) < 128u {
+        if ch as uint < 128u {
             self.write(&[ch as u8]);
         } else {
             self.write_str(str::from_char(ch));

trunk/src/libcore/num/strconv.rs

@@ -165,7 +165,7 @@ pub pure fn to_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+NumStrConv+Copy+
                                   Div<T,T>+Neg<T>+Modulo<T,T>+Mul<T,T>>(
         num: &T, radix: uint, negative_zero: bool,
         sign: SignFormat, digits: SignificantDigits) -> (~[u8], bool) {
-    if (radix as int) < 2 {
+    if radix as int <  2 {
         fail!(fmt!("to_str_bytes_common: radix %? to low, \
                    must lie in the range [2, 36]", radix));
     } else if radix as int > 36 {
@@ -455,10 +455,10 @@ pub pure fn from_str_bytes_common<T:NumCast+Zero+One+Ord+Copy+Div<T,T>+
         _ if special && radix >= DIGIT_I_RADIX // first digit of 'inf'
           => fail!(fmt!("from_str_bytes_common: radix %? incompatible with \
                         special values 'inf' and 'NaN'", radix)),
-        _ if (radix as int) < 2
+        _ if radix as int < 2
           => fail!(fmt!("from_str_bytes_common: radix %? to low, \
                         must lie in the range [2, 36]", radix)),
-        _ if (radix as int) > 36
+        _ if radix as int > 36
           => fail!(fmt!("from_str_bytes_common: radix %? to high, \
                         must lie in the range [2, 36]", radix)),
         _ => ()

trunk/src/libcore/repr.rs

@@ -242,7 +242,7 @@ pub impl ReprVisitor {
         let (sz, al) = unsafe { ((*inner).size, (*inner).align) };
         self.writer.write_char('[');
         let mut first = true;
-        while (p as uint) < (end as uint) {
+        while p as uint < end as uint {
             if first {
                 first = false;
             } else {

trunk/src/libcore/unstable/extfmt.rs

@@ -536,7 +536,7 @@ pub mod rt {
         // displayed
         let mut unpadded = match cv.precision {
           CountImplied => s.to_owned(),
-          CountIs(max) => if (max as uint) < str::char_len(s) {
+          CountIs(max) => if max as uint < str::char_len(s) {
             str::substr(s, 0, max as uint)
           } else {
             s.to_owned()

trunk/src/librustc/back/link.rs

@@ -849,7 +849,11 @@ pub fn link_binary(sess: Session,
     do cstore::iter_crate_data(cstore) |crate_num, _| {
         let link_args = csearch::get_link_args_for_crate(cstore, crate_num);
         do vec::consume(link_args) |_, link_arg| {
-            cc_args.push(link_arg);
+            // Linker arguments that don't begin with - are likely file names,
+            // so they should not be necessary.
+            if link_arg.starts_with("-") {
+              cc_args.push(link_arg);
+            }
         }
     }
 

trunk/src/librustc/middle/trans/callee.rs

@@ -492,12 +492,14 @@ pub fn trans_call_inner(
             }
         };
 
-        let args_res = trans_args(bcx, llenv, args, fn_expr_ty,
-                                  dest, ret_flag, autoref_arg);
-        bcx = args_res.bcx;
-        let mut llargs = /*bad*/copy args_res.args;
+        let llretslot = trans_ret_slot(bcx, fn_expr_ty, dest);
+
+        let mut llargs = ~[];
+        llargs.push(llretslot);
+        llargs.push(llenv);
+        bcx = trans_args(bcx, args, fn_expr_ty,
+                         ret_flag, autoref_arg, &mut llargs);
 
-        let llretslot = args_res.retslot;
 
         // Now that the arguments have finished evaluating, we need to revoke
         // the cleanup for the self argument, if it exists
@@ -555,30 +557,12 @@ pub enum CallArgs {
     ArgVals(&'self [ValueRef])
 }
 
-pub struct Args {
-    bcx: block,
-    args: ~[ValueRef],
-    retslot: ValueRef
-}
-
-pub fn trans_args(cx: block,
-                  llenv: ValueRef,
-                  +args: CallArgs,
-                  fn_ty: ty::t,
-                  dest: expr::Dest,
-                  ret_flag: Option<ValueRef>,
-                  +autoref_arg: AutorefArg) -> Args {
-    let _icx = cx.insn_ctxt("trans_args");
-    let mut temp_cleanups = ~[];
-    let arg_tys = ty::ty_fn_args(fn_ty);
-    let mut llargs: ~[ValueRef] = ~[];
-
-    let mut bcx = cx;
-
+pub fn trans_ret_slot(+bcx: block,
+                      +fn_ty: ty::t,
+                      +dest: expr::Dest) -> ValueRef
+{
     let retty = ty::ty_fn_ret(fn_ty);
-
-    // Arg 0: Output pointer.
-    let llretslot = match dest {
+    match dest {
         expr::SaveIn(dst) => dst,
         expr::Ignore => {
             if ty::type_is_nil(retty) {
@@ -589,13 +573,21 @@ pub fn trans_args(cx: block,
                 alloc_ty(bcx, retty)
             }
         }
-    };
-    llargs.push(llretslot);
+    }
+}
 
-    // Arg 1: Env (closure-bindings / self value)
-    llargs.push(llenv);
+pub fn trans_args(+cx: block,
+                  +args: CallArgs,
+                  +fn_ty: ty::t,
+                  +ret_flag: Option<ValueRef>,
+                  +autoref_arg: AutorefArg,
+                  +llargs: &mut ~[ValueRef]) -> block
+{
+    let _icx = cx.insn_ctxt("trans_args");
+    let mut temp_cleanups = ~[];
+    let arg_tys = ty::ty_fn_args(fn_ty);
 
-    // ... then explicit args.
+    let mut bcx = cx;
 
     // First we figure out the caller's view of the types of the arguments.
     // This will be needed if this is a generic call, because the callee has
@@ -624,7 +616,7 @@ pub fn trans_args(cx: block,
         revoke_clean(bcx, *c)
     }
 
-    Args { bcx: bcx, args: llargs, retslot: llretslot }
+    return bcx;
 }
 
 pub enum AutorefArg {

trunk/src/libstd/time.rs

@@ -819,8 +819,8 @@ priv fn do_strftime(format: &str, tm: &Tm) -> ~str {
           'M' => fmt!("%02d", tm.tm_min as int),
           'm' => fmt!("%02d", tm.tm_mon as int + 1),
           'n' => ~"\n",
-          'P' => if (tm.tm_hour as int) < 12 { ~"am" } else { ~"pm" },
-          'p' => if (tm.tm_hour as int) < 12 { ~"AM" } else { ~"PM" },
+          'P' => if tm.tm_hour as int < 12 { ~"am" } else { ~"pm" },
+          'p' => if tm.tm_hour as int < 12 { ~"AM" } else { ~"PM" },
           'R' => {
             fmt!("%s:%s",
                 parse_type('H', tm),

trunk/src/libsyntax/parse/parser.rs

@@ -581,9 +581,7 @@ pub impl Parser {
         }
     }
 
-    // Useless second parameter for compatibility with quasiquote macros.
-    // Bleh!
-    fn parse_ty(&self, _: bool) -> @Ty {
+    fn parse_ty(&self, colons_before_params: bool) -> @Ty {
         maybe_whole!(self, nt_ty);
 
         let lo = self.span.lo;
@@ -663,7 +661,7 @@ pub impl Parser {
             result
         } else if *self.token == token::MOD_SEP
             || is_ident_or_path(&*self.token) {
-            let path = self.parse_path_with_tps(false);
+            let path = self.parse_path_with_tps(colons_before_params);
             ty_path(path, self.get_id())
         } else {
             self.fatal(~"expected type");

trunk/src/libsyntax/print/pprust.rs

@@ -370,6 +370,10 @@ pub fn print_opt_lifetime(s: @ps, lifetime: Option<@ast::Lifetime>) {
 }
 
 pub fn print_type(s: @ps, &&ty: @ast::Ty) {
+    print_type_ex(s, ty, false);
+}
+
+pub fn print_type_ex(s: @ps, &&ty: @ast::Ty, print_colons: bool) {
     maybe_print_comment(s, ty.span.lo);
     ibox(s, 0u);
     match ty.node {
@@ -411,7 +415,7 @@ pub fn print_type(s: @ps, &&ty: @ast::Ty) {
                       f.purity, f.onceness, &f.decl, None,
                       None, None);
       }
-      ast::ty_path(path, _) => print_path(s, path, false),
+      ast::ty_path(path, _) => print_path(s, path, print_colons),
       ast::ty_fixed_length_vec(ref mt, v) => {
         word(s.s, ~"[");
         match mt.mutbl {
@@ -1207,7 +1211,7 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
         print_expr(s, expr);
         space(s.s);
         word_space(s, ~"as");
-        print_type(s, ty);
+        print_type_ex(s, ty, true);
       }
       ast::expr_if(test, ref blk, elseopt) => {
         print_if(s, test, blk, elseopt, false);

trunk/src/test/run-pass/issue-4120.rs

@@ -0,0 +1,17 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main()
+{
+    unsafe {
+        libc::exit(0);
+    }
+    error!("ack");
+}