---

yaml
---
r: 150773
b: refs/heads/try2
c: 5d284a0
h: refs/heads/master
i:
  150771: 0159f9a
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: 44e34c24c4752408038f95225f536d11605c5ba4
+refs/heads/try2: 5d284a0daa39f6b87028f97b5bfa2bb92f658f83
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustc/front/feature_gate.rs

@@ -96,7 +96,7 @@ impl<'a> Context<'a> {
     fn gate_feature(&self, feature: &str, span: Span, explain: &str) {
         if !self.has_feature(feature) {
             self.sess.span_err(span, explain);
-            self.sess.span_note(span, format!("add \\#[feature({})] to the \
+            self.sess.span_note(span, format!("add \\#![feature({})] to the \
                                                   crate attributes to enable",
                                                  feature));
         }

branches/try2/src/librustc/middle/typeck/check/mod.rs

@@ -3698,7 +3698,7 @@ pub fn instantiate_path(fcx: &FnCtxt,
             && !fcx.tcx().sess.features.default_type_params.get() {
             fcx.tcx().sess.span_err(pth.span, "default type parameters are \
                                                experimental and possibly buggy");
-            fcx.tcx().sess.span_note(pth.span, "add #[feature(default_type_params)] \
+            fcx.tcx().sess.span_note(pth.span, "add #![feature(default_type_params)] \
                                                 to the crate attributes to enable");
         }
 

branches/try2/src/librustc/util/ppaux.rs

@@ -341,10 +341,8 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> ~str {
       ty_bot => ~"!",
       ty_bool => ~"bool",
       ty_char => ~"char",
-      ty_int(ast::TyI) => ~"int",
-      ty_int(t) => ast_util::int_ty_to_str(t),
-      ty_uint(ast::TyU) => ~"uint",
-      ty_uint(t) => ast_util::uint_ty_to_str(t),
+      ty_int(t) => ast_util::int_ty_to_str(t, None),
+      ty_uint(t) => ast_util::uint_ty_to_str(t, None),
       ty_float(t) => ast_util::float_ty_to_str(t),
       ty_box(typ) => ~"@" + ty_to_str(cx, typ),
       ty_uniq(typ) => ~"~" + ty_to_str(cx, typ),

branches/try2/src/libstd/num/mod.rs

@@ -159,6 +159,7 @@ pub fn abs_sub<T: Signed>(x: T, y: T) -> T {
 /// - `-1` if the number is negative
 #[inline(always)] pub fn signum<T: Signed>(value: T) -> T { value.signum() }
 
+/// A trait for values which cannot be negative
 pub trait Unsigned: Num {}
 
 /// A collection of rounding operations.
@@ -205,6 +206,7 @@ pub fn pow<T: One + Mul<T, T>>(mut base: T, mut exp: uint) -> T {
     }
 }
 
+/// Numbers which have upper and lower bounds
 pub trait Bounded {
     // FIXME (#5527): These should be associated constants
     fn min_value() -> Self;
@@ -1046,10 +1048,12 @@ impl_num_cast!(int,   to_int)
 impl_num_cast!(f32,   to_f32)
 impl_num_cast!(f64,   to_f64)
 
+/// A generic trait for converting a value to a string with a radix (base)
 pub trait ToStrRadix {
     fn to_str_radix(&self, radix: uint) -> ~str;
 }
 
+/// A generic trait for converting a string with a radix (base) to a value
 pub trait FromStrRadix {
     fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
 }

branches/try2/src/libsyntax/ast.rs

@@ -707,7 +707,7 @@ pub enum IntTy {
 
 impl fmt::Show for IntTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f.buf, "{}", ast_util::int_ty_to_str(*self))
+        write!(f.buf, "{}", ast_util::int_ty_to_str(*self, None))
     }
 }
 
@@ -722,7 +722,7 @@ pub enum UintTy {
 
 impl fmt::Show for UintTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f.buf, "{}", ast_util::uint_ty_to_str(*self))
+        write!(f.buf, "{}", ast_util::uint_ty_to_str(*self, None))
     }
 }
 

branches/try2/src/libsyntax/ast_util.rs

@@ -132,13 +132,21 @@ pub fn is_path(e: @Expr) -> bool {
     return match e.node { ExprPath(_) => true, _ => false };
 }
 
-pub fn int_ty_to_str(t: IntTy) -> ~str {
-    match t {
-        TyI => ~"",
-        TyI8 => ~"i8",
-        TyI16 => ~"i16",
-        TyI32 => ~"i32",
-        TyI64 => ~"i64"
+// Get a string representation of a signed int type, with its value.
+// We want to avoid "45int" and "-3int" in favor of "45" and "-3"
+pub fn int_ty_to_str(t: IntTy, val: Option<i64>) -> ~str {
+    let s = match t {
+        TyI if val.is_some() => "",
+        TyI => "int",
+        TyI8 => "i8",
+        TyI16 => "i16",
+        TyI32 => "i32",
+        TyI64 => "i64"
+    };
+
+    match val {
+        Some(n) => format!("{}{}", n, s),
+        None => s.to_owned()
     }
 }
 
@@ -151,13 +159,21 @@ pub fn int_ty_max(t: IntTy) -> u64 {
     }
 }
 
-pub fn uint_ty_to_str(t: UintTy) -> ~str {
-    match t {
-        TyU => ~"u",
-        TyU8 => ~"u8",
-        TyU16 => ~"u16",
-        TyU32 => ~"u32",
-        TyU64 => ~"u64"
+// Get a string representation of an unsigned int type, with its value.
+// We want to avoid "42uint" in favor of "42u"
+pub fn uint_ty_to_str(t: UintTy, val: Option<u64>) -> ~str {
+    let s = match t {
+        TyU if val.is_some() => "u",
+        TyU => "uint",
+        TyU8 => "u8",
+        TyU16 => "u16",
+        TyU32 => "u32",
+        TyU64 => "u64"
+    };
+
+    match val {
+        Some(n) => format!("{}{}", n, s),
+        None => s.to_owned()
     }
 }
 

branches/try2/src/libsyntax/parse/token.rs

@@ -201,12 +201,8 @@ pub fn to_str(t: &Token) -> ~str {
           res.push_char('\'');
           res.into_owned()
       }
-      LIT_INT(i, t) => {
-          i.to_str() + ast_util::int_ty_to_str(t)
-      }
-      LIT_UINT(u, t) => {
-          u.to_str() + ast_util::uint_ty_to_str(t)
-      }
+      LIT_INT(i, t) => ast_util::int_ty_to_str(t, Some(i)),
+      LIT_UINT(u, t) => ast_util::uint_ty_to_str(t, Some(u)),
       LIT_INT_UNSUFFIXED(i) => { i.to_str() }
       LIT_FLOAT(s, t) => {
         let mut body = StrBuf::from_str(get_ident(s).get());

branches/try2/src/libsyntax/print/pprust.rs

@@ -2171,10 +2171,10 @@ impl<'a> State<'a> {
                 word(&mut self.s, res.into_owned())
             }
             ast::LitInt(i, t) => {
-                word(&mut self.s, format!("{}{}", i, ast_util::int_ty_to_str(t)))
+                word(&mut self.s, ast_util::int_ty_to_str(t, Some(i)))
             }
             ast::LitUint(u, t) => {
-                word(&mut self.s, format!("{}{}", u, ast_util::uint_ty_to_str(t)))
+                word(&mut self.s, ast_util::uint_ty_to_str(t, Some(u)))
             }
             ast::LitIntUnsuffixed(i) => {
                 word(&mut self.s, format!("{}", i))

branches/try2/src/test/compile-fail/issue13359.rs

@@ -0,0 +1,21 @@
+// Copyright 2014 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 foo(_s: i16) { }
+
+fn bar(_s: u32) { }
+
+fn main() {
+    foo(1*(1 as int));
+    //~^ ERROR: mismatched types: expected `i16` but found `int` (expected `i16` but found `int`)
+
+    bar(1*(1 as uint));
+    //~^ ERROR: mismatched types: expected `u32` but found `uint` (expected `u32` but found `uint`)
+}