From f1eebb8f371cf2703ca1d4096f974d037938ece8 Mon Sep 17 00:00:00 2001
From: Kevin Yap <me@kevinyap.ca>
Date: Fri, 6 Feb 2015 15:03:45 -0800
Subject: [PATCH 01/34] Order list of linted files by frequency

Since it makes more sense for .rs files to appear at the top of the
list of linted files and "other" files to appear at the end, this
commit moves the "other" count outside of the `file_counts` dictionary
and sorts the remaining "interesting" files by decreasing frequency.
---
 src/etc/tidy.py | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/etc/tidy.py b/src/etc/tidy.py
index fd3309dce12..5caa0c90f1b 100644
--- a/src/etc/tidy.py
+++ b/src/etc/tidy.py
@@ -66,20 +66,22 @@ src_dir = sys.argv[1]
 try:
     count_lines = 0
     count_non_blank_lines = 0
+    count_other_linted_files = 0
 
     interesting_files = ['.rs', '.py', '.js', '.sh', '.c', '.h']
 
     file_counts = {ext: 0 for ext in interesting_files}
-    file_counts['other'] = 0
 
     def update_counts(current_name):
         global file_counts
+        global count_other_linted_files
+
         _, ext = os.path.splitext(current_name)
 
-        if ext in file_counts:
+        if ext in interesting_files:
             file_counts[ext] += 1
         else:
-            file_counts['other'] += 1
+            count_other_linted_files += 1
 
     all_paths = set()
 
@@ -196,10 +198,11 @@ except UnicodeDecodeError as e:
     report_err("UTF-8 decoding error " + str(e))
 
 print
-for ext in file_counts:
-    print "* linted " + str(file_counts[ext]) + " " + ext + " files"
-print "* total lines of code: " + str(count_lines)
-print "* total non-blank lines of code: " + str(count_non_blank_lines)
+for ext in sorted(file_counts, key=file_counts.get, reverse=True):
+    print "* linted {} {} files".format(file_counts[ext], ext)
+print "* linted {} other files".format(count_other_linted_files)
+print "* total lines of code: {}".format(count_lines)
+print "* total non-blank lines of code: {}".format(count_non_blank_lines)
 print
 
 sys.exit(err)

From 956969162dd199682c16f40e9b124acc853e3992 Mon Sep 17 00:00:00 2001
From: Kevin Yap <me@kevinyap.ca>
Date: Sat, 7 Feb 2015 01:11:33 -0800
Subject: [PATCH 02/34] Refactor code in tidy.py

- Replace wildcard import with explicit import of `check_license`
- Move more logic outside of the `try` block.
- Group all helper functions together.
- Define `interesting_exts` and `uninteresting_files` at start of file
  (with the rest of the constant declarations).
---
 src/etc/tidy.py | 77 +++++++++++++++++++++++++------------------------
 1 file changed, 39 insertions(+), 38 deletions(-)

diff --git a/src/etc/tidy.py b/src/etc/tidy.py
index 5caa0c90f1b..c524fae7f0a 100644
--- a/src/etc/tidy.py
+++ b/src/etc/tidy.py
@@ -13,7 +13,7 @@ import fileinput
 import subprocess
 import re
 import os
-from licenseck import *
+from licenseck import check_license
 import snapshot
 
 err = 0
@@ -22,13 +22,8 @@ cr_flag = "ignore-tidy-cr"
 tab_flag = "ignore-tidy-tab"
 linelength_flag = "ignore-tidy-linelength"
 
-# Be careful to support Python 2.4, 2.6, and 3.x here!
-config_proc = subprocess.Popen(["git", "config", "core.autocrlf"],
-                               stdout=subprocess.PIPE)
-result = config_proc.communicate()[0]
-
-true = "true".encode('utf8')
-autocrlf = result.strip() == true if result is not None else False
+interesting_files = ['.rs', '.py', '.js', '.sh', '.c', '.h']
+uninteresting_files = ['miniz.c', 'jquery', 'rust_android_dummy']
 
 
 def report_error_name_no(name, no, s):
@@ -51,6 +46,34 @@ def do_license_check(name, contents):
     if not check_license(name, contents):
         report_error_name_no(name, 1, "incorrect license")
 
+
+def update_counts(current_name):
+    global file_counts
+    global count_other_linted_files
+
+    _, ext = os.path.splitext(current_name)
+
+    if ext in interesting_files:
+        file_counts[ext] += 1
+    else:
+        count_other_linted_files += 1
+
+
+def interesting_file(f):
+    if any(x in f for x in uninteresting_files):
+        return False
+
+    return any(os.path.splitext(f)[1] == ext for ext in interesting_files)
+
+
+# Be careful to support Python 2.4, 2.6, and 3.x here!
+config_proc = subprocess.Popen(["git", "config", "core.autocrlf"],
+                               stdout=subprocess.PIPE)
+result = config_proc.communicate()[0]
+
+true = "true".encode('utf8')
+autocrlf = result.strip() == true if result is not None else False
+
 current_name = ""
 current_contents = ""
 check_tab = True
@@ -63,30 +86,16 @@ if len(sys.argv) < 2:
 
 src_dir = sys.argv[1]
 
+count_lines = 0
+count_non_blank_lines = 0
+count_other_linted_files = 0
+
+file_counts = {ext: 0 for ext in interesting_files}
+
+all_paths = set()
+
 try:
-    count_lines = 0
-    count_non_blank_lines = 0
-    count_other_linted_files = 0
-
-    interesting_files = ['.rs', '.py', '.js', '.sh', '.c', '.h']
-
-    file_counts = {ext: 0 for ext in interesting_files}
-
-    def update_counts(current_name):
-        global file_counts
-        global count_other_linted_files
-
-        _, ext = os.path.splitext(current_name)
-
-        if ext in interesting_files:
-            file_counts[ext] += 1
-        else:
-            count_other_linted_files += 1
-
-    all_paths = set()
-
     for (dirpath, dirnames, filenames) in os.walk(src_dir):
-
         # Skip some third-party directories
         skippable_dirs = {
             'src/jemalloc',
@@ -105,14 +114,6 @@ try:
         if any(d in dirpath for d in skippable_dirs):
             continue
 
-        def interesting_file(f):
-            if "miniz.c" in f \
-            or "jquery" in f \
-            or "rust_android_dummy" in f:
-                return False
-
-            return any(os.path.splitext(f)[1] == ext for ext in interesting_files)
-
         file_names = [os.path.join(dirpath, f) for f in filenames
                       if interesting_file(f)
                       and not f.endswith("_gen.rs")

From e93b2abf37e594110ef15049d957a8dcac9bc977 Mon Sep 17 00:00:00 2001
From: Brian Leibig <brian@brianleibig.com>
Date: Sat, 28 Feb 2015 18:10:41 -0800
Subject: [PATCH 03/34] Bison grammar: support parsing default trait impls

---
 src/grammar/parser-lalr.y | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/grammar/parser-lalr.y b/src/grammar/parser-lalr.y
index 6a6f7e0e9f9..9cff58cf89a 100644
--- a/src/grammar/parser-lalr.y
+++ b/src/grammar/parser-lalr.y
@@ -582,6 +582,14 @@ item_impl
 {
   $$ = mk_node("ItemImplNeg", 7, $1, $3, $5, $7, $8, $10, $11);
 }
+| maybe_unsafe IMPL generic_params trait_ref FOR DOTDOT '{' '}'
+{
+  $$ = mk_node("ItemImplDefault", 3, $1, $3, $4);
+}
+| maybe_unsafe IMPL generic_params '!' trait_ref FOR DOTDOT '{' '}'
+{
+  $$ = mk_node("ItemImplDefaultNeg", 3, $1, $3, $4);
+}
 ;
 
 maybe_impl_items

From f1fe1b5d4f120e73735f133153794592835369df Mon Sep 17 00:00:00 2001
From: Brian Leibig <brian@brianleibig.com>
Date: Sat, 28 Feb 2015 18:54:32 -0800
Subject: [PATCH 04/34] Bison grammar: allow ExprQualifiedPath to have optional
 "as TRAIT_REF"

---
 src/grammar/parser-lalr.y | 31 ++++++++++++++++++-------------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/src/grammar/parser-lalr.y b/src/grammar/parser-lalr.y
index 9cff58cf89a..4727b1b23fb 100644
--- a/src/grammar/parser-lalr.y
+++ b/src/grammar/parser-lalr.y
@@ -1032,7 +1032,8 @@ ty_qualified_path_and_generic_values
 }
 | ty_qualified_path ',' ty_sums maybe_bindings
 {
-  $$ = mk_node("GenericValues", 3, mk_none(), ext_node(mk_node("TySums", 1, $1), 1, $3), $4); }
+  $$ = mk_node("GenericValues", 3, mk_none(), mk_node("TySums", 2, $1, $3), $4);
+}
 ;
 
 ty_qualified_path
@@ -1521,31 +1522,35 @@ nonblock_prefix_expr
 ;
 
 expr_qualified_path
-: '<' ty_sum AS trait_ref '>' MOD_SEP ident
+: '<' ty_sum maybe_as_trait_ref '>' MOD_SEP ident
 {
-  $$ = mk_node("ExprQualifiedPath", 3, $2, $4, $7);
+  $$ = mk_node("ExprQualifiedPath", 3, $2, $3, $6);
 }
-| '<' ty_sum AS trait_ref '>' MOD_SEP ident generic_args
+| '<' ty_sum maybe_as_trait_ref '>' MOD_SEP ident generic_args
 {
-  $$ = mk_node("ExprQualifiedPath", 4, $2, $4, $7, $8);
+  $$ = mk_node("ExprQualifiedPath", 4, $2, $3, $6, $7);
 }
-| SHL ty_sum AS trait_ref '>' MOD_SEP ident AS trait_ref '>' MOD_SEP ident
+| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_as_trait_ref '>' MOD_SEP ident
 {
-  $$ = mk_node("ExprQualifiedPath", 3, mk_node("ExprQualifiedPath", 3, $2, $4, $7), $9, $12);
+  $$ = mk_node("ExprQualifiedPath", 3, mk_node("ExprQualifiedPath", 3, $2, $3, $6), $7, $10);
 }
-| SHL ty_sum AS trait_ref '>' MOD_SEP ident generic_args AS trait_ref '>' MOD_SEP ident
+| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident generic_args maybe_as_trait_ref '>' MOD_SEP ident
 {
-  $$ = mk_node("ExprQualifiedPath", 3, mk_node("ExprQualifiedPath", 4, $2, $4, $7, $8), $10, $13);
+  $$ = mk_node("ExprQualifiedPath", 3, mk_node("ExprQualifiedPath", 4, $2, $3, $6, $7), $8, $11);
 }
-| SHL ty_sum AS trait_ref '>' MOD_SEP ident AS trait_ref '>' MOD_SEP ident generic_args
+| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident maybe_as_trait_ref '>' MOD_SEP ident generic_args
 {
-  $$ = mk_node("ExprQualifiedPath", 4, mk_node("ExprQualifiedPath", 3, $2, $4, $7), $9, $12, $13);
+  $$ = mk_node("ExprQualifiedPath", 4, mk_node("ExprQualifiedPath", 3, $2, $3, $6), $7, $10, $11);
 }
-| SHL ty_sum AS trait_ref '>' MOD_SEP ident generic_args AS trait_ref '>' MOD_SEP ident generic_args
+| SHL ty_sum maybe_as_trait_ref '>' MOD_SEP ident generic_args maybe_as_trait_ref '>' MOD_SEP ident generic_args
 {
-  $$ = mk_node("ExprQualifiedPath", 4, mk_node("ExprQualifiedPath", 4, $2, $4, $7, $8), $10, $13, $14);
+  $$ = mk_node("ExprQualifiedPath", 4, mk_node("ExprQualifiedPath", 4, $2, $3, $6, $7), $8, $11, $12);
 }
 
+maybe_as_trait_ref
+: AS trait_ref { $$ = $2; }
+| %empty       { $$ = mk_none(); }
+;
 
 lambda_expr
 : %prec LAMBDA

From 481b21cf1927a84d6fea1b7389a3a8d827656998 Mon Sep 17 00:00:00 2001
From: Brian Leibig <brian@brianleibig.com>
Date: Sun, 1 Mar 2015 13:59:12 -0800
Subject: [PATCH 05/34] Bison grammar: parse higher ranked constraints in where
 clauses

---
 src/grammar/parser-lalr.y | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/grammar/parser-lalr.y b/src/grammar/parser-lalr.y
index 4727b1b23fb..6c3fd186cd4 100644
--- a/src/grammar/parser-lalr.y
+++ b/src/grammar/parser-lalr.y
@@ -152,6 +152,12 @@ extern char *yytext;
 %precedence MOD_SEP
 %precedence RARROW ':'
 
+// In where clauses, "for" should have greater precedence when used as
+// a higher ranked constraint than when used as the beginning of a
+// for_in_type (which is a ty)
+%precedence FORTYPE
+%precedence FOR
+
 // Binops & unops, and their precedences
 %precedence BOX
 %precedence BOXPLACE
@@ -777,10 +783,14 @@ where_predicates
 ;
 
 where_predicate
-: lifetime ':' bounds    { $$ = mk_node("WherePredicate", 2, $1, $3); }
-| ty ':' ty_param_bounds { $$ = mk_node("WherePredicate", 2, $1, $3); }
+: maybe_for_lifetimes lifetime ':' bounds    { $$ = mk_node("WherePredicate", 3, $1, $2, $4); }
+| maybe_for_lifetimes ty ':' ty_param_bounds { $$ = mk_node("WherePredicate", 3, $1, $2, $4); }
 ;
 
+maybe_for_lifetimes
+: FOR '<' lifetimes '>' { $$ = mk_none(); }
+| %prec FORTYPE %empty  { $$ = mk_none(); }
+
 ty_params
 : ty_param               { $$ = mk_node("TyParams", 1, $1); }
 | ty_params ',' ty_param { $$ = ext_node($1, 1, $3); }

From 7d3119773f218e69ab9e71df4510549b8d61347b Mon Sep 17 00:00:00 2001
From: David Mally <djmally@gmail.com>
Date: Mon, 2 Mar 2015 14:32:42 -0500
Subject: [PATCH 06/34] Fixed references to set & take ; minor wording & syntax
 fixes

---
 src/libstd/collections/mod.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs
index 100d3e6ed4a..2d7e5cddc61 100644
--- a/src/libstd/collections/mod.rs
+++ b/src/libstd/collections/mod.rs
@@ -78,7 +78,7 @@
 //! * You want a bit vector.
 //!
 //! ### Use a `BitSet` when:
-//! * You want a `VecSet`.
+//! * You want a `BitVec`, but want `Set` properties
 //!
 //! ### Use a `BinaryHeap` when:
 //! * You want to store a bunch of elements, but only ever want to process the "biggest"
@@ -280,16 +280,16 @@
 //! a variant of the `Entry` enum.
 //!
 //! If a `Vacant(entry)` is yielded, then the key *was not* found. In this case the
-//! only valid operation is to `set` the value of the entry. When this is done,
+//! only valid operation is to `insert` a value into the entry. When this is done,
 //! the vacant entry is consumed and converted into a mutable reference to the
 //! the value that was inserted. This allows for further manipulation of the value
 //! beyond the lifetime of the search itself. This is useful if complex logic needs to
 //! be performed on the value regardless of whether the value was just inserted.
 //!
 //! If an `Occupied(entry)` is yielded, then the key *was* found. In this case, the user
-//! has several options: they can `get`, `set`, or `take` the value of the occupied
+//! has several options: they can `get`, `insert`, or `remove` the value of the occupied
 //! entry. Additionally, they can convert the occupied entry into a mutable reference
-//! to its value, providing symmetry to the vacant `set` case.
+//! to its value, providing symmetry to the vacant `insert` case.
 //!
 //! ### Examples
 //!
@@ -329,7 +329,7 @@
 //! use std::collections::btree_map::{BTreeMap, Entry};
 //!
 //! // A client of the bar. They have an id and a blood alcohol level.
-//! struct Person { id: u32, blood_alcohol: f32 };
+//! struct Person { id: u32, blood_alcohol: f32 }
 //!
 //! // All the orders made to the bar, by client id.
 //! let orders = vec![1,2,1,2,3,4,1,2,2,3,4,1,1,1];

From 0a1776495c48db19a8e1fe27acc81bab908e256a Mon Sep 17 00:00:00 2001
From: David Mally <djmally@gmail.com>
Date: Mon, 2 Mar 2015 15:01:44 -0500
Subject: [PATCH 07/34] Added note that method names in tables may differ from
 actual collections

---
 src/libstd/collections/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs
index 2d7e5cddc61..caada8ae50f 100644
--- a/src/libstd/collections/mod.rs
+++ b/src/libstd/collections/mod.rs
@@ -89,7 +89,8 @@
 //!
 //! Choosing the right collection for the job requires an understanding of what each collection
 //! is good at. Here we briefly summarize the performance of different collections for certain
-//! important operations. For further details, see each type's documentation.
+//! important operations. For further details, see each type's documentation, and note that the
+//! names of actual methods may differ from the tables below on certain collections.
 //!
 //! Throughout the documentation, we will follow a few conventions. For all operations,
 //! the collection's size is denoted by n. If another collection is involved in the operation, it

From 7496539a00b36d86620699576bc7c82ce03dca7e Mon Sep 17 00:00:00 2001
From: Ivan Radanov Ivanov <ivanradanov@yahoo.co.uk>
Date: Tue, 24 Feb 2015 16:07:54 +0200
Subject: [PATCH 08/34] Change span_help calls to fileline_help where
 appropriate

---
 src/librustc/metadata/loader.rs               |  2 +-
 src/librustc/metadata/macro_import.rs         |  2 +-
 src/librustc/middle/check_match.rs            |  2 +-
 src/librustc/middle/infer/error_reporting.rs  |  6 ++--
 .../borrowck/gather_loans/move_error.rs       |  2 +-
 src/librustc_borrowck/borrowck/mod.rs         | 10 +++++--
 src/librustc_lint/builtin.rs                  |  3 +-
 src/librustc_resolve/lib.rs                   | 29 ++++++++++++-------
 src/librustc_trans/trans/foreign.rs           |  2 +-
 src/librustc_typeck/astconv.rs                | 18 ++++++------
 src/librustc_typeck/check/callee.rs           |  2 +-
 src/librustc_typeck/check/mod.rs              |  4 +--
 src/librustc_typeck/check/wf.rs               |  2 +-
 src/librustc_typeck/coherence/mod.rs          |  2 +-
 src/librustc_typeck/collect.rs                |  2 +-
 src/libsyntax/diagnostics/macros.rs           |  7 +++++
 src/libsyntax/ext/base.rs                     |  4 +++
 src/libsyntax/ext/expand.rs                   |  2 +-
 src/libsyntax/feature_gate.rs                 |  4 +--
 src/libsyntax/parse/attr.rs                   |  2 +-
 src/libsyntax/parse/lexer/mod.rs              |  2 +-
 src/libsyntax/parse/mod.rs                    |  2 +-
 src/libsyntax/parse/parser.rs                 | 15 ++++++----
 23 files changed, 76 insertions(+), 50 deletions(-)

diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs
index 07082d81876..4f947b79a75 100644
--- a/src/librustc/metadata/loader.rs
+++ b/src/librustc/metadata/loader.rs
@@ -353,7 +353,7 @@ impl<'a> Context<'a> {
             }
         }
         if self.rejected_via_kind.len() > 0 {
-            self.sess.span_help(self.span, "please recompile this crate using \
+            self.sess.fileline_help(self.span, "please recompile this crate using \
                                             --crate-type lib");
             let mismatches = self.rejected_via_kind.iter();
             for (i, &CrateMismatch { ref path, .. }) in mismatches.enumerate() {
diff --git a/src/librustc/metadata/macro_import.rs b/src/librustc/metadata/macro_import.rs
index d25dc4f58a5..19a29b8eb1b 100644
--- a/src/librustc/metadata/macro_import.rs
+++ b/src/librustc/metadata/macro_import.rs
@@ -84,7 +84,7 @@ impl<'a, 'v> Visitor<'v> for MacroLoader<'a> {
                 }
                 "plugin" => {
                     self.sess.span_err(attr.span, "#[plugin] on `extern crate` is deprecated");
-                    self.sess.span_help(attr.span, &format!("use a crate attribute instead, \
+                    self.sess.fileline_help(attr.span, &format!("use a crate attribute instead, \
                                                             i.e. #![plugin({})]",
                                                             item.ident.as_str()));
                 }
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index c409c8fb13f..6667b550dd7 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -252,7 +252,7 @@ fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat)
                                 "pattern binding `{}` is named the same as one \
                                  of the variants of the type `{}`",
                                 &token::get_ident(ident.node), ty_to_string(cx.tcx, pat_ty));
-                            span_help!(cx.tcx.sess, p.span,
+                            fileline_help!(cx.tcx.sess, p.span,
                                 "if you meant to match on a variant, \
                                  consider making the path in the pattern qualified: `{}::{}`",
                                 ty_to_string(cx.tcx, pat_ty), &token::get_ident(ident.node));
diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs
index da4df813030..a7f5c2c8437 100644
--- a/src/librustc/middle/infer/error_reporting.rs
+++ b/src/librustc/middle/infer/error_reporting.rs
@@ -444,7 +444,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                 // Does the required lifetime have a nice name we can print?
                 span_err!(self.tcx.sess, origin.span(), E0309,
                     "{} may not live long enough", labeled_user_string);
-                self.tcx.sess.span_help(
+                self.tcx.sess.fileline_help(
                     origin.span(),
                     &format!(
                         "consider adding an explicit lifetime bound `{}: {}`...",
@@ -456,7 +456,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                 // Does the required lifetime have a nice name we can print?
                 span_err!(self.tcx.sess, origin.span(), E0310,
                     "{} may not live long enough", labeled_user_string);
-                self.tcx.sess.span_help(
+                self.tcx.sess.fileline_help(
                     origin.span(),
                     &format!(
                         "consider adding an explicit lifetime bound `{}: 'static`...",
@@ -468,7 +468,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                 span_err!(self.tcx.sess, origin.span(), E0311,
                         "{} may not live long enough",
                         labeled_user_string);
-                self.tcx.sess.span_help(
+                self.tcx.sess.fileline_help(
                     origin.span(),
                     &format!(
                         "consider adding an explicit lifetime bound for `{}`",
diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs
index 53761eb1471..84636ebaae4 100644
--- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs
+++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs
@@ -165,7 +165,7 @@ fn note_move_destination(bccx: &BorrowckCtxt,
         bccx.span_note(
             move_to_span,
             "attempting to move value to here");
-        bccx.span_help(
+        bccx.fileline_help(
             move_to_span,
             &format!("to prevent the move, \
                      use `ref {0}` or `ref mut {0}` to capture value by \
diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs
index 67462ab0100..ff5bde3282f 100644
--- a/src/librustc_borrowck/borrowck/mod.rs
+++ b/src/librustc_borrowck/borrowck/mod.rs
@@ -643,7 +643,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                             ol,
                             moved_lp_msg,
                             pat_ty.user_string(self.tcx)));
-                self.tcx.sess.span_help(span,
+                self.tcx.sess.fileline_help(span,
                     "use `ref` to override");
             }
 
@@ -675,7 +675,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                             moved_lp_msg,
                             expr_ty.user_string(self.tcx),
                             suggestion));
-                self.tcx.sess.span_help(expr_span, help);
+                self.tcx.sess.fileline_help(expr_span, help);
             }
         }
 
@@ -741,6 +741,10 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
         self.tcx.sess.span_help(s, m);
     }
 
+    pub fn fileline_help(&self, s: Span, m: &str) {
+        self.tcx.sess.fileline_help(s, m);
+    }
+
     pub fn bckerr_to_string(&self, err: &BckError<'tcx>) -> String {
         match err.code {
             err_mutbl => {
@@ -870,7 +874,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
         }
 
         if is_closure {
-            self.tcx.sess.span_help(
+            self.tcx.sess.fileline_help(
                 span,
                 "closures behind references must be called via `&mut`");
         }
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
index fe047d2334e..f8ea3e8857b 100644
--- a/src/librustc_lint/builtin.rs
+++ b/src/librustc_lint/builtin.rs
@@ -1921,7 +1921,8 @@ impl LintPass for UnconditionalRecursion {
                 for call in &self_call_spans {
                     sess.span_note(*call, "recursive call site")
                 }
-                sess.span_help(sp, "a `loop` may express intention better if this is on purpose")
+                sess.fileline_help(sp, "a `loop` may express intention \
+                                        better if this is on purpose")
             }
         }
 
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 78ce9abe07d..0ddfd707f00 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -4115,10 +4115,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                           uses it like a function name",
                                          path_name));
 
-                        self.session.span_help(expr.span,
-                            &format!("Did you mean to write: \
-                                     `{} {{ /* fields */ }}`?",
-                                     path_name));
+                        let msg = format!("Did you mean to write: \
+                                           `{} {{ /* fields */ }}`?",
+                                          path_name);
+                        if self.emit_errors {
+                            self.session.fileline_help(expr.span, &msg);
+                        } else {
+                            self.session.span_help(expr.span, &msg);
+                        }
                     } else {
                         // Write the result into the def map.
                         debug!("(resolving expr) resolved `{}`",
@@ -4146,18 +4150,21 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     match type_res.map(|r| r.base_def) {
                         Some(DefTy(struct_id, _))
                             if self.structs.contains_key(&struct_id) => {
-                            self.resolve_error(expr.span,
+                                self.resolve_error(expr.span,
                                     &format!("`{}` is a structure name, but \
                                                 this expression \
                                                 uses it like a function name",
                                                 path_name));
 
-                            self.session.span_help(expr.span,
-                                &format!("Did you mean to write: \
-                                            `{} {{ /* fields */ }}`?",
-                                            path_name));
-
-                        }
+                                let msg = format!("Did you mean to write: \
+                                                     `{} {{ /* fields */ }}`?",
+                                                    path_name);
+                                if self.emit_errors {
+                                    self.session.fileline_help(expr.span, &msg);
+                                } else {
+                                    self.session.span_help(expr.span, &msg);
+                                }
+                            }
                         _ => {
                             // Keep reporting some errors even if they're ignored above.
                             self.resolve_path(expr.id, path, 0, ValueNS, true);
diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs
index efae76c5ef4..b0383e355e4 100644
--- a/src/librustc_trans/trans/foreign.rs
+++ b/src/librustc_trans/trans/foreign.rs
@@ -440,7 +440,7 @@ fn gate_simd_ffi(tcx: &ty::ctxt, decl: &ast::FnDecl, ty: &ty::BareFnTy) {
                               &format!("use of SIMD type `{}` in FFI is highly experimental and \
                                         may result in invalid code",
                                        pprust::ty_to_string(ast_ty)));
-                tcx.sess.span_help(ast_ty.span,
+                tcx.sess.fileline_help(ast_ty.span,
                                    "add #![feature(simd_ffi)] to the crate attributes to enable");
             }
         };
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
index d9dc050aebf..958b162c4dc 100644
--- a/src/librustc_typeck/astconv.rs
+++ b/src/librustc_typeck/astconv.rs
@@ -212,18 +212,18 @@ pub fn opt_ast_region_to_region<'tcx>(
                                 }
                             }
                             if len == 1 {
-                                span_help!(this.tcx().sess, default_span,
+                                fileline_help!(this.tcx().sess, default_span,
                                     "this function's return type contains a borrowed value, but \
                                      the signature does not say which {} it is borrowed from",
                                     m);
                             } else if len == 0 {
-                                span_help!(this.tcx().sess, default_span,
+                                fileline_help!(this.tcx().sess, default_span,
                                     "this function's return type contains a borrowed value, but \
                                      there is no value for it to be borrowed from");
-                                span_help!(this.tcx().sess, default_span,
+                                fileline_help!(this.tcx().sess, default_span,
                                     "consider giving it a 'static lifetime");
                             } else {
-                                span_help!(this.tcx().sess, default_span,
+                                fileline_help!(this.tcx().sess, default_span,
                                     "this function's return type contains a borrowed value, but \
                                      the signature does not say whether it is borrowed from {}",
                                     m);
@@ -705,7 +705,7 @@ fn ast_path_to_trait_ref<'a,'tcx>(
                 span_err!(this.tcx().sess, span, E0215,
                                          "angle-bracket notation is not stable when \
                                          used with the `Fn` family of traits, use parentheses");
-                span_help!(this.tcx().sess, span,
+                fileline_help!(this.tcx().sess, span,
                            "add `#![feature(unboxed_closures)]` to \
                             the crate attributes to enable");
             }
@@ -719,7 +719,7 @@ fn ast_path_to_trait_ref<'a,'tcx>(
                 span_err!(this.tcx().sess, span, E0216,
                                          "parenthetical notation is only stable when \
                                          used with the `Fn` family of traits");
-                span_help!(this.tcx().sess, span,
+                fileline_help!(this.tcx().sess, span,
                            "add `#![feature(unboxed_closures)]` to \
                             the crate attributes to enable");
             }
@@ -944,14 +944,14 @@ fn ast_ty_to_trait_ref<'tcx>(this: &AstConv<'tcx>,
                       pprust::ty_to_string(ty));
             match ty.node {
                 ast::TyRptr(None, ref mut_ty) => {
-                    span_help!(this.tcx().sess, ty.span,
+                    fileline_help!(this.tcx().sess, ty.span,
                                "perhaps you meant `&{}({} +{})`? (per RFC 438)",
                                ppaux::mutability_to_string(mut_ty.mutbl),
                                pprust::ty_to_string(&*mut_ty.ty),
                                pprust::bounds_to_string(bounds));
                 }
                ast::TyRptr(Some(ref lt), ref mut_ty) => {
-                    span_help!(this.tcx().sess, ty.span,
+                    fileline_help!(this.tcx().sess, ty.span,
                                "perhaps you meant `&{} {}({} +{})`? (per RFC 438)",
                                pprust::lifetime_to_string(lt),
                                ppaux::mutability_to_string(mut_ty.mutbl),
@@ -960,7 +960,7 @@ fn ast_ty_to_trait_ref<'tcx>(this: &AstConv<'tcx>,
                 }
 
                 _ => {
-                    span_help!(this.tcx().sess, ty.span,
+                    fileline_help!(this.tcx().sess, ty.span,
                                "perhaps you forgot parentheses? (per RFC 438)");
                 }
             }
diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs
index f9495af79c5..33d18b1a33e 100644
--- a/src/librustc_typeck/check/callee.rs
+++ b/src/librustc_typeck/check/callee.rs
@@ -63,7 +63,7 @@ pub fn check_legal_trait_for_method_call(ccx: &CrateCtxt, span: Span, trait_id:
         span_err!(tcx.sess, span, E0174,
                   "explicit use of unboxed closure method `{}` is experimental",
                   method);
-        span_help!(tcx.sess, span,
+        fileline_help!(tcx.sess, span,
                    "add `#![feature(unboxed_closures)]` to the crate attributes to enable");
     }
 }
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index fd6ba79ec21..2af132d8b5e 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -3098,7 +3098,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                 },
                 expr_t, None);
 
-            tcx.sess.span_help(field.span,
+            tcx.sess.fileline_help(field.span,
                                "maybe a `()` to call it is missing? \
                                If not, try an anonymous function");
         } else {
@@ -4480,7 +4480,7 @@ pub fn check_instantiable(tcx: &ty::ctxt,
         span_err!(tcx.sess, sp, E0073,
             "this type cannot be instantiated without an \
              instance of itself");
-        span_help!(tcx.sess, sp, "consider using `Option<{}>`",
+        fileline_help!(tcx.sess, sp, "consider using `Option<{}>`",
             ppaux::ty_to_string(tcx, item_ty));
         false
     } else {
diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs
index e024526d001..ee567575106 100644
--- a/src/librustc_typeck/check/wf.rs
+++ b/src/librustc_typeck/check/wf.rs
@@ -400,7 +400,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> {
 
         match suggested_marker_id {
             Some(def_id) => {
-                self.tcx().sess.span_help(
+                self.tcx().sess.fileline_help(
                     span,
                     format!("consider removing `{}` or using a marker such as `{}`",
                             param_name.user_string(self.tcx()),
diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs
index 58b67d31ab5..9a8545f3dd5 100644
--- a/src/librustc_typeck/coherence/mod.rs
+++ b/src/librustc_typeck/coherence/mod.rs
@@ -524,7 +524,7 @@ fn enforce_trait_manually_implementable(tcx: &ty::ctxt, sp: Span, trait_def_id:
         return // everything OK
     };
     span_err!(tcx.sess, sp, E0183, "manual implementations of `{}` are experimental", trait_name);
-    span_help!(tcx.sess, sp,
+    fileline_help!(tcx.sess, sp,
                "add `#![feature(unboxed_closures)]` to the crate attributes to enable");
 }
 
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index 74fed6cbf39..9e63382acb1 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -1217,7 +1217,7 @@ fn trait_def_of_item<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
             it.span,
             "the `#[rustc_paren_sugar]` attribute is a temporary means of controlling \
              which traits can use parenthetical notation");
-        span_help!(ccx.tcx.sess, it.span,
+        fileline_help!(ccx.tcx.sess, it.span,
                    "add `#![feature(unboxed_closures)]` to \
                     the crate attributes to use it");
     }
diff --git a/src/libsyntax/diagnostics/macros.rs b/src/libsyntax/diagnostics/macros.rs
index 54689a1f77a..055ade46a3f 100644
--- a/src/libsyntax/diagnostics/macros.rs
+++ b/src/libsyntax/diagnostics/macros.rs
@@ -52,6 +52,13 @@ macro_rules! span_help {
     })
 }
 
+#[macro_export]
+macro_rules! fileline_help {
+    ($session:expr, $span:expr, $($message:tt)*) => ({
+        ($session).fileline_help($span, &format!($($message)*))
+    })
+}
+
 #[macro_export]
 macro_rules! register_diagnostics {
     ($($code:tt),*) => (
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index e5d1fe2388c..f1c4642aa48 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -747,6 +747,10 @@ impl<'a> ExtCtxt<'a> {
         self.print_backtrace();
         self.parse_sess.span_diagnostic.span_help(sp, msg);
     }
+    pub fn fileline_help(&self, sp: Span, msg: &str) {
+        self.print_backtrace();
+        self.parse_sess.span_diagnostic.fileline_help(sp, msg);
+    }
     pub fn bug(&self, msg: &str) -> ! {
         self.print_backtrace();
         self.parse_sess.span_diagnostic.handler().bug(msg);
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index bea57ae14e4..8896a8e0c4f 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -571,7 +571,7 @@ fn contains_macro_use(fld: &mut MacroExpander, attrs: &[ast::Attribute]) -> bool
             fld.cx.span_warn(attr.span, "macro_escape is a deprecated synonym for macro_use");
             is_use = true;
             if let ast::AttrInner = attr.node.style {
-                fld.cx.span_help(attr.span, "consider an outer attribute, \
+                fld.cx.fileline_help(attr.span, "consider an outer attribute, \
                                              #[macro_use] mod ...");
             }
         };
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index 8043bd9bd70..ce36bf20d02 100644
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -358,7 +358,7 @@ impl<'a> Context<'a> {
 
 pub fn emit_feature_err(diag: &SpanHandler, feature: &str, span: Span, explain: &str) {
     diag.span_err(span, explain);
-    diag.span_help(span, &format!("add #![feature({})] to the \
+    diag.fileline_help(span, &format!("add #![feature({})] to the \
                                    crate attributes to enable",
                                   feature));
 }
@@ -366,7 +366,7 @@ pub fn emit_feature_err(diag: &SpanHandler, feature: &str, span: Span, explain:
 pub fn emit_feature_warn(diag: &SpanHandler, feature: &str, span: Span, explain: &str) {
     diag.span_warn(span, explain);
     if diag.handler.can_emit_warnings {
-        diag.span_help(span, &format!("add #![feature({})] to the \
+        diag.fileline_help(span, &format!("add #![feature({})] to the \
                                        crate attributes to silence this warning",
                                       feature));
     }
diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs
index a0e2b4dbf5a..db5583cf13a 100644
--- a/src/libsyntax/parse/attr.rs
+++ b/src/libsyntax/parse/attr.rs
@@ -77,7 +77,7 @@ impl<'a> ParserAttr for Parser<'a> {
                         self.span_err(span,
                                       "an inner attribute is not permitted in \
                                        this context");
-                        self.span_help(span,
+                        self.fileline_help(span,
                                        "place inner attribute at the top of the module or block");
                     }
                     ast::AttrInner
diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs
index 83d2bb0cc70..31716ef243a 100644
--- a/src/libsyntax/parse/lexer/mod.rs
+++ b/src/libsyntax/parse/lexer/mod.rs
@@ -772,7 +772,7 @@ impl<'a> StringReader<'a> {
         self.span_diagnostic
             .span_warn(sp, "\\U00ABCD12 and \\uABCD escapes are deprecated");
         self.span_diagnostic
-            .span_help(sp, "use \\u{ABCD12} escapes instead");
+            .fileline_help(sp, "use \\u{ABCD12} escapes instead");
     }
 
     /// Scan for a single (possibly escaped) byte or char
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 4d099529cb4..95ed4880a5b 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -722,7 +722,7 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) ->
                                               &suf[1..]));
                 } else {
                     sd.span_err(sp, &*format!("illegal suffix `{}` for numeric literal", suf));
-                    sd.span_help(sp, "the suffix must be one of the integral types \
+                    sd.fileline_help(sp, "the suffix must be one of the integral types \
                                       (`u32`, `isize`, etc)");
                 }
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index c1acee57cf8..6ec3cc5394d 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -973,7 +973,7 @@ impl<'a> Parser<'a> {
     }
     pub fn span_fatal_help(&self, sp: Span, m: &str, help: &str) -> ! {
         self.span_err(sp, m);
-        self.span_help(sp, help);
+        self.fileline_help(sp, help);
         panic!(diagnostic::FatalError);
     }
     pub fn span_note(&self, sp: Span, m: &str) {
@@ -982,6 +982,9 @@ impl<'a> Parser<'a> {
     pub fn span_help(&self, sp: Span, m: &str) {
         self.sess.span_diagnostic.span_help(sp, m)
     }
+    pub fn fileline_help(&self, sp: Span, m: &str) {
+        self.sess.span_diagnostic.fileline_help(sp, m)
+    }
     pub fn bug(&self, m: &str) -> ! {
         self.sess.span_diagnostic.span_bug(self.span, m)
     }
@@ -2531,7 +2534,7 @@ impl<'a> Parser<'a> {
                             Some(f) => f,
                             None => continue,
                         };
-                        self.span_help(last_span,
+                        self.fileline_help(last_span,
                             &format!("try parenthesizing the first index; e.g., `(foo.{}){}`",
                                     float.trunc() as usize,
                                     &float.fract().to_string()[1..]));
@@ -2942,7 +2945,7 @@ impl<'a> Parser<'a> {
                 self.span_err(op_span,
                     "chained comparison operators require parentheses");
                 if op.node == BiLt && outer_op == BiGt {
-                    self.span_help(op_span,
+                    self.fileline_help(op_span,
                         "use `::<...>` instead of `<...>` if you meant to specify type arguments");
                 }
             }
@@ -4698,7 +4701,7 @@ impl<'a> Parser<'a> {
         match visa {
             Public => {
                 self.span_err(span, "can't qualify macro invocation with `pub`");
-                self.span_help(span, "try adjusting the macro to put `pub` inside \
+                self.fileline_help(span, "try adjusting the macro to put `pub` inside \
                                       the invocation");
             }
             Inherited => (),
@@ -5435,7 +5438,7 @@ impl<'a> Parser<'a> {
                     if self.token.is_ident() { self.bump(); }
 
                     self.span_err(span, "expected `;`, found `as`");
-                    self.span_help(span,
+                    self.fileline_help(span,
                                    &format!("perhaps you meant to enclose the crate name `{}` in \
                                            a string?",
                                           the_ident.as_str()));
@@ -5746,7 +5749,7 @@ impl<'a> Parser<'a> {
             if self.eat_keyword(keywords::Mut) {
                 let last_span = self.last_span;
                 self.span_err(last_span, "const globals cannot be mutable");
-                self.span_help(last_span, "did you mean to declare a static?");
+                self.fileline_help(last_span, "did you mean to declare a static?");
             }
             let (ident, item_, extra_attrs) = self.parse_item_const(None);
             let last_span = self.last_span;

From c9e2de42b590c6d294afd1db44334c5168a694bb Mon Sep 17 00:00:00 2001
From: Florian Zeitz <florob@babelmonkeys.de>
Date: Tue, 3 Mar 2015 18:35:41 +0100
Subject: [PATCH 09/34] unicode: Properly parse ranges in UnicodeData.txt

This handles the ranges contained in UnicodeData.txt.
Counterintuitively this actually makes the tables shorter.
---
 src/etc/unicode.py       |  33 ++-
 src/libunicode/tables.rs | 537 +++++++++++++++++++--------------------
 2 files changed, 285 insertions(+), 285 deletions(-)

diff --git a/src/etc/unicode.py b/src/etc/unicode.py
index 5472ba3c7ed..312076b1b13 100755
--- a/src/etc/unicode.py
+++ b/src/etc/unicode.py
@@ -84,8 +84,8 @@ def fetch(f):
         sys.stderr.write("cannot load %s" % f)
         exit(1)
 
-def is_valid_unicode(n):
-    return 0 <= n <= 0xD7FF or 0xE000 <= n <= 0x10FFFF
+def is_surrogate(n):
+    return 0xD800 <= n <= 0xDFFF
 
 def load_unicode_data(f):
     fetch(f)
@@ -96,19 +96,28 @@ def load_unicode_data(f):
     canon_decomp = {}
     compat_decomp = {}
 
+    udict = {};
+    range_start = -1;
     for line in fileinput.input(f):
-        fields = line.split(";")
-        if len(fields) != 15:
+        data = line.split(';');
+        if len(data) != 15:
             continue
-        [code, name, gencat, combine, bidi,
+        cp = int(data[0], 16);
+        if is_surrogate(cp):
+            continue
+        if range_start >= 0:
+            for i in xrange(range_start, cp):
+                udict[i] = data;
+            range_start = -1;
+        if data[1].endswith(", First>"):
+            range_start = cp;
+            continue;
+        udict[cp] = data;
+
+    for code in udict:
+        [code_org, name, gencat, combine, bidi,
          decomp, deci, digit, num, mirror,
-         old, iso, upcase, lowcase, titlecase ] = fields
-
-        code_org = code
-        code     = int(code, 16)
-
-        if not is_valid_unicode(code):
-            continue
+         old, iso, upcase, lowcase, titlecase ] = udict[code];
 
         # generate char to char direct common and simple conversions
         # uppercase to lowercase
diff --git a/src/libunicode/tables.rs b/src/libunicode/tables.rs
index 99a6b6aa180..1fb6ee7bc7c 100644
--- a/src/libunicode/tables.rs
+++ b/src/libunicode/tables.rs
@@ -115,27 +115,26 @@ pub mod general_category {
         '\u{2eff}'), ('\u{2fd6}', '\u{2fef}'), ('\u{2ffc}', '\u{2fff}'), ('\u{3040}', '\u{3040}'),
         ('\u{3097}', '\u{3098}'), ('\u{3100}', '\u{3104}'), ('\u{312e}', '\u{3130}'), ('\u{318f}',
         '\u{318f}'), ('\u{31bb}', '\u{31bf}'), ('\u{31e4}', '\u{31ef}'), ('\u{321f}', '\u{321f}'),
-        ('\u{32ff}', '\u{32ff}'), ('\u{3401}', '\u{4db4}'), ('\u{4db6}', '\u{4dbf}'), ('\u{4e01}',
-        '\u{9fcb}'), ('\u{9fcd}', '\u{9fff}'), ('\u{a48d}', '\u{a48f}'), ('\u{a4c7}', '\u{a4cf}'),
-        ('\u{a62c}', '\u{a63f}'), ('\u{a69e}', '\u{a69e}'), ('\u{a6f8}', '\u{a6ff}'), ('\u{a78f}',
-        '\u{a78f}'), ('\u{a7ae}', '\u{a7af}'), ('\u{a7b2}', '\u{a7f6}'), ('\u{a82c}', '\u{a82f}'),
-        ('\u{a83a}', '\u{a83f}'), ('\u{a878}', '\u{a87f}'), ('\u{a8c5}', '\u{a8cd}'), ('\u{a8da}',
-        '\u{a8df}'), ('\u{a8fc}', '\u{a8ff}'), ('\u{a954}', '\u{a95e}'), ('\u{a97d}', '\u{a97f}'),
-        ('\u{a9ce}', '\u{a9ce}'), ('\u{a9da}', '\u{a9dd}'), ('\u{a9ff}', '\u{a9ff}'), ('\u{aa37}',
-        '\u{aa3f}'), ('\u{aa4e}', '\u{aa4f}'), ('\u{aa5a}', '\u{aa5b}'), ('\u{aac3}', '\u{aada}'),
-        ('\u{aaf7}', '\u{ab00}'), ('\u{ab07}', '\u{ab08}'), ('\u{ab0f}', '\u{ab10}'), ('\u{ab17}',
-        '\u{ab1f}'), ('\u{ab27}', '\u{ab27}'), ('\u{ab2f}', '\u{ab2f}'), ('\u{ab60}', '\u{ab63}'),
-        ('\u{ab66}', '\u{abbf}'), ('\u{abee}', '\u{abef}'), ('\u{abfa}', '\u{abff}'), ('\u{ac01}',
-        '\u{d7a2}'), ('\u{d7a4}', '\u{d7af}'), ('\u{d7c7}', '\u{d7ca}'), ('\u{d7fc}', '\u{d7ff}'),
-        ('\u{e000}', '\u{f8ff}'), ('\u{fa6e}', '\u{fa6f}'), ('\u{fada}', '\u{faff}'), ('\u{fb07}',
-        '\u{fb12}'), ('\u{fb18}', '\u{fb1c}'), ('\u{fb37}', '\u{fb37}'), ('\u{fb3d}', '\u{fb3d}'),
-        ('\u{fb3f}', '\u{fb3f}'), ('\u{fb42}', '\u{fb42}'), ('\u{fb45}', '\u{fb45}'), ('\u{fbc2}',
-        '\u{fbd2}'), ('\u{fd40}', '\u{fd4f}'), ('\u{fd90}', '\u{fd91}'), ('\u{fdc8}', '\u{fdef}'),
-        ('\u{fdfe}', '\u{fdff}'), ('\u{fe1a}', '\u{fe1f}'), ('\u{fe2e}', '\u{fe2f}'), ('\u{fe53}',
-        '\u{fe53}'), ('\u{fe67}', '\u{fe67}'), ('\u{fe6c}', '\u{fe6f}'), ('\u{fe75}', '\u{fe75}'),
-        ('\u{fefd}', '\u{ff00}'), ('\u{ffbf}', '\u{ffc1}'), ('\u{ffc8}', '\u{ffc9}'), ('\u{ffd0}',
-        '\u{ffd1}'), ('\u{ffd8}', '\u{ffd9}'), ('\u{ffdd}', '\u{ffdf}'), ('\u{ffe7}', '\u{ffe7}'),
-        ('\u{ffef}', '\u{fffb}'), ('\u{fffe}', '\u{ffff}'), ('\u{1000c}', '\u{1000c}'),
+        ('\u{32ff}', '\u{32ff}'), ('\u{4db6}', '\u{4dbf}'), ('\u{9fcd}', '\u{9fff}'), ('\u{a48d}',
+        '\u{a48f}'), ('\u{a4c7}', '\u{a4cf}'), ('\u{a62c}', '\u{a63f}'), ('\u{a69e}', '\u{a69e}'),
+        ('\u{a6f8}', '\u{a6ff}'), ('\u{a78f}', '\u{a78f}'), ('\u{a7ae}', '\u{a7af}'), ('\u{a7b2}',
+        '\u{a7f6}'), ('\u{a82c}', '\u{a82f}'), ('\u{a83a}', '\u{a83f}'), ('\u{a878}', '\u{a87f}'),
+        ('\u{a8c5}', '\u{a8cd}'), ('\u{a8da}', '\u{a8df}'), ('\u{a8fc}', '\u{a8ff}'), ('\u{a954}',
+        '\u{a95e}'), ('\u{a97d}', '\u{a97f}'), ('\u{a9ce}', '\u{a9ce}'), ('\u{a9da}', '\u{a9dd}'),
+        ('\u{a9ff}', '\u{a9ff}'), ('\u{aa37}', '\u{aa3f}'), ('\u{aa4e}', '\u{aa4f}'), ('\u{aa5a}',
+        '\u{aa5b}'), ('\u{aac3}', '\u{aada}'), ('\u{aaf7}', '\u{ab00}'), ('\u{ab07}', '\u{ab08}'),
+        ('\u{ab0f}', '\u{ab10}'), ('\u{ab17}', '\u{ab1f}'), ('\u{ab27}', '\u{ab27}'), ('\u{ab2f}',
+        '\u{ab2f}'), ('\u{ab60}', '\u{ab63}'), ('\u{ab66}', '\u{abbf}'), ('\u{abee}', '\u{abef}'),
+        ('\u{abfa}', '\u{abff}'), ('\u{d7a4}', '\u{d7af}'), ('\u{d7c7}', '\u{d7ca}'), ('\u{d7fc}',
+        '\u{d7ff}'), ('\u{e000}', '\u{f8ff}'), ('\u{fa6e}', '\u{fa6f}'), ('\u{fada}', '\u{faff}'),
+        ('\u{fb07}', '\u{fb12}'), ('\u{fb18}', '\u{fb1c}'), ('\u{fb37}', '\u{fb37}'), ('\u{fb3d}',
+        '\u{fb3d}'), ('\u{fb3f}', '\u{fb3f}'), ('\u{fb42}', '\u{fb42}'), ('\u{fb45}', '\u{fb45}'),
+        ('\u{fbc2}', '\u{fbd2}'), ('\u{fd40}', '\u{fd4f}'), ('\u{fd90}', '\u{fd91}'), ('\u{fdc8}',
+        '\u{fdef}'), ('\u{fdfe}', '\u{fdff}'), ('\u{fe1a}', '\u{fe1f}'), ('\u{fe2e}', '\u{fe2f}'),
+        ('\u{fe53}', '\u{fe53}'), ('\u{fe67}', '\u{fe67}'), ('\u{fe6c}', '\u{fe6f}'), ('\u{fe75}',
+        '\u{fe75}'), ('\u{fefd}', '\u{ff00}'), ('\u{ffbf}', '\u{ffc1}'), ('\u{ffc8}', '\u{ffc9}'),
+        ('\u{ffd0}', '\u{ffd1}'), ('\u{ffd8}', '\u{ffd9}'), ('\u{ffdd}', '\u{ffdf}'), ('\u{ffe7}',
+        '\u{ffe7}'), ('\u{ffef}', '\u{fffb}'), ('\u{fffe}', '\u{ffff}'), ('\u{1000c}', '\u{1000c}'),
         ('\u{10027}', '\u{10027}'), ('\u{1003b}', '\u{1003b}'), ('\u{1003e}', '\u{1003e}'),
         ('\u{1004e}', '\u{1004f}'), ('\u{1005e}', '\u{1007f}'), ('\u{100fb}', '\u{100ff}'),
         ('\u{10103}', '\u{10106}'), ('\u{10134}', '\u{10136}'), ('\u{1018d}', '\u{1018f}'),
@@ -210,9 +209,8 @@ pub mod general_category {
         ('\u{1f643}', '\u{1f644}'), ('\u{1f6d0}', '\u{1f6df}'), ('\u{1f6ed}', '\u{1f6ef}'),
         ('\u{1f6f4}', '\u{1f6ff}'), ('\u{1f774}', '\u{1f77f}'), ('\u{1f7d5}', '\u{1f7ff}'),
         ('\u{1f80c}', '\u{1f80f}'), ('\u{1f848}', '\u{1f84f}'), ('\u{1f85a}', '\u{1f85f}'),
-        ('\u{1f888}', '\u{1f88f}'), ('\u{1f8ae}', '\u{1ffff}'), ('\u{20001}', '\u{2a6d5}'),
-        ('\u{2a6d7}', '\u{2a6ff}'), ('\u{2a701}', '\u{2b733}'), ('\u{2b735}', '\u{2b73f}'),
-        ('\u{2b741}', '\u{2b81c}'), ('\u{2b81e}', '\u{2f7ff}'), ('\u{2fa1e}', '\u{e00ff}'),
+        ('\u{1f888}', '\u{1f88f}'), ('\u{1f8ae}', '\u{1ffff}'), ('\u{2a6d7}', '\u{2a6ff}'),
+        ('\u{2b735}', '\u{2b73f}'), ('\u{2b81e}', '\u{2f7ff}'), ('\u{2fa1e}', '\u{e00ff}'),
         ('\u{e01f0}', '\u{10ffff}')
     ];
 
@@ -319,112 +317,108 @@ pub mod general_category {
         ('\u{2e9a}', '\u{2e9a}'), ('\u{2ef4}', '\u{2eff}'), ('\u{2fd6}', '\u{2fef}'), ('\u{2ffc}',
         '\u{2fff}'), ('\u{3040}', '\u{3040}'), ('\u{3097}', '\u{3098}'), ('\u{3100}', '\u{3104}'),
         ('\u{312e}', '\u{3130}'), ('\u{318f}', '\u{318f}'), ('\u{31bb}', '\u{31bf}'), ('\u{31e4}',
-        '\u{31ef}'), ('\u{321f}', '\u{321f}'), ('\u{32ff}', '\u{32ff}'), ('\u{3401}', '\u{4db4}'),
-        ('\u{4db6}', '\u{4dbf}'), ('\u{4e01}', '\u{9fcb}'), ('\u{9fcd}', '\u{9fff}'), ('\u{a48d}',
-        '\u{a48f}'), ('\u{a4c7}', '\u{a4cf}'), ('\u{a62c}', '\u{a63f}'), ('\u{a69e}', '\u{a69e}'),
-        ('\u{a6f8}', '\u{a6ff}'), ('\u{a78f}', '\u{a78f}'), ('\u{a7ae}', '\u{a7af}'), ('\u{a7b2}',
-        '\u{a7f6}'), ('\u{a82c}', '\u{a82f}'), ('\u{a83a}', '\u{a83f}'), ('\u{a878}', '\u{a87f}'),
-        ('\u{a8c5}', '\u{a8cd}'), ('\u{a8da}', '\u{a8df}'), ('\u{a8fc}', '\u{a8ff}'), ('\u{a954}',
-        '\u{a95e}'), ('\u{a97d}', '\u{a97f}'), ('\u{a9ce}', '\u{a9ce}'), ('\u{a9da}', '\u{a9dd}'),
-        ('\u{a9ff}', '\u{a9ff}'), ('\u{aa37}', '\u{aa3f}'), ('\u{aa4e}', '\u{aa4f}'), ('\u{aa5a}',
-        '\u{aa5b}'), ('\u{aac3}', '\u{aada}'), ('\u{aaf7}', '\u{ab00}'), ('\u{ab07}', '\u{ab08}'),
-        ('\u{ab0f}', '\u{ab10}'), ('\u{ab17}', '\u{ab1f}'), ('\u{ab27}', '\u{ab27}'), ('\u{ab2f}',
-        '\u{ab2f}'), ('\u{ab60}', '\u{ab63}'), ('\u{ab66}', '\u{abbf}'), ('\u{abee}', '\u{abef}'),
-        ('\u{abfa}', '\u{abff}'), ('\u{ac01}', '\u{d7a2}'), ('\u{d7a4}', '\u{d7af}'), ('\u{d7c7}',
-        '\u{d7ca}'), ('\u{d7fc}', '\u{d7ff}'), ('\u{e001}', '\u{f8fe}'), ('\u{fa6e}', '\u{fa6f}'),
-        ('\u{fada}', '\u{faff}'), ('\u{fb07}', '\u{fb12}'), ('\u{fb18}', '\u{fb1c}'), ('\u{fb37}',
-        '\u{fb37}'), ('\u{fb3d}', '\u{fb3d}'), ('\u{fb3f}', '\u{fb3f}'), ('\u{fb42}', '\u{fb42}'),
-        ('\u{fb45}', '\u{fb45}'), ('\u{fbc2}', '\u{fbd2}'), ('\u{fd40}', '\u{fd4f}'), ('\u{fd90}',
-        '\u{fd91}'), ('\u{fdc8}', '\u{fdef}'), ('\u{fdfe}', '\u{fdff}'), ('\u{fe1a}', '\u{fe1f}'),
-        ('\u{fe2e}', '\u{fe2f}'), ('\u{fe53}', '\u{fe53}'), ('\u{fe67}', '\u{fe67}'), ('\u{fe6c}',
-        '\u{fe6f}'), ('\u{fe75}', '\u{fe75}'), ('\u{fefd}', '\u{fefe}'), ('\u{ff00}', '\u{ff00}'),
-        ('\u{ffbf}', '\u{ffc1}'), ('\u{ffc8}', '\u{ffc9}'), ('\u{ffd0}', '\u{ffd1}'), ('\u{ffd8}',
-        '\u{ffd9}'), ('\u{ffdd}', '\u{ffdf}'), ('\u{ffe7}', '\u{ffe7}'), ('\u{ffef}', '\u{fff8}'),
-        ('\u{fffe}', '\u{ffff}'), ('\u{1000c}', '\u{1000c}'), ('\u{10027}', '\u{10027}'),
-        ('\u{1003b}', '\u{1003b}'), ('\u{1003e}', '\u{1003e}'), ('\u{1004e}', '\u{1004f}'),
-        ('\u{1005e}', '\u{1007f}'), ('\u{100fb}', '\u{100ff}'), ('\u{10103}', '\u{10106}'),
-        ('\u{10134}', '\u{10136}'), ('\u{1018d}', '\u{1018f}'), ('\u{1019c}', '\u{1019f}'),
-        ('\u{101a1}', '\u{101cf}'), ('\u{101fe}', '\u{1027f}'), ('\u{1029d}', '\u{1029f}'),
-        ('\u{102d1}', '\u{102df}'), ('\u{102fc}', '\u{102ff}'), ('\u{10324}', '\u{1032f}'),
-        ('\u{1034b}', '\u{1034f}'), ('\u{1037b}', '\u{1037f}'), ('\u{1039e}', '\u{1039e}'),
-        ('\u{103c4}', '\u{103c7}'), ('\u{103d6}', '\u{103ff}'), ('\u{1049e}', '\u{1049f}'),
-        ('\u{104aa}', '\u{104ff}'), ('\u{10528}', '\u{1052f}'), ('\u{10564}', '\u{1056e}'),
-        ('\u{10570}', '\u{105ff}'), ('\u{10737}', '\u{1073f}'), ('\u{10756}', '\u{1075f}'),
-        ('\u{10768}', '\u{107ff}'), ('\u{10806}', '\u{10807}'), ('\u{10809}', '\u{10809}'),
-        ('\u{10836}', '\u{10836}'), ('\u{10839}', '\u{1083b}'), ('\u{1083d}', '\u{1083e}'),
-        ('\u{10856}', '\u{10856}'), ('\u{1089f}', '\u{108a6}'), ('\u{108b0}', '\u{108ff}'),
-        ('\u{1091c}', '\u{1091e}'), ('\u{1093a}', '\u{1093e}'), ('\u{10940}', '\u{1097f}'),
-        ('\u{109b8}', '\u{109bd}'), ('\u{109c0}', '\u{109ff}'), ('\u{10a04}', '\u{10a04}'),
-        ('\u{10a07}', '\u{10a0b}'), ('\u{10a14}', '\u{10a14}'), ('\u{10a18}', '\u{10a18}'),
-        ('\u{10a34}', '\u{10a37}'), ('\u{10a3b}', '\u{10a3e}'), ('\u{10a48}', '\u{10a4f}'),
-        ('\u{10a59}', '\u{10a5f}'), ('\u{10aa0}', '\u{10abf}'), ('\u{10ae7}', '\u{10aea}'),
-        ('\u{10af7}', '\u{10aff}'), ('\u{10b36}', '\u{10b38}'), ('\u{10b56}', '\u{10b57}'),
-        ('\u{10b73}', '\u{10b77}'), ('\u{10b92}', '\u{10b98}'), ('\u{10b9d}', '\u{10ba8}'),
-        ('\u{10bb0}', '\u{10bff}'), ('\u{10c49}', '\u{10e5f}'), ('\u{10e7f}', '\u{10fff}'),
-        ('\u{1104e}', '\u{11051}'), ('\u{11070}', '\u{1107e}'), ('\u{110c2}', '\u{110cf}'),
-        ('\u{110e9}', '\u{110ef}'), ('\u{110fa}', '\u{110ff}'), ('\u{11135}', '\u{11135}'),
-        ('\u{11144}', '\u{1114f}'), ('\u{11177}', '\u{1117f}'), ('\u{111c9}', '\u{111cc}'),
-        ('\u{111ce}', '\u{111cf}'), ('\u{111db}', '\u{111e0}'), ('\u{111f5}', '\u{111ff}'),
-        ('\u{11212}', '\u{11212}'), ('\u{1123e}', '\u{112af}'), ('\u{112eb}', '\u{112ef}'),
-        ('\u{112fa}', '\u{11300}'), ('\u{11304}', '\u{11304}'), ('\u{1130d}', '\u{1130e}'),
-        ('\u{11311}', '\u{11312}'), ('\u{11329}', '\u{11329}'), ('\u{11331}', '\u{11331}'),
-        ('\u{11334}', '\u{11334}'), ('\u{1133a}', '\u{1133b}'), ('\u{11345}', '\u{11346}'),
-        ('\u{11349}', '\u{1134a}'), ('\u{1134e}', '\u{11356}'), ('\u{11358}', '\u{1135c}'),
-        ('\u{11364}', '\u{11365}'), ('\u{1136d}', '\u{1136f}'), ('\u{11375}', '\u{1147f}'),
-        ('\u{114c8}', '\u{114cf}'), ('\u{114da}', '\u{1157f}'), ('\u{115b6}', '\u{115b7}'),
-        ('\u{115ca}', '\u{115ff}'), ('\u{11645}', '\u{1164f}'), ('\u{1165a}', '\u{1167f}'),
-        ('\u{116b8}', '\u{116bf}'), ('\u{116ca}', '\u{1189f}'), ('\u{118f3}', '\u{118fe}'),
-        ('\u{11900}', '\u{11abf}'), ('\u{11af9}', '\u{11fff}'), ('\u{12399}', '\u{123ff}'),
-        ('\u{1246f}', '\u{1246f}'), ('\u{12475}', '\u{12fff}'), ('\u{1342f}', '\u{167ff}'),
-        ('\u{16a39}', '\u{16a3f}'), ('\u{16a5f}', '\u{16a5f}'), ('\u{16a6a}', '\u{16a6d}'),
-        ('\u{16a70}', '\u{16acf}'), ('\u{16aee}', '\u{16aef}'), ('\u{16af6}', '\u{16aff}'),
-        ('\u{16b46}', '\u{16b4f}'), ('\u{16b5a}', '\u{16b5a}'), ('\u{16b62}', '\u{16b62}'),
-        ('\u{16b78}', '\u{16b7c}'), ('\u{16b90}', '\u{16eff}'), ('\u{16f45}', '\u{16f4f}'),
-        ('\u{16f7f}', '\u{16f8e}'), ('\u{16fa0}', '\u{1afff}'), ('\u{1b002}', '\u{1bbff}'),
-        ('\u{1bc6b}', '\u{1bc6f}'), ('\u{1bc7d}', '\u{1bc7f}'), ('\u{1bc89}', '\u{1bc8f}'),
-        ('\u{1bc9a}', '\u{1bc9b}'), ('\u{1bca4}', '\u{1cfff}'), ('\u{1d0f6}', '\u{1d0ff}'),
-        ('\u{1d127}', '\u{1d128}'), ('\u{1d1de}', '\u{1d1ff}'), ('\u{1d246}', '\u{1d2ff}'),
-        ('\u{1d357}', '\u{1d35f}'), ('\u{1d372}', '\u{1d3ff}'), ('\u{1d455}', '\u{1d455}'),
-        ('\u{1d49d}', '\u{1d49d}'), ('\u{1d4a0}', '\u{1d4a1}'), ('\u{1d4a3}', '\u{1d4a4}'),
-        ('\u{1d4a7}', '\u{1d4a8}'), ('\u{1d4ad}', '\u{1d4ad}'), ('\u{1d4ba}', '\u{1d4ba}'),
-        ('\u{1d4bc}', '\u{1d4bc}'), ('\u{1d4c4}', '\u{1d4c4}'), ('\u{1d506}', '\u{1d506}'),
-        ('\u{1d50b}', '\u{1d50c}'), ('\u{1d515}', '\u{1d515}'), ('\u{1d51d}', '\u{1d51d}'),
-        ('\u{1d53a}', '\u{1d53a}'), ('\u{1d53f}', '\u{1d53f}'), ('\u{1d545}', '\u{1d545}'),
-        ('\u{1d547}', '\u{1d549}'), ('\u{1d551}', '\u{1d551}'), ('\u{1d6a6}', '\u{1d6a7}'),
-        ('\u{1d7cc}', '\u{1d7cd}'), ('\u{1d800}', '\u{1e7ff}'), ('\u{1e8c5}', '\u{1e8c6}'),
-        ('\u{1e8d7}', '\u{1edff}'), ('\u{1ee04}', '\u{1ee04}'), ('\u{1ee20}', '\u{1ee20}'),
-        ('\u{1ee23}', '\u{1ee23}'), ('\u{1ee25}', '\u{1ee26}'), ('\u{1ee28}', '\u{1ee28}'),
-        ('\u{1ee33}', '\u{1ee33}'), ('\u{1ee38}', '\u{1ee38}'), ('\u{1ee3a}', '\u{1ee3a}'),
-        ('\u{1ee3c}', '\u{1ee41}'), ('\u{1ee43}', '\u{1ee46}'), ('\u{1ee48}', '\u{1ee48}'),
-        ('\u{1ee4a}', '\u{1ee4a}'), ('\u{1ee4c}', '\u{1ee4c}'), ('\u{1ee50}', '\u{1ee50}'),
-        ('\u{1ee53}', '\u{1ee53}'), ('\u{1ee55}', '\u{1ee56}'), ('\u{1ee58}', '\u{1ee58}'),
-        ('\u{1ee5a}', '\u{1ee5a}'), ('\u{1ee5c}', '\u{1ee5c}'), ('\u{1ee5e}', '\u{1ee5e}'),
-        ('\u{1ee60}', '\u{1ee60}'), ('\u{1ee63}', '\u{1ee63}'), ('\u{1ee65}', '\u{1ee66}'),
-        ('\u{1ee6b}', '\u{1ee6b}'), ('\u{1ee73}', '\u{1ee73}'), ('\u{1ee78}', '\u{1ee78}'),
-        ('\u{1ee7d}', '\u{1ee7d}'), ('\u{1ee7f}', '\u{1ee7f}'), ('\u{1ee8a}', '\u{1ee8a}'),
-        ('\u{1ee9c}', '\u{1eea0}'), ('\u{1eea4}', '\u{1eea4}'), ('\u{1eeaa}', '\u{1eeaa}'),
-        ('\u{1eebc}', '\u{1eeef}'), ('\u{1eef2}', '\u{1efff}'), ('\u{1f02c}', '\u{1f02f}'),
-        ('\u{1f094}', '\u{1f09f}'), ('\u{1f0af}', '\u{1f0b0}'), ('\u{1f0c0}', '\u{1f0c0}'),
-        ('\u{1f0d0}', '\u{1f0d0}'), ('\u{1f0f6}', '\u{1f0ff}'), ('\u{1f10d}', '\u{1f10f}'),
-        ('\u{1f12f}', '\u{1f12f}'), ('\u{1f16c}', '\u{1f16f}'), ('\u{1f19b}', '\u{1f1e5}'),
-        ('\u{1f203}', '\u{1f20f}'), ('\u{1f23b}', '\u{1f23f}'), ('\u{1f249}', '\u{1f24f}'),
-        ('\u{1f252}', '\u{1f2ff}'), ('\u{1f32d}', '\u{1f32f}'), ('\u{1f37e}', '\u{1f37f}'),
-        ('\u{1f3cf}', '\u{1f3d3}'), ('\u{1f3f8}', '\u{1f3ff}'), ('\u{1f4ff}', '\u{1f4ff}'),
-        ('\u{1f54b}', '\u{1f54f}'), ('\u{1f57a}', '\u{1f57a}'), ('\u{1f5a4}', '\u{1f5a4}'),
-        ('\u{1f643}', '\u{1f644}'), ('\u{1f6d0}', '\u{1f6df}'), ('\u{1f6ed}', '\u{1f6ef}'),
-        ('\u{1f6f4}', '\u{1f6ff}'), ('\u{1f774}', '\u{1f77f}'), ('\u{1f7d5}', '\u{1f7ff}'),
-        ('\u{1f80c}', '\u{1f80f}'), ('\u{1f848}', '\u{1f84f}'), ('\u{1f85a}', '\u{1f85f}'),
-        ('\u{1f888}', '\u{1f88f}'), ('\u{1f8ae}', '\u{1ffff}'), ('\u{20001}', '\u{2a6d5}'),
-        ('\u{2a6d7}', '\u{2a6ff}'), ('\u{2a701}', '\u{2b733}'), ('\u{2b735}', '\u{2b73f}'),
-        ('\u{2b741}', '\u{2b81c}'), ('\u{2b81e}', '\u{2f7ff}'), ('\u{2fa1e}', '\u{e0000}'),
-        ('\u{e0002}', '\u{e001f}'), ('\u{e0080}', '\u{e00ff}'), ('\u{e01f0}', '\u{effff}'),
-        ('\u{f0001}', '\u{ffffc}'), ('\u{ffffe}', '\u{fffff}'), ('\u{100001}', '\u{10fffc}'),
-        ('\u{10fffe}', '\u{10ffff}')
+        '\u{31ef}'), ('\u{321f}', '\u{321f}'), ('\u{32ff}', '\u{32ff}'), ('\u{4db6}', '\u{4dbf}'),
+        ('\u{9fcd}', '\u{9fff}'), ('\u{a48d}', '\u{a48f}'), ('\u{a4c7}', '\u{a4cf}'), ('\u{a62c}',
+        '\u{a63f}'), ('\u{a69e}', '\u{a69e}'), ('\u{a6f8}', '\u{a6ff}'), ('\u{a78f}', '\u{a78f}'),
+        ('\u{a7ae}', '\u{a7af}'), ('\u{a7b2}', '\u{a7f6}'), ('\u{a82c}', '\u{a82f}'), ('\u{a83a}',
+        '\u{a83f}'), ('\u{a878}', '\u{a87f}'), ('\u{a8c5}', '\u{a8cd}'), ('\u{a8da}', '\u{a8df}'),
+        ('\u{a8fc}', '\u{a8ff}'), ('\u{a954}', '\u{a95e}'), ('\u{a97d}', '\u{a97f}'), ('\u{a9ce}',
+        '\u{a9ce}'), ('\u{a9da}', '\u{a9dd}'), ('\u{a9ff}', '\u{a9ff}'), ('\u{aa37}', '\u{aa3f}'),
+        ('\u{aa4e}', '\u{aa4f}'), ('\u{aa5a}', '\u{aa5b}'), ('\u{aac3}', '\u{aada}'), ('\u{aaf7}',
+        '\u{ab00}'), ('\u{ab07}', '\u{ab08}'), ('\u{ab0f}', '\u{ab10}'), ('\u{ab17}', '\u{ab1f}'),
+        ('\u{ab27}', '\u{ab27}'), ('\u{ab2f}', '\u{ab2f}'), ('\u{ab60}', '\u{ab63}'), ('\u{ab66}',
+        '\u{abbf}'), ('\u{abee}', '\u{abef}'), ('\u{abfa}', '\u{abff}'), ('\u{d7a4}', '\u{d7af}'),
+        ('\u{d7c7}', '\u{d7ca}'), ('\u{d7fc}', '\u{d7ff}'), ('\u{fa6e}', '\u{fa6f}'), ('\u{fada}',
+        '\u{faff}'), ('\u{fb07}', '\u{fb12}'), ('\u{fb18}', '\u{fb1c}'), ('\u{fb37}', '\u{fb37}'),
+        ('\u{fb3d}', '\u{fb3d}'), ('\u{fb3f}', '\u{fb3f}'), ('\u{fb42}', '\u{fb42}'), ('\u{fb45}',
+        '\u{fb45}'), ('\u{fbc2}', '\u{fbd2}'), ('\u{fd40}', '\u{fd4f}'), ('\u{fd90}', '\u{fd91}'),
+        ('\u{fdc8}', '\u{fdef}'), ('\u{fdfe}', '\u{fdff}'), ('\u{fe1a}', '\u{fe1f}'), ('\u{fe2e}',
+        '\u{fe2f}'), ('\u{fe53}', '\u{fe53}'), ('\u{fe67}', '\u{fe67}'), ('\u{fe6c}', '\u{fe6f}'),
+        ('\u{fe75}', '\u{fe75}'), ('\u{fefd}', '\u{fefe}'), ('\u{ff00}', '\u{ff00}'), ('\u{ffbf}',
+        '\u{ffc1}'), ('\u{ffc8}', '\u{ffc9}'), ('\u{ffd0}', '\u{ffd1}'), ('\u{ffd8}', '\u{ffd9}'),
+        ('\u{ffdd}', '\u{ffdf}'), ('\u{ffe7}', '\u{ffe7}'), ('\u{ffef}', '\u{fff8}'), ('\u{fffe}',
+        '\u{ffff}'), ('\u{1000c}', '\u{1000c}'), ('\u{10027}', '\u{10027}'), ('\u{1003b}',
+        '\u{1003b}'), ('\u{1003e}', '\u{1003e}'), ('\u{1004e}', '\u{1004f}'), ('\u{1005e}',
+        '\u{1007f}'), ('\u{100fb}', '\u{100ff}'), ('\u{10103}', '\u{10106}'), ('\u{10134}',
+        '\u{10136}'), ('\u{1018d}', '\u{1018f}'), ('\u{1019c}', '\u{1019f}'), ('\u{101a1}',
+        '\u{101cf}'), ('\u{101fe}', '\u{1027f}'), ('\u{1029d}', '\u{1029f}'), ('\u{102d1}',
+        '\u{102df}'), ('\u{102fc}', '\u{102ff}'), ('\u{10324}', '\u{1032f}'), ('\u{1034b}',
+        '\u{1034f}'), ('\u{1037b}', '\u{1037f}'), ('\u{1039e}', '\u{1039e}'), ('\u{103c4}',
+        '\u{103c7}'), ('\u{103d6}', '\u{103ff}'), ('\u{1049e}', '\u{1049f}'), ('\u{104aa}',
+        '\u{104ff}'), ('\u{10528}', '\u{1052f}'), ('\u{10564}', '\u{1056e}'), ('\u{10570}',
+        '\u{105ff}'), ('\u{10737}', '\u{1073f}'), ('\u{10756}', '\u{1075f}'), ('\u{10768}',
+        '\u{107ff}'), ('\u{10806}', '\u{10807}'), ('\u{10809}', '\u{10809}'), ('\u{10836}',
+        '\u{10836}'), ('\u{10839}', '\u{1083b}'), ('\u{1083d}', '\u{1083e}'), ('\u{10856}',
+        '\u{10856}'), ('\u{1089f}', '\u{108a6}'), ('\u{108b0}', '\u{108ff}'), ('\u{1091c}',
+        '\u{1091e}'), ('\u{1093a}', '\u{1093e}'), ('\u{10940}', '\u{1097f}'), ('\u{109b8}',
+        '\u{109bd}'), ('\u{109c0}', '\u{109ff}'), ('\u{10a04}', '\u{10a04}'), ('\u{10a07}',
+        '\u{10a0b}'), ('\u{10a14}', '\u{10a14}'), ('\u{10a18}', '\u{10a18}'), ('\u{10a34}',
+        '\u{10a37}'), ('\u{10a3b}', '\u{10a3e}'), ('\u{10a48}', '\u{10a4f}'), ('\u{10a59}',
+        '\u{10a5f}'), ('\u{10aa0}', '\u{10abf}'), ('\u{10ae7}', '\u{10aea}'), ('\u{10af7}',
+        '\u{10aff}'), ('\u{10b36}', '\u{10b38}'), ('\u{10b56}', '\u{10b57}'), ('\u{10b73}',
+        '\u{10b77}'), ('\u{10b92}', '\u{10b98}'), ('\u{10b9d}', '\u{10ba8}'), ('\u{10bb0}',
+        '\u{10bff}'), ('\u{10c49}', '\u{10e5f}'), ('\u{10e7f}', '\u{10fff}'), ('\u{1104e}',
+        '\u{11051}'), ('\u{11070}', '\u{1107e}'), ('\u{110c2}', '\u{110cf}'), ('\u{110e9}',
+        '\u{110ef}'), ('\u{110fa}', '\u{110ff}'), ('\u{11135}', '\u{11135}'), ('\u{11144}',
+        '\u{1114f}'), ('\u{11177}', '\u{1117f}'), ('\u{111c9}', '\u{111cc}'), ('\u{111ce}',
+        '\u{111cf}'), ('\u{111db}', '\u{111e0}'), ('\u{111f5}', '\u{111ff}'), ('\u{11212}',
+        '\u{11212}'), ('\u{1123e}', '\u{112af}'), ('\u{112eb}', '\u{112ef}'), ('\u{112fa}',
+        '\u{11300}'), ('\u{11304}', '\u{11304}'), ('\u{1130d}', '\u{1130e}'), ('\u{11311}',
+        '\u{11312}'), ('\u{11329}', '\u{11329}'), ('\u{11331}', '\u{11331}'), ('\u{11334}',
+        '\u{11334}'), ('\u{1133a}', '\u{1133b}'), ('\u{11345}', '\u{11346}'), ('\u{11349}',
+        '\u{1134a}'), ('\u{1134e}', '\u{11356}'), ('\u{11358}', '\u{1135c}'), ('\u{11364}',
+        '\u{11365}'), ('\u{1136d}', '\u{1136f}'), ('\u{11375}', '\u{1147f}'), ('\u{114c8}',
+        '\u{114cf}'), ('\u{114da}', '\u{1157f}'), ('\u{115b6}', '\u{115b7}'), ('\u{115ca}',
+        '\u{115ff}'), ('\u{11645}', '\u{1164f}'), ('\u{1165a}', '\u{1167f}'), ('\u{116b8}',
+        '\u{116bf}'), ('\u{116ca}', '\u{1189f}'), ('\u{118f3}', '\u{118fe}'), ('\u{11900}',
+        '\u{11abf}'), ('\u{11af9}', '\u{11fff}'), ('\u{12399}', '\u{123ff}'), ('\u{1246f}',
+        '\u{1246f}'), ('\u{12475}', '\u{12fff}'), ('\u{1342f}', '\u{167ff}'), ('\u{16a39}',
+        '\u{16a3f}'), ('\u{16a5f}', '\u{16a5f}'), ('\u{16a6a}', '\u{16a6d}'), ('\u{16a70}',
+        '\u{16acf}'), ('\u{16aee}', '\u{16aef}'), ('\u{16af6}', '\u{16aff}'), ('\u{16b46}',
+        '\u{16b4f}'), ('\u{16b5a}', '\u{16b5a}'), ('\u{16b62}', '\u{16b62}'), ('\u{16b78}',
+        '\u{16b7c}'), ('\u{16b90}', '\u{16eff}'), ('\u{16f45}', '\u{16f4f}'), ('\u{16f7f}',
+        '\u{16f8e}'), ('\u{16fa0}', '\u{1afff}'), ('\u{1b002}', '\u{1bbff}'), ('\u{1bc6b}',
+        '\u{1bc6f}'), ('\u{1bc7d}', '\u{1bc7f}'), ('\u{1bc89}', '\u{1bc8f}'), ('\u{1bc9a}',
+        '\u{1bc9b}'), ('\u{1bca4}', '\u{1cfff}'), ('\u{1d0f6}', '\u{1d0ff}'), ('\u{1d127}',
+        '\u{1d128}'), ('\u{1d1de}', '\u{1d1ff}'), ('\u{1d246}', '\u{1d2ff}'), ('\u{1d357}',
+        '\u{1d35f}'), ('\u{1d372}', '\u{1d3ff}'), ('\u{1d455}', '\u{1d455}'), ('\u{1d49d}',
+        '\u{1d49d}'), ('\u{1d4a0}', '\u{1d4a1}'), ('\u{1d4a3}', '\u{1d4a4}'), ('\u{1d4a7}',
+        '\u{1d4a8}'), ('\u{1d4ad}', '\u{1d4ad}'), ('\u{1d4ba}', '\u{1d4ba}'), ('\u{1d4bc}',
+        '\u{1d4bc}'), ('\u{1d4c4}', '\u{1d4c4}'), ('\u{1d506}', '\u{1d506}'), ('\u{1d50b}',
+        '\u{1d50c}'), ('\u{1d515}', '\u{1d515}'), ('\u{1d51d}', '\u{1d51d}'), ('\u{1d53a}',
+        '\u{1d53a}'), ('\u{1d53f}', '\u{1d53f}'), ('\u{1d545}', '\u{1d545}'), ('\u{1d547}',
+        '\u{1d549}'), ('\u{1d551}', '\u{1d551}'), ('\u{1d6a6}', '\u{1d6a7}'), ('\u{1d7cc}',
+        '\u{1d7cd}'), ('\u{1d800}', '\u{1e7ff}'), ('\u{1e8c5}', '\u{1e8c6}'), ('\u{1e8d7}',
+        '\u{1edff}'), ('\u{1ee04}', '\u{1ee04}'), ('\u{1ee20}', '\u{1ee20}'), ('\u{1ee23}',
+        '\u{1ee23}'), ('\u{1ee25}', '\u{1ee26}'), ('\u{1ee28}', '\u{1ee28}'), ('\u{1ee33}',
+        '\u{1ee33}'), ('\u{1ee38}', '\u{1ee38}'), ('\u{1ee3a}', '\u{1ee3a}'), ('\u{1ee3c}',
+        '\u{1ee41}'), ('\u{1ee43}', '\u{1ee46}'), ('\u{1ee48}', '\u{1ee48}'), ('\u{1ee4a}',
+        '\u{1ee4a}'), ('\u{1ee4c}', '\u{1ee4c}'), ('\u{1ee50}', '\u{1ee50}'), ('\u{1ee53}',
+        '\u{1ee53}'), ('\u{1ee55}', '\u{1ee56}'), ('\u{1ee58}', '\u{1ee58}'), ('\u{1ee5a}',
+        '\u{1ee5a}'), ('\u{1ee5c}', '\u{1ee5c}'), ('\u{1ee5e}', '\u{1ee5e}'), ('\u{1ee60}',
+        '\u{1ee60}'), ('\u{1ee63}', '\u{1ee63}'), ('\u{1ee65}', '\u{1ee66}'), ('\u{1ee6b}',
+        '\u{1ee6b}'), ('\u{1ee73}', '\u{1ee73}'), ('\u{1ee78}', '\u{1ee78}'), ('\u{1ee7d}',
+        '\u{1ee7d}'), ('\u{1ee7f}', '\u{1ee7f}'), ('\u{1ee8a}', '\u{1ee8a}'), ('\u{1ee9c}',
+        '\u{1eea0}'), ('\u{1eea4}', '\u{1eea4}'), ('\u{1eeaa}', '\u{1eeaa}'), ('\u{1eebc}',
+        '\u{1eeef}'), ('\u{1eef2}', '\u{1efff}'), ('\u{1f02c}', '\u{1f02f}'), ('\u{1f094}',
+        '\u{1f09f}'), ('\u{1f0af}', '\u{1f0b0}'), ('\u{1f0c0}', '\u{1f0c0}'), ('\u{1f0d0}',
+        '\u{1f0d0}'), ('\u{1f0f6}', '\u{1f0ff}'), ('\u{1f10d}', '\u{1f10f}'), ('\u{1f12f}',
+        '\u{1f12f}'), ('\u{1f16c}', '\u{1f16f}'), ('\u{1f19b}', '\u{1f1e5}'), ('\u{1f203}',
+        '\u{1f20f}'), ('\u{1f23b}', '\u{1f23f}'), ('\u{1f249}', '\u{1f24f}'), ('\u{1f252}',
+        '\u{1f2ff}'), ('\u{1f32d}', '\u{1f32f}'), ('\u{1f37e}', '\u{1f37f}'), ('\u{1f3cf}',
+        '\u{1f3d3}'), ('\u{1f3f8}', '\u{1f3ff}'), ('\u{1f4ff}', '\u{1f4ff}'), ('\u{1f54b}',
+        '\u{1f54f}'), ('\u{1f57a}', '\u{1f57a}'), ('\u{1f5a4}', '\u{1f5a4}'), ('\u{1f643}',
+        '\u{1f644}'), ('\u{1f6d0}', '\u{1f6df}'), ('\u{1f6ed}', '\u{1f6ef}'), ('\u{1f6f4}',
+        '\u{1f6ff}'), ('\u{1f774}', '\u{1f77f}'), ('\u{1f7d5}', '\u{1f7ff}'), ('\u{1f80c}',
+        '\u{1f80f}'), ('\u{1f848}', '\u{1f84f}'), ('\u{1f85a}', '\u{1f85f}'), ('\u{1f888}',
+        '\u{1f88f}'), ('\u{1f8ae}', '\u{1ffff}'), ('\u{2a6d7}', '\u{2a6ff}'), ('\u{2b735}',
+        '\u{2b73f}'), ('\u{2b81e}', '\u{2f7ff}'), ('\u{2fa1e}', '\u{e0000}'), ('\u{e0002}',
+        '\u{e001f}'), ('\u{e0080}', '\u{e00ff}'), ('\u{e01f0}', '\u{effff}'), ('\u{ffffe}',
+        '\u{fffff}'), ('\u{10fffe}', '\u{10ffff}')
     ];
 
     pub const Co_table: &'static [(char, char)] = &[
-        ('\u{e000}', '\u{e000}'), ('\u{f8ff}', '\u{f8ff}'), ('\u{f0000}', '\u{f0000}'),
-        ('\u{ffffd}', '\u{ffffd}'), ('\u{100000}', '\u{100000}'), ('\u{10fffd}', '\u{10fffd}')
+        ('\u{e000}', '\u{f8ff}'), ('\u{f0000}', '\u{ffffd}'), ('\u{100000}', '\u{10fffd}')
     ];
 
     pub const L_table: &'static [(char, char)] = &[
@@ -511,86 +505,84 @@ pub mod general_category {
         ('\u{2e2f}', '\u{2e2f}'), ('\u{3005}', '\u{3006}'), ('\u{3031}', '\u{3035}'), ('\u{303b}',
         '\u{303c}'), ('\u{3041}', '\u{3096}'), ('\u{309d}', '\u{309f}'), ('\u{30a1}', '\u{30fa}'),
         ('\u{30fc}', '\u{30ff}'), ('\u{3105}', '\u{312d}'), ('\u{3131}', '\u{318e}'), ('\u{31a0}',
-        '\u{31ba}'), ('\u{31f0}', '\u{31ff}'), ('\u{3400}', '\u{3400}'), ('\u{4db5}', '\u{4db5}'),
-        ('\u{4e00}', '\u{4e00}'), ('\u{9fcc}', '\u{9fcc}'), ('\u{a000}', '\u{a48c}'), ('\u{a4d0}',
-        '\u{a4fd}'), ('\u{a500}', '\u{a60c}'), ('\u{a610}', '\u{a61f}'), ('\u{a62a}', '\u{a62b}'),
-        ('\u{a640}', '\u{a66e}'), ('\u{a67f}', '\u{a69d}'), ('\u{a6a0}', '\u{a6e5}'), ('\u{a717}',
-        '\u{a71f}'), ('\u{a722}', '\u{a788}'), ('\u{a78b}', '\u{a78e}'), ('\u{a790}', '\u{a7ad}'),
-        ('\u{a7b0}', '\u{a7b1}'), ('\u{a7f7}', '\u{a801}'), ('\u{a803}', '\u{a805}'), ('\u{a807}',
-        '\u{a80a}'), ('\u{a80c}', '\u{a822}'), ('\u{a840}', '\u{a873}'), ('\u{a882}', '\u{a8b3}'),
-        ('\u{a8f2}', '\u{a8f7}'), ('\u{a8fb}', '\u{a8fb}'), ('\u{a90a}', '\u{a925}'), ('\u{a930}',
-        '\u{a946}'), ('\u{a960}', '\u{a97c}'), ('\u{a984}', '\u{a9b2}'), ('\u{a9cf}', '\u{a9cf}'),
-        ('\u{a9e0}', '\u{a9e4}'), ('\u{a9e6}', '\u{a9ef}'), ('\u{a9fa}', '\u{a9fe}'), ('\u{aa00}',
-        '\u{aa28}'), ('\u{aa40}', '\u{aa42}'), ('\u{aa44}', '\u{aa4b}'), ('\u{aa60}', '\u{aa76}'),
-        ('\u{aa7a}', '\u{aa7a}'), ('\u{aa7e}', '\u{aaaf}'), ('\u{aab1}', '\u{aab1}'), ('\u{aab5}',
-        '\u{aab6}'), ('\u{aab9}', '\u{aabd}'), ('\u{aac0}', '\u{aac0}'), ('\u{aac2}', '\u{aac2}'),
-        ('\u{aadb}', '\u{aadd}'), ('\u{aae0}', '\u{aaea}'), ('\u{aaf2}', '\u{aaf4}'), ('\u{ab01}',
-        '\u{ab06}'), ('\u{ab09}', '\u{ab0e}'), ('\u{ab11}', '\u{ab16}'), ('\u{ab20}', '\u{ab26}'),
-        ('\u{ab28}', '\u{ab2e}'), ('\u{ab30}', '\u{ab5a}'), ('\u{ab5c}', '\u{ab5f}'), ('\u{ab64}',
-        '\u{ab65}'), ('\u{abc0}', '\u{abe2}'), ('\u{ac00}', '\u{ac00}'), ('\u{d7a3}', '\u{d7a3}'),
-        ('\u{d7b0}', '\u{d7c6}'), ('\u{d7cb}', '\u{d7fb}'), ('\u{f900}', '\u{fa6d}'), ('\u{fa70}',
-        '\u{fad9}'), ('\u{fb00}', '\u{fb06}'), ('\u{fb13}', '\u{fb17}'), ('\u{fb1d}', '\u{fb1d}'),
-        ('\u{fb1f}', '\u{fb28}'), ('\u{fb2a}', '\u{fb36}'), ('\u{fb38}', '\u{fb3c}'), ('\u{fb3e}',
-        '\u{fb3e}'), ('\u{fb40}', '\u{fb41}'), ('\u{fb43}', '\u{fb44}'), ('\u{fb46}', '\u{fbb1}'),
-        ('\u{fbd3}', '\u{fd3d}'), ('\u{fd50}', '\u{fd8f}'), ('\u{fd92}', '\u{fdc7}'), ('\u{fdf0}',
-        '\u{fdfb}'), ('\u{fe70}', '\u{fe74}'), ('\u{fe76}', '\u{fefc}'), ('\u{ff21}', '\u{ff3a}'),
-        ('\u{ff41}', '\u{ff5a}'), ('\u{ff66}', '\u{ffbe}'), ('\u{ffc2}', '\u{ffc7}'), ('\u{ffca}',
-        '\u{ffcf}'), ('\u{ffd2}', '\u{ffd7}'), ('\u{ffda}', '\u{ffdc}'), ('\u{10000}', '\u{1000b}'),
-        ('\u{1000d}', '\u{10026}'), ('\u{10028}', '\u{1003a}'), ('\u{1003c}', '\u{1003d}'),
-        ('\u{1003f}', '\u{1004d}'), ('\u{10050}', '\u{1005d}'), ('\u{10080}', '\u{100fa}'),
-        ('\u{10280}', '\u{1029c}'), ('\u{102a0}', '\u{102d0}'), ('\u{10300}', '\u{1031f}'),
-        ('\u{10330}', '\u{10340}'), ('\u{10342}', '\u{10349}'), ('\u{10350}', '\u{10375}'),
-        ('\u{10380}', '\u{1039d}'), ('\u{103a0}', '\u{103c3}'), ('\u{103c8}', '\u{103cf}'),
-        ('\u{10400}', '\u{1049d}'), ('\u{10500}', '\u{10527}'), ('\u{10530}', '\u{10563}'),
-        ('\u{10600}', '\u{10736}'), ('\u{10740}', '\u{10755}'), ('\u{10760}', '\u{10767}'),
-        ('\u{10800}', '\u{10805}'), ('\u{10808}', '\u{10808}'), ('\u{1080a}', '\u{10835}'),
-        ('\u{10837}', '\u{10838}'), ('\u{1083c}', '\u{1083c}'), ('\u{1083f}', '\u{10855}'),
-        ('\u{10860}', '\u{10876}'), ('\u{10880}', '\u{1089e}'), ('\u{10900}', '\u{10915}'),
-        ('\u{10920}', '\u{10939}'), ('\u{10980}', '\u{109b7}'), ('\u{109be}', '\u{109bf}'),
-        ('\u{10a00}', '\u{10a00}'), ('\u{10a10}', '\u{10a13}'), ('\u{10a15}', '\u{10a17}'),
-        ('\u{10a19}', '\u{10a33}'), ('\u{10a60}', '\u{10a7c}'), ('\u{10a80}', '\u{10a9c}'),
-        ('\u{10ac0}', '\u{10ac7}'), ('\u{10ac9}', '\u{10ae4}'), ('\u{10b00}', '\u{10b35}'),
-        ('\u{10b40}', '\u{10b55}'), ('\u{10b60}', '\u{10b72}'), ('\u{10b80}', '\u{10b91}'),
-        ('\u{10c00}', '\u{10c48}'), ('\u{11003}', '\u{11037}'), ('\u{11083}', '\u{110af}'),
-        ('\u{110d0}', '\u{110e8}'), ('\u{11103}', '\u{11126}'), ('\u{11150}', '\u{11172}'),
-        ('\u{11176}', '\u{11176}'), ('\u{11183}', '\u{111b2}'), ('\u{111c1}', '\u{111c4}'),
-        ('\u{111da}', '\u{111da}'), ('\u{11200}', '\u{11211}'), ('\u{11213}', '\u{1122b}'),
-        ('\u{112b0}', '\u{112de}'), ('\u{11305}', '\u{1130c}'), ('\u{1130f}', '\u{11310}'),
-        ('\u{11313}', '\u{11328}'), ('\u{1132a}', '\u{11330}'), ('\u{11332}', '\u{11333}'),
-        ('\u{11335}', '\u{11339}'), ('\u{1133d}', '\u{1133d}'), ('\u{1135d}', '\u{11361}'),
-        ('\u{11480}', '\u{114af}'), ('\u{114c4}', '\u{114c5}'), ('\u{114c7}', '\u{114c7}'),
-        ('\u{11580}', '\u{115ae}'), ('\u{11600}', '\u{1162f}'), ('\u{11644}', '\u{11644}'),
-        ('\u{11680}', '\u{116aa}'), ('\u{118a0}', '\u{118df}'), ('\u{118ff}', '\u{118ff}'),
-        ('\u{11ac0}', '\u{11af8}'), ('\u{12000}', '\u{12398}'), ('\u{13000}', '\u{1342e}'),
-        ('\u{16800}', '\u{16a38}'), ('\u{16a40}', '\u{16a5e}'), ('\u{16ad0}', '\u{16aed}'),
-        ('\u{16b00}', '\u{16b2f}'), ('\u{16b40}', '\u{16b43}'), ('\u{16b63}', '\u{16b77}'),
-        ('\u{16b7d}', '\u{16b8f}'), ('\u{16f00}', '\u{16f44}'), ('\u{16f50}', '\u{16f50}'),
-        ('\u{16f93}', '\u{16f9f}'), ('\u{1b000}', '\u{1b001}'), ('\u{1bc00}', '\u{1bc6a}'),
-        ('\u{1bc70}', '\u{1bc7c}'), ('\u{1bc80}', '\u{1bc88}'), ('\u{1bc90}', '\u{1bc99}'),
-        ('\u{1d400}', '\u{1d454}'), ('\u{1d456}', '\u{1d49c}'), ('\u{1d49e}', '\u{1d49f}'),
-        ('\u{1d4a2}', '\u{1d4a2}'), ('\u{1d4a5}', '\u{1d4a6}'), ('\u{1d4a9}', '\u{1d4ac}'),
-        ('\u{1d4ae}', '\u{1d4b9}'), ('\u{1d4bb}', '\u{1d4bb}'), ('\u{1d4bd}', '\u{1d4c3}'),
-        ('\u{1d4c5}', '\u{1d505}'), ('\u{1d507}', '\u{1d50a}'), ('\u{1d50d}', '\u{1d514}'),
-        ('\u{1d516}', '\u{1d51c}'), ('\u{1d51e}', '\u{1d539}'), ('\u{1d53b}', '\u{1d53e}'),
-        ('\u{1d540}', '\u{1d544}'), ('\u{1d546}', '\u{1d546}'), ('\u{1d54a}', '\u{1d550}'),
-        ('\u{1d552}', '\u{1d6a5}'), ('\u{1d6a8}', '\u{1d6c0}'), ('\u{1d6c2}', '\u{1d6da}'),
-        ('\u{1d6dc}', '\u{1d6fa}'), ('\u{1d6fc}', '\u{1d714}'), ('\u{1d716}', '\u{1d734}'),
-        ('\u{1d736}', '\u{1d74e}'), ('\u{1d750}', '\u{1d76e}'), ('\u{1d770}', '\u{1d788}'),
-        ('\u{1d78a}', '\u{1d7a8}'), ('\u{1d7aa}', '\u{1d7c2}'), ('\u{1d7c4}', '\u{1d7cb}'),
-        ('\u{1e800}', '\u{1e8c4}'), ('\u{1ee00}', '\u{1ee03}'), ('\u{1ee05}', '\u{1ee1f}'),
-        ('\u{1ee21}', '\u{1ee22}'), ('\u{1ee24}', '\u{1ee24}'), ('\u{1ee27}', '\u{1ee27}'),
-        ('\u{1ee29}', '\u{1ee32}'), ('\u{1ee34}', '\u{1ee37}'), ('\u{1ee39}', '\u{1ee39}'),
-        ('\u{1ee3b}', '\u{1ee3b}'), ('\u{1ee42}', '\u{1ee42}'), ('\u{1ee47}', '\u{1ee47}'),
-        ('\u{1ee49}', '\u{1ee49}'), ('\u{1ee4b}', '\u{1ee4b}'), ('\u{1ee4d}', '\u{1ee4f}'),
-        ('\u{1ee51}', '\u{1ee52}'), ('\u{1ee54}', '\u{1ee54}'), ('\u{1ee57}', '\u{1ee57}'),
-        ('\u{1ee59}', '\u{1ee59}'), ('\u{1ee5b}', '\u{1ee5b}'), ('\u{1ee5d}', '\u{1ee5d}'),
-        ('\u{1ee5f}', '\u{1ee5f}'), ('\u{1ee61}', '\u{1ee62}'), ('\u{1ee64}', '\u{1ee64}'),
-        ('\u{1ee67}', '\u{1ee6a}'), ('\u{1ee6c}', '\u{1ee72}'), ('\u{1ee74}', '\u{1ee77}'),
-        ('\u{1ee79}', '\u{1ee7c}'), ('\u{1ee7e}', '\u{1ee7e}'), ('\u{1ee80}', '\u{1ee89}'),
-        ('\u{1ee8b}', '\u{1ee9b}'), ('\u{1eea1}', '\u{1eea3}'), ('\u{1eea5}', '\u{1eea9}'),
-        ('\u{1eeab}', '\u{1eebb}'), ('\u{20000}', '\u{20000}'), ('\u{2a6d6}', '\u{2a6d6}'),
-        ('\u{2a700}', '\u{2a700}'), ('\u{2b734}', '\u{2b734}'), ('\u{2b740}', '\u{2b740}'),
-        ('\u{2b81d}', '\u{2b81d}'), ('\u{2f800}', '\u{2fa1d}')
+        '\u{31ba}'), ('\u{31f0}', '\u{31ff}'), ('\u{3400}', '\u{4db5}'), ('\u{4e00}', '\u{9fcc}'),
+        ('\u{a000}', '\u{a48c}'), ('\u{a4d0}', '\u{a4fd}'), ('\u{a500}', '\u{a60c}'), ('\u{a610}',
+        '\u{a61f}'), ('\u{a62a}', '\u{a62b}'), ('\u{a640}', '\u{a66e}'), ('\u{a67f}', '\u{a69d}'),
+        ('\u{a6a0}', '\u{a6e5}'), ('\u{a717}', '\u{a71f}'), ('\u{a722}', '\u{a788}'), ('\u{a78b}',
+        '\u{a78e}'), ('\u{a790}', '\u{a7ad}'), ('\u{a7b0}', '\u{a7b1}'), ('\u{a7f7}', '\u{a801}'),
+        ('\u{a803}', '\u{a805}'), ('\u{a807}', '\u{a80a}'), ('\u{a80c}', '\u{a822}'), ('\u{a840}',
+        '\u{a873}'), ('\u{a882}', '\u{a8b3}'), ('\u{a8f2}', '\u{a8f7}'), ('\u{a8fb}', '\u{a8fb}'),
+        ('\u{a90a}', '\u{a925}'), ('\u{a930}', '\u{a946}'), ('\u{a960}', '\u{a97c}'), ('\u{a984}',
+        '\u{a9b2}'), ('\u{a9cf}', '\u{a9cf}'), ('\u{a9e0}', '\u{a9e4}'), ('\u{a9e6}', '\u{a9ef}'),
+        ('\u{a9fa}', '\u{a9fe}'), ('\u{aa00}', '\u{aa28}'), ('\u{aa40}', '\u{aa42}'), ('\u{aa44}',
+        '\u{aa4b}'), ('\u{aa60}', '\u{aa76}'), ('\u{aa7a}', '\u{aa7a}'), ('\u{aa7e}', '\u{aaaf}'),
+        ('\u{aab1}', '\u{aab1}'), ('\u{aab5}', '\u{aab6}'), ('\u{aab9}', '\u{aabd}'), ('\u{aac0}',
+        '\u{aac0}'), ('\u{aac2}', '\u{aac2}'), ('\u{aadb}', '\u{aadd}'), ('\u{aae0}', '\u{aaea}'),
+        ('\u{aaf2}', '\u{aaf4}'), ('\u{ab01}', '\u{ab06}'), ('\u{ab09}', '\u{ab0e}'), ('\u{ab11}',
+        '\u{ab16}'), ('\u{ab20}', '\u{ab26}'), ('\u{ab28}', '\u{ab2e}'), ('\u{ab30}', '\u{ab5a}'),
+        ('\u{ab5c}', '\u{ab5f}'), ('\u{ab64}', '\u{ab65}'), ('\u{abc0}', '\u{abe2}'), ('\u{ac00}',
+        '\u{d7a3}'), ('\u{d7b0}', '\u{d7c6}'), ('\u{d7cb}', '\u{d7fb}'), ('\u{f900}', '\u{fa6d}'),
+        ('\u{fa70}', '\u{fad9}'), ('\u{fb00}', '\u{fb06}'), ('\u{fb13}', '\u{fb17}'), ('\u{fb1d}',
+        '\u{fb1d}'), ('\u{fb1f}', '\u{fb28}'), ('\u{fb2a}', '\u{fb36}'), ('\u{fb38}', '\u{fb3c}'),
+        ('\u{fb3e}', '\u{fb3e}'), ('\u{fb40}', '\u{fb41}'), ('\u{fb43}', '\u{fb44}'), ('\u{fb46}',
+        '\u{fbb1}'), ('\u{fbd3}', '\u{fd3d}'), ('\u{fd50}', '\u{fd8f}'), ('\u{fd92}', '\u{fdc7}'),
+        ('\u{fdf0}', '\u{fdfb}'), ('\u{fe70}', '\u{fe74}'), ('\u{fe76}', '\u{fefc}'), ('\u{ff21}',
+        '\u{ff3a}'), ('\u{ff41}', '\u{ff5a}'), ('\u{ff66}', '\u{ffbe}'), ('\u{ffc2}', '\u{ffc7}'),
+        ('\u{ffca}', '\u{ffcf}'), ('\u{ffd2}', '\u{ffd7}'), ('\u{ffda}', '\u{ffdc}'), ('\u{10000}',
+        '\u{1000b}'), ('\u{1000d}', '\u{10026}'), ('\u{10028}', '\u{1003a}'), ('\u{1003c}',
+        '\u{1003d}'), ('\u{1003f}', '\u{1004d}'), ('\u{10050}', '\u{1005d}'), ('\u{10080}',
+        '\u{100fa}'), ('\u{10280}', '\u{1029c}'), ('\u{102a0}', '\u{102d0}'), ('\u{10300}',
+        '\u{1031f}'), ('\u{10330}', '\u{10340}'), ('\u{10342}', '\u{10349}'), ('\u{10350}',
+        '\u{10375}'), ('\u{10380}', '\u{1039d}'), ('\u{103a0}', '\u{103c3}'), ('\u{103c8}',
+        '\u{103cf}'), ('\u{10400}', '\u{1049d}'), ('\u{10500}', '\u{10527}'), ('\u{10530}',
+        '\u{10563}'), ('\u{10600}', '\u{10736}'), ('\u{10740}', '\u{10755}'), ('\u{10760}',
+        '\u{10767}'), ('\u{10800}', '\u{10805}'), ('\u{10808}', '\u{10808}'), ('\u{1080a}',
+        '\u{10835}'), ('\u{10837}', '\u{10838}'), ('\u{1083c}', '\u{1083c}'), ('\u{1083f}',
+        '\u{10855}'), ('\u{10860}', '\u{10876}'), ('\u{10880}', '\u{1089e}'), ('\u{10900}',
+        '\u{10915}'), ('\u{10920}', '\u{10939}'), ('\u{10980}', '\u{109b7}'), ('\u{109be}',
+        '\u{109bf}'), ('\u{10a00}', '\u{10a00}'), ('\u{10a10}', '\u{10a13}'), ('\u{10a15}',
+        '\u{10a17}'), ('\u{10a19}', '\u{10a33}'), ('\u{10a60}', '\u{10a7c}'), ('\u{10a80}',
+        '\u{10a9c}'), ('\u{10ac0}', '\u{10ac7}'), ('\u{10ac9}', '\u{10ae4}'), ('\u{10b00}',
+        '\u{10b35}'), ('\u{10b40}', '\u{10b55}'), ('\u{10b60}', '\u{10b72}'), ('\u{10b80}',
+        '\u{10b91}'), ('\u{10c00}', '\u{10c48}'), ('\u{11003}', '\u{11037}'), ('\u{11083}',
+        '\u{110af}'), ('\u{110d0}', '\u{110e8}'), ('\u{11103}', '\u{11126}'), ('\u{11150}',
+        '\u{11172}'), ('\u{11176}', '\u{11176}'), ('\u{11183}', '\u{111b2}'), ('\u{111c1}',
+        '\u{111c4}'), ('\u{111da}', '\u{111da}'), ('\u{11200}', '\u{11211}'), ('\u{11213}',
+        '\u{1122b}'), ('\u{112b0}', '\u{112de}'), ('\u{11305}', '\u{1130c}'), ('\u{1130f}',
+        '\u{11310}'), ('\u{11313}', '\u{11328}'), ('\u{1132a}', '\u{11330}'), ('\u{11332}',
+        '\u{11333}'), ('\u{11335}', '\u{11339}'), ('\u{1133d}', '\u{1133d}'), ('\u{1135d}',
+        '\u{11361}'), ('\u{11480}', '\u{114af}'), ('\u{114c4}', '\u{114c5}'), ('\u{114c7}',
+        '\u{114c7}'), ('\u{11580}', '\u{115ae}'), ('\u{11600}', '\u{1162f}'), ('\u{11644}',
+        '\u{11644}'), ('\u{11680}', '\u{116aa}'), ('\u{118a0}', '\u{118df}'), ('\u{118ff}',
+        '\u{118ff}'), ('\u{11ac0}', '\u{11af8}'), ('\u{12000}', '\u{12398}'), ('\u{13000}',
+        '\u{1342e}'), ('\u{16800}', '\u{16a38}'), ('\u{16a40}', '\u{16a5e}'), ('\u{16ad0}',
+        '\u{16aed}'), ('\u{16b00}', '\u{16b2f}'), ('\u{16b40}', '\u{16b43}'), ('\u{16b63}',
+        '\u{16b77}'), ('\u{16b7d}', '\u{16b8f}'), ('\u{16f00}', '\u{16f44}'), ('\u{16f50}',
+        '\u{16f50}'), ('\u{16f93}', '\u{16f9f}'), ('\u{1b000}', '\u{1b001}'), ('\u{1bc00}',
+        '\u{1bc6a}'), ('\u{1bc70}', '\u{1bc7c}'), ('\u{1bc80}', '\u{1bc88}'), ('\u{1bc90}',
+        '\u{1bc99}'), ('\u{1d400}', '\u{1d454}'), ('\u{1d456}', '\u{1d49c}'), ('\u{1d49e}',
+        '\u{1d49f}'), ('\u{1d4a2}', '\u{1d4a2}'), ('\u{1d4a5}', '\u{1d4a6}'), ('\u{1d4a9}',
+        '\u{1d4ac}'), ('\u{1d4ae}', '\u{1d4b9}'), ('\u{1d4bb}', '\u{1d4bb}'), ('\u{1d4bd}',
+        '\u{1d4c3}'), ('\u{1d4c5}', '\u{1d505}'), ('\u{1d507}', '\u{1d50a}'), ('\u{1d50d}',
+        '\u{1d514}'), ('\u{1d516}', '\u{1d51c}'), ('\u{1d51e}', '\u{1d539}'), ('\u{1d53b}',
+        '\u{1d53e}'), ('\u{1d540}', '\u{1d544}'), ('\u{1d546}', '\u{1d546}'), ('\u{1d54a}',
+        '\u{1d550}'), ('\u{1d552}', '\u{1d6a5}'), ('\u{1d6a8}', '\u{1d6c0}'), ('\u{1d6c2}',
+        '\u{1d6da}'), ('\u{1d6dc}', '\u{1d6fa}'), ('\u{1d6fc}', '\u{1d714}'), ('\u{1d716}',
+        '\u{1d734}'), ('\u{1d736}', '\u{1d74e}'), ('\u{1d750}', '\u{1d76e}'), ('\u{1d770}',
+        '\u{1d788}'), ('\u{1d78a}', '\u{1d7a8}'), ('\u{1d7aa}', '\u{1d7c2}'), ('\u{1d7c4}',
+        '\u{1d7cb}'), ('\u{1e800}', '\u{1e8c4}'), ('\u{1ee00}', '\u{1ee03}'), ('\u{1ee05}',
+        '\u{1ee1f}'), ('\u{1ee21}', '\u{1ee22}'), ('\u{1ee24}', '\u{1ee24}'), ('\u{1ee27}',
+        '\u{1ee27}'), ('\u{1ee29}', '\u{1ee32}'), ('\u{1ee34}', '\u{1ee37}'), ('\u{1ee39}',
+        '\u{1ee39}'), ('\u{1ee3b}', '\u{1ee3b}'), ('\u{1ee42}', '\u{1ee42}'), ('\u{1ee47}',
+        '\u{1ee47}'), ('\u{1ee49}', '\u{1ee49}'), ('\u{1ee4b}', '\u{1ee4b}'), ('\u{1ee4d}',
+        '\u{1ee4f}'), ('\u{1ee51}', '\u{1ee52}'), ('\u{1ee54}', '\u{1ee54}'), ('\u{1ee57}',
+        '\u{1ee57}'), ('\u{1ee59}', '\u{1ee59}'), ('\u{1ee5b}', '\u{1ee5b}'), ('\u{1ee5d}',
+        '\u{1ee5d}'), ('\u{1ee5f}', '\u{1ee5f}'), ('\u{1ee61}', '\u{1ee62}'), ('\u{1ee64}',
+        '\u{1ee64}'), ('\u{1ee67}', '\u{1ee6a}'), ('\u{1ee6c}', '\u{1ee72}'), ('\u{1ee74}',
+        '\u{1ee77}'), ('\u{1ee79}', '\u{1ee7c}'), ('\u{1ee7e}', '\u{1ee7e}'), ('\u{1ee80}',
+        '\u{1ee89}'), ('\u{1ee8b}', '\u{1ee9b}'), ('\u{1eea1}', '\u{1eea3}'), ('\u{1eea5}',
+        '\u{1eea9}'), ('\u{1eeab}', '\u{1eebb}'), ('\u{20000}', '\u{2a6d6}'), ('\u{2a700}',
+        '\u{2b734}'), ('\u{2b740}', '\u{2b81d}'), ('\u{2f800}', '\u{2fa1d}')
     ];
 
     pub const LC_table: &'static [(char, char)] = &[
@@ -896,72 +888,71 @@ pub mod general_category {
         '\u{2dd6}'), ('\u{2dd8}', '\u{2dde}'), ('\u{3006}', '\u{3006}'), ('\u{303c}', '\u{303c}'),
         ('\u{3041}', '\u{3096}'), ('\u{309f}', '\u{309f}'), ('\u{30a1}', '\u{30fa}'), ('\u{30ff}',
         '\u{30ff}'), ('\u{3105}', '\u{312d}'), ('\u{3131}', '\u{318e}'), ('\u{31a0}', '\u{31ba}'),
-        ('\u{31f0}', '\u{31ff}'), ('\u{3400}', '\u{3400}'), ('\u{4db5}', '\u{4db5}'), ('\u{4e00}',
-        '\u{4e00}'), ('\u{9fcc}', '\u{9fcc}'), ('\u{a000}', '\u{a014}'), ('\u{a016}', '\u{a48c}'),
-        ('\u{a4d0}', '\u{a4f7}'), ('\u{a500}', '\u{a60b}'), ('\u{a610}', '\u{a61f}'), ('\u{a62a}',
-        '\u{a62b}'), ('\u{a66e}', '\u{a66e}'), ('\u{a6a0}', '\u{a6e5}'), ('\u{a7f7}', '\u{a7f7}'),
-        ('\u{a7fb}', '\u{a801}'), ('\u{a803}', '\u{a805}'), ('\u{a807}', '\u{a80a}'), ('\u{a80c}',
-        '\u{a822}'), ('\u{a840}', '\u{a873}'), ('\u{a882}', '\u{a8b3}'), ('\u{a8f2}', '\u{a8f7}'),
-        ('\u{a8fb}', '\u{a8fb}'), ('\u{a90a}', '\u{a925}'), ('\u{a930}', '\u{a946}'), ('\u{a960}',
-        '\u{a97c}'), ('\u{a984}', '\u{a9b2}'), ('\u{a9e0}', '\u{a9e4}'), ('\u{a9e7}', '\u{a9ef}'),
-        ('\u{a9fa}', '\u{a9fe}'), ('\u{aa00}', '\u{aa28}'), ('\u{aa40}', '\u{aa42}'), ('\u{aa44}',
-        '\u{aa4b}'), ('\u{aa60}', '\u{aa6f}'), ('\u{aa71}', '\u{aa76}'), ('\u{aa7a}', '\u{aa7a}'),
-        ('\u{aa7e}', '\u{aaaf}'), ('\u{aab1}', '\u{aab1}'), ('\u{aab5}', '\u{aab6}'), ('\u{aab9}',
-        '\u{aabd}'), ('\u{aac0}', '\u{aac0}'), ('\u{aac2}', '\u{aac2}'), ('\u{aadb}', '\u{aadc}'),
-        ('\u{aae0}', '\u{aaea}'), ('\u{aaf2}', '\u{aaf2}'), ('\u{ab01}', '\u{ab06}'), ('\u{ab09}',
-        '\u{ab0e}'), ('\u{ab11}', '\u{ab16}'), ('\u{ab20}', '\u{ab26}'), ('\u{ab28}', '\u{ab2e}'),
-        ('\u{abc0}', '\u{abe2}'), ('\u{ac00}', '\u{ac00}'), ('\u{d7a3}', '\u{d7a3}'), ('\u{d7b0}',
-        '\u{d7c6}'), ('\u{d7cb}', '\u{d7fb}'), ('\u{f900}', '\u{fa6d}'), ('\u{fa70}', '\u{fad9}'),
-        ('\u{fb1d}', '\u{fb1d}'), ('\u{fb1f}', '\u{fb28}'), ('\u{fb2a}', '\u{fb36}'), ('\u{fb38}',
-        '\u{fb3c}'), ('\u{fb3e}', '\u{fb3e}'), ('\u{fb40}', '\u{fb41}'), ('\u{fb43}', '\u{fb44}'),
-        ('\u{fb46}', '\u{fbb1}'), ('\u{fbd3}', '\u{fd3d}'), ('\u{fd50}', '\u{fd8f}'), ('\u{fd92}',
-        '\u{fdc7}'), ('\u{fdf0}', '\u{fdfb}'), ('\u{fe70}', '\u{fe74}'), ('\u{fe76}', '\u{fefc}'),
-        ('\u{ff66}', '\u{ff6f}'), ('\u{ff71}', '\u{ff9d}'), ('\u{ffa0}', '\u{ffbe}'), ('\u{ffc2}',
-        '\u{ffc7}'), ('\u{ffca}', '\u{ffcf}'), ('\u{ffd2}', '\u{ffd7}'), ('\u{ffda}', '\u{ffdc}'),
-        ('\u{10000}', '\u{1000b}'), ('\u{1000d}', '\u{10026}'), ('\u{10028}', '\u{1003a}'),
-        ('\u{1003c}', '\u{1003d}'), ('\u{1003f}', '\u{1004d}'), ('\u{10050}', '\u{1005d}'),
-        ('\u{10080}', '\u{100fa}'), ('\u{10280}', '\u{1029c}'), ('\u{102a0}', '\u{102d0}'),
-        ('\u{10300}', '\u{1031f}'), ('\u{10330}', '\u{10340}'), ('\u{10342}', '\u{10349}'),
-        ('\u{10350}', '\u{10375}'), ('\u{10380}', '\u{1039d}'), ('\u{103a0}', '\u{103c3}'),
-        ('\u{103c8}', '\u{103cf}'), ('\u{10450}', '\u{1049d}'), ('\u{10500}', '\u{10527}'),
-        ('\u{10530}', '\u{10563}'), ('\u{10600}', '\u{10736}'), ('\u{10740}', '\u{10755}'),
-        ('\u{10760}', '\u{10767}'), ('\u{10800}', '\u{10805}'), ('\u{10808}', '\u{10808}'),
-        ('\u{1080a}', '\u{10835}'), ('\u{10837}', '\u{10838}'), ('\u{1083c}', '\u{1083c}'),
-        ('\u{1083f}', '\u{10855}'), ('\u{10860}', '\u{10876}'), ('\u{10880}', '\u{1089e}'),
-        ('\u{10900}', '\u{10915}'), ('\u{10920}', '\u{10939}'), ('\u{10980}', '\u{109b7}'),
-        ('\u{109be}', '\u{109bf}'), ('\u{10a00}', '\u{10a00}'), ('\u{10a10}', '\u{10a13}'),
-        ('\u{10a15}', '\u{10a17}'), ('\u{10a19}', '\u{10a33}'), ('\u{10a60}', '\u{10a7c}'),
-        ('\u{10a80}', '\u{10a9c}'), ('\u{10ac0}', '\u{10ac7}'), ('\u{10ac9}', '\u{10ae4}'),
-        ('\u{10b00}', '\u{10b35}'), ('\u{10b40}', '\u{10b55}'), ('\u{10b60}', '\u{10b72}'),
-        ('\u{10b80}', '\u{10b91}'), ('\u{10c00}', '\u{10c48}'), ('\u{11003}', '\u{11037}'),
-        ('\u{11083}', '\u{110af}'), ('\u{110d0}', '\u{110e8}'), ('\u{11103}', '\u{11126}'),
-        ('\u{11150}', '\u{11172}'), ('\u{11176}', '\u{11176}'), ('\u{11183}', '\u{111b2}'),
-        ('\u{111c1}', '\u{111c4}'), ('\u{111da}', '\u{111da}'), ('\u{11200}', '\u{11211}'),
-        ('\u{11213}', '\u{1122b}'), ('\u{112b0}', '\u{112de}'), ('\u{11305}', '\u{1130c}'),
-        ('\u{1130f}', '\u{11310}'), ('\u{11313}', '\u{11328}'), ('\u{1132a}', '\u{11330}'),
-        ('\u{11332}', '\u{11333}'), ('\u{11335}', '\u{11339}'), ('\u{1133d}', '\u{1133d}'),
-        ('\u{1135d}', '\u{11361}'), ('\u{11480}', '\u{114af}'), ('\u{114c4}', '\u{114c5}'),
-        ('\u{114c7}', '\u{114c7}'), ('\u{11580}', '\u{115ae}'), ('\u{11600}', '\u{1162f}'),
-        ('\u{11644}', '\u{11644}'), ('\u{11680}', '\u{116aa}'), ('\u{118ff}', '\u{118ff}'),
-        ('\u{11ac0}', '\u{11af8}'), ('\u{12000}', '\u{12398}'), ('\u{13000}', '\u{1342e}'),
-        ('\u{16800}', '\u{16a38}'), ('\u{16a40}', '\u{16a5e}'), ('\u{16ad0}', '\u{16aed}'),
-        ('\u{16b00}', '\u{16b2f}'), ('\u{16b63}', '\u{16b77}'), ('\u{16b7d}', '\u{16b8f}'),
-        ('\u{16f00}', '\u{16f44}'), ('\u{16f50}', '\u{16f50}'), ('\u{1b000}', '\u{1b001}'),
-        ('\u{1bc00}', '\u{1bc6a}'), ('\u{1bc70}', '\u{1bc7c}'), ('\u{1bc80}', '\u{1bc88}'),
-        ('\u{1bc90}', '\u{1bc99}'), ('\u{1e800}', '\u{1e8c4}'), ('\u{1ee00}', '\u{1ee03}'),
-        ('\u{1ee05}', '\u{1ee1f}'), ('\u{1ee21}', '\u{1ee22}'), ('\u{1ee24}', '\u{1ee24}'),
-        ('\u{1ee27}', '\u{1ee27}'), ('\u{1ee29}', '\u{1ee32}'), ('\u{1ee34}', '\u{1ee37}'),
-        ('\u{1ee39}', '\u{1ee39}'), ('\u{1ee3b}', '\u{1ee3b}'), ('\u{1ee42}', '\u{1ee42}'),
-        ('\u{1ee47}', '\u{1ee47}'), ('\u{1ee49}', '\u{1ee49}'), ('\u{1ee4b}', '\u{1ee4b}'),
-        ('\u{1ee4d}', '\u{1ee4f}'), ('\u{1ee51}', '\u{1ee52}'), ('\u{1ee54}', '\u{1ee54}'),
-        ('\u{1ee57}', '\u{1ee57}'), ('\u{1ee59}', '\u{1ee59}'), ('\u{1ee5b}', '\u{1ee5b}'),
-        ('\u{1ee5d}', '\u{1ee5d}'), ('\u{1ee5f}', '\u{1ee5f}'), ('\u{1ee61}', '\u{1ee62}'),
-        ('\u{1ee64}', '\u{1ee64}'), ('\u{1ee67}', '\u{1ee6a}'), ('\u{1ee6c}', '\u{1ee72}'),
-        ('\u{1ee74}', '\u{1ee77}'), ('\u{1ee79}', '\u{1ee7c}'), ('\u{1ee7e}', '\u{1ee7e}'),
-        ('\u{1ee80}', '\u{1ee89}'), ('\u{1ee8b}', '\u{1ee9b}'), ('\u{1eea1}', '\u{1eea3}'),
-        ('\u{1eea5}', '\u{1eea9}'), ('\u{1eeab}', '\u{1eebb}'), ('\u{20000}', '\u{20000}'),
-        ('\u{2a6d6}', '\u{2a6d6}'), ('\u{2a700}', '\u{2a700}'), ('\u{2b734}', '\u{2b734}'),
-        ('\u{2b740}', '\u{2b740}'), ('\u{2b81d}', '\u{2b81d}'), ('\u{2f800}', '\u{2fa1d}')
+        ('\u{31f0}', '\u{31ff}'), ('\u{3400}', '\u{4db5}'), ('\u{4e00}', '\u{9fcc}'), ('\u{a000}',
+        '\u{a014}'), ('\u{a016}', '\u{a48c}'), ('\u{a4d0}', '\u{a4f7}'), ('\u{a500}', '\u{a60b}'),
+        ('\u{a610}', '\u{a61f}'), ('\u{a62a}', '\u{a62b}'), ('\u{a66e}', '\u{a66e}'), ('\u{a6a0}',
+        '\u{a6e5}'), ('\u{a7f7}', '\u{a7f7}'), ('\u{a7fb}', '\u{a801}'), ('\u{a803}', '\u{a805}'),
+        ('\u{a807}', '\u{a80a}'), ('\u{a80c}', '\u{a822}'), ('\u{a840}', '\u{a873}'), ('\u{a882}',
+        '\u{a8b3}'), ('\u{a8f2}', '\u{a8f7}'), ('\u{a8fb}', '\u{a8fb}'), ('\u{a90a}', '\u{a925}'),
+        ('\u{a930}', '\u{a946}'), ('\u{a960}', '\u{a97c}'), ('\u{a984}', '\u{a9b2}'), ('\u{a9e0}',
+        '\u{a9e4}'), ('\u{a9e7}', '\u{a9ef}'), ('\u{a9fa}', '\u{a9fe}'), ('\u{aa00}', '\u{aa28}'),
+        ('\u{aa40}', '\u{aa42}'), ('\u{aa44}', '\u{aa4b}'), ('\u{aa60}', '\u{aa6f}'), ('\u{aa71}',
+        '\u{aa76}'), ('\u{aa7a}', '\u{aa7a}'), ('\u{aa7e}', '\u{aaaf}'), ('\u{aab1}', '\u{aab1}'),
+        ('\u{aab5}', '\u{aab6}'), ('\u{aab9}', '\u{aabd}'), ('\u{aac0}', '\u{aac0}'), ('\u{aac2}',
+        '\u{aac2}'), ('\u{aadb}', '\u{aadc}'), ('\u{aae0}', '\u{aaea}'), ('\u{aaf2}', '\u{aaf2}'),
+        ('\u{ab01}', '\u{ab06}'), ('\u{ab09}', '\u{ab0e}'), ('\u{ab11}', '\u{ab16}'), ('\u{ab20}',
+        '\u{ab26}'), ('\u{ab28}', '\u{ab2e}'), ('\u{abc0}', '\u{abe2}'), ('\u{ac00}', '\u{d7a3}'),
+        ('\u{d7b0}', '\u{d7c6}'), ('\u{d7cb}', '\u{d7fb}'), ('\u{f900}', '\u{fa6d}'), ('\u{fa70}',
+        '\u{fad9}'), ('\u{fb1d}', '\u{fb1d}'), ('\u{fb1f}', '\u{fb28}'), ('\u{fb2a}', '\u{fb36}'),
+        ('\u{fb38}', '\u{fb3c}'), ('\u{fb3e}', '\u{fb3e}'), ('\u{fb40}', '\u{fb41}'), ('\u{fb43}',
+        '\u{fb44}'), ('\u{fb46}', '\u{fbb1}'), ('\u{fbd3}', '\u{fd3d}'), ('\u{fd50}', '\u{fd8f}'),
+        ('\u{fd92}', '\u{fdc7}'), ('\u{fdf0}', '\u{fdfb}'), ('\u{fe70}', '\u{fe74}'), ('\u{fe76}',
+        '\u{fefc}'), ('\u{ff66}', '\u{ff6f}'), ('\u{ff71}', '\u{ff9d}'), ('\u{ffa0}', '\u{ffbe}'),
+        ('\u{ffc2}', '\u{ffc7}'), ('\u{ffca}', '\u{ffcf}'), ('\u{ffd2}', '\u{ffd7}'), ('\u{ffda}',
+        '\u{ffdc}'), ('\u{10000}', '\u{1000b}'), ('\u{1000d}', '\u{10026}'), ('\u{10028}',
+        '\u{1003a}'), ('\u{1003c}', '\u{1003d}'), ('\u{1003f}', '\u{1004d}'), ('\u{10050}',
+        '\u{1005d}'), ('\u{10080}', '\u{100fa}'), ('\u{10280}', '\u{1029c}'), ('\u{102a0}',
+        '\u{102d0}'), ('\u{10300}', '\u{1031f}'), ('\u{10330}', '\u{10340}'), ('\u{10342}',
+        '\u{10349}'), ('\u{10350}', '\u{10375}'), ('\u{10380}', '\u{1039d}'), ('\u{103a0}',
+        '\u{103c3}'), ('\u{103c8}', '\u{103cf}'), ('\u{10450}', '\u{1049d}'), ('\u{10500}',
+        '\u{10527}'), ('\u{10530}', '\u{10563}'), ('\u{10600}', '\u{10736}'), ('\u{10740}',
+        '\u{10755}'), ('\u{10760}', '\u{10767}'), ('\u{10800}', '\u{10805}'), ('\u{10808}',
+        '\u{10808}'), ('\u{1080a}', '\u{10835}'), ('\u{10837}', '\u{10838}'), ('\u{1083c}',
+        '\u{1083c}'), ('\u{1083f}', '\u{10855}'), ('\u{10860}', '\u{10876}'), ('\u{10880}',
+        '\u{1089e}'), ('\u{10900}', '\u{10915}'), ('\u{10920}', '\u{10939}'), ('\u{10980}',
+        '\u{109b7}'), ('\u{109be}', '\u{109bf}'), ('\u{10a00}', '\u{10a00}'), ('\u{10a10}',
+        '\u{10a13}'), ('\u{10a15}', '\u{10a17}'), ('\u{10a19}', '\u{10a33}'), ('\u{10a60}',
+        '\u{10a7c}'), ('\u{10a80}', '\u{10a9c}'), ('\u{10ac0}', '\u{10ac7}'), ('\u{10ac9}',
+        '\u{10ae4}'), ('\u{10b00}', '\u{10b35}'), ('\u{10b40}', '\u{10b55}'), ('\u{10b60}',
+        '\u{10b72}'), ('\u{10b80}', '\u{10b91}'), ('\u{10c00}', '\u{10c48}'), ('\u{11003}',
+        '\u{11037}'), ('\u{11083}', '\u{110af}'), ('\u{110d0}', '\u{110e8}'), ('\u{11103}',
+        '\u{11126}'), ('\u{11150}', '\u{11172}'), ('\u{11176}', '\u{11176}'), ('\u{11183}',
+        '\u{111b2}'), ('\u{111c1}', '\u{111c4}'), ('\u{111da}', '\u{111da}'), ('\u{11200}',
+        '\u{11211}'), ('\u{11213}', '\u{1122b}'), ('\u{112b0}', '\u{112de}'), ('\u{11305}',
+        '\u{1130c}'), ('\u{1130f}', '\u{11310}'), ('\u{11313}', '\u{11328}'), ('\u{1132a}',
+        '\u{11330}'), ('\u{11332}', '\u{11333}'), ('\u{11335}', '\u{11339}'), ('\u{1133d}',
+        '\u{1133d}'), ('\u{1135d}', '\u{11361}'), ('\u{11480}', '\u{114af}'), ('\u{114c4}',
+        '\u{114c5}'), ('\u{114c7}', '\u{114c7}'), ('\u{11580}', '\u{115ae}'), ('\u{11600}',
+        '\u{1162f}'), ('\u{11644}', '\u{11644}'), ('\u{11680}', '\u{116aa}'), ('\u{118ff}',
+        '\u{118ff}'), ('\u{11ac0}', '\u{11af8}'), ('\u{12000}', '\u{12398}'), ('\u{13000}',
+        '\u{1342e}'), ('\u{16800}', '\u{16a38}'), ('\u{16a40}', '\u{16a5e}'), ('\u{16ad0}',
+        '\u{16aed}'), ('\u{16b00}', '\u{16b2f}'), ('\u{16b63}', '\u{16b77}'), ('\u{16b7d}',
+        '\u{16b8f}'), ('\u{16f00}', '\u{16f44}'), ('\u{16f50}', '\u{16f50}'), ('\u{1b000}',
+        '\u{1b001}'), ('\u{1bc00}', '\u{1bc6a}'), ('\u{1bc70}', '\u{1bc7c}'), ('\u{1bc80}',
+        '\u{1bc88}'), ('\u{1bc90}', '\u{1bc99}'), ('\u{1e800}', '\u{1e8c4}'), ('\u{1ee00}',
+        '\u{1ee03}'), ('\u{1ee05}', '\u{1ee1f}'), ('\u{1ee21}', '\u{1ee22}'), ('\u{1ee24}',
+        '\u{1ee24}'), ('\u{1ee27}', '\u{1ee27}'), ('\u{1ee29}', '\u{1ee32}'), ('\u{1ee34}',
+        '\u{1ee37}'), ('\u{1ee39}', '\u{1ee39}'), ('\u{1ee3b}', '\u{1ee3b}'), ('\u{1ee42}',
+        '\u{1ee42}'), ('\u{1ee47}', '\u{1ee47}'), ('\u{1ee49}', '\u{1ee49}'), ('\u{1ee4b}',
+        '\u{1ee4b}'), ('\u{1ee4d}', '\u{1ee4f}'), ('\u{1ee51}', '\u{1ee52}'), ('\u{1ee54}',
+        '\u{1ee54}'), ('\u{1ee57}', '\u{1ee57}'), ('\u{1ee59}', '\u{1ee59}'), ('\u{1ee5b}',
+        '\u{1ee5b}'), ('\u{1ee5d}', '\u{1ee5d}'), ('\u{1ee5f}', '\u{1ee5f}'), ('\u{1ee61}',
+        '\u{1ee62}'), ('\u{1ee64}', '\u{1ee64}'), ('\u{1ee67}', '\u{1ee6a}'), ('\u{1ee6c}',
+        '\u{1ee72}'), ('\u{1ee74}', '\u{1ee77}'), ('\u{1ee79}', '\u{1ee7c}'), ('\u{1ee7e}',
+        '\u{1ee7e}'), ('\u{1ee80}', '\u{1ee89}'), ('\u{1ee8b}', '\u{1ee9b}'), ('\u{1eea1}',
+        '\u{1eea3}'), ('\u{1eea5}', '\u{1eea9}'), ('\u{1eeab}', '\u{1eebb}'), ('\u{20000}',
+        '\u{2a6d6}'), ('\u{2a700}', '\u{2b734}'), ('\u{2b740}', '\u{2b81d}'), ('\u{2f800}',
+        '\u{2fa1d}')
     ];
 
     pub const Lt_table: &'static [(char, char)] = &[

From da03392e1f65f51867c9680fe29972f2e4e3f124 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 3 Mar 2015 11:28:57 -0800
Subject: [PATCH 10/34] std: Mark `Index::Output` as a stable associated type

This stability attribute was left out by accident and the stability pass has
since picked up the ability to check for this. As a result, crates are currently
getting warnings for implementations of `Index`.
---
 src/libcore/ops.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index c382ac46d5d..4116d8be9fb 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -913,6 +913,7 @@ shr_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize }
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Index<Idx: ?Sized> {
     /// The returned type after indexing
+    #[stable(feature = "rust1", since = "1.0.0")]
     type Output: ?Sized;
 
     /// The method for the indexing (`Foo[Bar]`) operation

From 9893b44ad9a9c3a23067a083ed0e0a08c2e83886 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 3 Mar 2015 13:05:55 -0800
Subject: [PATCH 11/34] libc: Move features behind a cfg_attr gate

This same source is being built in the Cargo ecosystem and hence needs to build
on stable Rust as well. This commit places the `no_std` attribute along with the
`no_std` feature behind a `cfg_attr` flag so they are not processed when
compiled on crates.io
---
 src/liblibc/lib.rs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs
index 42143b06ca0..d650f935566 100644
--- a/src/liblibc/lib.rs
+++ b/src/liblibc/lib.rs
@@ -10,13 +10,10 @@
 
 #![crate_name = "libc"]
 #![crate_type = "rlib"]
-#![cfg_attr(not(feature = "cargo-build"),
-            unstable(feature = "libc"))]
-#![cfg_attr(not(feature = "cargo-build"), feature(staged_api))]
+#![cfg_attr(not(feature = "cargo-build"), unstable(feature = "libc"))]
+#![cfg_attr(not(feature = "cargo-build"), feature(staged_api, core, no_std))]
 #![cfg_attr(not(feature = "cargo-build"), staged_api)]
-#![cfg_attr(not(feature = "cargo-build"), feature(core))]
-#![feature(no_std)]
-#![no_std]
+#![cfg_attr(not(feature = "cargo-build"), no_std)]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/",

From 8c28284e51cbfc141939dde5dc3998383d0082e5 Mon Sep 17 00:00:00 2001
From: Niko Matsakis <niko@alum.mit.edu>
Date: Tue, 3 Mar 2015 19:27:50 -0500
Subject: [PATCH 12/34] When generating WF criteria, do not visit the same type
 more than once. Fixes an infinite stack overflow (#23003).

---
 src/librustc_typeck/check/implicator.rs       | 11 +++++-
 .../traits-issue-23003-overflow.rs            | 38 ++++++++++++++++++
 src/test/run-pass/traits-issue-23003.rs       | 39 +++++++++++++++++++
 3 files changed, 87 insertions(+), 1 deletion(-)
 create mode 100644 src/test/compile-fail/traits-issue-23003-overflow.rs
 create mode 100644 src/test/run-pass/traits-issue-23003.rs

diff --git a/src/librustc_typeck/check/implicator.rs b/src/librustc_typeck/check/implicator.rs
index f99ba894029..6b4a7761d0a 100644
--- a/src/librustc_typeck/check/implicator.rs
+++ b/src/librustc_typeck/check/implicator.rs
@@ -22,6 +22,7 @@ use syntax::ast;
 use syntax::codemap::Span;
 
 use util::common::ErrorReported;
+use util::nodemap::FnvHashSet;
 use util::ppaux::Repr;
 
 // Helper functions related to manipulating region types.
@@ -40,6 +41,7 @@ struct Implicator<'a, 'tcx: 'a> {
     stack: Vec<(ty::Region, Option<Ty<'tcx>>)>,
     span: Span,
     out: Vec<Implication<'tcx>>,
+    visited: FnvHashSet<Ty<'tcx>>,
 }
 
 /// This routine computes the well-formedness constraints that must hold for the type `ty` to
@@ -65,7 +67,8 @@ pub fn implications<'a,'tcx>(
                               body_id: body_id,
                               span: span,
                               stack: stack,
-                              out: Vec::new() };
+                              out: Vec::new(),
+                              visited: FnvHashSet() };
     wf.accumulate_from_ty(ty);
     debug!("implications: out={}", wf.out.repr(closure_typer.tcx()));
     wf.out
@@ -80,6 +83,12 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> {
         debug!("accumulate_from_ty(ty={})",
                ty.repr(self.tcx()));
 
+        // When expanding out associated types, we can visit a cyclic
+        // set of types. Issue #23003.
+        if !self.visited.insert(ty) {
+            return;
+        }
+
         match ty.sty {
             ty::ty_bool |
             ty::ty_char |
diff --git a/src/test/compile-fail/traits-issue-23003-overflow.rs b/src/test/compile-fail/traits-issue-23003-overflow.rs
new file mode 100644
index 00000000000..ea41775f310
--- /dev/null
+++ b/src/test/compile-fail/traits-issue-23003-overflow.rs
@@ -0,0 +1,38 @@
+// Copyright 2015 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.
+
+// A variant of traits-issue-23003 in which an infinite series of
+// types are required. This currently creates an overflow. This test
+// is included to ensure that some controlled failure, at least,
+// results -- but it might be that we should adjust the rules somewhat
+// to make this legal. -nmatsakis
+
+use std::marker::PhantomData;
+
+trait Async {
+    type Cancel;
+}
+
+struct Receipt<A:Async> {
+    marker: PhantomData<A>,
+}
+
+struct Complete<B> {
+    core: Option<B>,
+}
+
+impl<B> Async for Complete<B> {
+    type Cancel = Receipt<Complete<Option<B>>>;
+}
+
+fn foo(r: Receipt<Complete<()>>) { }
+//~^ ERROR overflow
+
+fn main() { }
diff --git a/src/test/run-pass/traits-issue-23003.rs b/src/test/run-pass/traits-issue-23003.rs
new file mode 100644
index 00000000000..37b13d319aa
--- /dev/null
+++ b/src/test/run-pass/traits-issue-23003.rs
@@ -0,0 +1,39 @@
+// Copyright 2015 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.
+
+// Test stack overflow triggered by evaluating the implications. To be
+// WF, the type `Receipt<Complete>` would require that `<Complete as
+// Async>::Cancel` be WF. This normalizes to `Receipt<Complete>`
+// again, leading to an infinite cycle. Issue #23003.
+
+#![allow(dead_code)]
+#![allow(unused_variables)]
+
+use std::marker::PhantomData;
+
+trait Async {
+    type Cancel;
+}
+
+struct Receipt<A:Async> {
+    marker: PhantomData<A>,
+}
+
+struct Complete {
+    core: Option<()>,
+}
+
+impl Async for Complete {
+    type Cancel = Receipt<Complete>;
+}
+
+fn foo(r: Receipt<Complete>) { }
+
+fn main() { }

From dde4e5885e9e49f28d4902eab3024c30b27b4366 Mon Sep 17 00:00:00 2001
From: Eric Platon <eric.platon@waku-waku.ne.jp>
Date: Mon, 2 Mar 2015 15:15:24 +0900
Subject: [PATCH 13/34] Made failing/working examples look alike.

The failing concurrency example was doing something different from the
working example. This commit changes just enough of the failing example
to (1) still fail with the same error, (2) tries to do the same as the
working example (increment a vector value and print it).

r? @steveklabnik
---
 src/doc/intro.md | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/doc/intro.md b/src/doc/intro.md
index 07a90959deb..ac5bf1bd35f 100644
--- a/src/doc/intro.md
+++ b/src/doc/intro.md
@@ -428,7 +428,8 @@ fn main() {
 
     let guards: Vec<_> = (0..3).map(|i| {
         Thread::scoped(move || {
-            for j in 0..3 { numbers[j] += 1 }
+            numbers[i] += 1;
+            println!("numbers[{}] is {}", i, numbers[i]);
         });
     }).collect();
 }
@@ -437,10 +438,12 @@ fn main() {
 It gives us this error:
 
 ```text
-7:29: 9:10 error: cannot move out of captured outer variable in an `FnMut` closure
-7         Thread::scoped(move || {
-8             for j in 0..3 { numbers[j] += 1 }
-9         });
+7:25: 10:6 error: cannot move out of captured outer variable in an `FnMut` closure
+7     Thread::scoped(move || {
+8       numbers[i] += 1;
+9       println!("numbers[{}] is {}", i, numbers[i]);
+10     });
+error: aborting due to previous error
 ```
 
 It mentions that "captured outer variable in an `FnMut` closure".

From 8e50853b542bcecdd2ee0d972e53e21e6f694095 Mon Sep 17 00:00:00 2001
From: Eduard Burtescu <edy.burt@gmail.com>
Date: Tue, 3 Mar 2015 10:42:26 +0200
Subject: [PATCH 14/34] Remove integer suffixes where the types in compiled
 code are identical.

---
 src/liballoc/boxed.rs                         |   2 +-
 src/liballoc/boxed_test.rs                    |   4 +-
 src/libcollections/bit.rs                     |  24 ++--
 src/libcollections/fmt.rs                     |   2 +-
 src/libcollections/slice.rs                   |  10 +-
 src/libcollections/str.rs                     |  10 +-
 src/libcollections/string.rs                  |  72 +++++-----
 src/libcore/char.rs                           |  42 +++---
 src/libcore/fmt/float.rs                      |   6 +-
 src/libcore/fmt/mod.rs                        |   4 +-
 src/libcore/fmt/num.rs                        |   2 +-
 src/libcore/hash/sip.rs                       |   2 +-
 src/libcore/intrinsics.rs                     |   2 +-
 src/libcore/iter.rs                           |   2 +-
 src/libcore/macros.rs                         |   2 +-
 src/libcore/option.rs                         |   2 +-
 src/libcore/str/mod.rs                        |   8 +-
 src/libcoretest/char.rs                       |   4 +-
 src/libcoretest/hash/mod.rs                   |   4 +-
 src/libcoretest/hash/sip.rs                   |   8 +-
 src/libcoretest/iter.rs                       |   8 +-
 src/libcoretest/mem.rs                        |   2 +-
 src/libcoretest/num/mod.rs                    |   8 +-
 src/libcoretest/ptr.rs                        |   6 +-
 src/liblibc/lib.rs                            |  50 +++----
 src/librand/chacha.rs                         |   6 +-
 src/librand/distributions/range.rs            |   4 +-
 src/librand/isaac.rs                          |   4 +-
 src/librand/lib.rs                            |   2 +-
 src/librand/reseeding.rs                      |   2 +-
 src/librbml/lib.rs                            |  46 +++----
 src/librustc/middle/const_eval.rs             |   2 +-
 src/librustc/util/lev_distance.rs             |   2 +-
 src/librustc_back/sha2.rs                     |  12 +-
 src/librustc_bitflags/lib.rs                  |   8 +-
 src/librustc_trans/trans/base.rs              |   4 +-
 src/librustc_trans/trans/cabi_aarch64.rs      |   2 +-
 src/libserialize/hex.rs                       |   2 +-
 src/libserialize/json.rs                      |   2 +-
 src/libstd/ascii.rs                           |  12 +-
 src/libstd/collections/hash/table.rs          |   4 +-
 src/libstd/fs/mod.rs                          |   4 +-
 src/libstd/io/buffered.rs                     |   4 +-
 src/libstd/io/cursor.rs                       |  14 +-
 src/libstd/net/addr.rs                        |   6 +-
 src/libstd/net/parser.rs                      |  10 +-
 src/libstd/num/f32.rs                         |  16 +--
 src/libstd/num/f64.rs                         |  14 +-
 src/libstd/num/mod.rs                         |  18 +--
 src/libstd/num/strconv.rs                     |  14 +-
 src/libstd/old_io/buffered.rs                 |   4 +-
 src/libstd/old_io/comm_adapters.rs            |  14 +-
 src/libstd/old_io/extensions.rs               |   8 +-
 src/libstd/old_io/fs.rs                       |   4 +-
 src/libstd/old_io/mod.rs                      |   8 +-
 src/libstd/old_io/net/ip.rs                   |  28 ++--
 src/libstd/old_io/net/tcp.rs                  |   6 +-
 src/libstd/old_io/test.rs                     |   4 +-
 src/libstd/old_io/util.rs                     |   4 +-
 src/libstd/rand/mod.rs                        |   2 +-
 src/libstd/rand/os.rs                         |  16 +--
 src/libstd/rand/reader.rs                     |  22 +--
 src/libstd/rt/util.rs                         |   2 +-
 src/libstd/sys/common/wtf8.rs                 |   4 +-
 src/libstd/sys/unix/fs.rs                     |   2 +-
 src/libstd/thread.rs                          |   2 +-
 src/libstd/tuple.rs                           |   2 +-
 src/libsyntax/ast_util.rs                     |  16 +--
 src/libterm/lib.rs                            |  32 ++---
 src/libterm/terminfo/parm.rs                  |   4 +-
 src/libtest/lib.rs                            |   4 +-
 src/libunicode/u_str.rs                       |   2 +-
 src/test/auxiliary/cci_class_3.rs             |   2 +-
 src/test/auxiliary/cci_class_4.rs             |   4 +-
 src/test/auxiliary/cci_class_cast.rs          |   4 +-
 src/test/auxiliary/cci_impl_lib.rs            |   2 +-
 src/test/auxiliary/cci_iter_lib.rs            |   4 +-
 src/test/auxiliary/cci_no_inline_lib.rs       |   4 +-
 src/test/auxiliary/macro_reexport_1.rs        |   2 +-
 src/test/auxiliary/roman_numerals.rs          |   2 +-
 .../auxiliary/unboxed-closures-cross-crate.rs |   4 +-
 src/test/bench/noise.rs                       |   2 +-
 src/test/bench/shootout-chameneos-redux.rs    |   2 +-
 src/test/bench/shootout-fannkuch-redux.rs     |   4 +-
 src/test/bench/shootout-fasta-redux.rs        |   2 +-
 src/test/bench/shootout-fasta.rs              |   2 +-
 src/test/bench/shootout-k-nucleotide.rs       |   4 +-
 src/test/bench/shootout-meteor.rs             |   4 +-
 src/test/bench/sudoku.rs                      | 114 ++++++++--------
 src/test/compile-fail-fulldeps/issue-18986.rs |   2 +-
 src/test/compile-fail/array-not-vector.rs     |   4 +-
 src/test/compile-fail/asm-in-bad-modifier.rs  |   4 +-
 src/test/compile-fail/asm-out-assign-imm.rs   |   2 +-
 src/test/compile-fail/asm-out-no-modifier.rs  |   2 +-
 src/test/compile-fail/assign-to-method.rs     |   4 +-
 src/test/compile-fail/bad-bang-ann-3.rs       |   2 +-
 src/test/compile-fail/bad-bang-ann.rs         |   2 +-
 src/test/compile-fail/bad-const-type.rs       |   2 +-
 .../compile-fail/bad-method-typaram-kind.rs   |   2 +-
 src/test/compile-fail/binop-logic-int.rs      |   2 +-
 .../borrow-immutable-upvar-mutation.rs        |  12 +-
 .../borrowck-move-error-with-note.rs          |   2 +-
 .../borrowck-report-with-custom-diagnostic.rs |   6 +-
 src/test/compile-fail/class-method-missing.rs |   2 +-
 src/test/compile-fail/class-missing-self.rs   |   2 +-
 src/test/compile-fail/coercion-slice.rs       |   2 +-
 .../const-block-non-item-statement.rs         |   4 +-
 src/test/compile-fail/deriving-non-type.rs    |   4 +-
 .../compile-fail/destructor-restrictions.rs   |   4 +-
 .../feature-gated-feature-in-macro-arg.rs     |   2 +-
 src/test/compile-fail/import-glob-circular.rs |   4 +-
 src/test/compile-fail/index-bot.rs            |   2 +-
 .../compile-fail/infinite-instantiation.rs    |   6 +-
 src/test/compile-fail/issue-11714.rs          |   2 +-
 src/test/compile-fail/issue-13058.rs          |   4 +-
 src/test/compile-fail/issue-13466.rs          |   2 +-
 src/test/compile-fail/issue-13482-2.rs        |   2 +-
 src/test/compile-fail/issue-14845.rs          |   2 +-
 src/test/compile-fail/issue-17283.rs          |   2 +-
 src/test/compile-fail/issue-17651.rs          |   2 +-
 src/test/compile-fail/issue-17718-patterns.rs |   2 +-
 src/test/compile-fail/issue-17933.rs          |   4 +-
 src/test/compile-fail/issue-18107.rs          |   2 +-
 src/test/compile-fail/issue-18252.rs          |   2 +-
 src/test/compile-fail/issue-18566.rs          |   2 +-
 src/test/compile-fail/issue-18783.rs          |   4 +-
 src/test/compile-fail/issue-18959.rs          |   2 +-
 src/test/compile-fail/issue-19991.rs          |   2 +-
 src/test/compile-fail/issue-20801.rs          |   4 +-
 src/test/compile-fail/issue-2150.rs           |   2 +-
 src/test/compile-fail/issue-4517.rs           |   2 +-
 src/test/compile-fail/issue-7575.rs           |   6 +-
 src/test/compile-fail/issue-7867.rs           |   2 +-
 src/test/compile-fail/kindck-nonsendable-1.rs |   2 +-
 ...me-inference-give-expl-lifetime-param-2.rs |   2 +-
 src/test/compile-fail/lint-dead-code-4.rs     |   2 +-
 .../liveness-return-last-stmt-semi.rs         |   2 +-
 .../macro-no-implicit-reexport.rs             |   2 +-
 .../macro-reexport-not-locally-visible.rs     |   2 +-
 src/test/compile-fail/method-self-arg-1.rs    |   2 +-
 .../compile-fail/mut-pattern-mismatched.rs    |   4 +-
 .../compile-fail/mutable-class-fields-2.rs    |   2 +-
 src/test/compile-fail/mutable-class-fields.rs |   2 +-
 .../non-exhaustive-pattern-witness.rs         |   2 +-
 src/test/compile-fail/or-patter-mismatch.rs   |   2 +-
 src/test/compile-fail/private-method.rs       |   2 +-
 .../private-struct-field-cross-crate.rs       |   4 +-
 src/test/compile-fail/range-1.rs              |   2 +-
 src/test/compile-fail/regions-addr-of-self.rs |   6 +-
 .../regions-addr-of-upvar-self.rs             |   2 +-
 .../compile-fail/regions-creating-enums.rs    |   4 +-
 .../regions-pattern-typing-issue-19997.rs     |   4 +-
 ...regions-return-ref-to-upvar-issue-17403.rs |   2 +-
 src/test/compile-fail/regions-trait-1.rs      |   4 +-
 .../structure-constructor-type-mismatch.rs    |  20 +--
 src/test/compile-fail/tail-typeck.rs          |   2 +-
 ...traits-multidispatch-convert-ambig-dest.rs |   2 +-
 .../compile-fail/tuple-index-out-of-bounds.rs |   4 +-
 .../compile-fail/type-mismatch-multiple.rs    |   2 +-
 .../type-params-in-different-spaces-1.rs      |   2 +-
 .../typeck_type_placeholder_item.rs           |   4 +-
 .../unboxed-closure-illegal-move.rs           |  12 +-
 .../unboxed-closure-immutable-capture.rs      |   2 +-
 .../compile-fail/unboxed-closure-region.rs    |   2 +-
 .../unboxed-closures-borrow-conflict.rs       |   2 +-
 .../unboxed-closures-mutate-upvar.rs          |  12 +-
 ...-closures-mutated-upvar-from-fn-closure.rs |   2 +-
 src/test/compile-fail/unreachable-arm.rs      |   2 +-
 .../unsafe-fn-assign-deref-ptr.rs             |   2 +-
 src/test/compile-fail/variance-issue-20533.rs |   6 +-
 .../compile-fail/vtable-res-trait-param.rs    |   2 +-
 src/test/debuginfo/associated-types.rs        |  14 +-
 src/test/debuginfo/recursive-struct.rs        |   4 +-
 src/test/debuginfo/simd.rs                    |  20 +--
 .../parse-fail/class-implements-bad-trait.rs  |   2 +-
 src/test/parse-fail/issue-5544-b.rs           |   2 +-
 .../parse-fail/lex-bad-numeric-literals.rs    |   2 +-
 src/test/parse-fail/regions-trait-2.rs        |   2 +-
 src/test/pretty/empty-lines.rs                |   2 +-
 src/test/pretty/issue-4264.pp                 |   4 +-
 src/test/pretty/issue-4264.rs                 |   4 +-
 src/test/run-fail/extern-panic.rs             |   8 +-
 src/test/run-fail/if-check-panic.rs           |   6 +-
 .../graphviz-flowgraph/f20.dot-expected.dot   |  18 +--
 src/test/run-make/graphviz-flowgraph/f20.rs   |   4 +-
 src/test/run-make/save-analysis/foo.rs        |   6 +-
 .../run-make/symbols-are-reasonable/lib.rs    |   2 +-
 src/test/run-pass/alias-uninit-value.rs       |   2 +-
 .../associated-types-constant-type.rs         |   2 +-
 src/test/run-pass/associated-types-return.rs  |   2 +-
 .../associated-types-struct-field-named.rs    |   4 +-
 .../associated-types-struct-field-numbered.rs |   4 +-
 .../run-pass/associated-types-sugar-path.rs   |   2 +-
 src/test/run-pass/auto-encode.rs              |  10 +-
 .../run-pass/autoderef-method-on-trait.rs     |   6 +-
 .../run-pass/autoderef-method-priority.rs     |   6 +-
 .../autoderef-method-twice-but-not-thrice.rs  |   6 +-
 src/test/run-pass/autoderef-method-twice.rs   |   6 +-
 src/test/run-pass/autoderef-method.rs         |   6 +-
 .../autoref-intermediate-types-issue-3585.rs  |   2 +-
 src/test/run-pass/big-literals.rs             |  10 +-
 src/test/run-pass/block-arg-call-as.rs        |   4 +-
 src/test/run-pass/block-iter-1.rs             |   4 +-
 src/test/run-pass/block-iter-2.rs             |   2 +-
 .../run-pass/borrowck-closures-two-imm.rs     |   6 +-
 src/test/run-pass/borrowck-mut-uniq.rs        |   2 +-
 .../capture-clauses-unboxed-closures.rs       |   4 +-
 src/test/run-pass/cast.rs                     |   2 +-
 src/test/run-pass/cci_borrow.rs               |   4 +-
 src/test/run-pass/cci_impl_exe.rs             |   2 +-
 src/test/run-pass/cci_iter_exe.rs             |   4 +-
 src/test/run-pass/cci_no_inline_exe.rs        |   2 +-
 .../class-cast-to-trait-cross-crate-2.rs      |   2 +-
 src/test/run-pass/class-cast-to-trait.rs      |   6 +-
 src/test/run-pass/class-dtor.rs               |   2 +-
 src/test/run-pass/class-exports.rs            |   2 +-
 src/test/run-pass/class-method-cross-crate.rs |   4 +-
 .../run-pass/class-methods-cross-crate.rs     |   6 +-
 src/test/run-pass/class-methods.rs            |   8 +-
 src/test/run-pass/class-poly-methods.rs       |   8 +-
 src/test/run-pass/class-separate-impl.rs      |   6 +-
 src/test/run-pass/class-typarams.rs           |   6 +-
 .../run-pass/classes-simple-cross-crate.rs    |   4 +-
 src/test/run-pass/classes-simple-method.rs    |   4 +-
 src/test/run-pass/classes-simple.rs           |   4 +-
 .../run-pass/coerce-reborrow-imm-vec-rcvr.rs  |   2 +-
 src/test/run-pass/concat.rs                   |   4 +-
 src/test/run-pass/const-block.rs              |   4 +-
 src/test/run-pass/const-bound.rs              |   2 +-
 src/test/run-pass/double-ref.rs               |  28 ++--
 src/test/run-pass/drop-trait-enum.rs          |   6 +-
 src/test/run-pass/extern-pass-char.rs         |   2 +-
 src/test/run-pass/extern-pass-u32.rs          |   2 +-
 src/test/run-pass/extern-pass-u64.rs          |   2 +-
 src/test/run-pass/foreign-fn-linkname.rs      |   2 +-
 src/test/run-pass/i32-sub.rs                  |   2 +-
 src/test/run-pass/i8-incr.rs                  |   8 +-
 src/test/run-pass/if-check.rs                 |   6 +-
 src/test/run-pass/intrinsic-alignment.rs      |  24 ++--
 src/test/run-pass/intrinsics-integer.rs       | 126 +++++++++---------
 src/test/run-pass/intrinsics-math.rs          |   4 +-
 src/test/run-pass/issue-1112.rs               |  20 +--
 src/test/run-pass/issue-11736.rs              |   2 +-
 src/test/run-pass/issue-11958.rs              |   2 +-
 src/test/run-pass/issue-12909.rs              |   2 +-
 src/test/run-pass/issue-15571.rs              |   2 +-
 src/test/run-pass/issue-15673.rs              |   2 +-
 src/test/run-pass/issue-15734.rs              |   4 +-
 src/test/run-pass/issue-17662.rs              |   2 +-
 src/test/run-pass/issue-18539.rs              |   2 +-
 src/test/run-pass/issue-20055-box-trait.rs    |   8 +-
 .../run-pass/issue-20055-box-unsized-array.rs |   8 +-
 src/test/run-pass/issue-20676.rs              |   2 +-
 src/test/run-pass/issue-21475.rs              |   6 +-
 src/test/run-pass/issue-2185.rs               |   8 +-
 src/test/run-pass/issue-22036.rs              |   2 +-
 src/test/run-pass/issue-2550.rs               |   2 +-
 src/test/run-pass/issue-2989.rs               |   8 +-
 src/test/run-pass/issue-3609.rs               |   2 +-
 src/test/run-pass/issue-6130.rs               |   6 +-
 src/test/run-pass/issue-6892.rs               |   4 +-
 src/test/run-pass/issue-7012.rs               |   6 +-
 src/test/run-pass/issue-8783.rs               |   2 +-
 src/test/run-pass/issue2170exe.rs             |   2 +-
 src/test/run-pass/ivec-tag.rs                 |   4 +-
 src/test/run-pass/last-use-in-cap-clause.rs   |   4 +-
 src/test/run-pass/macro-interpolation.rs      |   2 +-
 src/test/run-pass/macro-pat.rs                |   6 +-
 src/test/run-pass/match-with-ret-arm.rs       |   2 +-
 ...thod-mut-self-modifies-mut-slice-lvalue.rs |   2 +-
 src/test/run-pass/method-self-arg-aux1.rs     |   2 +-
 src/test/run-pass/method-self-arg-aux2.rs     |   2 +-
 src/test/run-pass/method-self-arg-trait.rs    |   2 +-
 src/test/run-pass/method-self-arg.rs          |   2 +-
 .../nullable-pointer-iotareduction.rs         |   2 +-
 src/test/run-pass/object-method-numbering.rs  |   2 +-
 .../objects-coerce-freeze-borrored.rs         |   4 +-
 ...owned-object-borrowed-method-headerless.rs |   2 +-
 src/test/run-pass/or-pattern.rs               |   2 +-
 .../overloaded-calls-param-vtables.rs         |   2 +-
 src/test/run-pass/packed-struct-vec.rs        |   2 +-
 src/test/run-pass/path.rs                     |   2 +-
 src/test/run-pass/private-class-field.rs      |   4 +-
 src/test/run-pass/pure-sum.rs                 |  16 +--
 src/test/run-pass/ranges-precedence.rs        |   2 +-
 src/test/run-pass/realloc-16687.rs            |  18 +--
 src/test/run-pass/rec-align-u32.rs            |  10 +-
 src/test/run-pass/rec-align-u64.rs            |  26 ++--
 src/test/run-pass/record-pat.rs               |   4 +-
 src/test/run-pass/regions-borrow-at.rs        |   4 +-
 src/test/run-pass/regions-borrow-uniq.rs      |   4 +-
 src/test/run-pass/regions-copy-closure.rs     |   2 +-
 .../run-pass/regions-escape-into-other-fn.rs  |   2 +-
 src/test/run-pass/regions-params.rs           |   4 +-
 src/test/run-pass/regions-refcell.rs          |  10 +-
 src/test/run-pass/regions-trait-object-1.rs   |   4 +-
 src/test/run-pass/rename-directory.rs         |   2 +-
 src/test/run-pass/ret-bang.rs                 |   4 +-
 src/test/run-pass/running-with-no-runtime.rs  |  10 +-
 src/test/run-pass/sendfn-is-a-block.rs        |   6 +-
 src/test/run-pass/shift-various-types.rs      |  20 +--
 src/test/run-pass/small-enums-with-fields.rs  |  12 +-
 src/test/run-pass/static-methods-in-traits.rs |   2 +-
 src/test/run-pass/string-self-append.rs       |   4 +-
 src/test/run-pass/struct-return.rs            |  20 +--
 .../run-pass/syntax-extension-source-utils.rs |   2 +-
 src/test/run-pass/tag-align-dyn-u64.rs        |   4 +-
 src/test/run-pass/tag-align-dyn-variants.rs   |  52 ++++----
 src/test/run-pass/tag-align-shape.rs          |   2 +-
 src/test/run-pass/tag-align-u64.rs            |   4 +-
 src/test/run-pass/task-comm-16.rs             |   8 +-
 src/test/run-pass/tcp-stress.rs               |   4 +-
 .../trait-default-method-bound-subst4.rs      |   4 +-
 src/test/run-pass/trait-object-generics.rs    |   2 +-
 .../trait-object-with-lifetime-bound.rs       |   4 +-
 src/test/run-pass/type-params-in-for-each.rs  |   4 +-
 .../run-pass/typeck_type_placeholder_1.rs     |   6 +-
 src/test/run-pass/u32-decr.rs                 |   6 +-
 src/test/run-pass/u8-incr-decr.rs             |   8 +-
 src/test/run-pass/u8-incr.rs                  |  12 +-
 src/test/run-pass/ufcs-trait-object.rs        |   2 +-
 .../unboxed-closures-unique-type-id.rs        |   8 +-
 src/test/run-pass/unique-pat-2.rs             |   2 +-
 src/test/run-pass/unique-send-2.rs            |  10 +-
 src/test/run-pass/unsized3.rs                 |   4 +-
 src/test/run-pass/utf8_chars.rs               |  30 ++---
 src/test/run-pass/vec-fixed-length.rs         |   4 +-
 src/test/run-pass/weird-exprs.rs              |   2 +-
 src/test/run-pass/where-for-self.rs           |   2 +-
 src/test/run-pass/x86stdcall.rs               |   2 +-
 src/test/run-pass/x86stdcall2.rs              |   8 +-
 331 files changed, 1072 insertions(+), 1074 deletions(-)

diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 630ca837daa..9351b110100 100644
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -42,7 +42,7 @@
 //! }
 //! ```
 //!
-//! This will print `Cons(1i32, Box(Cons(2i32, Box(Nil))))`.
+//! This will print `Cons(1, Box(Cons(2, Box(Nil))))`.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
diff --git a/src/liballoc/boxed_test.rs b/src/liballoc/boxed_test.rs
index b7bacaa0cae..bb1ff9428a7 100644
--- a/src/liballoc/boxed_test.rs
+++ b/src/liballoc/boxed_test.rs
@@ -72,13 +72,13 @@ fn test_show() {
 #[test]
 fn deref() {
     fn homura<T: Deref<Target=i32>>(_: T) { }
-    homura(Box::new(765i32));
+    homura(Box::new(765));
 }
 
 #[test]
 fn raw_sized() {
     unsafe {
-        let x = Box::new(17i32);
+        let x = Box::new(17);
         let p = boxed::into_raw(x);
         assert_eq!(17, *p);
         *p = 19;
diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs
index b0490b287ad..7524fb6cf18 100644
--- a/src/libcollections/bit.rs
+++ b/src/libcollections/bit.rs
@@ -118,11 +118,11 @@ fn match_words <'a,'b>(a: &'a BitVec, b: &'b BitVec) -> (MatchWords<'a>, MatchWo
 
     // have to uselessly pretend to pad the longer one for type matching
     if a_len < b_len {
-        (a.blocks().enumerate().chain(iter::repeat(0u32).enumerate().take(b_len).skip(a_len)),
-         b.blocks().enumerate().chain(iter::repeat(0u32).enumerate().take(0).skip(0)))
+        (a.blocks().enumerate().chain(iter::repeat(0).enumerate().take(b_len).skip(a_len)),
+         b.blocks().enumerate().chain(iter::repeat(0).enumerate().take(0).skip(0)))
     } else {
-        (a.blocks().enumerate().chain(iter::repeat(0u32).enumerate().take(0).skip(0)),
-         b.blocks().enumerate().chain(iter::repeat(0u32).enumerate().take(a_len).skip(b_len)))
+        (a.blocks().enumerate().chain(iter::repeat(0).enumerate().take(0).skip(0)),
+         b.blocks().enumerate().chain(iter::repeat(0).enumerate().take(a_len).skip(b_len)))
     }
 }
 
@@ -199,7 +199,7 @@ fn blocks_for_bits(bits: usize) -> usize {
 /// Computes the bitmask for the final word of the vector
 fn mask_for_bits(bits: usize) -> u32 {
     // Note especially that a perfect multiple of u32::BITS should mask all 1s.
-    !0u32 >> (u32::BITS as usize - bits % u32::BITS as usize) % u32::BITS as usize
+    !0 >> (u32::BITS as usize - bits % u32::BITS as usize) % u32::BITS as usize
 }
 
 impl BitVec {
@@ -275,7 +275,7 @@ impl BitVec {
     pub fn from_elem(nbits: usize, bit: bool) -> BitVec {
         let nblocks = blocks_for_bits(nbits);
         let mut bit_vec = BitVec {
-            storage: repeat(if bit { !0u32 } else { 0u32 }).take(nblocks).collect(),
+            storage: repeat(if bit { !0 } else { 0 }).take(nblocks).collect(),
             nbits: nbits
         };
         bit_vec.fix_last_block();
@@ -330,7 +330,7 @@ impl BitVec {
         }
 
         if extra_bytes > 0 {
-            let mut last_word = 0u32;
+            let mut last_word = 0;
             for (i, &byte) in bytes[complete_words*4..].iter().enumerate() {
                 last_word |= (reverse_bits(byte) as u32) << (i * 8);
             }
@@ -431,7 +431,7 @@ impl BitVec {
     /// ```
     #[inline]
     pub fn set_all(&mut self) {
-        for w in &mut self.storage { *w = !0u32; }
+        for w in &mut self.storage { *w = !0; }
         self.fix_last_block();
     }
 
@@ -566,12 +566,12 @@ impl BitVec {
     /// assert_eq!(bv.all(), false);
     /// ```
     pub fn all(&self) -> bool {
-        let mut last_word = !0u32;
+        let mut last_word = !0;
         // Check that every block but the last is all-ones...
         self.blocks().all(|elem| {
             let tmp = last_word;
             last_word = elem;
-            tmp == !0u32
+            tmp == !0
         // and then check the last one has enough ones
         }) && (last_word == mask_for_bits(self.nbits))
     }
@@ -912,7 +912,7 @@ impl BitVec {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn clear(&mut self) {
-        for w in &mut self.storage { *w = 0u32; }
+        for w in &mut self.storage { *w = 0; }
     }
 }
 
@@ -2313,7 +2313,7 @@ mod tests {
 
         assert_eq!(bit_vec.iter().collect::<Vec<bool>>(), bools);
 
-        let long: Vec<_> = (0i32..10000).map(|i| i % 2 == 0).collect();
+        let long: Vec<_> = (0..10000).map(|i| i % 2 == 0).collect();
         let bit_vec: BitVec = long.iter().map(|n| *n).collect();
         assert_eq!(bit_vec.iter().collect::<Vec<bool>>(), long)
     }
diff --git a/src/libcollections/fmt.rs b/src/libcollections/fmt.rs
index 5a20ba4b49f..c88be80679d 100644
--- a/src/libcollections/fmt.rs
+++ b/src/libcollections/fmt.rs
@@ -226,7 +226,7 @@
 //! Some examples of the output from both traits:
 //!
 //! ```
-//! assert_eq!(format!("{} {:?}", 3i32, 4i32), "3 4");
+//! assert_eq!(format!("{} {:?}", 3, 4), "3 4");
 //! assert_eq!(format!("{} {:?}", 'a', 'b'), "a 'b'");
 //! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\"");
 //! ```
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index ecff2c7cc4b..f3209a736cf 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -2639,7 +2639,7 @@ mod tests {
     #[test]
     fn test_bytes_set_memory() {
         use slice::bytes::MutableByteVector;
-        let mut values = [1u8,2,3,4,5];
+        let mut values = [1,2,3,4,5];
         values[0..5].set_memory(0xAB);
         assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]);
         values[2..4].set_memory(0xFF);
@@ -2809,26 +2809,26 @@ mod tests {
     fn test_mut_chunks() {
         use core::iter::ExactSizeIterator;
 
-        let mut v = [0u8, 1, 2, 3, 4, 5, 6];
+        let mut v = [0, 1, 2, 3, 4, 5, 6];
         assert_eq!(v.chunks_mut(2).len(), 4);
         for (i, chunk) in v.chunks_mut(3).enumerate() {
             for x in chunk {
                 *x = i as u8;
             }
         }
-        let result = [0u8, 0, 0, 1, 1, 1, 2];
+        let result = [0, 0, 0, 1, 1, 1, 2];
         assert!(v == result);
     }
 
     #[test]
     fn test_mut_chunks_rev() {
-        let mut v = [0u8, 1, 2, 3, 4, 5, 6];
+        let mut v = [0, 1, 2, 3, 4, 5, 6];
         for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
             for x in chunk {
                 *x = i as u8;
             }
         }
-        let result = [2u8, 2, 2, 1, 1, 1, 0];
+        let result = [2, 2, 2, 1, 1, 1, 0];
         assert!(v == result);
     }
 
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 599b92d05dd..7ea5b3fe9c0 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -383,7 +383,7 @@ macro_rules! utf8_first_byte {
 
 // return the value of $ch updated with continuation byte $byte
 macro_rules! utf8_acc_cont_byte {
-    ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as u32)
+    ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63) as u32)
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -2300,8 +2300,8 @@ mod tests {
 
     #[test]
     fn test_chars_decoding() {
-        let mut bytes = [0u8; 4];
-        for c in (0u32..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
+        let mut bytes = [0; 4];
+        for c in (0..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
             let len = c.encode_utf8(&mut bytes).unwrap_or(0);
             let s = ::core::str::from_utf8(&bytes[..len]).unwrap();
             if Some(c) != s.chars().next() {
@@ -2312,8 +2312,8 @@ mod tests {
 
     #[test]
     fn test_chars_rev_decoding() {
-        let mut bytes = [0u8; 4];
-        for c in (0u32..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
+        let mut bytes = [0; 4];
+        for c in (0..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
             let len = c.encode_utf8(&mut bytes).unwrap_or(0);
             let s = ::core::str::from_utf8(&bytes[..len]).unwrap();
             if Some(c) != s.chars().rev().next() {
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index 33189bd68bd..d6ec8f0d979 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -153,7 +153,7 @@ impl String {
             }
         }
 
-        const TAG_CONT_U8: u8 = 128u8;
+        const TAG_CONT_U8: u8 = 128;
         const REPLACEMENT: &'static [u8] = b"\xEF\xBF\xBD"; // U+FFFD in UTF-8
         let total = v.len();
         fn unsafe_get(xs: &[u8], i: usize) -> u8 {
@@ -195,14 +195,14 @@ impl String {
                 }
             })}
 
-            if byte < 128u8 {
+            if byte < 128 {
                 // subseqidx handles this
             } else {
                 let w = unicode_str::utf8_char_width(byte);
 
                 match w {
                     2 => {
-                        if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 {
+                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
                             error!();
                             continue;
                         }
@@ -220,7 +220,7 @@ impl String {
                             }
                         }
                         i += 1;
-                        if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 {
+                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
                             error!();
                             continue;
                         }
@@ -237,12 +237,12 @@ impl String {
                             }
                         }
                         i += 1;
-                        if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 {
+                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
                             error!();
                             continue;
                         }
                         i += 1;
-                        if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 {
+                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
                             error!();
                             continue;
                         }
@@ -1084,40 +1084,40 @@ mod tests {
     fn test_from_utf16() {
         let pairs =
             [(String::from_str("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"),
-              vec![0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16,
-                0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16,
-                0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16,
-                0xd800_u16, 0xdf30_u16, 0x000a_u16]),
+              vec![0xd800, 0xdf45, 0xd800, 0xdf3f,
+                0xd800, 0xdf3b, 0xd800, 0xdf46,
+                0xd800, 0xdf39, 0xd800, 0xdf3b,
+                0xd800, 0xdf30, 0x000a]),
 
              (String::from_str("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"),
-              vec![0xd801_u16, 0xdc12_u16, 0xd801_u16,
-                0xdc49_u16, 0xd801_u16, 0xdc2e_u16, 0xd801_u16,
-                0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16,
-                0xdc4b_u16, 0x0020_u16, 0xd801_u16, 0xdc0f_u16,
-                0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4d_u16,
-                0x000a_u16]),
+              vec![0xd801, 0xdc12, 0xd801,
+                0xdc49, 0xd801, 0xdc2e, 0xd801,
+                0xdc40, 0xd801, 0xdc32, 0xd801,
+                0xdc4b, 0x0020, 0xd801, 0xdc0f,
+                0xd801, 0xdc32, 0xd801, 0xdc4d,
+                0x000a]),
 
              (String::from_str("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
-              vec![0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16,
-                0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16,
-                0xd800_u16, 0xdf11_u16, 0xd800_u16, 0xdf09_u16,
-                0x00b7_u16, 0xd800_u16, 0xdf0c_u16, 0xd800_u16,
-                0xdf04_u16, 0xd800_u16, 0xdf15_u16, 0xd800_u16,
-                0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16,
-                0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]),
+              vec![0xd800, 0xdf00, 0xd800, 0xdf16,
+                0xd800, 0xdf0b, 0xd800, 0xdf04,
+                0xd800, 0xdf11, 0xd800, 0xdf09,
+                0x00b7, 0xd800, 0xdf0c, 0xd800,
+                0xdf04, 0xd800, 0xdf15, 0xd800,
+                0xdf04, 0xd800, 0xdf0b, 0xd800,
+                0xdf09, 0xd800, 0xdf11, 0x000a ]),
 
              (String::from_str("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
-              vec![0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16,
-                0xd801_u16, 0xdc88_u16, 0xd801_u16, 0xdc91_u16,
-                0xd801_u16, 0xdc9b_u16, 0xd801_u16, 0xdc92_u16,
-                0x0020_u16, 0xd801_u16, 0xdc95_u16, 0xd801_u16,
-                0xdc93_u16, 0x0020_u16, 0xd801_u16, 0xdc88_u16,
-                0xd801_u16, 0xdc9a_u16, 0xd801_u16, 0xdc8d_u16,
-                0x0020_u16, 0xd801_u16, 0xdc8f_u16, 0xd801_u16,
-                0xdc9c_u16, 0xd801_u16, 0xdc92_u16, 0xd801_u16,
-                0xdc96_u16, 0xd801_u16, 0xdc86_u16, 0x0020_u16,
-                0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
-                0x000a_u16 ]),
+              vec![0xd801, 0xdc8b, 0xd801, 0xdc98,
+                0xd801, 0xdc88, 0xd801, 0xdc91,
+                0xd801, 0xdc9b, 0xd801, 0xdc92,
+                0x0020, 0xd801, 0xdc95, 0xd801,
+                0xdc93, 0x0020, 0xd801, 0xdc88,
+                0xd801, 0xdc9a, 0xd801, 0xdc8d,
+                0x0020, 0xd801, 0xdc8f, 0xd801,
+                0xdc9c, 0xd801, 0xdc92, 0xd801,
+                0xdc96, 0xd801, 0xdc86, 0x0020,
+                0xd801, 0xdc95, 0xd801, 0xdc86,
+                0x000a ]),
              // Issue #12318, even-numbered non-BMP planes
              (String::from_str("\u{20000}"),
               vec![0xD840, 0xDC00])];
@@ -1303,7 +1303,7 @@ mod tests {
         assert_eq!(1.to_string(), "1");
         assert_eq!((-1).to_string(), "-1");
         assert_eq!(200.to_string(), "200");
-        assert_eq!(2u8.to_string(), "2");
+        assert_eq!(2.to_string(), "2");
         assert_eq!(true.to_string(), "true");
         assert_eq!(false.to_string(), "false");
         assert_eq!(("hi".to_string()).to_string(), "hi");
@@ -1421,7 +1421,7 @@ mod tests {
 
     #[bench]
     fn from_utf8_lossy_100_invalid(b: &mut Bencher) {
-        let s = repeat(0xf5u8).take(100).collect::<Vec<_>>();
+        let s = repeat(0xf5).take(100).collect::<Vec<_>>();
         b.iter(|| {
             let _ = String::from_utf8_lossy(&s);
         });
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 8e27ae1cea9..973070677d8 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -22,13 +22,13 @@ use option::Option;
 use slice::SliceExt;
 
 // UTF-8 ranges and tags for encoding characters
-const TAG_CONT: u8    = 0b1000_0000u8;
-const TAG_TWO_B: u8   = 0b1100_0000u8;
-const TAG_THREE_B: u8 = 0b1110_0000u8;
-const TAG_FOUR_B: u8  = 0b1111_0000u8;
-const MAX_ONE_B: u32   =     0x80u32;
-const MAX_TWO_B: u32   =    0x800u32;
-const MAX_THREE_B: u32 =  0x10000u32;
+const TAG_CONT: u8    = 0b1000_0000;
+const TAG_TWO_B: u8   = 0b1100_0000;
+const TAG_THREE_B: u8 = 0b1110_0000;
+const TAG_FOUR_B: u8  = 0b1111_0000;
+const MAX_ONE_B: u32   =     0x80;
+const MAX_TWO_B: u32   =    0x800;
+const MAX_THREE_B: u32 =  0x10000;
 
 /*
     Lu  Uppercase_Letter        an uppercase letter
@@ -413,7 +413,7 @@ impl CharExt for char {
     #[stable(feature = "rust1", since = "1.0.0")]
     fn len_utf16(self) -> usize {
         let ch = self as u32;
-        if (ch & 0xFFFF_u32) == ch { 1 } else { 2 }
+        if (ch & 0xFFFF) == ch { 1 } else { 2 }
     }
 
     #[inline]
@@ -444,19 +444,19 @@ pub fn encode_utf8_raw(code: u32, dst: &mut [u8]) -> Option<usize> {
         dst[0] = code as u8;
         Some(1)
     } else if code < MAX_TWO_B && dst.len() >= 2 {
-        dst[0] = (code >> 6 & 0x1F_u32) as u8 | TAG_TWO_B;
-        dst[1] = (code & 0x3F_u32) as u8 | TAG_CONT;
+        dst[0] = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
+        dst[1] = (code & 0x3F) as u8 | TAG_CONT;
         Some(2)
     } else if code < MAX_THREE_B && dst.len() >= 3  {
-        dst[0] = (code >> 12 & 0x0F_u32) as u8 | TAG_THREE_B;
-        dst[1] = (code >>  6 & 0x3F_u32) as u8 | TAG_CONT;
-        dst[2] = (code & 0x3F_u32) as u8 | TAG_CONT;
+        dst[0] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+        dst[1] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
+        dst[2] = (code & 0x3F) as u8 | TAG_CONT;
         Some(3)
     } else if dst.len() >= 4 {
-        dst[0] = (code >> 18 & 0x07_u32) as u8 | TAG_FOUR_B;
-        dst[1] = (code >> 12 & 0x3F_u32) as u8 | TAG_CONT;
-        dst[2] = (code >>  6 & 0x3F_u32) as u8 | TAG_CONT;
-        dst[3] = (code & 0x3F_u32) as u8 | TAG_CONT;
+        dst[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
+        dst[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+        dst[2] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
+        dst[3] = (code & 0x3F) as u8 | TAG_CONT;
         Some(4)
     } else {
         None
@@ -472,15 +472,15 @@ pub fn encode_utf8_raw(code: u32, dst: &mut [u8]) -> Option<usize> {
 #[unstable(feature = "core")]
 pub fn encode_utf16_raw(mut ch: u32, dst: &mut [u16]) -> Option<usize> {
     // Marked #[inline] to allow llvm optimizing it away
-    if (ch & 0xFFFF_u32) == ch  && dst.len() >= 1 {
+    if (ch & 0xFFFF) == ch  && dst.len() >= 1 {
         // The BMP falls through (assuming non-surrogate, as it should)
         dst[0] = ch as u16;
         Some(1)
     } else if dst.len() >= 2 {
         // Supplementary planes break into surrogates.
-        ch -= 0x1_0000_u32;
-        dst[0] = 0xD800_u16 | ((ch >> 10) as u16);
-        dst[1] = 0xDC00_u16 | ((ch as u16) & 0x3FF_u16);
+        ch -= 0x1_0000;
+        dst[0] = 0xD800 | ((ch >> 10) as u16);
+        dst[1] = 0xDC00 | ((ch as u16) & 0x3FF);
         Some(2)
     } else {
         None
diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
index 2eeb564859c..0df04c296c8 100644
--- a/src/libcore/fmt/float.rs
+++ b/src/libcore/fmt/float.rs
@@ -123,13 +123,13 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
     // For an f64 the exponent is in the range of [-1022, 1023] for base 2, so
     // we may have up to that many digits. Give ourselves some extra wiggle room
     // otherwise as well.
-    let mut buf = [0u8; 1536];
+    let mut buf = [0; 1536];
     let mut end = 0;
     let radix_gen: T = cast(radix as int).unwrap();
 
     let (num, exp) = match exp_format {
-        ExpNone => (num, 0i32),
-        ExpDec if num == _0 => (num, 0i32),
+        ExpNone => (num, 0),
+        ExpDec if num == _0 => (num, 0),
         ExpDec => {
             let (exp, exp_base) = match exp_format {
                 ExpDec => (num.abs().log10().floor(), cast::<f64, T>(10.0f64).unwrap()),
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 9544fbaa55b..e640bf02f5a 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -565,7 +565,7 @@ impl<'a> Formatter<'a> {
             Alignment::Center => (padding / 2, (padding + 1) / 2),
         };
 
-        let mut fill = [0u8; 4];
+        let mut fill = [0; 4];
         let len = self.fill.encode_utf8(&mut fill).unwrap_or(0);
         let fill = unsafe { str::from_utf8_unchecked(&fill[..len]) };
 
@@ -689,7 +689,7 @@ impl Debug for char {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Display for char {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        let mut utf8 = [0u8; 4];
+        let mut utf8 = [0; 4];
         let amt = self.encode_utf8(&mut utf8).unwrap_or(0);
         let s: &str = unsafe { mem::transmute(&utf8[..amt]) };
         Display::fmt(s, f)
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 045442e28ac..b3f2302bb3e 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -38,7 +38,7 @@ trait GenericRadix {
         // characters for a base 2 number.
         let zero = Int::zero();
         let is_positive = x >= zero;
-        let mut buf = [0u8; 64];
+        let mut buf = [0; 64];
         let mut curr = buf.len();
         let base = cast(self.base()).unwrap();
         if is_positive {
diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs
index df0008c500b..bd1516e0cfc 100644
--- a/src/libcore/hash/sip.rs
+++ b/src/libcore/hash/sip.rs
@@ -60,7 +60,7 @@ macro_rules! u8to64_le {
     ($buf:expr, $i:expr, $len:expr) =>
     ({
         let mut t = 0;
-        let mut out = 0u64;
+        let mut out = 0;
         while t < $len {
             out |= ($buf[t+$i] as u64) << t*8;
             t += 1;
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index ed129136091..c6fc8ba5867 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -230,7 +230,7 @@ extern "rust-intrinsic" {
     /// use std::mem;
     ///
     /// let v: &[u8] = unsafe { mem::transmute("L") };
-    /// assert!(v == [76u8]);
+    /// assert!(v == [76]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn transmute<T,U>(e: T) -> U;
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 9495bc2e19d..840318b486a 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -1149,7 +1149,7 @@ pub trait AdditiveIterator<A> {
     /// ```
     /// use std::iter::AdditiveIterator;
     ///
-    /// let a = [1i32, 2, 3, 4, 5];
+    /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().cloned();
     /// assert!(it.sum() == 15);
     /// ```
diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs
index 94ca9ec37b4..f56206e8782 100644
--- a/src/libcore/macros.rs
+++ b/src/libcore/macros.rs
@@ -227,7 +227,7 @@ macro_rules! writeln {
 ///
 /// ```rust
 /// fn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3
-///     for i in std::iter::count(0_u32, 1) {
+///     for i in std::iter::count(0, 1) {
 ///         if 3*i < i { panic!("u32 overflow"); }
 ///         if x < 3*i { return i-1; }
 ///     }
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 1ecbd8fae8c..5343cdaaf08 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -385,7 +385,7 @@ impl<T> Option<T> {
     /// # Example
     ///
     /// ```
-    /// let k = 10i32;
+    /// let k = 10;
     /// assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4);
     /// assert_eq!(None.unwrap_or_else(|| 2 * k), 20);
     /// ```
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 4f4164f673b..1d4b81512dd 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -1119,9 +1119,9 @@ pub struct CharRange {
 }
 
 /// Mask of the value bits of a continuation byte
-const CONT_MASK: u8 = 0b0011_1111u8;
+const CONT_MASK: u8 = 0b0011_1111;
 /// Value of the tag bits (tag mask is !CONT_MASK) of a continuation byte
-const TAG_CONT_U8: u8 = 0b1000_0000u8;
+const TAG_CONT_U8: u8 = 0b1000_0000;
 
 /*
 Section: Trait implementations
@@ -1568,7 +1568,7 @@ impl StrExt for str {
         if index == self.len() { return true; }
         match self.as_bytes().get(index) {
             None => false,
-            Some(&b) => b < 128u8 || b >= 192u8,
+            Some(&b) => b < 128 || b >= 192,
         }
     }
 
@@ -1680,7 +1680,7 @@ impl StrExt for str {
 #[inline]
 #[unstable(feature = "core")]
 pub fn char_range_at_raw(bytes: &[u8], i: usize) -> (u32, usize) {
-    if bytes[i] < 128u8 {
+    if bytes[i] < 128 {
         return (bytes[i] as u32, i + 1);
     }
 
diff --git a/src/libcoretest/char.rs b/src/libcoretest/char.rs
index 32dc6440b13..46d1f7ff3ae 100644
--- a/src/libcoretest/char.rs
+++ b/src/libcoretest/char.rs
@@ -165,7 +165,7 @@ fn test_escape_unicode() {
 #[test]
 fn test_encode_utf8() {
     fn check(input: char, expect: &[u8]) {
-        let mut buf = [0u8; 4];
+        let mut buf = [0; 4];
         let n = input.encode_utf8(&mut buf).unwrap_or(0);
         assert_eq!(&buf[..n], expect);
     }
@@ -179,7 +179,7 @@ fn test_encode_utf8() {
 #[test]
 fn test_encode_utf16() {
     fn check(input: char, expect: &[u16]) {
-        let mut buf = [0u16; 2];
+        let mut buf = [0; 2];
         let n = input.encode_utf16(&mut buf).unwrap_or(0);
         assert_eq!(&buf[..n], expect);
     }
diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs
index da96680d84b..2b1f9490ae6 100644
--- a/src/libcoretest/hash/mod.rs
+++ b/src/libcoretest/hash/mod.rs
@@ -62,10 +62,10 @@ fn test_writer_hasher() {
     // FIXME (#18283) Enable test
     //let s: Box<str> = box "a";
     //assert_eq!(hasher.hash(& s), 97 + 0xFF);
-    let cs: &[u8] = &[1u8, 2u8, 3u8];
+    let cs: &[u8] = &[1, 2, 3];
     assert_eq!(hash(& cs), 9);
     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
-    let cs: Box<[u8]> = Box::new([1u8, 2u8, 3u8]);
+    let cs: Box<[u8]> = Box::new([1, 2, 3]);
     assert_eq!(hash(& cs), 9);
 
     // FIXME (#18248) Add tests for hashing Rc<str> and Rc<[T]>
diff --git a/src/libcoretest/hash/sip.rs b/src/libcoretest/hash/sip.rs
index 248cad32ef4..8289d06d04c 100644
--- a/src/libcoretest/hash/sip.rs
+++ b/src/libcoretest/hash/sip.rs
@@ -100,8 +100,8 @@ fn test_siphash() {
         [ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, ]
     ];
 
-    let k0 = 0x_07_06_05_04_03_02_01_00_u64;
-    let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08_u64;
+    let k0 = 0x_07_06_05_04_03_02_01_00;
+    let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
     let mut buf = Vec::new();
     let mut t = 0;
     let mut state_inc = SipState::new_with_keys(k0, k1);
@@ -230,8 +230,8 @@ fn test_hash_no_concat_alias() {
     assert!(s != t && t != u);
     assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u));
 
-    let v: (&[u8], &[u8], &[u8]) = (&[1u8], &[0u8, 0], &[0u8]);
-    let w: (&[u8], &[u8], &[u8]) = (&[1u8, 0, 0, 0], &[], &[]);
+    let v: (&[u8], &[u8], &[u8]) = (&[1], &[0, 0], &[0]);
+    let w: (&[u8], &[u8], &[u8]) = (&[1, 0, 0, 0], &[], &[]);
 
     assert!(v != w);
     assert!(hash(&v) != hash(&w));
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
index b1b10b582e5..91d1ea27476 100644
--- a/src/libcoretest/iter.rs
+++ b/src/libcoretest/iter.rs
@@ -778,9 +778,9 @@ fn test_range_step() {
     assert_eq!(range_step(0, 20, 5).collect::<Vec<int>>(), [0, 5, 10, 15]);
     assert_eq!(range_step(20, 0, -5).collect::<Vec<int>>(), [20, 15, 10, 5]);
     assert_eq!(range_step(20, 0, -6).collect::<Vec<int>>(), [20, 14, 8, 2]);
-    assert_eq!(range_step(200u8, 255, 50).collect::<Vec<u8>>(), [200u8, 250]);
-    assert_eq!(range_step(200i, -5, 1).collect::<Vec<int>>(), []);
-    assert_eq!(range_step(200i, 200, 1).collect::<Vec<int>>(), []);
+    assert_eq!(range_step(200, 255, 50).collect::<Vec<u8>>(), [200, 250]);
+    assert_eq!(range_step(200, -5, 1).collect::<Vec<int>>(), []);
+    assert_eq!(range_step(200, 200, 1).collect::<Vec<int>>(), []);
 }
 
 #[test]
@@ -788,7 +788,7 @@ fn test_range_step_inclusive() {
     assert_eq!(range_step_inclusive(0, 20, 5).collect::<Vec<int>>(), [0, 5, 10, 15, 20]);
     assert_eq!(range_step_inclusive(20, 0, -5).collect::<Vec<int>>(), [20, 15, 10, 5, 0]);
     assert_eq!(range_step_inclusive(20, 0, -6).collect::<Vec<int>>(), [20, 14, 8, 2]);
-    assert_eq!(range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>(), [200u8, 250]);
+    assert_eq!(range_step_inclusive(200, 255, 50).collect::<Vec<u8>>(), [200, 250]);
     assert_eq!(range_step_inclusive(200, -5, 1).collect::<Vec<int>>(), []);
     assert_eq!(range_step_inclusive(200, 200, 1).collect::<Vec<int>>(), [200]);
 }
diff --git a/src/libcoretest/mem.rs b/src/libcoretest/mem.rs
index 73000670c61..bf3e1cf03cb 100644
--- a/src/libcoretest/mem.rs
+++ b/src/libcoretest/mem.rs
@@ -103,7 +103,7 @@ fn test_transmute() {
     }
 
     unsafe {
-        assert_eq!([76u8], transmute::<_, Vec<u8>>("L".to_string()));
+        assert_eq!([76], transmute::<_, Vec<u8>>("L".to_string()));
     }
 }
 
diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs
index 721354b6a44..9087b87f640 100644
--- a/src/libcoretest/num/mod.rs
+++ b/src/libcoretest/num/mod.rs
@@ -88,7 +88,7 @@ mod test {
 
     #[test]
     fn test_int_from_str_overflow() {
-        let mut i8_val: i8 = 127_i8;
+        let mut i8_val: i8 = 127;
         assert_eq!("127".parse::<i8>().ok(), Some(i8_val));
         assert_eq!("128".parse::<i8>().ok(), None);
 
@@ -96,7 +96,7 @@ mod test {
         assert_eq!("-128".parse::<i8>().ok(), Some(i8_val));
         assert_eq!("-129".parse::<i8>().ok(), None);
 
-        let mut i16_val: i16 = 32_767_i16;
+        let mut i16_val: i16 = 32_767;
         assert_eq!("32767".parse::<i16>().ok(), Some(i16_val));
         assert_eq!("32768".parse::<i16>().ok(), None);
 
@@ -104,7 +104,7 @@ mod test {
         assert_eq!("-32768".parse::<i16>().ok(), Some(i16_val));
         assert_eq!("-32769".parse::<i16>().ok(), None);
 
-        let mut i32_val: i32 = 2_147_483_647_i32;
+        let mut i32_val: i32 = 2_147_483_647;
         assert_eq!("2147483647".parse::<i32>().ok(), Some(i32_val));
         assert_eq!("2147483648".parse::<i32>().ok(), None);
 
@@ -112,7 +112,7 @@ mod test {
         assert_eq!("-2147483648".parse::<i32>().ok(), Some(i32_val));
         assert_eq!("-2147483649".parse::<i32>().ok(), None);
 
-        let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
+        let mut i64_val: i64 = 9_223_372_036_854_775_807;
         assert_eq!("9223372036854775807".parse::<i64>().ok(), Some(i64_val));
         assert_eq!("9223372036854775808".parse::<i64>().ok(), None);
 
diff --git a/src/libcoretest/ptr.rs b/src/libcoretest/ptr.rs
index c8a54ef59ab..6a25c8be14e 100644
--- a/src/libcoretest/ptr.rs
+++ b/src/libcoretest/ptr.rs
@@ -139,12 +139,12 @@ fn test_ptr_addition() {
 fn test_ptr_subtraction() {
     unsafe {
         let xs = vec![0,1,2,3,4,5,6,7,8,9];
-        let mut idx = 9i8;
+        let mut idx = 9;
         let ptr = xs.as_ptr();
 
-        while idx >= 0i8 {
+        while idx >= 0 {
             assert_eq!(*(ptr.offset(idx as int)), idx as int);
-            idx = idx - 1i8;
+            idx = idx - 1;
         }
 
         let mut xs_mut = xs;
diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs
index 42143b06ca0..7a91e692775 100644
--- a/src/liblibc/lib.rs
+++ b/src/liblibc/lib.rs
@@ -2203,11 +2203,11 @@ pub mod consts {
             pub const _IOFBF : c_int = 0;
             pub const _IONBF : c_int = 4;
             pub const _IOLBF : c_int = 64;
-            pub const BUFSIZ : c_uint = 512_u32;
-            pub const FOPEN_MAX : c_uint = 20_u32;
-            pub const FILENAME_MAX : c_uint = 260_u32;
-            pub const L_tmpnam : c_uint = 16_u32;
-            pub const TMP_MAX : c_uint = 32767_u32;
+            pub const BUFSIZ : c_uint = 512;
+            pub const FOPEN_MAX : c_uint = 20;
+            pub const FILENAME_MAX : c_uint = 260;
+            pub const L_tmpnam : c_uint = 16;
+            pub const TMP_MAX : c_uint = 32767;
 
             pub const WSAEINTR: c_int = 10004;
             pub const WSAEBADF: c_int = 10009;
@@ -2584,11 +2584,11 @@ pub mod consts {
             pub const _IOFBF : c_int = 0;
             pub const _IONBF : c_int = 2;
             pub const _IOLBF : c_int = 1;
-            pub const BUFSIZ : c_uint = 8192_u32;
-            pub const FOPEN_MAX : c_uint = 16_u32;
-            pub const FILENAME_MAX : c_uint = 4096_u32;
-            pub const L_tmpnam : c_uint = 20_u32;
-            pub const TMP_MAX : c_uint = 238328_u32;
+            pub const BUFSIZ : c_uint = 8192;
+            pub const FOPEN_MAX : c_uint = 16;
+            pub const FILENAME_MAX : c_uint = 4096;
+            pub const L_tmpnam : c_uint = 20;
+            pub const TMP_MAX : c_uint = 238328;
         }
         pub mod c99 {
         }
@@ -3450,11 +3450,11 @@ pub mod consts {
             pub const _IOFBF : c_int = 0;
             pub const _IONBF : c_int = 2;
             pub const _IOLBF : c_int = 1;
-            pub const BUFSIZ : c_uint = 1024_u32;
-            pub const FOPEN_MAX : c_uint = 20_u32;
-            pub const FILENAME_MAX : c_uint = 1024_u32;
-            pub const L_tmpnam : c_uint = 1024_u32;
-            pub const TMP_MAX : c_uint = 308915776_u32;
+            pub const BUFSIZ : c_uint = 1024;
+            pub const FOPEN_MAX : c_uint = 20;
+            pub const FILENAME_MAX : c_uint = 1024;
+            pub const L_tmpnam : c_uint = 1024;
+            pub const TMP_MAX : c_uint = 308915776;
         }
         pub mod c99 {
         }
@@ -3858,11 +3858,11 @@ pub mod consts {
             pub const _IOFBF : c_int = 0;
             pub const _IONBF : c_int = 2;
             pub const _IOLBF : c_int = 1;
-            pub const BUFSIZ : c_uint = 1024_u32;
-            pub const FOPEN_MAX : c_uint = 20_u32;
-            pub const FILENAME_MAX : c_uint = 1024_u32;
-            pub const L_tmpnam : c_uint = 1024_u32;
-            pub const TMP_MAX : c_uint = 308915776_u32;
+            pub const BUFSIZ : c_uint = 1024;
+            pub const FOPEN_MAX : c_uint = 20;
+            pub const FILENAME_MAX : c_uint = 1024;
+            pub const L_tmpnam : c_uint = 1024;
+            pub const TMP_MAX : c_uint = 308915776;
         }
         pub mod c99 {
         }
@@ -4236,11 +4236,11 @@ pub mod consts {
             pub const _IOFBF : c_int = 0;
             pub const _IONBF : c_int = 2;
             pub const _IOLBF : c_int = 1;
-            pub const BUFSIZ : c_uint = 1024_u32;
-            pub const FOPEN_MAX : c_uint = 20_u32;
-            pub const FILENAME_MAX : c_uint = 1024_u32;
-            pub const L_tmpnam : c_uint = 1024_u32;
-            pub const TMP_MAX : c_uint = 308915776_u32;
+            pub const BUFSIZ : c_uint = 1024;
+            pub const FOPEN_MAX : c_uint = 20;
+            pub const FILENAME_MAX : c_uint = 1024;
+            pub const L_tmpnam : c_uint = 1024;
+            pub const TMP_MAX : c_uint = 308915776;
         }
         pub mod c99 {
         }
diff --git a/src/librand/chacha.rs b/src/librand/chacha.rs
index 71ace016d6b..d54f1837074 100644
--- a/src/librand/chacha.rs
+++ b/src/librand/chacha.rs
@@ -173,7 +173,7 @@ impl<'a> SeedableRng<&'a [u32]> for ChaChaRng {
 
     fn reseed(&mut self, seed: &'a [u32]) {
         // reset state
-        self.init(&[0u32; KEY_WORDS]);
+        self.init(&[0; KEY_WORDS]);
         // set key in place
         let key = &mut self.state[4 .. 4+KEY_WORDS];
         for (k, s) in key.iter_mut().zip(seed.iter()) {
@@ -245,7 +245,7 @@ mod test {
     fn test_rng_true_values() {
         // Test vectors 1 and 2 from
         // http://tools.ietf.org/html/draft-nir-cfrg-chacha20-poly1305-04
-        let seed : &[_] = &[0u32; 8];
+        let seed : &[_] = &[0; 8];
         let mut ra: ChaChaRng = SeedableRng::from_seed(seed);
 
         let v = (0..16).map(|_| ra.next_u32()).collect::<Vec<_>>();
@@ -285,7 +285,7 @@ mod test {
 
     #[test]
     fn test_rng_clone() {
-        let seed : &[_] = &[0u32; 8];
+        let seed : &[_] = &[0; 8];
         let mut rng: ChaChaRng = SeedableRng::from_seed(seed);
         let mut clone = rng.clone();
         for _ in 0..16 {
diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs
index fb73a44c2b9..4afc67d63c8 100644
--- a/src/librand/distributions/range.rs
+++ b/src/librand/distributions/range.rs
@@ -23,8 +23,8 @@ use distributions::{Sample, IndependentSample};
 ///
 /// This gives a uniform distribution (assuming the RNG used to sample
 /// it is itself uniform & the `SampleRange` implementation for the
-/// given type is correct), even for edge cases like `low = 0u8`,
-/// `high = 170u8`, for which a naive modulo operation would return
+/// given type is correct), even for edge cases like `low = 0`,
+/// `high = 170`, for which a naive modulo operation would return
 /// numbers less than 85 with double the probability to those greater
 /// than 85.
 ///
diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs
index 28f1ea872d7..5532e41028a 100644
--- a/src/librand/isaac.rs
+++ b/src/librand/isaac.rs
@@ -217,7 +217,7 @@ impl<'a> SeedableRng<&'a [u32]> for IsaacRng {
     fn reseed(&mut self, seed: &'a [u32]) {
         // make the seed into [seed[0], seed[1], ..., seed[seed.len()
         // - 1], 0, 0, ...], to fill rng.rsl.
-        let seed_iter = seed.iter().cloned().chain(repeat(0u32));
+        let seed_iter = seed.iter().cloned().chain(repeat(0));
 
         for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) {
             *rsl_elem = seed_elem;
@@ -460,7 +460,7 @@ impl<'a> SeedableRng<&'a [u64]> for Isaac64Rng {
     fn reseed(&mut self, seed: &'a [u64]) {
         // make the seed into [seed[0], seed[1], ..., seed[seed.len()
         // - 1], 0, 0, ...], to fill rng.rsl.
-        let seed_iter = seed.iter().cloned().chain(repeat(0u64));
+        let seed_iter = seed.iter().cloned().chain(repeat(0));
 
         for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) {
             *rsl_elem = seed_elem;
diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index 3458d519af5..c92f6c5e52d 100644
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -149,7 +149,7 @@ pub trait Rng : Sized {
     /// ```rust
     /// use std::rand::{thread_rng, Rng};
     ///
-    /// let mut v = [0u8; 13579];
+    /// let mut v = [0; 13579];
     /// thread_rng().fill_bytes(&mut v);
     /// println!("{:?}", v.as_slice());
     /// ```
diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs
index 0072c555d14..22b77a75931 100644
--- a/src/librand/reseeding.rs
+++ b/src/librand/reseeding.rs
@@ -215,7 +215,7 @@ mod test {
     const FILL_BYTES_V_LEN: uint = 13579;
     #[test]
     fn test_rng_fill_bytes() {
-        let mut v = repeat(0u8).take(FILL_BYTES_V_LEN).collect::<Vec<_>>();
+        let mut v = repeat(0).take(FILL_BYTES_V_LEN).collect::<Vec<_>>();
         ::test::rng().fill_bytes(&mut v);
 
         // Sanity test: if we've gotten here, `fill_bytes` has not infinitely
diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs
index 844d097bdaf..f0b79640f7d 100644
--- a/src/librbml/lib.rs
+++ b/src/librbml/lib.rs
@@ -290,22 +290,22 @@ pub mod reader {
     #[inline(never)]
     fn vuint_at_slow(data: &[u8], start: uint) -> DecodeResult<Res> {
         let a = data[start];
-        if a & 0x80u8 != 0u8 {
-            return Ok(Res {val: (a & 0x7fu8) as uint, next: start + 1});
+        if a & 0x80 != 0 {
+            return Ok(Res {val: (a & 0x7f) as uint, next: start + 1});
         }
-        if a & 0x40u8 != 0u8 {
-            return Ok(Res {val: ((a & 0x3fu8) as uint) << 8 |
+        if a & 0x40 != 0 {
+            return Ok(Res {val: ((a & 0x3f) as uint) << 8 |
                         (data[start + 1] as uint),
                     next: start + 2});
         }
-        if a & 0x20u8 != 0u8 {
-            return Ok(Res {val: ((a & 0x1fu8) as uint) << 16 |
+        if a & 0x20 != 0 {
+            return Ok(Res {val: ((a & 0x1f) as uint) << 16 |
                         (data[start + 1] as uint) << 8 |
                         (data[start + 2] as uint),
                     next: start + 3});
         }
-        if a & 0x10u8 != 0u8 {
-            return Ok(Res {val: ((a & 0x0fu8) as uint) << 24 |
+        if a & 0x10 != 0 {
+            return Ok(Res {val: ((a & 0x0f) as uint) << 24 |
                         (data[start + 1] as uint) << 16 |
                         (data[start + 2] as uint) << 8 |
                         (data[start + 3] as uint),
@@ -877,11 +877,11 @@ pub mod writer {
 
     fn write_sized_vuint<W: Writer>(w: &mut W, n: uint, size: uint) -> EncodeResult {
         match size {
-            1 => w.write_all(&[0x80u8 | (n as u8)]),
-            2 => w.write_all(&[0x40u8 | ((n >> 8) as u8), n as u8]),
-            3 => w.write_all(&[0x20u8 | ((n >> 16) as u8), (n >> 8) as u8,
+            1 => w.write_all(&[0x80 | (n as u8)]),
+            2 => w.write_all(&[0x40 | ((n >> 8) as u8), n as u8]),
+            3 => w.write_all(&[0x20 | ((n >> 16) as u8), (n >> 8) as u8,
                             n as u8]),
-            4 => w.write_all(&[0x10u8 | ((n >> 24) as u8), (n >> 16) as u8,
+            4 => w.write_all(&[0x10 | ((n >> 24) as u8), (n >> 16) as u8,
                             (n >> 8) as u8, n as u8]),
             _ => Err(old_io::IoError {
                 kind: old_io::OtherIoError,
@@ -930,7 +930,7 @@ pub mod writer {
 
             // Write a placeholder four-byte size.
             self.size_positions.push(try!(self.writer.tell()) as uint);
-            let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8];
+            let zeroes: &[u8] = &[0, 0, 0, 0];
             self.writer.write_all(zeroes)
         }
 
@@ -1422,9 +1422,9 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_A_aligned(b: &mut Bencher) {
-        let data = (0i32..4*100).map(|i| {
+        let data = (0..4*100).map(|i| {
             match i % 2 {
-              0 => 0x80u8,
+              0 => 0x80,
               _ => i as u8,
             }
         }).collect::<Vec<_>>();
@@ -1440,9 +1440,9 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_A_unaligned(b: &mut Bencher) {
-        let data = (0i32..4*100+1).map(|i| {
+        let data = (0..4*100+1).map(|i| {
             match i % 2 {
-              1 => 0x80u8,
+              1 => 0x80,
               _ => i as u8
             }
         }).collect::<Vec<_>>();
@@ -1458,11 +1458,11 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_D_aligned(b: &mut Bencher) {
-        let data = (0i32..4*100).map(|i| {
+        let data = (0..4*100).map(|i| {
             match i % 4 {
-              0 => 0x10u8,
+              0 => 0x10,
               3 => i as u8,
-              _ => 0u8
+              _ => 0
             }
         }).collect::<Vec<_>>();
         let mut sum = 0;
@@ -1477,11 +1477,11 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_D_unaligned(b: &mut Bencher) {
-        let data = (0i32..4*100+1).map(|i| {
+        let data = (0..4*100+1).map(|i| {
             match i % 4 {
-              1 => 0x10u8,
+              1 => 0x10,
               0 => i as u8,
-              _ => 0u8
+              _ => 0
             }
         }).collect::<Vec<_>>();
         let mut sum = 0;
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index ae43738d471..896a0010e7e 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -537,7 +537,7 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
       ast::ExprBlock(ref block) => {
         match block.expr {
             Some(ref expr) => try!(eval_const_expr_partial(tcx, &**expr, ety)),
-            None => const_int(0i64)
+            None => const_int(0)
         }
       }
       ast::ExprTupField(ref base, index) => {
diff --git a/src/librustc/util/lev_distance.rs b/src/librustc/util/lev_distance.rs
index 10a7b2abea8..d3b9b07ea41 100644
--- a/src/librustc/util/lev_distance.rs
+++ b/src/librustc/util/lev_distance.rs
@@ -45,7 +45,7 @@ pub fn lev_distance(me: &str, t: &str) -> uint {
 fn test_lev_distance() {
     use std::char::{ from_u32, MAX };
     // Test bytelength agnosticity
-    for c in (0u32..MAX as u32)
+    for c in (0..MAX as u32)
              .filter_map(|i| from_u32(i))
              .map(|i| i.to_string()) {
         assert_eq!(lev_distance(&c[..], &c[..]), 0);
diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs
index 844920ad5ec..482c710149c 100644
--- a/src/librustc_back/sha2.rs
+++ b/src/librustc_back/sha2.rs
@@ -119,7 +119,7 @@ impl FixedBuffer64 {
     /// Create a new FixedBuffer64
     fn new() -> FixedBuffer64 {
         return FixedBuffer64 {
-            buffer: [0u8; 64],
+            buffer: [0; 64],
             buffer_idx: 0
         };
     }
@@ -258,7 +258,7 @@ pub trait Digest {
     /// Convenience function that retrieves the result of a digest as a
     /// newly allocated vec of bytes.
     fn result_bytes(&mut self) -> Vec<u8> {
-        let mut buf: Vec<u8> = repeat(0u8).take((self.output_bits()+7)/8).collect();
+        let mut buf: Vec<u8> = repeat(0).take((self.output_bits()+7)/8).collect();
         self.result(&mut buf);
         buf
     }
@@ -342,7 +342,7 @@ impl Engine256State {
         let mut g = self.h6;
         let mut h = self.h7;
 
-        let mut w = [0u32; 64];
+        let mut w = [0; 64];
 
         // Sha-512 and Sha-256 use basically the same calculations which are implemented
         // by these macros. Inlining the calculations seems to result in better generated code.
@@ -660,7 +660,7 @@ mod bench {
     #[bench]
     pub fn sha256_10(b: &mut Bencher) {
         let mut sh = Sha256::new();
-        let bytes = [1u8; 10];
+        let bytes = [1; 10];
         b.iter(|| {
             sh.input(&bytes);
         });
@@ -670,7 +670,7 @@ mod bench {
     #[bench]
     pub fn sha256_1k(b: &mut Bencher) {
         let mut sh = Sha256::new();
-        let bytes = [1u8; 1024];
+        let bytes = [1; 1024];
         b.iter(|| {
             sh.input(&bytes);
         });
@@ -680,7 +680,7 @@ mod bench {
     #[bench]
     pub fn sha256_64k(b: &mut Bencher) {
         let mut sh = Sha256::new();
-        let bytes = [1u8; 65536];
+        let bytes = [1; 65536];
         b.iter(|| {
             sh.input(&bytes);
         });
diff --git a/src/librustc_bitflags/lib.rs b/src/librustc_bitflags/lib.rs
index 370a5d48dec..2199beb7a20 100644
--- a/src/librustc_bitflags/lib.rs
+++ b/src/librustc_bitflags/lib.rs
@@ -316,7 +316,7 @@ mod tests {
 
     bitflags! {
         flags AnotherSetOfFlags: i8 {
-            const AnotherFlag = -1_i8,
+            const AnotherFlag = -1,
         }
     }
 
@@ -327,7 +327,7 @@ mod tests {
         assert_eq!(FlagABC.bits(), 0b00000111);
 
         assert_eq!(AnotherSetOfFlags::empty().bits(), 0b00);
-        assert_eq!(AnotherFlag.bits(), !0_i8);
+        assert_eq!(AnotherFlag.bits(), !0);
     }
 
     #[test]
@@ -338,7 +338,7 @@ mod tests {
         assert!(Flags::from_bits(0b11) == Some(FlagA | FlagB));
         assert!(Flags::from_bits(0b1000) == None);
 
-        assert!(AnotherSetOfFlags::from_bits(!0_i8) == Some(AnotherFlag));
+        assert!(AnotherSetOfFlags::from_bits(!0) == Some(AnotherFlag));
     }
 
     #[test]
@@ -350,7 +350,7 @@ mod tests {
         assert!(Flags::from_bits_truncate(0b1000) == Flags::empty());
         assert!(Flags::from_bits_truncate(0b1001) == FlagA);
 
-        assert!(AnotherSetOfFlags::from_bits_truncate(0_i8) == AnotherSetOfFlags::empty());
+        assert!(AnotherSetOfFlags::from_bits_truncate(0) == AnotherSetOfFlags::empty());
     }
 
     #[test]
diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs
index 13f882bc363..8302d0abe21 100644
--- a/src/librustc_trans/trans/base.rs
+++ b/src/librustc_trans/trans/base.rs
@@ -833,11 +833,11 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>(
 
     let (is_zero, is_signed) = match rhs_t.sty {
         ty::ty_int(t) => {
-            let zero = C_integral(Type::int_from_ty(cx.ccx(), t), 0u64, false);
+            let zero = C_integral(Type::int_from_ty(cx.ccx(), t), 0, false);
             (ICmp(cx, llvm::IntEQ, rhs, zero, debug_loc), true)
         }
         ty::ty_uint(t) => {
-            let zero = C_integral(Type::uint_from_ty(cx.ccx(), t), 0u64, false);
+            let zero = C_integral(Type::uint_from_ty(cx.ccx(), t), 0, false);
             (ICmp(cx, llvm::IntEQ, rhs, zero, debug_loc), false)
         }
         _ => {
diff --git a/src/librustc_trans/trans/cabi_aarch64.rs b/src/librustc_trans/trans/cabi_aarch64.rs
index 5d1e6d2c9e8..03496a966bf 100644
--- a/src/librustc_trans/trans/cabi_aarch64.rs
+++ b/src/librustc_trans/trans/cabi_aarch64.rs
@@ -117,7 +117,7 @@ fn classify_arg_ty(ccx: &CrateContext, ty: Type) -> ArgType {
     let size = ty_size(ty);
     if size <= 16 {
         let llty = if size == 0 {
-            Type::array(&Type::i64(ccx), 0u64)
+            Type::array(&Type::i64(ccx), 0)
         } else if size == 1 {
             Type::i8(ccx)
         } else if size == 2 {
diff --git a/src/libserialize/hex.rs b/src/libserialize/hex.rs
index 970ae06763c..6f3d90d45b0 100644
--- a/src/libserialize/hex.rs
+++ b/src/libserialize/hex.rs
@@ -117,7 +117,7 @@ impl FromHex for str {
         // This may be an overestimate if there is any whitespace
         let mut b = Vec::with_capacity(self.len() / 2);
         let mut modulus = 0;
-        let mut buf = 0u8;
+        let mut buf = 0;
 
         for (idx, byte) in self.bytes().enumerate() {
             buf <<= 4;
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index bf4d006fcfa..0d445739b39 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -1653,7 +1653,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
 
     fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
         let mut i = 0;
-        let mut n = 0u16;
+        let mut n = 0;
         while i < 4 && !self.eof() {
             self.bump();
             n = match self.ch_or_null() {
diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index 94457a5d714..8b275d1bc4a 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -186,7 +186,7 @@ impl OwnedAsciiExt for Vec<u8> {
 impl AsciiExt for u8 {
     type Owned = u8;
     #[inline]
-    fn is_ascii(&self) -> bool { *self & 128 == 0u8 }
+    fn is_ascii(&self) -> bool { *self & 128 == 0 }
     #[inline]
     fn to_ascii_uppercase(&self) -> u8 { ASCII_UPPERCASE_MAP[*self as usize] }
     #[inline]
@@ -398,7 +398,7 @@ mod tests {
         assert_eq!("url()URL()uRl()ürl".to_ascii_uppercase(), "URL()URL()URL()üRL");
         assert_eq!("hıKß".to_ascii_uppercase(), "HıKß");
 
-        for i in 0u32..501 {
+        for i in 0..501 {
             let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
                         else { i };
             assert_eq!((from_u32(i).unwrap()).to_string().to_ascii_uppercase(),
@@ -412,7 +412,7 @@ mod tests {
         // Dotted capital I, Kelvin sign, Sharp S.
         assert_eq!("HİKß".to_ascii_lowercase(), "hİKß");
 
-        for i in 0u32..501 {
+        for i in 0..501 {
             let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
                         else { i };
             assert_eq!((from_u32(i).unwrap()).to_string().to_ascii_lowercase(),
@@ -426,7 +426,7 @@ mod tests {
                    "URL()URL()URL()üRL".to_string());
         assert_eq!(("hıKß".to_string()).into_ascii_uppercase(), "HıKß");
 
-        for i in 0u32..501 {
+        for i in 0..501 {
             let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
                         else { i };
             assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_uppercase(),
@@ -441,7 +441,7 @@ mod tests {
         // Dotted capital I, Kelvin sign, Sharp S.
         assert_eq!(("HİKß".to_string()).into_ascii_lowercase(), "hİKß");
 
-        for i in 0u32..501 {
+        for i in 0..501 {
             let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
                         else { i };
             assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_lowercase(),
@@ -459,7 +459,7 @@ mod tests {
         assert!(!"K".eq_ignore_ascii_case("k"));
         assert!(!"ß".eq_ignore_ascii_case("s"));
 
-        for i in 0u32..501 {
+        for i in 0..501 {
             let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
                         else { i };
             assert!((from_u32(i).unwrap()).to_string().eq_ignore_ascii_case(
diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
index 2670cd0c003..69fd0a57d5f 100644
--- a/src/libstd/collections/hash/table.rs
+++ b/src/libstd/collections/hash/table.rs
@@ -28,7 +28,7 @@ use ptr::{self, PtrExt, Unique};
 use rt::heap::{allocate, deallocate, EMPTY};
 use collections::hash_state::HashState;
 
-const EMPTY_BUCKET: u64 = 0u64;
+const EMPTY_BUCKET: u64 = 0;
 
 /// The raw hashtable, providing safe-ish access to the unzipped and highly
 /// optimized arrays of hashes, keys, and values.
@@ -149,7 +149,7 @@ pub fn make_hash<T: ?Sized, S>(hash_state: &S, t: &T) -> SafeHash
 {
     let mut state = hash_state.hasher();
     t.hash(&mut state);
-    // We need to avoid 0u64 in order to prevent collisions with
+    // We need to avoid 0 in order to prevent collisions with
     // EMPTY_HASH. We can maintain our precious uniform distribution
     // of initial indexes by unconditionally setting the MSB,
     // effectively reducing 64-bits hashes to 63 bits.
diff --git a/src/libstd/fs/mod.rs b/src/libstd/fs/mod.rs
index 64ec025a5c4..565c0b13efe 100644
--- a/src/libstd/fs/mod.rs
+++ b/src/libstd/fs/mod.rs
@@ -1053,7 +1053,7 @@ mod tests {
             check!(w.write(msg));
         }
         let files = check!(fs::read_dir(dir));
-        let mut mem = [0u8; 4];
+        let mut mem = [0; 4];
         for f in files {
             let f = f.unwrap().path();
             {
@@ -1083,7 +1083,7 @@ mod tests {
         check!(File::create(&dir2.join("14")));
 
         let files = check!(fs::walk_dir(dir));
-        let mut cur = [0u8; 2];
+        let mut cur = [0; 2];
         for f in files {
             let f = f.unwrap().path();
             let stem = f.file_stem().unwrap().to_str().unwrap();
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 11356099590..3603f127504 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -616,14 +616,14 @@ mod tests {
 
     #[test]
     fn read_char_buffered() {
-        let buf = [195u8, 159u8];
+        let buf = [195, 159];
         let reader = BufReader::with_capacity(1, &buf[..]);
         assert_eq!(reader.chars().next(), Some(Ok('ß')));
     }
 
     #[test]
     fn test_chars() {
-        let buf = [195u8, 159u8, b'a'];
+        let buf = [195, 159, b'a'];
         let reader = BufReader::with_capacity(1, &buf[..]);
         let mut it = reader.chars();
         assert_eq!(it.next(), Some(Ok('ß')));
diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs
index b1779587528..8a841742de4 100644
--- a/src/libstd/io/cursor.rs
+++ b/src/libstd/io/cursor.rs
@@ -237,7 +237,7 @@ mod tests {
 
     #[test]
     fn test_mem_reader() {
-        let mut reader = Cursor::new(vec!(0u8, 1, 2, 3, 4, 5, 6, 7));
+        let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         let mut buf = [];
         assert_eq!(reader.read(&mut buf), Ok(0));
         assert_eq!(reader.position(), 0);
@@ -259,7 +259,7 @@ mod tests {
 
     #[test]
     fn read_to_end() {
-        let mut reader = Cursor::new(vec!(0u8, 1, 2, 3, 4, 5, 6, 7));
+        let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         let mut v = Vec::new();
         reader.read_to_end(&mut v).ok().unwrap();
         assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
@@ -267,7 +267,7 @@ mod tests {
 
     #[test]
     fn test_slice_reader() {
-        let in_buf = vec![0u8, 1, 2, 3, 4, 5, 6, 7];
+        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
         let mut reader = &mut in_buf.as_slice();
         let mut buf = [];
         assert_eq!(reader.read(&mut buf), Ok(0));
@@ -289,7 +289,7 @@ mod tests {
 
     #[test]
     fn test_buf_reader() {
-        let in_buf = vec![0u8, 1, 2, 3, 4, 5, 6, 7];
+        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
         let mut reader = Cursor::new(in_buf.as_slice());
         let mut buf = [];
         assert_eq!(reader.read(&mut buf), Ok(0));
@@ -335,7 +335,7 @@ mod tests {
         assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
         assert_eq!(r.read(&mut [0]), Ok(0));
 
-        let mut r = Cursor::new(vec!(10u8));
+        let mut r = Cursor::new(vec!(10));
         assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
         assert_eq!(r.read(&mut [0]), Ok(0));
 
@@ -347,11 +347,11 @@ mod tests {
 
     #[test]
     fn seek_before_0() {
-        let buf = [0xff_u8];
+        let buf = [0xff];
         let mut r = Cursor::new(&buf[..]);
         assert!(r.seek(SeekFrom::End(-2)).is_err());
 
-        let mut r = Cursor::new(vec!(10u8));
+        let mut r = Cursor::new(vec!(10));
         assert!(r.seek(SeekFrom::End(-2)).is_err());
 
         let mut buf = [0];
diff --git a/src/libstd/net/addr.rs b/src/libstd/net/addr.rs
index f16f501c46a..916abe78eb3 100644
--- a/src/libstd/net/addr.rs
+++ b/src/libstd/net/addr.rs
@@ -562,7 +562,7 @@ mod tests {
     #[test]
     fn to_socket_addr_ipaddr_u16() {
         let a = IpAddr::new_v4(77, 88, 21, 11);
-        let p = 12345u16;
+        let p = 12345;
         let e = SocketAddr::new(a, p);
         assert_eq!(Ok(vec![e]), tsa((a, p)));
     }
@@ -570,13 +570,13 @@ mod tests {
     #[test]
     fn to_socket_addr_str_u16() {
         let a = SocketAddr::new(IpAddr::new_v4(77, 88, 21, 11), 24352);
-        assert_eq!(Ok(vec![a]), tsa(("77.88.21.11", 24352u16)));
+        assert_eq!(Ok(vec![a]), tsa(("77.88.21.11", 24352)));
 
         let a = SocketAddr::new(IpAddr::new_v6(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 53);
         assert_eq!(Ok(vec![a]), tsa(("2a02:6b8:0:1::1", 53)));
 
         let a = SocketAddr::new(IpAddr::new_v4(127, 0, 0, 1), 23924);
-        assert!(tsa(("localhost", 23924u16)).unwrap().contains(&a));
+        assert!(tsa(("localhost", 23924)).unwrap().contains(&a));
     }
 
     #[test]
diff --git a/src/libstd/net/parser.rs b/src/libstd/net/parser.rs
index e82dc88cddd..aa54a432d62 100644
--- a/src/libstd/net/parser.rs
+++ b/src/libstd/net/parser.rs
@@ -136,7 +136,7 @@ impl<'a> Parser<'a> {
     }
 
     fn read_number_impl(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
-        let mut r = 0u32;
+        let mut r = 0;
         let mut digit_count = 0;
         loop {
             match self.read_digit(radix) {
@@ -164,7 +164,7 @@ impl<'a> Parser<'a> {
     }
 
     fn read_ipv4_addr_impl(&mut self) -> Option<Ipv4Addr> {
-        let mut bs = [0u8; 4];
+        let mut bs = [0; 4];
         let mut i = 0;
         while i < 4 {
             if i != 0 && self.read_given_char('.').is_none() {
@@ -189,7 +189,7 @@ impl<'a> Parser<'a> {
     fn read_ipv6_addr_impl(&mut self) -> Option<Ipv6Addr> {
         fn ipv6_addr_from_head_tail(head: &[u16], tail: &[u16]) -> Ipv6Addr {
             assert!(head.len() + tail.len() <= 8);
-            let mut gs = [0u16; 8];
+            let mut gs = [0; 8];
             gs.clone_from_slice(head);
             gs[(8 - tail.len()) .. 8].clone_from_slice(tail);
             Ipv6Addr::new(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
@@ -231,7 +231,7 @@ impl<'a> Parser<'a> {
             (i, false)
         }
 
-        let mut head = [0u16; 8];
+        let mut head = [0; 8];
         let (head_size, head_ipv4) = read_groups(self, &mut head, 8);
 
         if head_size == 8 {
@@ -250,7 +250,7 @@ impl<'a> Parser<'a> {
             return None;
         }
 
-        let mut tail = [0u16; 8];
+        let mut tail = [0; 8];
         let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
         Some(ipv6_addr_from_head_tail(&head[..head_size], &tail[..tail_size]))
     }
diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs
index 7d15a16309e..093cde55bbb 100644
--- a/src/libstd/num/f32.rs
+++ b/src/libstd/num/f32.rs
@@ -824,14 +824,14 @@ mod tests {
 
     #[test]
     fn test_integer_decode() {
-        assert_eq!(3.14159265359f32.integer_decode(), (13176795u64, -22i16, 1i8));
-        assert_eq!((-8573.5918555f32).integer_decode(), (8779358u64, -10i16, -1i8));
-        assert_eq!(2f32.powf(100.0).integer_decode(), (8388608u64, 77i16, 1i8));
-        assert_eq!(0f32.integer_decode(), (0u64, -150i16, 1i8));
-        assert_eq!((-0f32).integer_decode(), (0u64, -150i16, -1i8));
-        assert_eq!(INFINITY.integer_decode(), (8388608u64, 105i16, 1i8));
-        assert_eq!(NEG_INFINITY.integer_decode(), (8388608u64, 105i16, -1i8));
-        assert_eq!(NAN.integer_decode(), (12582912u64, 105i16, 1i8));
+        assert_eq!(3.14159265359f32.integer_decode(), (13176795, -22, 1));
+        assert_eq!((-8573.5918555f32).integer_decode(), (8779358, -10, -1));
+        assert_eq!(2f32.powf(100.0).integer_decode(), (8388608, 77, 1));
+        assert_eq!(0f32.integer_decode(), (0, -150, 1));
+        assert_eq!((-0f32).integer_decode(), (0, -150, -1));
+        assert_eq!(INFINITY.integer_decode(), (8388608, 105, 1));
+        assert_eq!(NEG_INFINITY.integer_decode(), (8388608, 105, -1));
+        assert_eq!(NAN.integer_decode(), (12582912, 105, 1));
     }
 
     #[test]
diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs
index 0ce56371c77..a7bdad70a36 100644
--- a/src/libstd/num/f64.rs
+++ b/src/libstd/num/f64.rs
@@ -826,14 +826,14 @@ mod tests {
 
     #[test]
     fn test_integer_decode() {
-        assert_eq!(3.14159265359f64.integer_decode(), (7074237752028906u64, -51i16, 1i8));
-        assert_eq!((-8573.5918555f64).integer_decode(), (4713381968463931u64, -39i16, -1i8));
-        assert_eq!(2f64.powf(100.0).integer_decode(), (4503599627370496u64, 48i16, 1i8));
-        assert_eq!(0f64.integer_decode(), (0u64, -1075i16, 1i8));
-        assert_eq!((-0f64).integer_decode(), (0u64, -1075i16, -1i8));
-        assert_eq!(INFINITY.integer_decode(), (4503599627370496u64, 972i16, 1i8));
+        assert_eq!(3.14159265359f64.integer_decode(), (7074237752028906, -51, 1));
+        assert_eq!((-8573.5918555f64).integer_decode(), (4713381968463931, -39, -1));
+        assert_eq!(2f64.powf(100.0).integer_decode(), (4503599627370496, 48, 1));
+        assert_eq!(0f64.integer_decode(), (0, -1075, 1));
+        assert_eq!((-0f64).integer_decode(), (0, -1075, -1));
+        assert_eq!(INFINITY.integer_decode(), (4503599627370496, 972, 1));
         assert_eq!(NEG_INFINITY.integer_decode(), (4503599627370496, 972, -1));
-        assert_eq!(NAN.integer_decode(), (6755399441055744u64, 972i16, 1i8));
+        assert_eq!(NAN.integer_decode(), (6755399441055744, 972, 1));
     }
 
     #[test]
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index 0bca60ed1a0..9458ed1d353 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -312,7 +312,7 @@ pub trait Float
     ///
     /// let num = 2.0f32;
     ///
-    /// // (8388608u64, -22i16, 1i8)
+    /// // (8388608, -22, 1)
     /// let (mantissa, exponent, sign) = num.integer_decode();
     /// let sign_f = sign as f32;
     /// let mantissa_f = mantissa as f32;
@@ -1755,25 +1755,25 @@ mod tests {
 
     #[test]
     fn test_uint_to_str_overflow() {
-        let mut u8_val: u8 = 255_u8;
+        let mut u8_val: u8 = 255;
         assert_eq!(u8_val.to_string(), "255");
 
         u8_val = u8_val.wrapping_add(1);
         assert_eq!(u8_val.to_string(), "0");
 
-        let mut u16_val: u16 = 65_535_u16;
+        let mut u16_val: u16 = 65_535;
         assert_eq!(u16_val.to_string(), "65535");
 
         u16_val = u16_val.wrapping_add(1);
         assert_eq!(u16_val.to_string(), "0");
 
-        let mut u32_val: u32 = 4_294_967_295_u32;
+        let mut u32_val: u32 = 4_294_967_295;
         assert_eq!(u32_val.to_string(), "4294967295");
 
         u32_val = u32_val.wrapping_add(1);
         assert_eq!(u32_val.to_string(), "0");
 
-        let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
+        let mut u64_val: u64 = 18_446_744_073_709_551_615;
         assert_eq!(u64_val.to_string(), "18446744073709551615");
 
         u64_val = u64_val.wrapping_add(1);
@@ -1786,7 +1786,7 @@ mod tests {
 
     #[test]
     fn test_uint_from_str_overflow() {
-        let mut u8_val: u8 = 255_u8;
+        let mut u8_val: u8 = 255;
         assert_eq!(from_str::<u8>("255"), Some(u8_val));
         assert_eq!(from_str::<u8>("256"), None);
 
@@ -1794,7 +1794,7 @@ mod tests {
         assert_eq!(from_str::<u8>("0"), Some(u8_val));
         assert_eq!(from_str::<u8>("-1"), None);
 
-        let mut u16_val: u16 = 65_535_u16;
+        let mut u16_val: u16 = 65_535;
         assert_eq!(from_str::<u16>("65535"), Some(u16_val));
         assert_eq!(from_str::<u16>("65536"), None);
 
@@ -1802,7 +1802,7 @@ mod tests {
         assert_eq!(from_str::<u16>("0"), Some(u16_val));
         assert_eq!(from_str::<u16>("-1"), None);
 
-        let mut u32_val: u32 = 4_294_967_295_u32;
+        let mut u32_val: u32 = 4_294_967_295;
         assert_eq!(from_str::<u32>("4294967295"), Some(u32_val));
         assert_eq!(from_str::<u32>("4294967296"), None);
 
@@ -1810,7 +1810,7 @@ mod tests {
         assert_eq!(from_str::<u32>("0"), Some(u32_val));
         assert_eq!(from_str::<u32>("-1"), None);
 
-        let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
+        let mut u64_val: u64 = 18_446_744_073_709_551_615;
         assert_eq!(from_str::<u64>("18446744073709551615"), Some(u64_val));
         assert_eq!(from_str::<u64>("18446744073709551616"), None);
 
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index b38c52dad1a..5fdd42dbc7a 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -104,7 +104,7 @@ fn int_to_str_bytes_common<T, F>(num: T, radix: uint, sign: SignFormat, mut f: F
     // This is just for integral types, the largest of which is a u64. The
     // smallest base that we can have is 2, so the most number of digits we're
     // ever going to have is 64
-    let mut buf = [0u8; 64];
+    let mut buf = [0; 64];
     let mut cur = 0;
 
     // Loop at least once to make sure at least a `0` gets emitted.
@@ -221,10 +221,10 @@ pub fn float_to_str_bytes_common<T: Float>(
     let radix_gen: T = num::cast(radix as int).unwrap();
 
     let (num, exp) = match exp_format {
-        ExpNone => (num, 0i32),
+        ExpNone => (num, 0),
         ExpDec | ExpBin => {
             if num == _0 {
-                (num, 0i32)
+                (num, 0)
             } else {
                 let (exp, exp_base) = match exp_format {
                     ExpDec => (num.abs().log10().floor(), num::cast::<f64, T>(10.0f64).unwrap()),
@@ -432,25 +432,25 @@ mod tests {
 
     #[test]
     fn test_int_to_str_overflow() {
-        let mut i8_val: i8 = 127_i8;
+        let mut i8_val: i8 = 127;
         assert_eq!(i8_val.to_string(), "127");
 
         i8_val = i8_val.wrapping_add(1);
         assert_eq!(i8_val.to_string(), "-128");
 
-        let mut i16_val: i16 = 32_767_i16;
+        let mut i16_val: i16 = 32_767;
         assert_eq!(i16_val.to_string(), "32767");
 
         i16_val = i16_val.wrapping_add(1);
         assert_eq!(i16_val.to_string(), "-32768");
 
-        let mut i32_val: i32 = 2_147_483_647_i32;
+        let mut i32_val: i32 = 2_147_483_647;
         assert_eq!(i32_val.to_string(), "2147483647");
 
         i32_val = i32_val.wrapping_add(1);
         assert_eq!(i32_val.to_string(), "-2147483648");
 
-        let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
+        let mut i64_val: i64 = 9_223_372_036_854_775_807;
         assert_eq!(i64_val.to_string(), "9223372036854775807");
 
         i64_val = i64_val.wrapping_add(1);
diff --git a/src/libstd/old_io/buffered.rs b/src/libstd/old_io/buffered.rs
index 2d2d0d8b33a..fe2510b668f 100644
--- a/src/libstd/old_io/buffered.rs
+++ b/src/libstd/old_io/buffered.rs
@@ -642,14 +642,14 @@ mod test {
 
     #[test]
     fn read_char_buffered() {
-        let buf = [195u8, 159u8];
+        let buf = [195, 159];
         let mut reader = BufferedReader::with_capacity(1, &buf[..]);
         assert_eq!(reader.read_char(), Ok('ß'));
     }
 
     #[test]
     fn test_chars() {
-        let buf = [195u8, 159u8, b'a'];
+        let buf = [195, 159, b'a'];
         let mut reader = BufferedReader::with_capacity(1, &buf[..]);
         let mut it = reader.chars();
         assert_eq!(it.next(), Some(Ok('ß')));
diff --git a/src/libstd/old_io/comm_adapters.rs b/src/libstd/old_io/comm_adapters.rs
index 207d3d39167..dec1ae98ba0 100644
--- a/src/libstd/old_io/comm_adapters.rs
+++ b/src/libstd/old_io/comm_adapters.rs
@@ -30,7 +30,7 @@ use vec::Vec;
 /// # drop(tx);
 /// let mut reader = ChanReader::new(rx);
 ///
-/// let mut buf = [0u8; 100];
+/// let mut buf = [0; 100];
 /// match reader.read(&mut buf) {
 ///     Ok(nread) => println!("Read {} bytes", nread),
 ///     Err(e) => println!("read error: {}", e),
@@ -167,15 +167,15 @@ mod test {
     fn test_rx_reader() {
         let (tx, rx) = channel();
         thread::spawn(move|| {
-          tx.send(vec![1u8, 2u8]).unwrap();
+          tx.send(vec![1, 2]).unwrap();
           tx.send(vec![]).unwrap();
-          tx.send(vec![3u8, 4u8]).unwrap();
-          tx.send(vec![5u8, 6u8]).unwrap();
-          tx.send(vec![7u8, 8u8]).unwrap();
+          tx.send(vec![3, 4]).unwrap();
+          tx.send(vec![5, 6]).unwrap();
+          tx.send(vec![7, 8]).unwrap();
         });
 
         let mut reader = ChanReader::new(rx);
-        let mut buf = [0u8; 3];
+        let mut buf = [0; 3];
 
         assert_eq!(Ok(0), reader.read(&mut []));
 
@@ -233,7 +233,7 @@ mod test {
         let mut writer = ChanWriter::new(tx);
         writer.write_be_u32(42).unwrap();
 
-        let wanted = vec![0u8, 0u8, 0u8, 42u8];
+        let wanted = vec![0, 0, 0, 42];
         let got = thread::scoped(move|| { rx.recv().unwrap() }).join();
         assert_eq!(wanted, got);
 
diff --git a/src/libstd/old_io/extensions.rs b/src/libstd/old_io/extensions.rs
index 45a86a9fde7..a2bc28962c3 100644
--- a/src/libstd/old_io/extensions.rs
+++ b/src/libstd/old_io/extensions.rs
@@ -101,7 +101,7 @@ pub fn u64_to_le_bytes<T, F>(n: u64, size: uint, f: F) -> T where
         let mut i = size;
         let mut n = n;
         while i > 0 {
-            bytes.push((n & 255_u64) as u8);
+            bytes.push((n & 255) as u8);
             n >>= 8;
             i -= 1;
         }
@@ -170,7 +170,7 @@ pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
         panic!("index out of bounds");
     }
 
-    let mut buf = [0u8; 8];
+    let mut buf = [0; 8];
     unsafe {
         let ptr = data.as_ptr().offset(start as int);
         let out = buf.as_mut_ptr();
@@ -522,8 +522,8 @@ mod bench {
         ({
             use super::u64_from_be_bytes;
 
-            let data = (0u8..$stride*100+$start_index).collect::<Vec<_>>();
-            let mut sum = 0u64;
+            let data = (0..$stride*100+$start_index).collect::<Vec<_>>();
+            let mut sum = 0;
             $b.iter(|| {
                 let mut i = $start_index;
                 while i < data.len() {
diff --git a/src/libstd/old_io/fs.rs b/src/libstd/old_io/fs.rs
index 4e9c1b36055..64092311e6c 100644
--- a/src/libstd/old_io/fs.rs
+++ b/src/libstd/old_io/fs.rs
@@ -1110,7 +1110,7 @@ mod test {
             check!(w.write(msg));
         }
         let files = check!(readdir(dir));
-        let mut mem = [0u8; 4];
+        let mut mem = [0; 4];
         for f in &files {
             {
                 let n = f.filestem_str();
@@ -1142,7 +1142,7 @@ mod test {
         check!(File::create(&dir2.join("14")));
 
         let mut files = check!(walk_dir(dir));
-        let mut cur = [0u8; 2];
+        let mut cur = [0; 2];
         for f in files {
             let stem = f.filestem_str().unwrap();
             let root = stem.as_bytes()[0] - b'0';
diff --git a/src/libstd/old_io/mod.rs b/src/libstd/old_io/mod.rs
index 728a5dac4e4..9ce888efceb 100644
--- a/src/libstd/old_io/mod.rs
+++ b/src/libstd/old_io/mod.rs
@@ -670,7 +670,7 @@ pub trait Reader {
     fn read_le_uint_n(&mut self, nbytes: uint) -> IoResult<u64> {
         assert!(nbytes > 0 && nbytes <= 8);
 
-        let mut val = 0u64;
+        let mut val = 0;
         let mut pos = 0;
         let mut i = nbytes;
         while i > 0 {
@@ -694,7 +694,7 @@ pub trait Reader {
     fn read_be_uint_n(&mut self, nbytes: uint) -> IoResult<u64> {
         assert!(nbytes > 0 && nbytes <= 8);
 
-        let mut val = 0u64;
+        let mut val = 0;
         let mut i = nbytes;
         while i > 0 {
             i -= 1;
@@ -1078,7 +1078,7 @@ pub trait Writer {
     /// Write a single char, encoded as UTF-8.
     #[inline]
     fn write_char(&mut self, c: char) -> IoResult<()> {
-        let mut buf = [0u8; 4];
+        let mut buf = [0; 4];
         let n = c.encode_utf8(&mut buf).unwrap_or(0);
         self.write_all(&buf[..n])
     }
@@ -1896,7 +1896,7 @@ mod tests {
     fn test_read_at_least() {
         let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
                                    vec![GoodBehavior(usize::MAX)]);
-        let buf = &mut [0u8; 5];
+        let buf = &mut [0; 5];
         assert!(r.read_at_least(1, buf).unwrap() >= 1);
         assert!(r.read_exact(5).unwrap().len() == 5); // read_exact uses read_at_least
         assert!(r.read_at_least(0, buf).is_ok());
diff --git a/src/libstd/old_io/net/ip.rs b/src/libstd/old_io/net/ip.rs
index f1634cd4229..6e2f491262d 100644
--- a/src/libstd/old_io/net/ip.rs
+++ b/src/libstd/old_io/net/ip.rs
@@ -198,7 +198,7 @@ impl<'a> Parser<'a> {
     }
 
     fn read_number_impl(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
-        let mut r = 0u32;
+        let mut r = 0;
         let mut digit_count = 0;
         loop {
             match self.read_digit(radix) {
@@ -226,7 +226,7 @@ impl<'a> Parser<'a> {
     }
 
     fn read_ipv4_addr_impl(&mut self) -> Option<IpAddr> {
-        let mut bs = [0u8; 4];
+        let mut bs = [0; 4];
         let mut i = 0;
         while i < 4 {
             if i != 0 && self.read_given_char('.').is_none() {
@@ -251,7 +251,7 @@ impl<'a> Parser<'a> {
     fn read_ipv6_addr_impl(&mut self) -> Option<IpAddr> {
         fn ipv6_addr_from_head_tail(head: &[u16], tail: &[u16]) -> IpAddr {
             assert!(head.len() + tail.len() <= 8);
-            let mut gs = [0u16; 8];
+            let mut gs = [0; 8];
             gs.clone_from_slice(head);
             gs[(8 - tail.len()) .. 8].clone_from_slice(tail);
             Ipv6Addr(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
@@ -294,7 +294,7 @@ impl<'a> Parser<'a> {
             (i, false)
         }
 
-        let mut head = [0u16; 8];
+        let mut head = [0; 8];
         let (head_size, head_ipv4) = read_groups(self, &mut head, 8);
 
         if head_size == 8 {
@@ -313,7 +313,7 @@ impl<'a> Parser<'a> {
             return None;
         }
 
-        let mut tail = [0u16; 8];
+        let mut tail = [0; 8];
         let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
         Some(ipv6_addr_from_head_tail(&head[..head_size], &tail[..tail_size]))
     }
@@ -425,17 +425,17 @@ pub struct ParseError;
 ///     // The following lines are equivalent modulo possible "localhost" name resolution
 ///     // differences
 ///     let tcp_s = TcpStream::connect(SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 12345 });
-///     let tcp_s = TcpStream::connect((Ipv4Addr(127, 0, 0, 1), 12345u16));
-///     let tcp_s = TcpStream::connect(("127.0.0.1", 12345u16));
-///     let tcp_s = TcpStream::connect(("localhost", 12345u16));
+///     let tcp_s = TcpStream::connect((Ipv4Addr(127, 0, 0, 1), 12345));
+///     let tcp_s = TcpStream::connect(("127.0.0.1", 12345));
+///     let tcp_s = TcpStream::connect(("localhost", 12345));
 ///     let tcp_s = TcpStream::connect("127.0.0.1:12345");
 ///     let tcp_s = TcpStream::connect("localhost:12345");
 ///
 ///     // TcpListener::bind(), UdpSocket::bind() and UdpSocket::send_to() behave similarly
 ///     let tcp_l = TcpListener::bind("localhost:12345");
 ///
-///     let mut udp_s = UdpSocket::bind(("127.0.0.1", 23451u16)).unwrap();
-///     udp_s.send_to([7u8, 7u8, 7u8].as_slice(), (Ipv4Addr(127, 0, 0, 1), 23451u16));
+///     let mut udp_s = UdpSocket::bind(("127.0.0.1", 23451)).unwrap();
+///     udp_s.send_to([7, 7, 7].as_slice(), (Ipv4Addr(127, 0, 0, 1), 23451));
 /// }
 /// ```
 pub trait ToSocketAddr {
@@ -674,7 +674,7 @@ mod test {
     #[test]
     fn to_socket_addr_ipaddr_u16() {
         let a = Ipv4Addr(77, 88, 21, 11);
-        let p = 12345u16;
+        let p = 12345;
         let e = SocketAddr { ip: a, port: p };
         assert_eq!(Ok(e), (a, p).to_socket_addr());
         assert_eq!(Ok(vec![e]), (a, p).to_socket_addr_all());
@@ -683,15 +683,15 @@ mod test {
     #[test]
     fn to_socket_addr_str_u16() {
         let a = SocketAddr { ip: Ipv4Addr(77, 88, 21, 11), port: 24352 };
-        assert_eq!(Ok(a), ("77.88.21.11", 24352u16).to_socket_addr());
-        assert_eq!(Ok(vec![a]), ("77.88.21.11", 24352u16).to_socket_addr_all());
+        assert_eq!(Ok(a), ("77.88.21.11", 24352).to_socket_addr());
+        assert_eq!(Ok(vec![a]), ("77.88.21.11", 24352).to_socket_addr_all());
 
         let a = SocketAddr { ip: Ipv6Addr(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), port: 53 };
         assert_eq!(Ok(a), ("2a02:6b8:0:1::1", 53).to_socket_addr());
         assert_eq!(Ok(vec![a]), ("2a02:6b8:0:1::1", 53).to_socket_addr_all());
 
         let a = SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 23924 };
-        assert!(("localhost", 23924u16).to_socket_addr_all().unwrap().contains(&a));
+        assert!(("localhost", 23924).to_socket_addr_all().unwrap().contains(&a));
     }
 
     #[test]
diff --git a/src/libstd/old_io/net/tcp.rs b/src/libstd/old_io/net/tcp.rs
index 19a6f6e3def..73ef21fa3aa 100644
--- a/src/libstd/old_io/net/tcp.rs
+++ b/src/libstd/old_io/net/tcp.rs
@@ -1162,7 +1162,7 @@ mod test {
                 tx.send(TcpStream::connect(addr).unwrap()).unwrap();
             });
             let _l = rx.recv().unwrap();
-            for i in 0i32..1001 {
+            for i in 0..1001 {
                 match a.accept() {
                     Ok(..) => break,
                     Err(ref e) if e.kind == TimedOut => {}
@@ -1262,7 +1262,7 @@ mod test {
         assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         s.set_timeout(Some(20));
-        for i in 0i32..1001 {
+        for i in 0..1001 {
             match s.write(&[0; 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
@@ -1320,7 +1320,7 @@ mod test {
 
         let mut s = a.accept().unwrap();
         s.set_write_timeout(Some(20));
-        for i in 0i32..1001 {
+        for i in 0..1001 {
             match s.write(&[0; 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
diff --git a/src/libstd/old_io/test.rs b/src/libstd/old_io/test.rs
index 43c0b9268a2..9fbdac84a80 100644
--- a/src/libstd/old_io/test.rs
+++ b/src/libstd/old_io/test.rs
@@ -73,8 +73,8 @@ it is running in and assigns a port range based on it.
 */
 fn base_port() -> u16 {
 
-    let base = 9600u16;
-    let range = 1000u16;
+    let base = 9600;
+    let range = 1000;
 
     let bases = [
         ("32-opt", base + range * 1),
diff --git a/src/libstd/old_io/util.rs b/src/libstd/old_io/util.rs
index 8e49335ed54..5283b28e20d 100644
--- a/src/libstd/old_io/util.rs
+++ b/src/libstd/old_io/util.rs
@@ -418,7 +418,7 @@ mod test {
 
     #[test]
     fn test_iter_reader() {
-        let mut r = IterReader::new(0u8..8);
+        let mut r = IterReader::new(0..8);
         let mut buf = [0, 0, 0];
         let len = r.read(&mut buf).unwrap();
         assert_eq!(len, 3);
@@ -437,7 +437,7 @@ mod test {
 
     #[test]
     fn iter_reader_zero_length() {
-        let mut r = IterReader::new(0u8..8);
+        let mut r = IterReader::new(0..8);
         let mut buf = [];
         assert_eq!(Ok(0), r.read(&mut buf));
     }
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index a49db012882..4ed1520ed03 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -468,7 +468,7 @@ mod test {
         let lengths = [0, 1, 2, 3, 4, 5, 6, 7,
                        80, 81, 82, 83, 84, 85, 86, 87];
         for &n in &lengths {
-            let mut v = repeat(0u8).take(n).collect::<Vec<_>>();
+            let mut v = repeat(0).take(n).collect::<Vec<_>>();
             r.fill_bytes(&mut v);
 
             // use this to get nicer error messages.
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index c2ead267578..6cb3eb4d16e 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -80,13 +80,13 @@ mod imp {
     }
 
     fn getrandom_next_u32() -> u32 {
-        let mut buf: [u8; 4] = [0u8; 4];
+        let mut buf: [u8; 4] = [0; 4];
         getrandom_fill_bytes(&mut buf);
         unsafe { mem::transmute::<[u8; 4], u32>(buf) }
     }
 
     fn getrandom_next_u64() -> u64 {
-        let mut buf: [u8; 8] = [0u8; 8];
+        let mut buf: [u8; 8] = [0; 8];
         getrandom_fill_bytes(&mut buf);
         unsafe { mem::transmute::<[u8; 8], u64>(buf) }
     }
@@ -231,12 +231,12 @@ mod imp {
 
     impl Rng for OsRng {
         fn next_u32(&mut self) -> u32 {
-            let mut v = [0u8; 4];
+            let mut v = [0; 4];
             self.fill_bytes(&mut v);
             unsafe { mem::transmute(v) }
         }
         fn next_u64(&mut self) -> u64 {
-            let mut v = [0u8; 8];
+            let mut v = [0; 8];
             self.fill_bytes(&mut v);
             unsafe { mem::transmute(v) }
         }
@@ -318,12 +318,12 @@ mod imp {
 
     impl Rng for OsRng {
         fn next_u32(&mut self) -> u32 {
-            let mut v = [0u8; 4];
+            let mut v = [0; 4];
             self.fill_bytes(&mut v);
             unsafe { mem::transmute(v) }
         }
         fn next_u64(&mut self) -> u64 {
-            let mut v = [0u8; 8];
+            let mut v = [0; 8];
             self.fill_bytes(&mut v);
             unsafe { mem::transmute(v) }
         }
@@ -366,7 +366,7 @@ mod test {
         r.next_u32();
         r.next_u64();
 
-        let mut v = [0u8; 1000];
+        let mut v = [0; 1000];
         r.fill_bytes(&mut v);
     }
 
@@ -386,7 +386,7 @@ mod test {
                 // as possible (XXX: is this a good test?)
                 let mut r = OsRng::new().unwrap();
                 thread::yield_now();
-                let mut v = [0u8; 1000];
+                let mut v = [0; 1000];
 
                 for _ in 0..100 {
                     r.next_u32();
diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs
index b71e8b4fd61..ba1ebc2ab22 100644
--- a/src/libstd/rand/reader.rs
+++ b/src/libstd/rand/reader.rs
@@ -84,28 +84,28 @@ mod test {
     #[test]
     fn test_reader_rng_u64() {
         // transmute from the target to avoid endianness concerns.
-        let v = vec![0u8, 0, 0, 0, 0, 0, 0, 1,
+        let v = vec![0, 0, 0, 0, 0, 0, 0, 1,
                      0  , 0, 0, 0, 0, 0, 0, 2,
                      0,   0, 0, 0, 0, 0, 0, 3];
         let mut rng = ReaderRng::new(MemReader::new(v));
 
-        assert_eq!(rng.next_u64(), 1_u64.to_be());
-        assert_eq!(rng.next_u64(), 2_u64.to_be());
-        assert_eq!(rng.next_u64(), 3_u64.to_be());
+        assert_eq!(rng.next_u64(), 1.to_be());
+        assert_eq!(rng.next_u64(), 2.to_be());
+        assert_eq!(rng.next_u64(), 3.to_be());
     }
     #[test]
     fn test_reader_rng_u32() {
-        let v = vec![0u8, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3];
+        let v = vec![0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3];
         let mut rng = ReaderRng::new(MemReader::new(v));
 
-        assert_eq!(rng.next_u32(), 1_u32.to_be());
-        assert_eq!(rng.next_u32(), 2_u32.to_be());
-        assert_eq!(rng.next_u32(), 3_u32.to_be());
+        assert_eq!(rng.next_u32(), 1.to_be());
+        assert_eq!(rng.next_u32(), 2.to_be());
+        assert_eq!(rng.next_u32(), 3.to_be());
     }
     #[test]
     fn test_reader_rng_fill_bytes() {
-        let v = [1u8, 2, 3, 4, 5, 6, 7, 8];
-        let mut w = [0u8; 8];
+        let v = [1, 2, 3, 4, 5, 6, 7, 8];
+        let mut w = [0; 8];
 
         let mut rng = ReaderRng::new(MemReader::new(v.to_vec()));
         rng.fill_bytes(&mut w);
@@ -117,7 +117,7 @@ mod test {
     #[should_fail]
     fn test_reader_rng_insufficient_bytes() {
         let mut rng = ReaderRng::new(MemReader::new(vec!()));
-        let mut v = [0u8; 3];
+        let mut v = [0; 3];
         rng.fill_bytes(&mut v);
     }
 }
diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs
index a304f1f844d..dc557403153 100644
--- a/src/libstd/rt/util.rs
+++ b/src/libstd/rt/util.rs
@@ -139,7 +139,7 @@ pub fn abort(args: fmt::Arguments) -> ! {
     }
 
     // Convert the arguments into a stack-allocated string
-    let mut msg = [0u8; 512];
+    let mut msg = [0; 512];
     let mut w = BufWriter { buf: &mut msg, pos: 0 };
     let _ = write!(&mut w, "{}", args);
     let msg = str::from_utf8(&w.buf[..w.pos]).unwrap_or("aborted");
diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs
index 31bdaee1e34..719c74179ac 100644
--- a/src/libstd/sys/common/wtf8.rs
+++ b/src/libstd/sys/common/wtf8.rs
@@ -714,7 +714,7 @@ pub fn is_code_point_boundary(slice: &Wtf8, index: uint) -> bool {
     if index == slice.len() { return true; }
     match slice.bytes.get(index) {
         None => false,
-        Some(&b) => b < 128u8 || b >= 192u8,
+        Some(&b) => b < 128 || b >= 192,
     }
 }
 
@@ -776,7 +776,7 @@ impl<'a> Iterator for EncodeWide<'a> {
             return Some(tmp);
         }
 
-        let mut buf = [0u16; 2];
+        let mut buf = [0; 2];
         self.code_points.next().map(|code_point| {
             let n = encode_utf16_raw(code_point.value, &mut buf)
                 .unwrap_or(0);
diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs
index 71b6214460f..3d490380bfd 100644
--- a/src/libstd/sys/unix/fs.rs
+++ b/src/libstd/sys/unix/fs.rs
@@ -389,7 +389,7 @@ mod tests {
         let mut writer = FileDesc::new(writer, true);
 
         writer.write(b"test").ok().unwrap();
-        let mut buf = [0u8; 4];
+        let mut buf = [0; 4];
         match reader.read(&mut buf) {
             Ok(4) => {
                 assert_eq!(buf[0], 't' as u8);
diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs
index 9be77e78ed1..0ce3ca1f97a 100644
--- a/src/libstd/thread.rs
+++ b/src/libstd/thread.rs
@@ -901,7 +901,7 @@ mod test {
                 assert!(e.is::<T>());
                 let any = e.downcast::<T>().ok().unwrap();
                 assert!(any.is::<u16>());
-                assert_eq!(*any.downcast::<u16>().ok().unwrap(), 413u16);
+                assert_eq!(*any.downcast::<u16>().ok().unwrap(), 413);
             }
             Ok(()) => panic!()
         }
diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs
index 988b13cd160..41b70889c9f 100644
--- a/src/libstd/tuple.rs
+++ b/src/libstd/tuple.rs
@@ -53,7 +53,7 @@
 //! assert!(b == c);
 //!
 //! let d : (u32, f32) = Default::default();
-//! assert_eq!(d, (0u32, 0.0f32));
+//! assert_eq!(d, (0, 0.0f32));
 //! ```
 
 #![doc(primitive = "tuple")]
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 264e05f5c8d..26d7562cdb2 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -159,10 +159,10 @@ pub fn int_ty_to_string(t: IntTy, val: Option<i64>) -> String {
 
 pub fn int_ty_max(t: IntTy) -> u64 {
     match t {
-        TyI8 => 0x80u64,
-        TyI16 => 0x8000u64,
-        TyIs(_) | TyI32 => 0x80000000u64, // actually ni about TyIs
-        TyI64 => 0x8000000000000000u64
+        TyI8 => 0x80,
+        TyI16 => 0x8000,
+        TyIs(_) | TyI32 => 0x80000000, // actually ni about TyIs
+        TyI64 => 0x8000000000000000
     }
 }
 
@@ -185,10 +185,10 @@ pub fn uint_ty_to_string(t: UintTy, val: Option<u64>) -> String {
 
 pub fn uint_ty_max(t: UintTy) -> u64 {
     match t {
-        TyU8 => 0xffu64,
-        TyU16 => 0xffffu64,
-        TyUs(_) | TyU32 => 0xffffffffu64, // actually ni about TyUs
-        TyU64 => 0xffffffffffffffffu64
+        TyU8 => 0xff,
+        TyU16 => 0xffff,
+        TyUs(_) | TyU32 => 0xffffffff, // actually ni about TyUs
+        TyU64 => 0xffffffffffffffff
     }
 }
 
diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs
index 756d67b5db1..f3433db5e9b 100644
--- a/src/libterm/lib.rs
+++ b/src/libterm/lib.rs
@@ -153,23 +153,23 @@ pub mod color {
     /// Number for a terminal color
     pub type Color = u16;
 
-    pub const BLACK:   Color = 0u16;
-    pub const RED:     Color = 1u16;
-    pub const GREEN:   Color = 2u16;
-    pub const YELLOW:  Color = 3u16;
-    pub const BLUE:    Color = 4u16;
-    pub const MAGENTA: Color = 5u16;
-    pub const CYAN:    Color = 6u16;
-    pub const WHITE:   Color = 7u16;
+    pub const BLACK:   Color = 0;
+    pub const RED:     Color = 1;
+    pub const GREEN:   Color = 2;
+    pub const YELLOW:  Color = 3;
+    pub const BLUE:    Color = 4;
+    pub const MAGENTA: Color = 5;
+    pub const CYAN:    Color = 6;
+    pub const WHITE:   Color = 7;
 
-    pub const BRIGHT_BLACK:   Color = 8u16;
-    pub const BRIGHT_RED:     Color = 9u16;
-    pub const BRIGHT_GREEN:   Color = 10u16;
-    pub const BRIGHT_YELLOW:  Color = 11u16;
-    pub const BRIGHT_BLUE:    Color = 12u16;
-    pub const BRIGHT_MAGENTA: Color = 13u16;
-    pub const BRIGHT_CYAN:    Color = 14u16;
-    pub const BRIGHT_WHITE:   Color = 15u16;
+    pub const BRIGHT_BLACK:   Color = 8;
+    pub const BRIGHT_RED:     Color = 9;
+    pub const BRIGHT_GREEN:   Color = 10;
+    pub const BRIGHT_YELLOW:  Color = 11;
+    pub const BRIGHT_BLUE:    Color = 12;
+    pub const BRIGHT_MAGENTA: Color = 13;
+    pub const BRIGHT_CYAN:    Color = 14;
+    pub const BRIGHT_WHITE:   Color = 15;
 }
 
 /// Terminal attributes
diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs
index 112525fcce9..30b732781db 100644
--- a/src/libterm/terminfo/parm.rs
+++ b/src/libterm/terminfo/parm.rs
@@ -128,7 +128,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
                             // if c is 0, use 0200 (128) for ncurses compatibility
                             Number(c) => {
                                 output.push(if c == 0 {
-                                    128u8
+                                    128
                                 } else {
                                     c as u8
                                 })
@@ -647,7 +647,7 @@ mod test {
 
     #[test]
     fn test_comparison_ops() {
-        let v = [('<', [1u8, 0u8, 0u8]), ('=', [0u8, 1u8, 0u8]), ('>', [0u8, 0u8, 1u8])];
+        let v = [('<', [1, 0, 0]), ('=', [0, 1, 0]), ('>', [0, 0, 1])];
         for &(op, bs) in &v {
             let s = format!("%{{1}}%{{2}}%{}%d", op);
             let res = expand(s.as_bytes(), &[], &mut Variables::new());
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
index a144904903e..34daca0aa63 100644
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@@ -1011,7 +1011,7 @@ impl Bencher {
     pub fn iter<T, F>(&mut self, mut inner: F) where F: FnMut() -> T {
         self.dur = Duration::span(|| {
             let k = self.iterations;
-            for _ in 0u64..k {
+            for _ in 0..k {
                 black_box(inner());
             }
         });
@@ -1037,7 +1037,7 @@ impl Bencher {
     // This is a more statistics-driven benchmark algorithm
     pub fn auto_bench<F>(&mut self, mut f: F) -> stats::Summary<f64> where F: FnMut(&mut Bencher) {
         // Initial bench run to get ballpark figure.
-        let mut n = 1_u64;
+        let mut n = 1;
         self.bench_n(n, |x| f(x));
 
         // Try to estimate iter count for 1ms falling back to 1m
diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs
index 38cbe5c7dea..57439addeaa 100644
--- a/src/libunicode/u_str.rs
+++ b/src/libunicode/u_str.rs
@@ -525,7 +525,7 @@ impl<I> Iterator for Utf16Encoder<I> where I: Iterator<Item=char> {
             return Some(tmp);
         }
 
-        let mut buf = [0u16; 2];
+        let mut buf = [0; 2];
         self.chars.next().map(|ch| {
             let n = CharExt::encode_utf16(ch, &mut buf).unwrap_or(0);
             if n == 2 { self.extra = buf[1]; }
diff --git a/src/test/auxiliary/cci_class_3.rs b/src/test/auxiliary/cci_class_3.rs
index 98881eb09bf..44d3a69fde4 100644
--- a/src/test/auxiliary/cci_class_3.rs
+++ b/src/test/auxiliary/cci_class_3.rs
@@ -16,7 +16,7 @@ pub mod kitties {
     }
 
     impl cat {
-        pub fn speak(&mut self) { self.meows += 1_usize; }
+        pub fn speak(&mut self) { self.meows += 1; }
         pub fn meow_count(&mut self) -> uint { self.meows }
     }
 
diff --git a/src/test/auxiliary/cci_class_4.rs b/src/test/auxiliary/cci_class_4.rs
index 9d7905cdebd..c10ef805a65 100644
--- a/src/test/auxiliary/cci_class_4.rs
+++ b/src/test/auxiliary/cci_class_4.rs
@@ -34,8 +34,8 @@ pub mod kitties {
     impl cat {
         pub fn meow(&mut self) {
             println!("Meow");
-            self.meows += 1_usize;
-            if self.meows % 5_usize == 0_usize {
+            self.meows += 1;
+            if self.meows % 5 == 0 {
                 self.how_hungry += 1;
             }
         }
diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs
index 96a06968c5f..28fa354fef3 100644
--- a/src/test/auxiliary/cci_class_cast.rs
+++ b/src/test/auxiliary/cci_class_cast.rs
@@ -26,8 +26,8 @@ pub mod kitty {
     impl cat {
         fn meow(&mut self) {
             println!("Meow");
-            self.meows += 1_usize;
-            if self.meows % 5_usize == 0_usize {
+            self.meows += 1;
+            if self.meows % 5 == 0 {
                 self.how_hungry += 1;
             }
         }
diff --git a/src/test/auxiliary/cci_impl_lib.rs b/src/test/auxiliary/cci_impl_lib.rs
index 6ee497370e8..a650b30e593 100644
--- a/src/test/auxiliary/cci_impl_lib.rs
+++ b/src/test/auxiliary/cci_impl_lib.rs
@@ -20,7 +20,7 @@ impl uint_helpers for uint {
         let mut i = *self;
         while i < v {
             f(i);
-            i += 1_usize;
+            i += 1;
         }
     }
 }
diff --git a/src/test/auxiliary/cci_iter_lib.rs b/src/test/auxiliary/cci_iter_lib.rs
index 8e00b0dc7be..07d03b4c759 100644
--- a/src/test/auxiliary/cci_iter_lib.rs
+++ b/src/test/auxiliary/cci_iter_lib.rs
@@ -12,10 +12,10 @@
 
 #[inline]
 pub fn iter<T, F>(v: &[T], mut f: F) where F: FnMut(&T) {
-    let mut i = 0_usize;
+    let mut i = 0;
     let n = v.len();
     while i < n {
         f(&v[i]);
-        i += 1_usize;
+        i += 1;
     }
 }
diff --git a/src/test/auxiliary/cci_no_inline_lib.rs b/src/test/auxiliary/cci_no_inline_lib.rs
index ce041118906..f3ad2a3aeb9 100644
--- a/src/test/auxiliary/cci_no_inline_lib.rs
+++ b/src/test/auxiliary/cci_no_inline_lib.rs
@@ -13,10 +13,10 @@
 
 // same as cci_iter_lib, more-or-less, but not marked inline
 pub fn iter<F>(v: Vec<uint> , mut f: F) where F: FnMut(uint) {
-    let mut i = 0_usize;
+    let mut i = 0;
     let n = v.len();
     while i < n {
         f(v[i]);
-        i += 1_usize;
+        i += 1;
     }
 }
diff --git a/src/test/auxiliary/macro_reexport_1.rs b/src/test/auxiliary/macro_reexport_1.rs
index 9c72cb1a680..aaeccc6e898 100644
--- a/src/test/auxiliary/macro_reexport_1.rs
+++ b/src/test/auxiliary/macro_reexport_1.rs
@@ -11,5 +11,5 @@
 #![crate_type = "dylib"]
 #[macro_export]
 macro_rules! reexported {
-    () => ( 3_usize )
+    () => ( 3 )
 }
diff --git a/src/test/auxiliary/roman_numerals.rs b/src/test/auxiliary/roman_numerals.rs
index e5c42111105..0ea7c000570 100644
--- a/src/test/auxiliary/roman_numerals.rs
+++ b/src/test/auxiliary/roman_numerals.rs
@@ -47,7 +47,7 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
     };
 
     let mut text = &*text;
-    let mut total = 0_usize;
+    let mut total = 0;
     while !text.is_empty() {
         match NUMERALS.iter().find(|&&(rn, _)| text.starts_with(rn)) {
             Some(&(rn, val)) => {
diff --git a/src/test/auxiliary/unboxed-closures-cross-crate.rs b/src/test/auxiliary/unboxed-closures-cross-crate.rs
index a5178c03443..26925a35067 100644
--- a/src/test/auxiliary/unboxed-closures-cross-crate.rs
+++ b/src/test/auxiliary/unboxed-closures-cross-crate.rs
@@ -14,9 +14,9 @@ use std::ops::Add;
 
 #[inline]
 pub fn has_closures() -> uint {
-    let x = 1_usize;
+    let x = 1;
     let mut f = move || x;
-    let y = 1_usize;
+    let y = 1;
     let g = || y;
     f() + g()
 }
diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs
index 53c52ae3019..de88c7733b3 100644
--- a/src/test/bench/noise.rs
+++ b/src/test/bench/noise.rs
@@ -49,7 +49,7 @@ impl Noise2DContext {
             *x = random_gradient(&mut rng);
         }
 
-        let mut permutations = [0i32; 256];
+        let mut permutations = [0; 256];
         for (i, x) in permutations.iter_mut().enumerate() {
             *x = i as i32;
         }
diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs
index 73e7c8eb073..4a8bb24270d 100644
--- a/src/test/bench/shootout-chameneos-redux.rs
+++ b/src/test/bench/shootout-chameneos-redux.rs
@@ -145,7 +145,7 @@ fn creature(
     to_rendezvous: Sender<CreatureInfo>,
     to_rendezvous_log: Sender<String>
 ) {
-    let mut creatures_met = 0i32;
+    let mut creatures_met = 0;
     let mut evil_clones_met = 0;
     let mut rendezvous = from_rendezvous.iter();
 
diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs
index f7de935d08f..3688c224a7d 100644
--- a/src/test/bench/shootout-fannkuch-redux.rs
+++ b/src/test/bench/shootout-fannkuch-redux.rs
@@ -91,7 +91,7 @@ impl Perm {
     }
 
     fn get(&mut self, mut idx: i32) -> P {
-        let mut pp = [0u8; 16];
+        let mut pp = [0; 16];
         self.permcount = idx as u32;
         for (i, place) in self.perm.p.iter_mut().enumerate() {
             *place = i as i32 + 1;
@@ -183,7 +183,7 @@ fn main() {
     let n = std::env::args()
         .nth(1)
         .and_then(|arg| arg.parse().ok())
-        .unwrap_or(2i32);
+        .unwrap_or(2);
 
     let (checksum, maxflips) = fannkuch(n);
     println!("{}\nPfannkuchen({}) = {}", checksum, n, maxflips);
diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index 277c3ee73df..9cee75757aa 100644
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -121,7 +121,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> {
 
     fn make(&mut self, n: usize) -> IoResult<()> {
         let alu_len = self.alu.len();
-        let mut buf = repeat(0u8).take(alu_len + LINE_LEN).collect::<Vec<_>>();
+        let mut buf = repeat(0).take(alu_len + LINE_LEN).collect::<Vec<_>>();
         let alu: &[u8] = self.alu.as_bytes();
 
         copy_memory(&mut buf, alu);
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 2c640c4b092..e15f9d99ff6 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -89,7 +89,7 @@ fn make_fasta<W: Writer, I: Iterator<Item=u8>>(
     -> std::old_io::IoResult<()>
 {
     try!(wr.write(header.as_bytes()));
-    let mut line = [0u8; LINE_LENGTH + 1];
+    let mut line = [0; LINE_LENGTH + 1];
     while n > 0 {
         let nb = min(LINE_LENGTH, n);
         for i in 0..nb {
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 5cfe62d967c..9e5885041b6 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -78,11 +78,11 @@ impl Code {
     }
 
     fn rotate(&self, c: u8, frame: usize) -> Code {
-        Code(self.push_char(c).hash() & ((1u64 << (2 * frame)) - 1))
+        Code(self.push_char(c).hash() & ((1 << (2 * frame)) - 1))
     }
 
     fn pack(string: &str) -> Code {
-        string.bytes().fold(Code(0u64), |a, b| a.push_char(b))
+        string.bytes().fold(Code(0), |a, b| a.push_char(b))
     }
 
     fn unpack(&self, frame: usize) -> String {
diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs
index a94fe0ccd95..79a5245a408 100644
--- a/src/test/bench/shootout-meteor.rs
+++ b/src/test/bench/shootout-meteor.rs
@@ -169,7 +169,7 @@ fn make_masks() -> Vec<Vec<Vec<u64> > > {
         .map(|(id, p)| transform(p, id != 3))
         .collect();
 
-    (0i32..50).map(|yx| {
+    (0..50).map(|yx| {
         transforms.iter().enumerate().map(|(id, t)| {
             t.iter().filter_map(|p| mask(yx / 5, yx % 5, id, p)).collect()
         }).collect()
@@ -211,7 +211,7 @@ fn filter_masks(masks: &mut Vec<Vec<Vec<u64>>>) {
 
 // Gets the identifier of a mask.
 fn get_id(m: u64) -> u8 {
-    for id in 0u8..10 {
+    for id in 0..10 {
         if m & (1 << (id + 50) as usize) != 0 {return id;}
     }
     panic!("{:016x} does not have a valid identifier", m);
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index f308743ad13..9a82614510e 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -60,7 +60,7 @@ impl Sudoku {
         reader.read_line(&mut s).unwrap();
         assert_eq!(s, "9,9\n");
 
-        let mut g = repeat(vec![0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])
+        let mut g = repeat(vec![0, 0, 0, 0, 0, 0, 0, 0, 0])
                           .take(10).collect::<Vec<_>>();
         for line in reader.lines() {
             let line = line.unwrap();
@@ -94,10 +94,10 @@ impl Sudoku {
     // solve sudoku grid
     pub fn solve(&mut self) {
         let mut work: Vec<(u8, u8)> = Vec::new(); /* queue of uncolored fields */
-        for row in 0u8..9u8 {
-            for col in 0u8..9u8 {
+        for row in 0..9 {
+            for col in 0..9 {
                 let color = self.grid[row as usize][col as usize];
-                if color == 0u8 {
+                if color == 0 {
                     work.push((row, col));
                 }
             }
@@ -122,7 +122,7 @@ impl Sudoku {
     }
 
     fn next_color(&mut self, row: u8, col: u8, start_color: u8) -> bool {
-        if start_color < 10u8 {
+        if start_color < 10 {
             // colors not yet used
             let mut avail: Box<_> = box Colors::new(start_color);
 
@@ -132,15 +132,15 @@ impl Sudoku {
             // find first remaining color that is available
             let next = avail.next();
             self.grid[row as usize][col as usize] = next;
-            return 0u8 != next;
+            return 0 != next;
         }
-        self.grid[row as usize][col as usize] = 0u8;
+        self.grid[row as usize][col as usize] = 0;
         return false;
     }
 
     // find colors available in neighbourhood of (row, col)
     fn drop_colors(&mut self, avail: &mut Colors, row: u8, col: u8) {
-        for idx in 0u8..9u8 {
+        for idx in 0..9 {
             /* check same column fields */
             avail.remove(self.grid[idx as usize][col as usize]);
             /* check same row fields */
@@ -148,10 +148,10 @@ impl Sudoku {
         }
 
         // check same block fields
-        let row0 = (row / 3u8) * 3u8;
-        let col0 = (col / 3u8) * 3u8;
-        for alt_row in row0..row0 + 3u8 {
-            for alt_col in col0..col0 + 3u8 {
+        let row0 = (row / 3) * 3;
+        let col0 = (col / 3) * 3;
+        for alt_row in row0..row0 + 3 {
+            for alt_col in col0..col0 + 3 {
                 avail.remove(self.grid[alt_row as usize][alt_col as usize]);
             }
         }
@@ -161,29 +161,29 @@ impl Sudoku {
 // Stores available colors as simple bitfield, bit 0 is always unset
 struct Colors(u16);
 
-static HEADS: u16 = (1u16 << 10) - 1; /* bits 9..0 */
+static HEADS: u16 = (1 << 10) - 1; /* bits 9..0 */
 
 impl Colors {
     fn new(start_color: u8) -> Colors {
         // Sets bits 9..start_color
-        let tails = !0u16 << start_color as usize;
+        let tails = !0 << start_color as usize;
         return Colors(HEADS & tails);
     }
 
     fn next(&self) -> u8 {
         let Colors(c) = *self;
         let val = c & HEADS;
-        if 0u16 == val {
-            return 0u8;
+        if 0 == val {
+            return 0;
         } else {
             return val.trailing_zeros() as u8
         }
     }
 
     fn remove(&mut self, color: u8) {
-        if color != 0u8 {
+        if color != 0 {
             let Colors(val) = *self;
-            let mask = !(1u16 << color as usize);
+            let mask = !(1 << color as usize);
             *self    = Colors(val & mask);
         }
     }
@@ -191,57 +191,57 @@ impl Colors {
 
 static DEFAULT_SUDOKU: [[u8;9];9] = [
          /* 0    1    2    3    4    5    6    7    8    */
-  /* 0 */  [0u8, 4u8, 0u8, 6u8, 0u8, 0u8, 0u8, 3u8, 2u8],
-  /* 1 */  [0u8, 0u8, 8u8, 0u8, 2u8, 0u8, 0u8, 0u8, 0u8],
-  /* 2 */  [7u8, 0u8, 0u8, 8u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-  /* 3 */  [0u8, 0u8, 0u8, 5u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-  /* 4 */  [0u8, 5u8, 0u8, 0u8, 0u8, 3u8, 6u8, 0u8, 0u8],
-  /* 5 */  [6u8, 8u8, 0u8, 0u8, 0u8, 0u8, 0u8, 9u8, 0u8],
-  /* 6 */  [0u8, 9u8, 5u8, 0u8, 0u8, 6u8, 0u8, 7u8, 0u8],
-  /* 7 */  [0u8, 0u8, 0u8, 0u8, 4u8, 0u8, 0u8, 6u8, 0u8],
-  /* 8 */  [4u8, 0u8, 0u8, 0u8, 0u8, 7u8, 2u8, 0u8, 3u8]
+  /* 0 */  [0, 4, 0, 6, 0, 0, 0, 3, 2],
+  /* 1 */  [0, 0, 8, 0, 2, 0, 0, 0, 0],
+  /* 2 */  [7, 0, 0, 8, 0, 0, 0, 0, 0],
+  /* 3 */  [0, 0, 0, 5, 0, 0, 0, 0, 0],
+  /* 4 */  [0, 5, 0, 0, 0, 3, 6, 0, 0],
+  /* 5 */  [6, 8, 0, 0, 0, 0, 0, 9, 0],
+  /* 6 */  [0, 9, 5, 0, 0, 6, 0, 7, 0],
+  /* 7 */  [0, 0, 0, 0, 4, 0, 0, 6, 0],
+  /* 8 */  [4, 0, 0, 0, 0, 7, 2, 0, 3]
 ];
 
 #[cfg(test)]
 static DEFAULT_SOLUTION: [[u8;9];9] = [
          /* 0    1    2    3    4    5    6    7    8    */
-  /* 0 */  [1u8, 4u8, 9u8, 6u8, 7u8, 5u8, 8u8, 3u8, 2u8],
-  /* 1 */  [5u8, 3u8, 8u8, 1u8, 2u8, 9u8, 7u8, 4u8, 6u8],
-  /* 2 */  [7u8, 2u8, 6u8, 8u8, 3u8, 4u8, 1u8, 5u8, 9u8],
-  /* 3 */  [9u8, 1u8, 4u8, 5u8, 6u8, 8u8, 3u8, 2u8, 7u8],
-  /* 4 */  [2u8, 5u8, 7u8, 4u8, 9u8, 3u8, 6u8, 1u8, 8u8],
-  /* 5 */  [6u8, 8u8, 3u8, 7u8, 1u8, 2u8, 5u8, 9u8, 4u8],
-  /* 6 */  [3u8, 9u8, 5u8, 2u8, 8u8, 6u8, 4u8, 7u8, 1u8],
-  /* 7 */  [8u8, 7u8, 2u8, 3u8, 4u8, 1u8, 9u8, 6u8, 5u8],
-  /* 8 */  [4u8, 6u8, 1u8, 9u8, 5u8, 7u8, 2u8, 8u8, 3u8]
+  /* 0 */  [1, 4, 9, 6, 7, 5, 8, 3, 2],
+  /* 1 */  [5, 3, 8, 1, 2, 9, 7, 4, 6],
+  /* 2 */  [7, 2, 6, 8, 3, 4, 1, 5, 9],
+  /* 3 */  [9, 1, 4, 5, 6, 8, 3, 2, 7],
+  /* 4 */  [2, 5, 7, 4, 9, 3, 6, 1, 8],
+  /* 5 */  [6, 8, 3, 7, 1, 2, 5, 9, 4],
+  /* 6 */  [3, 9, 5, 2, 8, 6, 4, 7, 1],
+  /* 7 */  [8, 7, 2, 3, 4, 1, 9, 6, 5],
+  /* 8 */  [4, 6, 1, 9, 5, 7, 2, 8, 3]
 ];
 
 #[test]
 fn colors_new_works() {
-    assert_eq!(*Colors::new(1), 1022u16);
-    assert_eq!(*Colors::new(2), 1020u16);
-    assert_eq!(*Colors::new(3), 1016u16);
-    assert_eq!(*Colors::new(4), 1008u16);
-    assert_eq!(*Colors::new(5), 992u16);
-    assert_eq!(*Colors::new(6), 960u16);
-    assert_eq!(*Colors::new(7), 896u16);
-    assert_eq!(*Colors::new(8), 768u16);
-    assert_eq!(*Colors::new(9), 512u16);
+    assert_eq!(*Colors::new(1), 1022);
+    assert_eq!(*Colors::new(2), 1020);
+    assert_eq!(*Colors::new(3), 1016);
+    assert_eq!(*Colors::new(4), 1008);
+    assert_eq!(*Colors::new(5), 992);
+    assert_eq!(*Colors::new(6), 960);
+    assert_eq!(*Colors::new(7), 896);
+    assert_eq!(*Colors::new(8), 768);
+    assert_eq!(*Colors::new(9), 512);
 }
 
 #[test]
 fn colors_next_works() {
-    assert_eq!(Colors(0).next(), 0u8);
-    assert_eq!(Colors(2).next(), 1u8);
-    assert_eq!(Colors(4).next(), 2u8);
-    assert_eq!(Colors(8).next(), 3u8);
-    assert_eq!(Colors(16).next(), 4u8);
-    assert_eq!(Colors(32).next(), 5u8);
-    assert_eq!(Colors(64).next(), 6u8);
-    assert_eq!(Colors(128).next(), 7u8);
-    assert_eq!(Colors(256).next(), 8u8);
-    assert_eq!(Colors(512).next(), 9u8);
-    assert_eq!(Colors(1024).next(), 0u8);
+    assert_eq!(Colors(0).next(), 0);
+    assert_eq!(Colors(2).next(), 1);
+    assert_eq!(Colors(4).next(), 2);
+    assert_eq!(Colors(8).next(), 3);
+    assert_eq!(Colors(16).next(), 4);
+    assert_eq!(Colors(32).next(), 5);
+    assert_eq!(Colors(64).next(), 6);
+    assert_eq!(Colors(128).next(), 7);
+    assert_eq!(Colors(256).next(), 8);
+    assert_eq!(Colors(512).next(), 9);
+    assert_eq!(Colors(1024).next(), 0);
 }
 
 #[test]
@@ -253,7 +253,7 @@ fn colors_remove_works() {
     colors.remove(1);
 
     // THEN
-    assert_eq!(colors.next(), 2u8);
+    assert_eq!(colors.next(), 2);
 }
 
 #[test]
diff --git a/src/test/compile-fail-fulldeps/issue-18986.rs b/src/test/compile-fail-fulldeps/issue-18986.rs
index 9b696e05c50..06fc3db58c1 100644
--- a/src/test/compile-fail-fulldeps/issue-18986.rs
+++ b/src/test/compile-fail-fulldeps/issue-18986.rs
@@ -15,6 +15,6 @@ pub use use_from_trait_xc::Trait;
 
 fn main() {
     match () {
-        Trait { x: 42_usize } => () //~ ERROR use of trait `Trait` in a struct pattern
+        Trait { x: 42 } => () //~ ERROR use of trait `Trait` in a struct pattern
     }
 }
diff --git a/src/test/compile-fail/array-not-vector.rs b/src/test/compile-fail/array-not-vector.rs
index 7111c00d124..81883108a2b 100644
--- a/src/test/compile-fail/array-not-vector.rs
+++ b/src/test/compile-fail/array-not-vector.rs
@@ -9,14 +9,14 @@
 // except according to those terms.
 
 fn main() {
-    let _x: i32 = [1i32, 2, 3];
+    let _x: i32 = [1, 2, 3];
     //~^ ERROR mismatched types
     //~| expected `i32`
     //~| found `[i32; 3]`
     //~| expected i32
     //~| found array of 3 elements
 
-    let x: &[i32] = &[1i32, 2, 3];
+    let x: &[i32] = &[1, 2, 3];
     let _y: &i32 = x;
     //~^ ERROR mismatched types
     //~| expected `&i32`
diff --git a/src/test/compile-fail/asm-in-bad-modifier.rs b/src/test/compile-fail/asm-in-bad-modifier.rs
index 01481af817b..3cb608a9c5e 100644
--- a/src/test/compile-fail/asm-in-bad-modifier.rs
+++ b/src/test/compile-fail/asm-in-bad-modifier.rs
@@ -20,8 +20,8 @@ pub fn main() {
     let x: isize;
     let y: isize;
     unsafe {
-        asm!("mov $1, $0" : "=r"(x) : "=r"(5_usize)); //~ ERROR operand constraint contains '='
-        asm!("mov $1, $0" : "=r"(y) : "+r"(5_usize)); //~ ERROR operand constraint contains '+'
+        asm!("mov $1, $0" : "=r"(x) : "=r"(5)); //~ ERROR operand constraint contains '='
+        asm!("mov $1, $0" : "=r"(y) : "+r"(5)); //~ ERROR operand constraint contains '+'
     }
     foo(x);
     foo(y);
diff --git a/src/test/compile-fail/asm-out-assign-imm.rs b/src/test/compile-fail/asm-out-assign-imm.rs
index ff56fb14f7d..8c8451623d5 100644
--- a/src/test/compile-fail/asm-out-assign-imm.rs
+++ b/src/test/compile-fail/asm-out-assign-imm.rs
@@ -21,7 +21,7 @@ pub fn main() {
     x = 1; //~ NOTE prior assignment occurs here
     foo(x);
     unsafe {
-        asm!("mov $1, $0" : "=r"(x) : "r"(5_usize));
+        asm!("mov $1, $0" : "=r"(x) : "r"(5));
         //~^ ERROR re-assignment of immutable variable `x`
     }
     foo(x);
diff --git a/src/test/compile-fail/asm-out-no-modifier.rs b/src/test/compile-fail/asm-out-no-modifier.rs
index 17c19c77ab9..9cf43bebe65 100644
--- a/src/test/compile-fail/asm-out-no-modifier.rs
+++ b/src/test/compile-fail/asm-out-no-modifier.rs
@@ -19,7 +19,7 @@ fn foo(x: isize) { println!("{}", x); }
 pub fn main() {
     let x: isize;
     unsafe {
-        asm!("mov $1, $0" : "r"(x) : "r"(5_usize)); //~ ERROR output operand constraint lacks '='
+        asm!("mov $1, $0" : "r"(x) : "r"(5)); //~ ERROR output operand constraint lacks '='
     }
     foo(x);
 }
diff --git a/src/test/compile-fail/assign-to-method.rs b/src/test/compile-fail/assign-to-method.rs
index d32ea327d0a..4518ce36b6d 100644
--- a/src/test/compile-fail/assign-to-method.rs
+++ b/src/test/compile-fail/assign-to-method.rs
@@ -15,7 +15,7 @@ struct cat {
 }
 
 impl cat {
-    pub fn speak(&self) { self.meows += 1_usize; }
+    pub fn speak(&self) { self.meows += 1; }
 }
 
 fn cat(in_x : usize, in_y : isize) -> cat {
@@ -26,6 +26,6 @@ fn cat(in_x : usize, in_y : isize) -> cat {
 }
 
 fn main() {
-  let nyan : cat = cat(52_usize, 99);
+  let nyan : cat = cat(52, 99);
   nyan.speak = || println!("meow"); //~ ERROR attempted to take value of method
 }
diff --git a/src/test/compile-fail/bad-bang-ann-3.rs b/src/test/compile-fail/bad-bang-ann-3.rs
index 58a8314af21..de315a41361 100644
--- a/src/test/compile-fail/bad-bang-ann-3.rs
+++ b/src/test/compile-fail/bad-bang-ann-3.rs
@@ -11,7 +11,7 @@
 // Tests that a function with a ! annotation always actually fails
 
 fn bad_bang(i: usize) -> ! {
-    return 7_usize; //~ ERROR `return` in a function declared as diverging [E0166]
+    return 7; //~ ERROR `return` in a function declared as diverging [E0166]
 }
 
 fn main() { bad_bang(5); }
diff --git a/src/test/compile-fail/bad-bang-ann.rs b/src/test/compile-fail/bad-bang-ann.rs
index 03c24c2fa3d..f0ecf31fd10 100644
--- a/src/test/compile-fail/bad-bang-ann.rs
+++ b/src/test/compile-fail/bad-bang-ann.rs
@@ -11,7 +11,7 @@
 // Tests that a function with a ! annotation always actually fails
 
 fn bad_bang(i: usize) -> ! { //~ ERROR computation may converge in a function marked as diverging
-    if i < 0_usize { } else { panic!(); }
+    if i < 0 { } else { panic!(); }
 }
 
 fn main() { bad_bang(5); }
diff --git a/src/test/compile-fail/bad-const-type.rs b/src/test/compile-fail/bad-const-type.rs
index 7e3c356b870..93ff7c08f79 100644
--- a/src/test/compile-fail/bad-const-type.rs
+++ b/src/test/compile-fail/bad-const-type.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static i: String = 10i32;
+static i: String = 10;
 //~^ ERROR mismatched types
 //~| expected `collections::string::String`
 //~| found `i32`
diff --git a/src/test/compile-fail/bad-method-typaram-kind.rs b/src/test/compile-fail/bad-method-typaram-kind.rs
index a97cf5d41e8..2129d4fbd50 100644
--- a/src/test/compile-fail/bad-method-typaram-kind.rs
+++ b/src/test/compile-fail/bad-method-typaram-kind.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn foo<T:'static>() {
-    1_usize.bar::<T>(); //~ ERROR `core::marker::Send` is not implemented
+    1.bar::<T>(); //~ ERROR `core::marker::Send` is not implemented
 }
 
 trait bar {
diff --git a/src/test/compile-fail/binop-logic-int.rs b/src/test/compile-fail/binop-logic-int.rs
index 2217cf5e4da..1a3db388877 100644
--- a/src/test/compile-fail/binop-logic-int.rs
+++ b/src/test/compile-fail/binop-logic-int.rs
@@ -10,4 +10,4 @@
 
 // error-pattern:`&&` cannot be applied to type `i32`
 
-fn main() { let x = 1i32 && 2i32; }
+fn main() { let x = 1 && 2; }
diff --git a/src/test/compile-fail/borrow-immutable-upvar-mutation.rs b/src/test/compile-fail/borrow-immutable-upvar-mutation.rs
index a82aa12dc80..00f51973a41 100644
--- a/src/test/compile-fail/borrow-immutable-upvar-mutation.rs
+++ b/src/test/compile-fail/borrow-immutable-upvar-mutation.rs
@@ -21,25 +21,25 @@ fn to_fn_mut<A,F:FnMut<A>>(f: F) -> F { f }
 fn main() {
     // By-ref captures
     {
-        let mut x = 0_usize;
+        let mut x = 0;
         let _f = to_fn(|| x = 42); //~ ERROR cannot assign
 
-        let mut y = 0_usize;
+        let mut y = 0;
         let _g = to_fn(|| set(&mut y)); //~ ERROR cannot borrow
 
-        let mut z = 0_usize;
+        let mut z = 0;
         let _h = to_fn_mut(|| { set(&mut z); to_fn(|| z = 42); }); //~ ERROR cannot assign
     }
 
     // By-value captures
     {
-        let mut x = 0_usize;
+        let mut x = 0;
         let _f = to_fn(move || x = 42); //~ ERROR cannot assign
 
-        let mut y = 0_usize;
+        let mut y = 0;
         let _g = to_fn(move || set(&mut y)); //~ ERROR cannot borrow
 
-        let mut z = 0_usize;
+        let mut z = 0;
         let _h = to_fn_mut(move || { set(&mut z); to_fn(move || z = 42); }); //~ ERROR cannot assign
     }
 }
diff --git a/src/test/compile-fail/borrowck-move-error-with-note.rs b/src/test/compile-fail/borrowck-move-error-with-note.rs
index 2d82c8be519..e4b9fb26711 100644
--- a/src/test/compile-fail/borrowck-move-error-with-note.rs
+++ b/src/test/compile-fail/borrowck-move-error-with-note.rs
@@ -17,7 +17,7 @@ enum Foo {
 }
 
 fn blah() {
-    let f = &Foo::Foo1(box 1u32, box 2u32);
+    let f = &Foo::Foo1(box 1, box 2);
     match *f {             //~ ERROR cannot move out of
         Foo::Foo1(num1,         //~ NOTE attempting to move value to here
                   num2) => (),  //~ NOTE and here
diff --git a/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs b/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs
index 21637370724..61bf2c11a1f 100644
--- a/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs
+++ b/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs
@@ -11,7 +11,7 @@
 #![allow(dead_code)]
 fn main() {
     // Original borrow ends at end of function
-    let mut x = 1_usize;
+    let mut x = 1;
     let y = &mut x;
     let z = &x; //~ ERROR cannot borrow
 }
@@ -21,7 +21,7 @@ fn foo() {
     match true {
         true => {
             // Original borrow ends at end of match arm
-            let mut x = 1_usize;
+            let mut x = 1;
             let y = &x;
             let z = &mut x; //~ ERROR cannot borrow
         }
@@ -33,7 +33,7 @@ fn foo() {
 fn bar() {
     // Original borrow ends at end of closure
     || {
-        let mut x = 1_usize;
+        let mut x = 1;
         let y = &mut x;
         let z = &mut x; //~ ERROR cannot borrow
     };
diff --git a/src/test/compile-fail/class-method-missing.rs b/src/test/compile-fail/class-method-missing.rs
index ada45e8c1fc..46b100a4d39 100644
--- a/src/test/compile-fail/class-method-missing.rs
+++ b/src/test/compile-fail/class-method-missing.rs
@@ -27,5 +27,5 @@ fn cat(in_x : usize) -> cat {
 }
 
 fn main() {
-  let nyan = cat(0_usize);
+  let nyan = cat(0);
 }
diff --git a/src/test/compile-fail/class-missing-self.rs b/src/test/compile-fail/class-missing-self.rs
index f25b2e65388..ab76af1cbe6 100644
--- a/src/test/compile-fail/class-missing-self.rs
+++ b/src/test/compile-fail/class-missing-self.rs
@@ -16,7 +16,7 @@ impl cat {
     fn sleep(&self) { loop{} }
     fn meow(&self) {
       println!("Meow");
-      meows += 1_usize; //~ ERROR unresolved name
+      meows += 1; //~ ERROR unresolved name
       sleep();     //~ ERROR unresolved name
     }
 
diff --git a/src/test/compile-fail/coercion-slice.rs b/src/test/compile-fail/coercion-slice.rs
index aac180f9ad7..40fbcd556b0 100644
--- a/src/test/compile-fail/coercion-slice.rs
+++ b/src/test/compile-fail/coercion-slice.rs
@@ -11,7 +11,7 @@
 // Tests that we forbid coercion from `[T; n]` to `&[T]`
 
 fn main() {
-    let _: &[i32] = [0i32];
+    let _: &[i32] = [0];
     //~^ ERROR mismatched types
     //~| expected `&[i32]`
     //~| found `[i32; 1]`
diff --git a/src/test/compile-fail/const-block-non-item-statement.rs b/src/test/compile-fail/const-block-non-item-statement.rs
index fa63b16afa6..5ccfb1ddec7 100644
--- a/src/test/compile-fail/const-block-non-item-statement.rs
+++ b/src/test/compile-fail/const-block-non-item-statement.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-const A: usize = { 1_usize; 2 };
+const A: usize = { 1; 2 };
 //~^ ERROR: blocks in constants are limited to items and tail expressions
 
 const B: usize = { { } 2 };
@@ -19,7 +19,7 @@ macro_rules! foo {
 }
 const C: usize = { foo!(); 2 };
 
-const D: usize = { let x = 4_usize; 2 };
+const D: usize = { let x = 4; 2 };
 //~^ ERROR: blocks in constants are limited to items and tail expressions
 
 pub fn main() {
diff --git a/src/test/compile-fail/deriving-non-type.rs b/src/test/compile-fail/deriving-non-type.rs
index 966e28a789c..5b215f3ccd9 100644
--- a/src/test/compile-fail/deriving-non-type.rs
+++ b/src/test/compile-fail/deriving-non-type.rs
@@ -22,10 +22,10 @@ impl S { }
 impl T for S { }
 
 #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums
-static s: usize = 0_usize;
+static s: usize = 0;
 
 #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums
-const c: usize = 0_usize;
+const c: usize = 0;
 
 #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums
 mod m { }
diff --git a/src/test/compile-fail/destructor-restrictions.rs b/src/test/compile-fail/destructor-restrictions.rs
index 0836cd1695d..22f615cafd7 100644
--- a/src/test/compile-fail/destructor-restrictions.rs
+++ b/src/test/compile-fail/destructor-restrictions.rs
@@ -14,8 +14,8 @@ use std::cell::RefCell;
 
 fn main() {
     let b = {
-        let a = Box::new(RefCell::new(4i8));
-        *a.borrow() + 1i8    //~ ERROR `*a` does not live long enough
+        let a = Box::new(RefCell::new(4));
+        *a.borrow() + 1    //~ ERROR `*a` does not live long enough
     };
     println!("{}", b);
 }
diff --git a/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs b/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs
index 1e15e67876e..54bdaf011c8 100644
--- a/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs
+++ b/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs
@@ -21,7 +21,7 @@
 // test. Not ideal, but oh well :(
 
 fn main() {
-    let a = &[1i32, 2, 3];
+    let a = &[1, 2, 3];
     println!("{}", {
         extern "rust-intrinsic" { //~ ERROR intrinsics are subject to change
             fn atomic_fence();
diff --git a/src/test/compile-fail/import-glob-circular.rs b/src/test/compile-fail/import-glob-circular.rs
index f38172db444..67834a99969 100644
--- a/src/test/compile-fail/import-glob-circular.rs
+++ b/src/test/compile-fail/import-glob-circular.rs
@@ -13,13 +13,13 @@
 mod circ1 {
     pub use circ2::f2;
     pub fn f1() { println!("f1"); }
-    pub fn common() -> usize { return 0_usize; }
+    pub fn common() -> usize { return 0; }
 }
 
 mod circ2 {
     pub use circ1::f1;
     pub fn f2() { println!("f2"); }
-    pub fn common() -> usize { return 1_usize; }
+    pub fn common() -> usize { return 1; }
 }
 
 mod test {
diff --git a/src/test/compile-fail/index-bot.rs b/src/test/compile-fail/index-bot.rs
index b28f2a746fd..70c362303ae 100644
--- a/src/test/compile-fail/index-bot.rs
+++ b/src/test/compile-fail/index-bot.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    (return)[0_usize]; //~ ERROR the type of this value must be known in this context
+    (return)[0]; //~ ERROR the type of this value must be known in this context
 }
diff --git a/src/test/compile-fail/infinite-instantiation.rs b/src/test/compile-fail/infinite-instantiation.rs
index d39efa3c2ab..559e0e9a292 100644
--- a/src/test/compile-fail/infinite-instantiation.rs
+++ b/src/test/compile-fail/infinite-instantiation.rs
@@ -32,13 +32,13 @@ impl<T:Clone> ToOpt for Option<T> {
 }
 
 fn function<T:ToOpt + Clone>(counter: usize, t: T) {
-    if counter > 0_usize {
-        function(counter - 1_usize, t.to_option());
+    if counter > 0 {
+        function(counter - 1, t.to_option());
         // FIXME(#4287) Error message should be here. It should be
         // a type error to instantiate `test` at a type other than T.
     }
 }
 
 fn main() {
-    function(22_usize, 22_usize);
+    function(22, 22);
 }
diff --git a/src/test/compile-fail/issue-11714.rs b/src/test/compile-fail/issue-11714.rs
index d307352517f..998576097a0 100644
--- a/src/test/compile-fail/issue-11714.rs
+++ b/src/test/compile-fail/issue-11714.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn blah() -> i32 { //~ ERROR not all control paths return a value
-    1i32
+    1
 
     ; //~ HELP consider removing this semicolon:
 }
diff --git a/src/test/compile-fail/issue-13058.rs b/src/test/compile-fail/issue-13058.rs
index 06f14158b91..6f024fc5382 100644
--- a/src/test/compile-fail/issue-13058.rs
+++ b/src/test/compile-fail/issue-13058.rs
@@ -24,7 +24,7 @@ fn check<'r, I: Iterator<Item=usize>, T: Itble<'r, usize, I>>(cont: &T) -> bool
 {
     let cont_iter = cont.iter();
 //~^ ERROR cannot infer an appropriate lifetime for autoref due to conflicting requirements
-    let result = cont_iter.fold(Some(0u16), |state, val| {
+    let result = cont_iter.fold(Some(0), |state, val| {
         state.map_or(None, |mask| {
             let bit = 1 << val;
             if mask & bit == 0 {Some(mask|bit)} else {None}
@@ -34,7 +34,7 @@ fn check<'r, I: Iterator<Item=usize>, T: Itble<'r, usize, I>>(cont: &T) -> bool
 }
 
 fn main() {
-    check((3_usize, 5_usize));
+    check((3, 5));
 //~^ ERROR mismatched types
 //~| expected `&_`
 //~| found `(usize, usize)`
diff --git a/src/test/compile-fail/issue-13466.rs b/src/test/compile-fail/issue-13466.rs
index 16128e52d64..3eb42f902f9 100644
--- a/src/test/compile-fail/issue-13466.rs
+++ b/src/test/compile-fail/issue-13466.rs
@@ -14,7 +14,7 @@ pub fn main() {
     // The expected arm type `Option<T>` has one type parameter, while
     // the actual arm `Result<T, E>` has two. typeck should not be
     // tricked into looking up a non-existing second type parameter.
-    let _x: usize = match Some(1_usize) {
+    let _x: usize = match Some(1) {
         Ok(u) => u,
         //~^ ERROR mismatched types
         //~| expected `core::option::Option<usize>`
diff --git a/src/test/compile-fail/issue-13482-2.rs b/src/test/compile-fail/issue-13482-2.rs
index 86a79416c77..7af10aa13a8 100644
--- a/src/test/compile-fail/issue-13482-2.rs
+++ b/src/test/compile-fail/issue-13482-2.rs
@@ -15,7 +15,7 @@ fn main() {
     let y = match x {
         [] => None,
 //~^ ERROR mismatched types
-//~| expected `[_#0i; 2]`
+//~| expected `[_#0; 2]`
 //~| found `[_#7t; 0]`
 //~| expected an array with a fixed size of 2 elements
 //~| found one with 0 elements
diff --git a/src/test/compile-fail/issue-14845.rs b/src/test/compile-fail/issue-14845.rs
index d7ff6f2fe63..3381b930714 100644
--- a/src/test/compile-fail/issue-14845.rs
+++ b/src/test/compile-fail/issue-14845.rs
@@ -22,7 +22,7 @@ fn main() {
     //~| expected u8
     //~| found array of 1 elements
 
-    let local = [0u8];
+    let local = [0];
     let _v = &local as *mut u8;
     //~^ ERROR mismatched types
     //~| expected `*mut u8`
diff --git a/src/test/compile-fail/issue-17283.rs b/src/test/compile-fail/issue-17283.rs
index 65731379094..a481fec6bf9 100644
--- a/src/test/compile-fail/issue-17283.rs
+++ b/src/test/compile-fail/issue-17283.rs
@@ -16,7 +16,7 @@ struct Foo {
 }
 
 fn main() {
-    let x = 1_usize;
+    let x = 1;
     let y: Foo;
 
     // `x { ... }` should not be interpreted as a struct literal here
diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs
index d6471ca018d..723b4ca03e7 100644
--- a/src/test/compile-fail/issue-17651.rs
+++ b/src/test/compile-fail/issue-17651.rs
@@ -13,6 +13,6 @@
 
 fn main() {
     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
-    (|| Box::new(*[0_usize].as_slice()))();
+    (|| Box::new(*[0].as_slice()))();
     //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[usize]`
 }
diff --git a/src/test/compile-fail/issue-17718-patterns.rs b/src/test/compile-fail/issue-17718-patterns.rs
index b7f58791bfc..4e63f667d26 100644
--- a/src/test/compile-fail/issue-17718-patterns.rs
+++ b/src/test/compile-fail/issue-17718-patterns.rs
@@ -13,7 +13,7 @@ static mut A2: usize = 1;
 const A3: usize = 1;
 
 fn main() {
-    match 1_usize {
+    match 1 {
         A1 => {} //~ ERROR: static variables cannot be referenced in a pattern
         A2 => {} //~ ERROR: static variables cannot be referenced in a pattern
         A3 => {}
diff --git a/src/test/compile-fail/issue-17933.rs b/src/test/compile-fail/issue-17933.rs
index bd047408498..657b31fa83c 100644
--- a/src/test/compile-fail/issue-17933.rs
+++ b/src/test/compile-fail/issue-17933.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub static X: usize = 1_usize;
+pub static X: usize = 1;
 
 fn main() {
-    match 1_usize {
+    match 1 {
         self::X => { },
         //~^ ERROR static variables cannot be referenced in a pattern, use a `const` instead
         _       => { },
diff --git a/src/test/compile-fail/issue-18107.rs b/src/test/compile-fail/issue-18107.rs
index d5fb22bdebd..60ab616d598 100644
--- a/src/test/compile-fail/issue-18107.rs
+++ b/src/test/compile-fail/issue-18107.rs
@@ -16,7 +16,7 @@ fn _create_render(_: &()) ->
     AbstractRenderer
 //~^ ERROR: the trait `core::marker::Sized` is not implemented
 {
-    match 0_usize {
+    match 0 {
         _ => unimplemented!()
     }
 }
diff --git a/src/test/compile-fail/issue-18252.rs b/src/test/compile-fail/issue-18252.rs
index 54c51405bd7..e3e56c7f97a 100644
--- a/src/test/compile-fail/issue-18252.rs
+++ b/src/test/compile-fail/issue-18252.rs
@@ -13,5 +13,5 @@ enum Foo {
 }
 
 fn main() {
-    let f = Foo::Variant(42_usize); //~ ERROR uses it like a function
+    let f = Foo::Variant(42); //~ ERROR uses it like a function
 }
diff --git a/src/test/compile-fail/issue-18566.rs b/src/test/compile-fail/issue-18566.rs
index dd3844b1a0e..41e82d0cd89 100644
--- a/src/test/compile-fail/issue-18566.rs
+++ b/src/test/compile-fail/issue-18566.rs
@@ -28,7 +28,7 @@ impl Tr for usize {
 }
 
 fn main() {
-    let s = &mut 1_usize;
+    let s = &mut 1;
 
     MyPtr(s).poke(s);
     //~^ ERROR cannot borrow `*s` as mutable more than once at a time
diff --git a/src/test/compile-fail/issue-18783.rs b/src/test/compile-fail/issue-18783.rs
index f6a3da81857..5eb3c439df2 100644
--- a/src/test/compile-fail/issue-18783.rs
+++ b/src/test/compile-fail/issue-18783.rs
@@ -13,7 +13,7 @@ use std::cell::RefCell;
 // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
 
 fn main() {
-    let mut y = 1_usize;
+    let mut y = 1;
     let c = RefCell::new(vec![]);
     c.push(Box::new(|| y = 0));
     c.push(Box::new(|| y = 0));
@@ -21,7 +21,7 @@ fn main() {
 }
 
 fn ufcs() {
-    let mut y = 1_usize;
+    let mut y = 1;
     let c = RefCell::new(vec![]);
 
     Push::push(&c, Box::new(|| y = 0));
diff --git a/src/test/compile-fail/issue-18959.rs b/src/test/compile-fail/issue-18959.rs
index 8fb543fb967..ebda2481803 100644
--- a/src/test/compile-fail/issue-18959.rs
+++ b/src/test/compile-fail/issue-18959.rs
@@ -19,7 +19,7 @@ impl Foo for Thing {
 
 #[inline(never)]
 fn foo(b: &Bar) {
-    b.foo(&0usize)
+    b.foo(&0)
     //~^ ERROR the trait `Foo` is not implemented for the type `Bar`
 }
 
diff --git a/src/test/compile-fail/issue-19991.rs b/src/test/compile-fail/issue-19991.rs
index 2d73b98ec1e..7c1e18ba997 100644
--- a/src/test/compile-fail/issue-19991.rs
+++ b/src/test/compile-fail/issue-19991.rs
@@ -17,6 +17,6 @@ fn main() {
                                            //~| found `i32`
                                            //~| expected ()
                                            //~| found i32
-        765i32
+        765
     };
 }
diff --git a/src/test/compile-fail/issue-20801.rs b/src/test/compile-fail/issue-20801.rs
index 929c8ec0fd6..fe7807042e5 100644
--- a/src/test/compile-fail/issue-20801.rs
+++ b/src/test/compile-fail/issue-20801.rs
@@ -25,11 +25,11 @@ fn mut_ref() -> &'static mut T {
 }
 
 fn mut_ptr() -> *mut T {
-    unsafe { 0u8 as *mut T }
+    unsafe { 0 as *mut T }
 }
 
 fn const_ptr() -> *const T {
-    unsafe { 0u8 as *const T }
+    unsafe { 0 as *const T }
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/issue-2150.rs b/src/test/compile-fail/issue-2150.rs
index 505885e6c41..8b109b0a5c0 100644
--- a/src/test/compile-fail/issue-2150.rs
+++ b/src/test/compile-fail/issue-2150.rs
@@ -15,7 +15,7 @@
 fn fail_len(v: Vec<isize> ) -> usize {
     let mut i = 3;
     panic!();
-    for x in &v { i += 1_usize; }
+    for x in &v { i += 1; }
     //~^ ERROR: unreachable statement
     return i;
 }
diff --git a/src/test/compile-fail/issue-4517.rs b/src/test/compile-fail/issue-4517.rs
index 6d4777be40b..a1804b5a268 100644
--- a/src/test/compile-fail/issue-4517.rs
+++ b/src/test/compile-fail/issue-4517.rs
@@ -11,7 +11,7 @@
 fn bar(int_param: usize) {}
 
 fn main() {
-    let foo: [u8; 4] = [1u8; 4_usize];
+    let foo: [u8; 4] = [1; 4];
     bar(foo);
     //~^ ERROR mismatched types
     //~| expected `usize`
diff --git a/src/test/compile-fail/issue-7575.rs b/src/test/compile-fail/issue-7575.rs
index b6643f43952..9c019f6ec47 100644
--- a/src/test/compile-fail/issue-7575.rs
+++ b/src/test/compile-fail/issue-7575.rs
@@ -32,17 +32,17 @@ trait UnusedTrait : MarkerTrait {
 
 impl CtxtFn for usize {
     fn f8(self, i: usize) -> usize {
-        i * 4_usize
+        i * 4
     }
 
     fn f9(i: usize) -> usize {
-        i * 4_usize
+        i * 4
     }
 }
 
 impl OtherTrait for usize {
     fn f9(i: usize) -> usize {
-        i * 8_usize
+        i * 8
     }
 }
 
diff --git a/src/test/compile-fail/issue-7867.rs b/src/test/compile-fail/issue-7867.rs
index 7bb4aac23d6..1eaa85c3b7e 100644
--- a/src/test/compile-fail/issue-7867.rs
+++ b/src/test/compile-fail/issue-7867.rs
@@ -23,7 +23,7 @@ fn main() {
         _ => ()
     }
 
-    match &Some(42i32) {
+    match &Some(42) {
         Some(x) => (),
         //~^ ERROR mismatched types
         //~| expected `&core::option::Option<i32>`
diff --git a/src/test/compile-fail/kindck-nonsendable-1.rs b/src/test/compile-fail/kindck-nonsendable-1.rs
index e6041cddead..c370aa4b8fb 100644
--- a/src/test/compile-fail/kindck-nonsendable-1.rs
+++ b/src/test/compile-fail/kindck-nonsendable-1.rs
@@ -16,7 +16,7 @@ fn foo(_x: Rc<usize>) {}
 fn bar<F:FnOnce() + Send>(_: F) { }
 
 fn main() {
-    let x = Rc::new(3_usize);
+    let x = Rc::new(3);
     bar(move|| foo(x));
     //~^ ERROR `core::marker::Send` is not implemented
 }
diff --git a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs
index fac518c7635..0a8e4514b43 100644
--- a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs
+++ b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs
@@ -24,7 +24,7 @@ impl<'r> Itble<'r, usize, Range<usize>> for (usize, usize) {
 fn check<'r, I: Iterator<Item=usize>, T: Itble<'r, usize, I>>(cont: &T) -> bool {
 //~^ HELP: consider using an explicit lifetime parameter as shown: fn check<'r, I: Iterator<Item = usize>, T: Itble<'r, usize, I>>(cont: &'r T)
     let cont_iter = cont.iter(); //~ ERROR: cannot infer
-    let result = cont_iter.fold(Some(0u16), |state, val| {
+    let result = cont_iter.fold(Some(0), |state, val| {
         state.map_or(None, |mask| {
             let bit = 1 << val;
             if mask & bit == 0 {Some(mask|bit)} else {None}
diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs
index f304c26efb5..8441fb3ade9 100644
--- a/src/test/compile-fail/lint-dead-code-4.rs
+++ b/src/test/compile-fail/lint-dead-code-4.rs
@@ -63,6 +63,6 @@ fn field_match_in_let(f: Bar) -> bool {
 fn main() {
     field_read(Foo { x: 1, b: false, marker: std::marker::NoCopy });
     field_match_in_patterns(XYZ::Z);
-    field_match_in_let(Bar { x: 42_usize, b: true, _guard: () });
+    field_match_in_let(Bar { x: 42, b: true, _guard: () });
     let _ = Baz { x: 0 };
 }
diff --git a/src/test/compile-fail/liveness-return-last-stmt-semi.rs b/src/test/compile-fail/liveness-return-last-stmt-semi.rs
index 57252dd58d7..a4eb1630afe 100644
--- a/src/test/compile-fail/liveness-return-last-stmt-semi.rs
+++ b/src/test/compile-fail/liveness-return-last-stmt-semi.rs
@@ -10,7 +10,7 @@
 //
 // regression test for #8005
 
-macro_rules! test { () => { fn foo() -> i32 { 1i32; } } }
+macro_rules! test { () => { fn foo() -> i32 { 1; } } }
                                            //~^ ERROR not all control paths return a value
                                            //~^^ HELP consider removing this semicolon
 
diff --git a/src/test/compile-fail/macro-no-implicit-reexport.rs b/src/test/compile-fail/macro-no-implicit-reexport.rs
index 13dbab12b77..e8d9f444cef 100644
--- a/src/test/compile-fail/macro-no-implicit-reexport.rs
+++ b/src/test/compile-fail/macro-no-implicit-reexport.rs
@@ -16,5 +16,5 @@
 extern crate macro_non_reexport_2;
 
 fn main() {
-    assert_eq!(reexported!(), 3_usize);  //~ ERROR macro undefined
+    assert_eq!(reexported!(), 3);  //~ ERROR macro undefined
 }
diff --git a/src/test/compile-fail/macro-reexport-not-locally-visible.rs b/src/test/compile-fail/macro-reexport-not-locally-visible.rs
index dc8f4fadc76..26de51a7cf8 100644
--- a/src/test/compile-fail/macro-reexport-not-locally-visible.rs
+++ b/src/test/compile-fail/macro-reexport-not-locally-visible.rs
@@ -18,5 +18,5 @@
 extern crate macro_reexport_1;
 
 fn main() {
-    assert_eq!(reexported!(), 3_usize);  //~ ERROR macro undefined
+    assert_eq!(reexported!(), 3);  //~ ERROR macro undefined
 }
diff --git a/src/test/compile-fail/method-self-arg-1.rs b/src/test/compile-fail/method-self-arg-1.rs
index 7b6868af805..666812c98bc 100644
--- a/src/test/compile-fail/method-self-arg-1.rs
+++ b/src/test/compile-fail/method-self-arg-1.rs
@@ -23,7 +23,7 @@ fn main() {
                  //~| found `Foo`
                  //~| expected &-ptr
                  //~| found struct `Foo`
-    Foo::bar(&42i32); //~  ERROR mismatched types
+    Foo::bar(&42); //~  ERROR mismatched types
                       //~| expected `&Foo`
                       //~| found `&i32`
                       //~| expected struct `Foo`
diff --git a/src/test/compile-fail/mut-pattern-mismatched.rs b/src/test/compile-fail/mut-pattern-mismatched.rs
index 6de69a9adb0..1b748624491 100644
--- a/src/test/compile-fail/mut-pattern-mismatched.rs
+++ b/src/test/compile-fail/mut-pattern-mismatched.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let foo = &mut 1i32;
+    let foo = &mut 1;
 
     // (separate lines to ensure the spans are accurate)
 
@@ -20,7 +20,7 @@ fn main() {
         = foo;
     let &mut _ = foo;
 
-    let bar = &1i32;
+    let bar = &1;
     let &_ = bar;
     let &mut _ //~  ERROR mismatched types
                //~| expected `&i32`
diff --git a/src/test/compile-fail/mutable-class-fields-2.rs b/src/test/compile-fail/mutable-class-fields-2.rs
index b6744d4b33a..46af3a862c2 100644
--- a/src/test/compile-fail/mutable-class-fields-2.rs
+++ b/src/test/compile-fail/mutable-class-fields-2.rs
@@ -29,6 +29,6 @@ fn cat(in_x : usize, in_y : isize) -> cat {
 }
 
 fn main() {
-  let nyan : cat = cat(52_usize, 99);
+  let nyan : cat = cat(52, 99);
   nyan.eat();
 }
diff --git a/src/test/compile-fail/mutable-class-fields.rs b/src/test/compile-fail/mutable-class-fields.rs
index 94b1047f85e..c163dc2b4d2 100644
--- a/src/test/compile-fail/mutable-class-fields.rs
+++ b/src/test/compile-fail/mutable-class-fields.rs
@@ -21,6 +21,6 @@ fn cat(in_x : usize, in_y : isize) -> cat {
 }
 
 fn main() {
-  let nyan : cat = cat(52_usize, 99);
+  let nyan : cat = cat(52, 99);
   nyan.how_hungry = 0; //~ ERROR cannot assign
 }
diff --git a/src/test/compile-fail/non-exhaustive-pattern-witness.rs b/src/test/compile-fail/non-exhaustive-pattern-witness.rs
index 0eb91e0419a..3ed91459ae9 100644
--- a/src/test/compile-fail/non-exhaustive-pattern-witness.rs
+++ b/src/test/compile-fail/non-exhaustive-pattern-witness.rs
@@ -27,7 +27,7 @@ fn struct_with_a_nested_enum_and_vector() {
         Foo { first: true, second: None } => (),
         Foo { first: true, second: Some(_) } => (),
         Foo { first: false, second: None } => (),
-        Foo { first: false, second: Some([1_usize, 2_usize, 3_usize, 4_usize]) } => ()
+        Foo { first: false, second: Some([1, 2, 3, 4]) } => ()
     }
 }
 
diff --git a/src/test/compile-fail/or-patter-mismatch.rs b/src/test/compile-fail/or-patter-mismatch.rs
index 4b261d89888..59508d6ac95 100644
--- a/src/test/compile-fail/or-patter-mismatch.rs
+++ b/src/test/compile-fail/or-patter-mismatch.rs
@@ -12,4 +12,4 @@
 
 enum blah { a(isize, isize, usize), b(isize, isize), }
 
-fn main() { match blah::a(1, 1, 2_usize) { blah::a(_, x, y) | blah::b(x, y) => { } } }
+fn main() { match blah::a(1, 1, 2) { blah::a(_, x, y) | blah::b(x, y) => { } } }
diff --git a/src/test/compile-fail/private-method.rs b/src/test/compile-fail/private-method.rs
index ccbdd52a983..16510c2c8c9 100644
--- a/src/test/compile-fail/private-method.rs
+++ b/src/test/compile-fail/private-method.rs
@@ -30,6 +30,6 @@ mod kitties {
 }
 
 fn main() {
-  let nyan : kitties::cat = kitties::cat(52_usize, 99);
+  let nyan : kitties::cat = kitties::cat(52, 99);
   nyan.nap();
 }
diff --git a/src/test/compile-fail/private-struct-field-cross-crate.rs b/src/test/compile-fail/private-struct-field-cross-crate.rs
index 243d835d46e..fb4491a6375 100644
--- a/src/test/compile-fail/private-struct-field-cross-crate.rs
+++ b/src/test/compile-fail/private-struct-field-cross-crate.rs
@@ -13,7 +13,7 @@ extern crate cci_class;
 use cci_class::kitties::cat;
 
 fn main() {
-  let nyan : cat = cat(52_usize, 99);
-  assert!((nyan.meows == 52_usize));
+  let nyan : cat = cat(52, 99);
+  assert!((nyan.meows == 52));
   //~^ ERROR field `meows` of struct `cci_class::kitties::cat` is private
 }
diff --git a/src/test/compile-fail/range-1.rs b/src/test/compile-fail/range-1.rs
index a8b6e399418..e7b34d6d1bc 100644
--- a/src/test/compile-fail/range-1.rs
+++ b/src/test/compile-fail/range-1.rs
@@ -20,7 +20,7 @@ pub fn main() {
     //~^ ERROR the trait `core::num::Int` is not implemented for the type `f32`
 
     // Unsized type.
-    let arr: &[_] = &[1u32, 2, 3];
+    let arr: &[_] = &[1, 2, 3];
     let range = *arr..;
     //~^ ERROR the trait `core::marker::Sized` is not implemented
 }
diff --git a/src/test/compile-fail/regions-addr-of-self.rs b/src/test/compile-fail/regions-addr-of-self.rs
index 45e468b3ab0..04ee0526403 100644
--- a/src/test/compile-fail/regions-addr-of-self.rs
+++ b/src/test/compile-fail/regions-addr-of-self.rs
@@ -15,18 +15,18 @@ struct dog {
 impl dog {
     pub fn chase_cat(&mut self) {
         let p: &'static mut usize = &mut self.cats_chased; //~ ERROR cannot infer
-        *p += 1_usize;
+        *p += 1;
     }
 
     pub fn chase_cat_2(&mut self) {
         let p: &mut usize = &mut self.cats_chased;
-        *p += 1_usize;
+        *p += 1;
     }
 }
 
 fn dog() -> dog {
     dog {
-        cats_chased: 0_usize
+        cats_chased: 0
     }
 }
 
diff --git a/src/test/compile-fail/regions-addr-of-upvar-self.rs b/src/test/compile-fail/regions-addr-of-upvar-self.rs
index 8cc2dd6afc6..28491f1155c 100644
--- a/src/test/compile-fail/regions-addr-of-upvar-self.rs
+++ b/src/test/compile-fail/regions-addr-of-upvar-self.rs
@@ -18,7 +18,7 @@ impl dog {
     pub fn chase_cat(&mut self) {
         let _f = || {
             let p: &'static mut usize = &mut self.food; //~ ERROR cannot infer
-            *p = 3_usize;
+            *p = 3;
         };
     }
 }
diff --git a/src/test/compile-fail/regions-creating-enums.rs b/src/test/compile-fail/regions-creating-enums.rs
index 4c361427bf3..ad2dc28afef 100644
--- a/src/test/compile-fail/regions-creating-enums.rs
+++ b/src/test/compile-fail/regions-creating-enums.rs
@@ -14,8 +14,8 @@ enum ast<'a> {
 }
 
 fn build() {
-    let x = ast::num(3_usize);
-    let y = ast::num(4_usize);
+    let x = ast::num(3);
+    let y = ast::num(4);
     let z = ast::add(&x, &y);
     compute(&z);
 }
diff --git a/src/test/compile-fail/regions-pattern-typing-issue-19997.rs b/src/test/compile-fail/regions-pattern-typing-issue-19997.rs
index da839d72172..ae9ceb600d4 100644
--- a/src/test/compile-fail/regions-pattern-typing-issue-19997.rs
+++ b/src/test/compile-fail/regions-pattern-typing-issue-19997.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 fn main() {
-    let a0 = 0u8;
-    let f = 1u8;
+    let a0 = 0;
+    let f = 1;
     let mut a1 = &a0;
     match (&a1,) {
         (&ref b0,) => {
diff --git a/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs b/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs
index aa20efa5a12..1e2224eafae 100644
--- a/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs
+++ b/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs
@@ -15,7 +15,7 @@
 fn main() {
     // Unboxed closure case
     {
-        let mut x = 0_usize;
+        let mut x = 0;
         let mut f = || &mut x; //~ ERROR cannot infer
         let x = f();
         let y = f();
diff --git a/src/test/compile-fail/regions-trait-1.rs b/src/test/compile-fail/regions-trait-1.rs
index b45a37d26e5..01439ce5e68 100644
--- a/src/test/compile-fail/regions-trait-1.rs
+++ b/src/test/compile-fail/regions-trait-1.rs
@@ -34,7 +34,7 @@ fn get_v(gc: Box<get_ctxt>) -> usize {
 }
 
 fn main() {
-    let ctxt = ctxt { v: 22_usize };
+    let ctxt = ctxt { v: 22 };
     let hc = has_ctxt { c: &ctxt };
-    assert_eq!(get_v(box hc as Box<get_ctxt>), 22_usize);
+    assert_eq!(get_v(box hc as Box<get_ctxt>), 22);
 }
diff --git a/src/test/compile-fail/structure-constructor-type-mismatch.rs b/src/test/compile-fail/structure-constructor-type-mismatch.rs
index c276228b18e..4a0006338e6 100644
--- a/src/test/compile-fail/structure-constructor-type-mismatch.rs
+++ b/src/test/compile-fail/structure-constructor-type-mismatch.rs
@@ -27,39 +27,39 @@ fn main() {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
         //~| found i32
-        x: 1i32,
-        y: 2i32,
+        x: 1,
+        y: 2,
     };
 
     let pt2 = Point::<f32> {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
         //~| found i32
-        x: 3i32,
-        y: 4i32,
+        x: 3,
+        y: 4,
     };
 
     let pair = PairF {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
         //~| found i32
-        x: 5i32,
-        y: 6i32,
+        x: 5,
+        y: 6,
     };
 
     let pair2 = PairF::<i32> {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
         //~| found i32
-        x: 7i32,
-        y: 8i32,
+        x: 7,
+        y: 8,
     };
 
     let pt3 = PointF::<i32> {
         //~^ ERROR wrong number of type arguments
         //~| ERROR structure constructor specifies a structure of type
-        x: 9i32,
-        y: 10i32,
+        x: 9,
+        y: 10,
     };
 }
 
diff --git a/src/test/compile-fail/tail-typeck.rs b/src/test/compile-fail/tail-typeck.rs
index 9c1d318d588..5c1270aa0e4 100644
--- a/src/test/compile-fail/tail-typeck.rs
+++ b/src/test/compile-fail/tail-typeck.rs
@@ -12,6 +12,6 @@
 
 fn f() -> isize { return g(); }
 
-fn g() -> usize { return 0_usize; }
+fn g() -> usize { return 0; }
 
 fn main() { let y = f(); }
diff --git a/src/test/compile-fail/traits-multidispatch-convert-ambig-dest.rs b/src/test/compile-fail/traits-multidispatch-convert-ambig-dest.rs
index 0a5aa1b7bd3..8fe1f4d2371 100644
--- a/src/test/compile-fail/traits-multidispatch-convert-ambig-dest.rs
+++ b/src/test/compile-fail/traits-multidispatch-convert-ambig-dest.rs
@@ -33,7 +33,7 @@ where T : Convert<U>
 }
 
 fn a() {
-    test(22_i32, std::default::Default::default()); //~ ERROR type annotations required
+    test(22, std::default::Default::default()); //~ ERROR type annotations required
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/tuple-index-out-of-bounds.rs b/src/test/compile-fail/tuple-index-out-of-bounds.rs
index 54b8d551f20..e2a951cab72 100644
--- a/src/test/compile-fail/tuple-index-out-of-bounds.rs
+++ b/src/test/compile-fail/tuple-index-out-of-bounds.rs
@@ -11,12 +11,12 @@
 struct Point(i32, i32);
 
 fn main() {
-    let origin = Point(0i32, 0i32);
+    let origin = Point(0, 0);
     origin.0;
     origin.1;
     origin.2;
     //~^ ERROR attempted out-of-bounds tuple index `2` on type `Point`
-    let tuple = (0i32, 0i32);
+    let tuple = (0, 0);
     tuple.0;
     tuple.1;
     tuple.2;
diff --git a/src/test/compile-fail/type-mismatch-multiple.rs b/src/test/compile-fail/type-mismatch-multiple.rs
index 3bf0896d990..a51a8172543 100644
--- a/src/test/compile-fail/type-mismatch-multiple.rs
+++ b/src/test/compile-fail/type-mismatch-multiple.rs
@@ -10,7 +10,7 @@
 
 // Checking that the compiler reports multiple type errors at once
 
-fn main() { let a: bool = 1i32; let b: i32 = true; }
+fn main() { let a: bool = 1; let b: i32 = true; }
 //~^ ERROR mismatched types
 //~| expected `bool`
 //~| found `i32`
diff --git a/src/test/compile-fail/type-params-in-different-spaces-1.rs b/src/test/compile-fail/type-params-in-different-spaces-1.rs
index de9623de7cd..88d8788d63a 100644
--- a/src/test/compile-fail/type-params-in-different-spaces-1.rs
+++ b/src/test/compile-fail/type-params-in-different-spaces-1.rs
@@ -23,7 +23,7 @@ trait BrokenAdd: Int {
 impl<T: Int> BrokenAdd for T {}
 
 pub fn main() {
-    let foo: u8 = 0u8;
+    let foo: u8 = 0;
     let x: u8 = foo.broken_add("hello darkness my old friend".to_string());
     println!("{}", x);
 }
diff --git a/src/test/compile-fail/typeck_type_placeholder_item.rs b/src/test/compile-fail/typeck_type_placeholder_item.rs
index 5bfad94867e..d4f3cdfd8b7 100644
--- a/src/test/compile-fail/typeck_type_placeholder_item.rs
+++ b/src/test/compile-fail/typeck_type_placeholder_item.rs
@@ -21,7 +21,7 @@ fn test2() -> (_, _) { (5, 5) }
 static TEST3: _ = "test";
 //~^ ERROR the type placeholder `_` is not allowed within types on item signatures
 
-static TEST4: _ = 145u16;
+static TEST4: _ = 145;
 //~^ ERROR the type placeholder `_` is not allowed within types on item signatures
 
 static TEST5: (_, _) = (1, 2);
@@ -74,7 +74,7 @@ pub fn main() {
     static FN_TEST3: _ = "test";
     //~^ ERROR the type placeholder `_` is not allowed within types on item signatures
 
-    static FN_TEST4: _ = 145u16;
+    static FN_TEST4: _ = 145;
     //~^ ERROR the type placeholder `_` is not allowed within types on item signatures
 
     static FN_TEST5: (_, _) = (1, 2);
diff --git a/src/test/compile-fail/unboxed-closure-illegal-move.rs b/src/test/compile-fail/unboxed-closure-illegal-move.rs
index 86e326f3c5a..564b1b4669f 100644
--- a/src/test/compile-fail/unboxed-closure-illegal-move.rs
+++ b/src/test/compile-fail/unboxed-closure-illegal-move.rs
@@ -23,28 +23,28 @@ fn to_fn_once<A,F:FnOnce<A>>(f: F) -> F { f }
 fn main() {
     // By-ref cases
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn(|| drop(x)); //~ ERROR cannot move
     }
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn_mut(|| drop(x)); //~ ERROR cannot move
     }
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn_once(|| drop(x)); // OK -- FnOnce
     }
     // By-value cases
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn(move || drop(x)); //~ ERROR cannot move
     }
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn_mut(move || drop(x)); //~ ERROR cannot move
     }
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn_once(move || drop(x)); // this one is ok
     }
 }
diff --git a/src/test/compile-fail/unboxed-closure-immutable-capture.rs b/src/test/compile-fail/unboxed-closure-immutable-capture.rs
index b40a91181ad..5be2738b47e 100644
--- a/src/test/compile-fail/unboxed-closure-immutable-capture.rs
+++ b/src/test/compile-fail/unboxed-closure-immutable-capture.rs
@@ -17,7 +17,7 @@
 fn set(x: &mut usize) { *x = 0; }
 
 fn main() {
-    let x = 0_usize;
+    let x = 0;
     move || x = 1; //~ ERROR cannot assign
     move || set(&mut x); //~ ERROR cannot borrow
     move || x = 1; //~ ERROR cannot assign
diff --git a/src/test/compile-fail/unboxed-closure-region.rs b/src/test/compile-fail/unboxed-closure-region.rs
index 5f4bf0d33be..eee1b6ce30b 100644
--- a/src/test/compile-fail/unboxed-closure-region.rs
+++ b/src/test/compile-fail/unboxed-closure-region.rs
@@ -14,7 +14,7 @@
 // reference cannot escape the region of that variable.
 fn main() {
     let _f = {
-        let x = 0_usize;
+        let x = 0;
         || x //~ ERROR `x` does not live long enough
     };
 }
diff --git a/src/test/compile-fail/unboxed-closures-borrow-conflict.rs b/src/test/compile-fail/unboxed-closures-borrow-conflict.rs
index 1191cfa2600..372f3277931 100644
--- a/src/test/compile-fail/unboxed-closures-borrow-conflict.rs
+++ b/src/test/compile-fail/unboxed-closures-borrow-conflict.rs
@@ -14,7 +14,7 @@
 // cause borrow conflicts.
 
 fn main() {
-    let mut x = 0_usize;
+    let mut x = 0;
     let f = || x += 1;
     let _y = x; //~ ERROR cannot use `x` because it was mutably borrowed
 }
diff --git a/src/test/compile-fail/unboxed-closures-mutate-upvar.rs b/src/test/compile-fail/unboxed-closures-mutate-upvar.rs
index 650bb17bb77..35052ec0bd5 100644
--- a/src/test/compile-fail/unboxed-closures-mutate-upvar.rs
+++ b/src/test/compile-fail/unboxed-closures-mutate-upvar.rs
@@ -20,21 +20,21 @@ fn to_fn<A,F:Fn<A>>(f: F) -> F { f }
 fn to_fn_mut<A,F:FnMut<A>>(f: F) -> F { f }
 
 fn a() {
-    let n = 0u8;
+    let n = 0;
     let mut f = to_fn_mut(|| { //~ ERROR closure cannot assign
         n += 1;
     });
 }
 
 fn b() {
-    let mut n = 0u8;
+    let mut n = 0;
     let mut f = to_fn_mut(|| {
         n += 1; // OK
     });
 }
 
 fn c() {
-    let n = 0u8;
+    let n = 0;
     let mut f = to_fn_mut(move || {
         // If we just did a straight-forward desugaring, this would
         // compile, but we do something a bit more subtle, and hence
@@ -44,21 +44,21 @@ fn c() {
 }
 
 fn d() {
-    let mut n = 0u8;
+    let mut n = 0;
     let mut f = to_fn_mut(move || {
         n += 1; // OK
     });
 }
 
 fn e() {
-    let n = 0u8;
+    let n = 0;
     let mut f = to_fn(move || {
         n += 1; //~ ERROR cannot assign
     });
 }
 
 fn f() {
-    let mut n = 0u8;
+    let mut n = 0;
     let mut f = to_fn(move || {
         n += 1; //~ ERROR cannot assign
     });
diff --git a/src/test/compile-fail/unboxed-closures-mutated-upvar-from-fn-closure.rs b/src/test/compile-fail/unboxed-closures-mutated-upvar-from-fn-closure.rs
index 2345a86595e..432c7fa5d1b 100644
--- a/src/test/compile-fail/unboxed-closures-mutated-upvar-from-fn-closure.rs
+++ b/src/test/compile-fail/unboxed-closures-mutated-upvar-from-fn-closure.rs
@@ -16,7 +16,7 @@ fn call<F>(f: F) where F : Fn() {
 }
 
 fn main() {
-    let mut counter = 0_u32;
+    let mut counter = 0;
     call(|| {
         counter += 1;
         //~^ ERROR cannot assign to data in a captured outer variable in an `Fn` closure
diff --git a/src/test/compile-fail/unreachable-arm.rs b/src/test/compile-fail/unreachable-arm.rs
index eb5ffeaf888..bc93b86a391 100644
--- a/src/test/compile-fail/unreachable-arm.rs
+++ b/src/test/compile-fail/unreachable-arm.rs
@@ -15,4 +15,4 @@
 
 enum foo { a(Box<foo>, isize), b(usize), }
 
-fn main() { match foo::b(1_usize) { foo::b(_) | foo::a(box _, 1) => { } foo::a(_, 1) => { } } }
+fn main() { match foo::b(1) { foo::b(_) | foo::a(box _, 1) => { } foo::a(_, 1) => { } } }
diff --git a/src/test/compile-fail/unsafe-fn-assign-deref-ptr.rs b/src/test/compile-fail/unsafe-fn-assign-deref-ptr.rs
index 97908118e35..4ea7051775e 100644
--- a/src/test/compile-fail/unsafe-fn-assign-deref-ptr.rs
+++ b/src/test/compile-fail/unsafe-fn-assign-deref-ptr.rs
@@ -10,7 +10,7 @@
 
 
 fn f(p: *const u8) {
-    *p = 0u8; //~ ERROR dereference of unsafe pointer requires unsafe function or block
+    *p = 0; //~ ERROR dereference of unsafe pointer requires unsafe function or block
     return;
 }
 
diff --git a/src/test/compile-fail/variance-issue-20533.rs b/src/test/compile-fail/variance-issue-20533.rs
index 0254f56bd1a..e5473f12bf2 100644
--- a/src/test/compile-fail/variance-issue-20533.rs
+++ b/src/test/compile-fail/variance-issue-20533.rs
@@ -33,19 +33,19 @@ struct AffineU32(u32);
 
 fn main() {
     {
-        let a = AffineU32(1_u32);
+        let a = AffineU32(1);
         let x = foo(&a);
         drop(a); //~ ERROR cannot move out of `a`
         drop(x);
     }
     {
-        let a = AffineU32(1_u32);
+        let a = AffineU32(1);
         let x = bar(&a);
         drop(a); //~ ERROR cannot move out of `a`
         drop(x);
     }
     {
-        let a = AffineU32(1_u32);
+        let a = AffineU32(1);
         let x = baz(&a);
         drop(a); //~ ERROR cannot move out of `a`
         drop(x);
diff --git a/src/test/compile-fail/vtable-res-trait-param.rs b/src/test/compile-fail/vtable-res-trait-param.rs
index cc6ff2d8ebc..654272f5bc6 100644
--- a/src/test/compile-fail/vtable-res-trait-param.rs
+++ b/src/test/compile-fail/vtable-res-trait-param.rs
@@ -23,7 +23,7 @@ impl TraitB for isize {
 }
 
 fn call_it<B:TraitB>(b: B)  -> isize {
-    let y = 4_usize;
+    let y = 4;
     b.gimme_an_a(y) //~ ERROR the trait `TraitA` is not implemented
 }
 
diff --git a/src/test/debuginfo/associated-types.rs b/src/test/debuginfo/associated-types.rs
index 26117e7a13b..63132d91327 100644
--- a/src/test/debuginfo/associated-types.rs
+++ b/src/test/debuginfo/associated-types.rs
@@ -139,13 +139,13 @@ fn assoc_enum<T: TraitWithAssocType>(arg: Enum<T>) {
 }
 
 fn main() {
-    assoc_struct(Struct { b: -1i32, b1: 0i64 });
-    assoc_local(1i32);
-    assoc_arg::<i32>(2i64);
-    assoc_return_value(3i32);
-    assoc_tuple((4i32, 5i64));
-    assoc_enum(Enum::Variant1(6i32, 7i64));
-    assoc_enum(Enum::Variant2(8i64, 9i32));
+    assoc_struct(Struct { b: -1, b1: 0 });
+    assoc_local(1);
+    assoc_arg::<i32>(2);
+    assoc_return_value(3);
+    assoc_tuple((4, 5));
+    assoc_enum(Enum::Variant1(6, 7));
+    assoc_enum(Enum::Variant2(8, 9));
 }
 
 fn zzz() { () }
diff --git a/src/test/debuginfo/recursive-struct.rs b/src/test/debuginfo/recursive-struct.rs
index 3b1979337d5..25afd3514b0 100644
--- a/src/test/debuginfo/recursive-struct.rs
+++ b/src/test/debuginfo/recursive-struct.rs
@@ -128,10 +128,10 @@ fn main() {
         next: Val {
             val: box UniqueNode {
                 next: Empty,
-                value: 1_u16,
+                value: 1,
             }
         },
-        value: 0_u16,
+        value: 0,
     };
 
     let unique_unique: Box<UniqueNode<u32>> = box UniqueNode {
diff --git a/src/test/debuginfo/simd.rs b/src/test/debuginfo/simd.rs
index 161392c94c8..12c7b146342 100644
--- a/src/test/debuginfo/simd.rs
+++ b/src/test/debuginfo/simd.rs
@@ -47,18 +47,18 @@ use std::simd::{i8x16, i16x8,i32x4,i64x2,u8x16,u16x8,u32x4,u64x2,f32x4,f64x2};
 
 fn main() {
 
-    let vi8x16 = i8x16(0i8, 1i8, 2i8, 3i8, 4i8, 5i8, 6i8, 7i8,
-                      8i8, 9i8, 10i8, 11i8, 12i8, 13i8, 14i8, 15i8);
+    let vi8x16 = i8x16(0, 1, 2, 3, 4, 5, 6, 7,
+                      8, 9, 10, 11, 12, 13, 14, 15);
 
-    let vi16x8 = i16x8(16i16, 17i16, 18i16, 19i16, 20i16, 21i16, 22i16, 23i16);
-    let vi32x4 = i32x4(24i32, 25i32, 26i32, 27i32);
-    let vi64x2 = i64x2(28i64, 29i64);
+    let vi16x8 = i16x8(16, 17, 18, 19, 20, 21, 22, 23);
+    let vi32x4 = i32x4(24, 25, 26, 27);
+    let vi64x2 = i64x2(28, 29);
 
-    let vu8x16 = u8x16(30u8, 31u8, 32u8, 33u8, 34u8, 35u8, 36u8, 37u8,
-                      38u8, 39u8, 40u8, 41u8, 42u8, 43u8, 44u8, 45u8);
-    let vu16x8 = u16x8(46u16, 47u16, 48u16, 49u16, 50u16, 51u16, 52u16, 53u16);
-    let vu32x4 = u32x4(54u32, 55u32, 56u32, 57u32);
-    let vu64x2 = u64x2(58u64, 59u64);
+    let vu8x16 = u8x16(30, 31, 32, 33, 34, 35, 36, 37,
+                      38, 39, 40, 41, 42, 43, 44, 45);
+    let vu16x8 = u16x8(46, 47, 48, 49, 50, 51, 52, 53);
+    let vu32x4 = u32x4(54, 55, 56, 57);
+    let vu64x2 = u64x2(58, 59);
 
     let vf32x4 = f32x4(60.5f32, 61.5f32, 62.5f32, 63.5f32);
     let vf64x2 = f64x2(64.5f64, 65.5f64);
diff --git a/src/test/parse-fail/class-implements-bad-trait.rs b/src/test/parse-fail/class-implements-bad-trait.rs
index d709ffdc3fc..7de51c1ea75 100644
--- a/src/test/parse-fail/class-implements-bad-trait.rs
+++ b/src/test/parse-fail/class-implements-bad-trait.rs
@@ -15,5 +15,5 @@ class cat : nonexistent {
 }
 
 fn main() {
-  let nyan = cat(0us);
+  let nyan = cat(0);
 }
diff --git a/src/test/parse-fail/issue-5544-b.rs b/src/test/parse-fail/issue-5544-b.rs
index afff5984b46..9c35d77baf0 100644
--- a/src/test/parse-fail/issue-5544-b.rs
+++ b/src/test/parse-fail/issue-5544-b.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 fn main() {
-    let __isize = 0xff_ffff_ffff_ffff_ffff__isize;
+    let __isize = 0xff_ffff_ffff_ffff_ffff;
     //~^ ERROR int literal is too large
 }
diff --git a/src/test/parse-fail/lex-bad-numeric-literals.rs b/src/test/parse-fail/lex-bad-numeric-literals.rs
index 9a490be6a01..62b87e3f480 100644
--- a/src/test/parse-fail/lex-bad-numeric-literals.rs
+++ b/src/test/parse-fail/lex-bad-numeric-literals.rs
@@ -22,7 +22,7 @@ fn main() {
     1e+; //~ ERROR: expected at least one digit in exponent
     0x539.0; //~ ERROR: hexadecimal float literal is not supported
     99999999999999999999999999999999; //~ ERROR: int literal is too large
-    99999999999999999999999999999999u32; //~ ERROR: int literal is too large
+    99999999999999999999999999999999; //~ ERROR: int literal is too large
     0x; //~ ERROR: no valid digits
     0xu32; //~ ERROR: no valid digits
     0ou32; //~ ERROR: no valid digits
diff --git a/src/test/parse-fail/regions-trait-2.rs b/src/test/parse-fail/regions-trait-2.rs
index 8b36e87db3e..7a7113cd594 100644
--- a/src/test/parse-fail/regions-trait-2.rs
+++ b/src/test/parse-fail/regions-trait-2.rs
@@ -26,7 +26,7 @@ impl<'a> get_ctxt for has_ctxt<'a> {
 }
 
 fn make_gc() -> @get_ctxt  {
-    let ctxt = ctxt { v: 22us };
+    let ctxt = ctxt { v: 22 };
     let hc = has_ctxt { c: &ctxt };
     return @hc as @get_ctxt;
     //~^ ERROR source contains reference
diff --git a/src/test/pretty/empty-lines.rs b/src/test/pretty/empty-lines.rs
index 58f6ae960b1..6a9cbef1015 100644
--- a/src/test/pretty/empty-lines.rs
+++ b/src/test/pretty/empty-lines.rs
@@ -13,5 +13,5 @@
 
 fn a() -> uint {
 
-    1usize
+    1
 }
diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index 83ee2bd08f4..58cd19059c0 100644
--- a/src/test/pretty/issue-4264.pp
+++ b/src/test/pretty/issue-4264.pp
@@ -26,12 +26,12 @@ pub fn bar() {
     const FOO: usize = ((5 as usize) - (4 as usize) as usize);
     let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]);
 
-    let _: [(); (1usize as usize)] = ([(() as ())] as [(); 1]);
+    let _: [(); (1 as usize)] = ([(() as ())] as [(); 1]);
 
     let _ =
         (((&((([(1 as i32), (2 as i32), (3 as i32)] as [i32; 3])) as [i32; 3])
               as &[i32; 3]) as *const _ as *const [i32; 3]) as
-            *const [i32; (3usize as usize)] as *const [i32; 3]);
+            *const [i32; (3 as usize)] as *const [i32; 3]);
 
 
 
diff --git a/src/test/pretty/issue-4264.rs b/src/test/pretty/issue-4264.rs
index 3aa2f4826b2..90757c92c4c 100644
--- a/src/test/pretty/issue-4264.rs
+++ b/src/test/pretty/issue-4264.rs
@@ -20,9 +20,9 @@ pub fn bar() {
     const FOO: usize = 5 - 4;
     let _: [(); FOO] = [()];
 
-    let _ : [(); 1usize] = [()];
+    let _ : [(); 1] = [()];
 
-    let _ = &([1,2,3]) as *const _ as *const [i32; 3usize];
+    let _ = &([1,2,3]) as *const _ as *const [i32; 3];
 
     format!("test");
 }
diff --git a/src/test/run-fail/extern-panic.rs b/src/test/run-fail/extern-panic.rs
index 225ce5a741b..127700e963a 100644
--- a/src/test/run-fail/extern-panic.rs
+++ b/src/test/run-fail/extern-panic.rs
@@ -26,10 +26,10 @@ mod rustrt {
 }
 
 extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
-    if data == 1_usize {
+    if data == 1 {
         data
     } else {
-        count(data - 1_usize) + count(data - 1_usize)
+        count(data - 1) + count(data - 1)
     }
 }
 
@@ -41,9 +41,9 @@ fn count(n: uint) -> uint {
 }
 
 fn main() {
-    for _ in 0..10_usize {
+    for _ in 0..10 {
         task::spawn(move|| {
-            let result = count(5_usize);
+            let result = count(5);
             println!("result = %?", result);
             panic!();
         });
diff --git a/src/test/run-fail/if-check-panic.rs b/src/test/run-fail/if-check-panic.rs
index 19a57db5ec7..e3af5b2bbf5 100644
--- a/src/test/run-fail/if-check-panic.rs
+++ b/src/test/run-fail/if-check-panic.rs
@@ -10,9 +10,9 @@
 
 // error-pattern:Number is odd
 fn even(x: uint) -> bool {
-    if x < 2_usize {
+    if x < 2 {
         return false;
-    } else if x == 2_usize { return true; } else { return even(x - 2_usize); }
+    } else if x == 2 { return true; } else { return even(x - 2); }
 }
 
 fn foo(x: uint) {
@@ -23,4 +23,4 @@ fn foo(x: uint) {
     }
 }
 
-fn main() { foo(3_usize); }
+fn main() { foo(3); }
diff --git a/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot
index b4ec986ef25..21e84fb858b 100644
--- a/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot
+++ b/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot
@@ -1,17 +1,17 @@
 digraph block {
     N0[label="entry"];
     N1[label="exit"];
-    N2[label="expr 2usize"];
-    N3[label="expr 0usize"];
-    N4[label="expr 20usize"];
-    N5[label="expr [2usize, 0usize, 20usize]"];
+    N2[label="expr 2"];
+    N3[label="expr 0"];
+    N4[label="expr 20"];
+    N5[label="expr [2, 0, 20]"];
     N6[label="local v"];
-    N7[label="stmt let v = [2usize, 0usize, 20usize];"];
+    N7[label="stmt let v = [2, 0, 20];"];
     N8[label="expr v"];
-    N9[label="expr 20usize"];
-    N10[label="expr v[20usize]"];
-    N11[label="stmt v[20usize];"];
-    N12[label="block { let v = [2usize, 0usize, 20usize]; v[20usize]; }"];
+    N9[label="expr 20"];
+    N10[label="expr v[20]"];
+    N11[label="stmt v[20];"];
+    N12[label="block { let v = [2, 0, 20]; v[20]; }"];
     N0 -> N2;
     N2 -> N3;
     N3 -> N4;
diff --git a/src/test/run-make/graphviz-flowgraph/f20.rs b/src/test/run-make/graphviz-flowgraph/f20.rs
index d65de18b547..d7349932355 100644
--- a/src/test/run-make/graphviz-flowgraph/f20.rs
+++ b/src/test/run-make/graphviz-flowgraph/f20.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 pub fn expr_index_20() {
-    let v = [2_usize, 0_usize, 20_usize];
-    v[20_usize];
+    let v = [2, 0, 20];
+    v[20];
 }
diff --git a/src/test/run-make/save-analysis/foo.rs b/src/test/run-make/save-analysis/foo.rs
index 7d94f4c7b17..2e2b8d2578e 100644
--- a/src/test/run-make/save-analysis/foo.rs
+++ b/src/test/run-make/save-analysis/foo.rs
@@ -39,17 +39,17 @@ static bob: Option<&'static [isize]> = None;
 // buglink test - see issue #1337.
 
 fn test_alias<I: Iterator>(i: Option<<I as Iterator>::Item>) {
-    let s = sub_struct{ field2: 45u32, };
+    let s = sub_struct{ field2: 45, };
 
     // import tests
     fn foo(x: &Float) {}
     let _: Option<u8> = from_i32(45);
 
-    let x = 42_usize;
+    let x = 42;
 
     myflate::deflate_bytes(&[]);
 
-    let x = (3, 4_usize);
+    let x = (3, 4);
     let y = x.1;
 }
 
diff --git a/src/test/run-make/symbols-are-reasonable/lib.rs b/src/test/run-make/symbols-are-reasonable/lib.rs
index e1f36ecda53..f81d4803f8f 100644
--- a/src/test/run-make/symbols-are-reasonable/lib.rs
+++ b/src/test/run-make/symbols-are-reasonable/lib.rs
@@ -16,5 +16,5 @@ impl Foo for uint {}
 
 pub fn dummy() {
     // force the vtable to be created
-    let _x = &1_usize as &Foo;
+    let _x = &1 as &Foo;
 }
diff --git a/src/test/run-pass/alias-uninit-value.rs b/src/test/run-pass/alias-uninit-value.rs
index b1bebf0b3e6..45dd213d71f 100644
--- a/src/test/run-pass/alias-uninit-value.rs
+++ b/src/test/run-pass/alias-uninit-value.rs
@@ -17,7 +17,7 @@ enum sty { ty_nil, }
 struct RawT {struct_: sty, cname: Option<String>, hash: uint}
 
 fn mk_raw_ty(st: sty, cname: Option<String>) -> RawT {
-    return RawT {struct_: st, cname: cname, hash: 0_usize};
+    return RawT {struct_: st, cname: cname, hash: 0};
 }
 
 pub fn main() { mk_raw_ty(sty::ty_nil, None::<String>); }
diff --git a/src/test/run-pass/associated-types-constant-type.rs b/src/test/run-pass/associated-types-constant-type.rs
index 57e9230336c..299225e3a47 100644
--- a/src/test/run-pass/associated-types-constant-type.rs
+++ b/src/test/run-pass/associated-types-constant-type.rs
@@ -35,5 +35,5 @@ fn get(x: int) -> <int as SignedUnsigned>::Opposite {
 
 fn main() {
     let x = get(22);
-    assert_eq!(22_usize, x);
+    assert_eq!(22, x);
 }
diff --git a/src/test/run-pass/associated-types-return.rs b/src/test/run-pass/associated-types-return.rs
index 8ae550be3fc..e7ab910bc95 100644
--- a/src/test/run-pass/associated-types-return.rs
+++ b/src/test/run-pass/associated-types-return.rs
@@ -43,7 +43,7 @@ fn foo2<I: Foo>(x: I) -> <I as Foo>::A {
 
 pub fn main() {
     let a = 42;
-    assert!(foo2(a) == 42_usize);
+    assert!(foo2(a) == 42);
 
     let a = Bar;
     assert!(foo2(a) == 43);
diff --git a/src/test/run-pass/associated-types-struct-field-named.rs b/src/test/run-pass/associated-types-struct-field-named.rs
index 8667f6c8430..a63274beb0e 100644
--- a/src/test/run-pass/associated-types-struct-field-named.rs
+++ b/src/test/run-pass/associated-types-struct-field-named.rs
@@ -36,8 +36,8 @@ impl UnifyKey for u32 {
 
 pub fn main() {
     let node: Node<i32> = Node { key: 1, value: Some(22) };
-    assert_eq!(foo(&node), Some(22_u32));
+    assert_eq!(foo(&node), Some(22));
 
     let node: Node<u32> = Node { key: 1, value: Some(22) };
-    assert_eq!(foo(&node), Some(22_i32));
+    assert_eq!(foo(&node), Some(22));
 }
diff --git a/src/test/run-pass/associated-types-struct-field-numbered.rs b/src/test/run-pass/associated-types-struct-field-numbered.rs
index 9503f78a71b..3be2623185b 100644
--- a/src/test/run-pass/associated-types-struct-field-numbered.rs
+++ b/src/test/run-pass/associated-types-struct-field-numbered.rs
@@ -33,8 +33,8 @@ impl UnifyKey for u32 {
 
 pub fn main() {
     let node: Node<i32> = Node(1, Some(22));
-    assert_eq!(foo(&node), Some(22_u32));
+    assert_eq!(foo(&node), Some(22));
 
     let node: Node<u32> = Node(1, Some(22));
-    assert_eq!(foo(&node), Some(22_i32));
+    assert_eq!(foo(&node), Some(22));
 }
diff --git a/src/test/run-pass/associated-types-sugar-path.rs b/src/test/run-pass/associated-types-sugar-path.rs
index c068065ac6a..7e7299961d8 100644
--- a/src/test/run-pass/associated-types-sugar-path.rs
+++ b/src/test/run-pass/associated-types-sugar-path.rs
@@ -41,5 +41,5 @@ impl<T: Foo> C for B<T> {
 }
 
 pub fn main() {
-    let z: uint = bar(2, 4_usize);
+    let z: uint = bar(2, 4);
 }
diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs
index 7c126fc420a..2b84adcb15c 100644
--- a/src/test/run-pass/auto-encode.rs
+++ b/src/test/run-pass/auto-encode.rs
@@ -131,19 +131,19 @@ enum Quark<T> {
 enum CLike { A, B, C }
 
 pub fn main() {
-    let a = &Plus(@Minus(@Val(3_usize), @Val(10_usize)), @Plus(@Val(22_usize), @Val(5_usize)));
+    let a = &Plus(@Minus(@Val(3), @Val(10)), @Plus(@Val(22), @Val(5)));
     test_rbml(a);
 
-    let a = &Spanned {lo: 0_usize, hi: 5_usize, node: 22_usize};
+    let a = &Spanned {lo: 0, hi: 5, node: 22};
     test_rbml(a);
 
-    let a = &Point {x: 3_usize, y: 5_usize};
+    let a = &Point {x: 3, y: 5};
     test_rbml(a);
 
-    let a = &Top(22_usize);
+    let a = &Top(22);
     test_rbml(a);
 
-    let a = &Bottom(222_usize);
+    let a = &Bottom(222);
     test_rbml(a);
 
     let a = &A;
diff --git a/src/test/run-pass/autoderef-method-on-trait.rs b/src/test/run-pass/autoderef-method-on-trait.rs
index 8121edfd2cc..6a90fa47e58 100644
--- a/src/test/run-pass/autoderef-method-on-trait.rs
+++ b/src/test/run-pass/autoderef-method-on-trait.rs
@@ -16,10 +16,10 @@ trait double {
 }
 
 impl double for uint {
-    fn double(self: Box<uint>) -> uint { *self * 2_usize }
+    fn double(self: Box<uint>) -> uint { *self * 2 }
 }
 
 pub fn main() {
-    let x: Box<_> = box() (box 3_usize as Box<double>);
-    assert_eq!(x.double(), 6_usize);
+    let x: Box<_> = box() (box 3 as Box<double>);
+    assert_eq!(x.double(), 6);
 }
diff --git a/src/test/run-pass/autoderef-method-priority.rs b/src/test/run-pass/autoderef-method-priority.rs
index 537894bfd15..cadce45b18d 100644
--- a/src/test/run-pass/autoderef-method-priority.rs
+++ b/src/test/run-pass/autoderef-method-priority.rs
@@ -20,10 +20,10 @@ impl double for uint {
 }
 
 impl double for Box<uint> {
-    fn double(self) -> uint { *self * 2_usize }
+    fn double(self) -> uint { *self * 2 }
 }
 
 pub fn main() {
-    let x: Box<_> = box 3_usize;
-    assert_eq!(x.double(), 6_usize);
+    let x: Box<_> = box 3;
+    assert_eq!(x.double(), 6);
 }
diff --git a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
index 2ffdd576ffb..746107803c9 100644
--- a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
+++ b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
@@ -16,10 +16,10 @@ trait double {
 }
 
 impl double for Box<uint> {
-    fn double(self: Box<Box<uint>>) -> uint { **self * 2_usize }
+    fn double(self: Box<Box<uint>>) -> uint { **self * 2 }
 }
 
 pub fn main() {
-    let x: Box<Box<Box<Box<Box<_>>>>> = box box box box box 3_usize;
-    assert_eq!(x.double(), 6_usize);
+    let x: Box<Box<Box<Box<Box<_>>>>> = box box box box box 3;
+    assert_eq!(x.double(), 6);
 }
diff --git a/src/test/run-pass/autoderef-method-twice.rs b/src/test/run-pass/autoderef-method-twice.rs
index 82510aea162..51b5c98816a 100644
--- a/src/test/run-pass/autoderef-method-twice.rs
+++ b/src/test/run-pass/autoderef-method-twice.rs
@@ -16,10 +16,10 @@ trait double {
 }
 
 impl double for uint {
-    fn double(self: Box<uint>) -> uint { *self * 2_usize }
+    fn double(self: Box<uint>) -> uint { *self * 2 }
 }
 
 pub fn main() {
-    let x: Box<Box<_>> = box box 3_usize;
-    assert_eq!(x.double(), 6_usize);
+    let x: Box<Box<_>> = box box 3;
+    assert_eq!(x.double(), 6);
 }
diff --git a/src/test/run-pass/autoderef-method.rs b/src/test/run-pass/autoderef-method.rs
index c9aa1133101..61e704276af 100644
--- a/src/test/run-pass/autoderef-method.rs
+++ b/src/test/run-pass/autoderef-method.rs
@@ -16,10 +16,10 @@ trait double {
 }
 
 impl double for uint {
-    fn double(self: Box<uint>) -> uint { *self * 2_usize }
+    fn double(self: Box<uint>) -> uint { *self * 2 }
 }
 
 pub fn main() {
-    let x: Box<_> = box 3_usize;
-    assert_eq!(x.double(), 6_usize);
+    let x: Box<_> = box 3;
+    assert_eq!(x.double(), 6);
 }
diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
index 6e6e58a7ddf..86d6a91e75b 100644
--- a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
+++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
@@ -29,6 +29,6 @@ impl Foo for uint {
 }
 
 pub fn main() {
-    let x: Box<_> = box 3_usize;
+    let x: Box<_> = box 3;
     assert_eq!(x.foo(), "box 3".to_string());
 }
diff --git a/src/test/run-pass/big-literals.rs b/src/test/run-pass/big-literals.rs
index 8afb33c7669..01ac2fc20bf 100644
--- a/src/test/run-pass/big-literals.rs
+++ b/src/test/run-pass/big-literals.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 pub fn main() {
-    assert_eq!(0xffffffffu32, (-1 as u32));
-    assert_eq!(4294967295u32, (-1 as u32));
-    assert_eq!(0xffffffffffffffffu64, (-1 as u64));
-    assert_eq!(18446744073709551615u64, (-1 as u64));
+    assert_eq!(0xffffffff, (-1 as u32));
+    assert_eq!(4294967295, (-1 as u32));
+    assert_eq!(0xffffffffffffffff, (-1 as u64));
+    assert_eq!(18446744073709551615, (-1 as u64));
 
-    assert_eq!(-2147483648i32 - 1i32, 2147483647i32);
+    assert_eq!(-2147483648 - 1, 2147483647);
 }
diff --git a/src/test/run-pass/block-arg-call-as.rs b/src/test/run-pass/block-arg-call-as.rs
index d319aaa2f8e..8be6d1bd35a 100644
--- a/src/test/run-pass/block-arg-call-as.rs
+++ b/src/test/run-pass/block-arg-call-as.rs
@@ -13,6 +13,6 @@ fn asBlock<F>(f: F) -> uint where F: FnOnce() -> uint {
 }
 
 pub fn main() {
-   let x = asBlock(|| 22_usize);
-   assert_eq!(x, 22_usize);
+   let x = asBlock(|| 22);
+   assert_eq!(x, 22);
 }
diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs
index d5d26f42ef0..7cbe8104deb 100644
--- a/src/test/run-pass/block-iter-1.rs
+++ b/src/test/run-pass/block-iter-1.rs
@@ -11,8 +11,8 @@
 fn iter_vec<T, F>(v: Vec<T> , mut f: F) where F: FnMut(&T) { for x in &v { f(x); } }
 
 pub fn main() {
-    let v = vec![1i32, 2, 3, 4, 5, 6, 7];
-    let mut odds = 0i32;
+    let v = vec![1, 2, 3, 4, 5, 6, 7];
+    let mut odds = 0;
     iter_vec(v, |i| {
         if *i % 2 == 1 {
             odds += 1;
diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs
index 8c079ca4b07..7701f6114ca 100644
--- a/src/test/run-pass/block-iter-2.rs
+++ b/src/test/run-pass/block-iter-2.rs
@@ -11,7 +11,7 @@
 fn iter_vec<T, F>(v: Vec<T>, mut f: F) where F: FnMut(&T) { for x in &v { f(x); } }
 
 pub fn main() {
-    let v = vec![1i32, 2, 3, 4, 5];
+    let v = vec![1, 2, 3, 4, 5];
     let mut sum = 0;
     iter_vec(v.clone(), |i| {
         iter_vec(v.clone(), |j| {
diff --git a/src/test/run-pass/borrowck-closures-two-imm.rs b/src/test/run-pass/borrowck-closures-two-imm.rs
index c907778339e..75161d16bc0 100644
--- a/src/test/run-pass/borrowck-closures-two-imm.rs
+++ b/src/test/run-pass/borrowck-closures-two-imm.rs
@@ -15,7 +15,7 @@
 // the closures are in scope. Issue #6801.
 
 fn a() -> i32 {
-    let mut x = 3i32;
+    let mut x = 3;
     x += 1;
     let c1 = || x * 4;
     let c2 = || x * 5;
@@ -27,7 +27,7 @@ fn get(x: &i32) -> i32 {
 }
 
 fn b() -> i32 {
-    let mut x = 3i32;
+    let mut x = 3;
     x += 1;
     let c1 = || get(&x);
     let c2 = || get(&x);
@@ -35,7 +35,7 @@ fn b() -> i32 {
 }
 
 fn c() -> i32 {
-    let mut x = 3i32;
+    let mut x = 3;
     x += 1;
     let c1 = || x * 5;
     let c2 = || get(&x);
diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs
index 499650a6e51..d35600ef22e 100644
--- a/src/test/run-pass/borrowck-mut-uniq.rs
+++ b/src/test/run-pass/borrowck-mut-uniq.rs
@@ -26,7 +26,7 @@ fn add_int(x: &mut Ints, v: int) {
 
 fn iter_ints<F>(x: &Ints, mut f: F) -> bool where F: FnMut(&int) -> bool {
     let l = x.values.len();
-    (0_usize..l).all(|i| f(&x.values[i]))
+    (0..l).all(|i| f(&x.values[i]))
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/capture-clauses-unboxed-closures.rs b/src/test/run-pass/capture-clauses-unboxed-closures.rs
index dd417f1a9eb..19316590c26 100644
--- a/src/test/run-pass/capture-clauses-unboxed-closures.rs
+++ b/src/test/run-pass/capture-clauses-unboxed-closures.rs
@@ -17,8 +17,8 @@ fn each<'a,T,F:FnMut(&'a T)>(x: &'a [T], mut f: F) {
 }
 
 fn main() {
-    let mut sum = 0_usize;
-    let elems = [ 1_usize, 2, 3, 4, 5 ];
+    let mut sum = 0;
+    let elems = [ 1, 2, 3, 4, 5 ];
     each(&elems, |val: &uint| sum += *val);
     assert_eq!(sum, 15);
 }
diff --git a/src/test/run-pass/cast.rs b/src/test/run-pass/cast.rs
index f8a680b2a97..fc71e6c59fc 100644
--- a/src/test/run-pass/cast.rs
+++ b/src/test/run-pass/cast.rs
@@ -16,6 +16,6 @@ pub fn main() {
     assert_eq!(u, 'Q' as u32);
     assert_eq!(i as u8, 'Q' as u8);
     assert_eq!(i as u8 as i8, 'Q' as u8 as i8);
-    assert_eq!(0x51u8 as char, 'Q');
+    assert_eq!(0x51 as char, 'Q');
     assert_eq!(0 as u32, false as u32);
 }
diff --git a/src/test/run-pass/cci_borrow.rs b/src/test/run-pass/cci_borrow.rs
index 89babb8f722..cd8f783a2e5 100644
--- a/src/test/run-pass/cci_borrow.rs
+++ b/src/test/run-pass/cci_borrow.rs
@@ -17,8 +17,8 @@ extern crate cci_borrow_lib;
 use cci_borrow_lib::foo;
 
 pub fn main() {
-    let p: Box<_> = box 22_usize;
+    let p: Box<_> = box 22;
     let r = foo(&*p);
     println!("r={}", r);
-    assert_eq!(r, 22_usize);
+    assert_eq!(r, 22);
 }
diff --git a/src/test/run-pass/cci_impl_exe.rs b/src/test/run-pass/cci_impl_exe.rs
index c4b55b9962f..bda3b73e29c 100644
--- a/src/test/run-pass/cci_impl_exe.rs
+++ b/src/test/run-pass/cci_impl_exe.rs
@@ -17,7 +17,7 @@ pub fn main() {
     //let bt0 = sys::frame_address();
     //println!("%?", bt0);
 
-    3_usize.to(10_usize, |i| {
+    3.to(10, |i| {
         println!("{}", i);
 
         //let bt1 = sys::frame_address();
diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs
index e4b26ba74be..5b91af7a194 100644
--- a/src/test/run-pass/cci_iter_exe.rs
+++ b/src/test/run-pass/cci_iter_exe.rs
@@ -13,10 +13,10 @@
 extern crate cci_iter_lib;
 
 pub fn main() {
-    //let bt0 = sys::rusti::frame_address(1u32);
+    //let bt0 = sys::rusti::frame_address(1);
     //println!("%?", bt0);
     cci_iter_lib::iter(&[1, 2, 3], |i| {
         println!("{}", *i);
-        //assert!(bt0 == sys::rusti::frame_address(2u32));
+        //assert!(bt0 == sys::rusti::frame_address(2));
     })
 }
diff --git a/src/test/run-pass/cci_no_inline_exe.rs b/src/test/run-pass/cci_no_inline_exe.rs
index 2040bd7ad71..cc76ed530c4 100644
--- a/src/test/run-pass/cci_no_inline_exe.rs
+++ b/src/test/run-pass/cci_no_inline_exe.rs
@@ -21,7 +21,7 @@ pub fn main() {
     // actually working.
     //let bt0 = sys::frame_address();
     //println!("%?", bt0);
-    iter(vec!(1_usize, 2_usize, 3_usize), |i| {
+    iter(vec!(1, 2, 3), |i| {
         println!("{}", i);
 
         //let bt1 = sys::frame_address();
diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
index 9a388c9bc24..da51ad761c7 100644
--- a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
+++ b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
@@ -25,6 +25,6 @@ fn print_out(thing: Box<ToString>, expected: String) {
 }
 
 pub fn main() {
-  let nyan: Box<ToString> = box cat(0_usize, 2, "nyan".to_string()) as Box<ToString>;
+  let nyan: Box<ToString> = box cat(0, 2, "nyan".to_string()) as Box<ToString>;
   print_out(nyan, "nyan".to_string());
 }
diff --git a/src/test/run-pass/class-cast-to-trait.rs b/src/test/run-pass/class-cast-to-trait.rs
index 476594c270e..01513ab6f47 100644
--- a/src/test/run-pass/class-cast-to-trait.rs
+++ b/src/test/run-pass/class-cast-to-trait.rs
@@ -42,8 +42,8 @@ impl cat {
 impl cat {
     fn meow(&mut self) {
       println!("Meow");
-      self.meows += 1_usize;
-      if self.meows % 5_usize == 0_usize {
+      self.meows += 1;
+      if self.meows % 5 == 0 {
           self.how_hungry += 1;
       }
     }
@@ -59,7 +59,7 @@ fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
 
 
 pub fn main() {
-    let mut nyan = cat(0_usize, 2, "nyan".to_string());
+    let mut nyan = cat(0, 2, "nyan".to_string());
     let mut nyan: &mut noisy = &mut nyan;
     nyan.speak();
 }
diff --git a/src/test/run-pass/class-dtor.rs b/src/test/run-pass/class-dtor.rs
index 14247ad7754..c98e53c8a95 100644
--- a/src/test/run-pass/class-dtor.rs
+++ b/src/test/run-pass/class-dtor.rs
@@ -21,7 +21,7 @@ impl Drop for cat {
 
 fn cat(done: extern fn(uint)) -> cat {
     cat {
-        meows: 0_usize,
+        meows: 0,
         done: done
     }
 }
diff --git a/src/test/run-pass/class-exports.rs b/src/test/run-pass/class-exports.rs
index 4c7d0e6951a..1cf4c35ee96 100644
--- a/src/test/run-pass/class-exports.rs
+++ b/src/test/run-pass/class-exports.rs
@@ -27,7 +27,7 @@ mod kitty {
     pub fn cat(in_name: String) -> cat {
         cat {
             name: in_name,
-            meows: 0_usize
+            meows: 0
         }
     }
 }
diff --git a/src/test/run-pass/class-method-cross-crate.rs b/src/test/run-pass/class-method-cross-crate.rs
index 47cc500e44e..55acd2e040d 100644
--- a/src/test/run-pass/class-method-cross-crate.rs
+++ b/src/test/run-pass/class-method-cross-crate.rs
@@ -13,8 +13,8 @@ extern crate cci_class_2;
 use cci_class_2::kitties::cat;
 
 pub fn main() {
-  let nyan : cat = cat(52_usize, 99);
-  let kitty = cat(1000_usize, 2);
+  let nyan : cat = cat(52, 99);
+  let kitty = cat(1000, 2);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
   nyan.speak();
diff --git a/src/test/run-pass/class-methods-cross-crate.rs b/src/test/run-pass/class-methods-cross-crate.rs
index d62a726dcdd..34c309780b1 100644
--- a/src/test/run-pass/class-methods-cross-crate.rs
+++ b/src/test/run-pass/class-methods-cross-crate.rs
@@ -13,10 +13,10 @@ extern crate cci_class_3;
 use cci_class_3::kitties::cat;
 
 pub fn main() {
-    let mut nyan : cat = cat(52_usize, 99);
-    let kitty = cat(1000_usize, 2);
+    let mut nyan : cat = cat(52, 99);
+    let kitty = cat(1000, 2);
     assert_eq!(nyan.how_hungry, 99);
     assert_eq!(kitty.how_hungry, 2);
     nyan.speak();
-    assert_eq!(nyan.meow_count(), 53_usize);
+    assert_eq!(nyan.meow_count(), 53);
 }
diff --git a/src/test/run-pass/class-methods.rs b/src/test/run-pass/class-methods.rs
index 18fb03ec935..8fa76342286 100644
--- a/src/test/run-pass/class-methods.rs
+++ b/src/test/run-pass/class-methods.rs
@@ -15,7 +15,7 @@ struct cat {
 }
 
 impl cat {
-    pub fn speak(&mut self) { self.meows += 1_usize; }
+    pub fn speak(&mut self) { self.meows += 1; }
     pub fn meow_count(&mut self) -> uint { self.meows }
 }
 
@@ -27,10 +27,10 @@ fn cat(in_x: uint, in_y: int) -> cat {
 }
 
 pub fn main() {
-  let mut nyan: cat = cat(52_usize, 99);
-  let kitty = cat(1000_usize, 2);
+  let mut nyan: cat = cat(52, 99);
+  let kitty = cat(1000, 2);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
   nyan.speak();
-  assert_eq!(nyan.meow_count(), 53_usize);
+  assert_eq!(nyan.meow_count(), 53);
 }
diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs
index b529b0a0772..557f9986238 100644
--- a/src/test/run-pass/class-poly-methods.rs
+++ b/src/test/run-pass/class-poly-methods.rs
@@ -32,12 +32,12 @@ fn cat<U>(in_x : uint, in_y : int, in_info: Vec<U> ) -> cat<U> {
 }
 
 pub fn main() {
-  let mut nyan : cat<int> = cat::<int>(52_usize, 99, vec!(9));
-  let mut kitty = cat(1000_usize, 2, vec!("tabby".to_string()));
+  let mut nyan : cat<int> = cat::<int>(52, 99, vec!(9));
+  let mut kitty = cat(1000, 2, vec!("tabby".to_string()));
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
   nyan.speak(vec!(1,2,3));
-  assert_eq!(nyan.meow_count(), 55_usize);
+  assert_eq!(nyan.meow_count(), 55);
   kitty.speak(vec!("meow".to_string(), "mew".to_string(), "purr".to_string(), "chirp".to_string()));
-  assert_eq!(kitty.meow_count(), 1004_usize);
+  assert_eq!(kitty.meow_count(), 1004);
 }
diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs
index daff321efcf..2bdc053675f 100644
--- a/src/test/run-pass/class-separate-impl.rs
+++ b/src/test/run-pass/class-separate-impl.rs
@@ -39,8 +39,8 @@ impl cat {
 impl cat {
     fn meow(&mut self) {
         println!("Meow");
-        self.meows += 1_usize;
-        if self.meows % 5_usize == 0_usize {
+        self.meows += 1;
+        if self.meows % 5 == 0 {
             self.how_hungry += 1;
         }
     }
@@ -67,6 +67,6 @@ fn print_out(thing: Box<ToString>, expected: String) {
 }
 
 pub fn main() {
-  let nyan: Box<ToString> = box cat(0_usize, 2, "nyan".to_string()) as Box<ToString>;
+  let nyan: Box<ToString> = box cat(0, 2, "nyan".to_string()) as Box<ToString>;
   print_out(nyan, "nyan".to_string());
 }
diff --git a/src/test/run-pass/class-typarams.rs b/src/test/run-pass/class-typarams.rs
index b56a749d33b..c50a8cc83a5 100644
--- a/src/test/run-pass/class-typarams.rs
+++ b/src/test/run-pass/class-typarams.rs
@@ -17,7 +17,7 @@ struct cat<U> {
 }
 
 impl<U> cat<U> {
-    pub fn speak(&mut self) { self.meows += 1_usize; }
+    pub fn speak(&mut self) { self.meows += 1; }
     pub fn meow_count(&mut self) -> uint { self.meows }
 }
 
@@ -31,6 +31,6 @@ fn cat<U>(in_x : uint, in_y : int) -> cat<U> {
 
 
 pub fn main() {
-  let _nyan : cat<int> = cat::<int>(52_usize, 99);
-  //  let mut kitty = cat(1000_usize, 2);
+  let _nyan : cat<int> = cat::<int>(52, 99);
+  //  let mut kitty = cat(1000, 2);
 }
diff --git a/src/test/run-pass/classes-simple-cross-crate.rs b/src/test/run-pass/classes-simple-cross-crate.rs
index 8037d77807d..09660454648 100644
--- a/src/test/run-pass/classes-simple-cross-crate.rs
+++ b/src/test/run-pass/classes-simple-cross-crate.rs
@@ -13,8 +13,8 @@ extern crate cci_class;
 use cci_class::kitties::cat;
 
 pub fn main() {
-  let nyan : cat = cat(52_usize, 99);
-  let kitty = cat(1000_usize, 2);
+  let nyan : cat = cat(52, 99);
+  let kitty = cat(1000, 2);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
 }
diff --git a/src/test/run-pass/classes-simple-method.rs b/src/test/run-pass/classes-simple-method.rs
index b15d6544fed..502fa73ed93 100644
--- a/src/test/run-pass/classes-simple-method.rs
+++ b/src/test/run-pass/classes-simple-method.rs
@@ -26,8 +26,8 @@ fn cat(in_x : uint, in_y : int) -> cat {
 }
 
 pub fn main() {
-  let mut nyan : cat = cat(52_usize, 99);
-  let kitty = cat(1000_usize, 2);
+  let mut nyan : cat = cat(52, 99);
+  let kitty = cat(1000, 2);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
   nyan.speak();
diff --git a/src/test/run-pass/classes-simple.rs b/src/test/run-pass/classes-simple.rs
index 9bf8df3ce4b..3cf529f2958 100644
--- a/src/test/run-pass/classes-simple.rs
+++ b/src/test/run-pass/classes-simple.rs
@@ -22,8 +22,8 @@ fn cat(in_x : uint, in_y : int) -> cat {
 }
 
 pub fn main() {
-  let nyan : cat = cat(52_usize, 99);
-  let kitty = cat(1000_usize, 2);
+  let nyan : cat = cat(52, 99);
+  let kitty = cat(1000, 2);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
 }
diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
index ade18a71259..32230c82a72 100644
--- a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
@@ -18,7 +18,7 @@ fn bip(v: &[uint]) -> Vec<uint> {
 }
 
 pub fn main() {
-    let mut the_vec = vec!(1_usize, 2, 3, 100);
+    let mut the_vec = vec!(1, 2, 3, 100);
     assert_eq!(the_vec.clone(), bar(&mut the_vec));
     assert_eq!(the_vec.clone(), bip(&the_vec));
 }
diff --git a/src/test/run-pass/concat.rs b/src/test/run-pass/concat.rs
index b0c3a5922b6..2de881993f1 100644
--- a/src/test/run-pass/concat.rs
+++ b/src/test/run-pass/concat.rs
@@ -15,12 +15,12 @@ pub fn main() {
     assert_eq!(concat!("qux", "quux",).to_string(), "quxquux".to_string());
 
     assert_eq!(
-        concat!(1, 2, 3_usize, 4f32, 4.0, 'a', true),
+        concat!(1, 2, 3, 4f32, 4.0, 'a', true),
         "12344.0atrue"
     );
 
     assert!(match "12344.0atrue" {
-        concat!(1, 2, 3_usize, 4f32, 4.0, 'a', true) => true,
+        concat!(1, 2, 3, 4f32, 4.0, 'a', true) => true,
         _ => false
     })
 }
diff --git a/src/test/run-pass/const-block.rs b/src/test/run-pass/const-block.rs
index cdb96e5dcbf..bdde0cf02c9 100644
--- a/src/test/run-pass/const-block.rs
+++ b/src/test/run-pass/const-block.rs
@@ -58,6 +58,6 @@ pub fn main() {
     assert_eq!(BLOCK_FN(300), 300);
     assert_eq!(BLOCK_ENUM_CONSTRUCTOR(200), Some(200));
     // FIXME #13972
-    // assert_eq!(BLOCK_UNSAFE_SAFE_PTR as *const isize as usize, 0xdeadbeef_us);
-    // assert_eq!(BLOCK_UNSAFE_SAFE_PTR_2 as *const isize as usize, 0xdeadbeef_us);
+    // assert_eq!(BLOCK_UNSAFE_SAFE_PTR as *const isize as usize, 0xdeadbeef);
+    // assert_eq!(BLOCK_UNSAFE_SAFE_PTR_2 as *const isize as usize, 0xdeadbeef);
 }
diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs
index 3a64f53dbb0..9b0e7e4e75e 100644
--- a/src/test/run-pass/const-bound.rs
+++ b/src/test/run-pass/const-bound.rs
@@ -20,7 +20,7 @@ pub fn main() {
     foo("hi".to_string());
     foo(~[1, 2, 3]);
     foo(F{field: 42});
-    foo((1, 2_usize));
+    foo((1, 2));
     foo(@1);*/
     foo(Box::new(1));
 }
diff --git a/src/test/run-pass/double-ref.rs b/src/test/run-pass/double-ref.rs
index 8018f681f38..0cb48670f23 100644
--- a/src/test/run-pass/double-ref.rs
+++ b/src/test/run-pass/double-ref.rs
@@ -9,23 +9,23 @@
 // except according to those terms.
 
 fn check_expr() {
-    let _:         & uint =     &1_usize;
-    let _:       & & uint =    &&1_usize;
-    let _:     & & & uint =   &&&1_usize;
-    let _:     & & & uint =  & &&1_usize;
-    let _:   & & & & uint =  &&&&1_usize;
-    let _:   & & & & uint = & &&&1_usize;
-    let _: & & & & & uint = &&&&&1_usize;
+    let _:         & uint =     &1;
+    let _:       & & uint =    &&1;
+    let _:     & & & uint =   &&&1;
+    let _:     & & & uint =  & &&1;
+    let _:   & & & & uint =  &&&&1;
+    let _:   & & & & uint = & &&&1;
+    let _: & & & & & uint = &&&&&1;
 }
 
 fn check_ty() {
-    let _:     &uint =         & 1_usize;
-    let _:    &&uint =       & & 1_usize;
-    let _:   &&&uint =     & & & 1_usize;
-    let _:  & &&uint =     & & & 1_usize;
-    let _:  &&&&uint =   & & & & 1_usize;
-    let _: & &&&uint =   & & & & 1_usize;
-    let _: &&&&&uint = & & & & & 1_usize;
+    let _:     &uint =         & 1;
+    let _:    &&uint =       & & 1;
+    let _:   &&&uint =     & & & 1;
+    let _:  & &&uint =     & & & 1;
+    let _:  &&&&uint =   & & & & 1;
+    let _: & &&&uint =   & & & & 1;
+    let _: &&&&&uint = & & & & & 1;
 }
 
 fn check_pat() {
diff --git a/src/test/run-pass/drop-trait-enum.rs b/src/test/run-pass/drop-trait-enum.rs
index f94da9fc747..353bd7a9ce0 100644
--- a/src/test/run-pass/drop-trait-enum.rs
+++ b/src/test/run-pass/drop-trait-enum.rs
@@ -62,7 +62,7 @@ pub fn main() {
 
     let (sender, receiver) = channel();
     {
-        let v = Foo::NestedVariant(box 42_usize, SendOnDrop { sender: sender.clone() }, sender);
+        let v = Foo::NestedVariant(box 42, SendOnDrop { sender: sender.clone() }, sender);
     }
     assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
     assert_eq!(receiver.recv().unwrap(), Message::Dropped);
@@ -79,10 +79,10 @@ pub fn main() {
     let (sender, receiver) = channel();
     let t = {
         thread::spawn(move|| {
-            let mut v = Foo::NestedVariant(box 42usize, SendOnDrop {
+            let mut v = Foo::NestedVariant(box 42, SendOnDrop {
                 sender: sender.clone()
             }, sender.clone());
-            v = Foo::NestedVariant(box 42_usize,
+            v = Foo::NestedVariant(box 42,
                                    SendOnDrop { sender: sender.clone() },
                                    sender.clone());
             v = Foo::SimpleVariant(sender.clone());
diff --git a/src/test/run-pass/extern-pass-char.rs b/src/test/run-pass/extern-pass-char.rs
index 49c3bf62dbc..2e86b3774c8 100644
--- a/src/test/run-pass/extern-pass-char.rs
+++ b/src/test/run-pass/extern-pass-char.rs
@@ -17,6 +17,6 @@ extern {
 
 pub fn main() {
     unsafe {
-        assert_eq!(22_u8, rust_dbg_extern_identity_u8(22_u8));
+        assert_eq!(22, rust_dbg_extern_identity_u8(22));
     }
 }
diff --git a/src/test/run-pass/extern-pass-u32.rs b/src/test/run-pass/extern-pass-u32.rs
index 07c04af8e1b..2c018084407 100644
--- a/src/test/run-pass/extern-pass-u32.rs
+++ b/src/test/run-pass/extern-pass-u32.rs
@@ -17,6 +17,6 @@ extern {
 
 pub fn main() {
     unsafe {
-        assert_eq!(22_u32, rust_dbg_extern_identity_u32(22_u32));
+        assert_eq!(22, rust_dbg_extern_identity_u32(22));
     }
 }
diff --git a/src/test/run-pass/extern-pass-u64.rs b/src/test/run-pass/extern-pass-u64.rs
index e19c73ebe20..e72e87d3d93 100644
--- a/src/test/run-pass/extern-pass-u64.rs
+++ b/src/test/run-pass/extern-pass-u64.rs
@@ -17,6 +17,6 @@ extern {
 
 pub fn main() {
     unsafe {
-        assert_eq!(22_u64, rust_dbg_extern_identity_u64(22_u64));
+        assert_eq!(22, rust_dbg_extern_identity_u64(22));
     }
 }
diff --git a/src/test/run-pass/foreign-fn-linkname.rs b/src/test/run-pass/foreign-fn-linkname.rs
index 24b711328a1..1c36ad73238 100644
--- a/src/test/run-pass/foreign-fn-linkname.rs
+++ b/src/test/run-pass/foreign-fn-linkname.rs
@@ -32,5 +32,5 @@ fn strlen(str: String) -> uint {
 
 pub fn main() {
     let len = strlen("Rust".to_string());
-    assert_eq!(len, 4_usize);
+    assert_eq!(len, 4);
 }
diff --git a/src/test/run-pass/i32-sub.rs b/src/test/run-pass/i32-sub.rs
index e5451431ade..cebfd89d8aa 100644
--- a/src/test/run-pass/i32-sub.rs
+++ b/src/test/run-pass/i32-sub.rs
@@ -11,4 +11,4 @@
 
 
 
-pub fn main() { let mut x: i32 = -400_i32; x = 0_i32 - x; assert!((x == 400_i32)); }
+pub fn main() { let mut x: i32 = -400; x = 0 - x; assert!((x == 400)); }
diff --git a/src/test/run-pass/i8-incr.rs b/src/test/run-pass/i8-incr.rs
index fbb4e446dd5..c91e738b822 100644
--- a/src/test/run-pass/i8-incr.rs
+++ b/src/test/run-pass/i8-incr.rs
@@ -12,9 +12,9 @@
 
 
 pub fn main() {
-    let mut x: i8 = -12i8;
-    let y: i8 = -12i8;
-    x = x + 1i8;
-    x = x - 1i8;
+    let mut x: i8 = -12;
+    let y: i8 = -12;
+    x = x + 1;
+    x = x - 1;
     assert_eq!(x, y);
 }
diff --git a/src/test/run-pass/if-check.rs b/src/test/run-pass/if-check.rs
index d2a1a3c71a5..766cced4c26 100644
--- a/src/test/run-pass/if-check.rs
+++ b/src/test/run-pass/if-check.rs
@@ -9,9 +9,9 @@
 // except according to those terms.
 
 fn even(x: uint) -> bool {
-    if x < 2_usize {
+    if x < 2 {
         return false;
-    } else if x == 2_usize { return true; } else { return even(x - 2_usize); }
+    } else if x == 2 { return true; } else { return even(x - 2); }
 }
 
 fn foo(x: uint) {
@@ -22,4 +22,4 @@ fn foo(x: uint) {
     }
 }
 
-pub fn main() { foo(2_usize); }
+pub fn main() { foo(2); }
diff --git a/src/test/run-pass/intrinsic-alignment.rs b/src/test/run-pass/intrinsic-alignment.rs
index 4b0e9168e19..d111462ed5a 100644
--- a/src/test/run-pass/intrinsic-alignment.rs
+++ b/src/test/run-pass/intrinsic-alignment.rs
@@ -27,8 +27,8 @@ mod m {
     #[cfg(target_arch = "x86")]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8_usize);
-            assert_eq!(::rusti::min_align_of::<u64>(), 4_usize);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 4);
         }
     }
 
@@ -36,8 +36,8 @@ mod m {
     #[cfg(any(target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64"))]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8_usize);
-            assert_eq!(::rusti::min_align_of::<u64>(), 8_usize);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 8);
         }
     }
 }
@@ -48,8 +48,8 @@ mod m {
     #[cfg(target_arch = "x86_64")]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8u);
-            assert_eq!(::rusti::min_align_of::<u64>(), 8u);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 8);
         }
     }
 }
@@ -60,8 +60,8 @@ mod m {
     #[cfg(target_arch = "x86")]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8_usize);
-            assert_eq!(::rusti::min_align_of::<u64>(), 8_usize);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 8);
         }
     }
 
@@ -69,8 +69,8 @@ mod m {
     #[cfg(target_arch = "x86_64")]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8_usize);
-            assert_eq!(::rusti::min_align_of::<u64>(), 8_usize);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 8);
         }
     }
 }
@@ -81,8 +81,8 @@ mod m {
     #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8_usize);
-            assert_eq!(::rusti::min_align_of::<u64>(), 8_usize);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 8);
         }
     }
 }
diff --git a/src/test/run-pass/intrinsics-integer.rs b/src/test/run-pass/intrinsics-integer.rs
index 2b0f7cc7d7d..e5724c1e0dc 100644
--- a/src/test/run-pass/intrinsics-integer.rs
+++ b/src/test/run-pass/intrinsics-integer.rs
@@ -37,83 +37,83 @@ pub fn main() {
     unsafe {
         use rusti::*;
 
-        assert_eq!(ctpop8(0u8), 0u8);
-        assert_eq!(ctpop16(0u16), 0u16);
-        assert_eq!(ctpop32(0u32), 0u32);
-        assert_eq!(ctpop64(0u64), 0u64);
+        assert_eq!(ctpop8(0), 0);
+        assert_eq!(ctpop16(0), 0);
+        assert_eq!(ctpop32(0), 0);
+        assert_eq!(ctpop64(0), 0);
 
-        assert_eq!(ctpop8(1u8), 1u8);
-        assert_eq!(ctpop16(1u16), 1u16);
-        assert_eq!(ctpop32(1u32), 1u32);
-        assert_eq!(ctpop64(1u64), 1u64);
+        assert_eq!(ctpop8(1), 1);
+        assert_eq!(ctpop16(1), 1);
+        assert_eq!(ctpop32(1), 1);
+        assert_eq!(ctpop64(1), 1);
 
-        assert_eq!(ctpop8(10u8), 2u8);
-        assert_eq!(ctpop16(10u16), 2u16);
-        assert_eq!(ctpop32(10u32), 2u32);
-        assert_eq!(ctpop64(10u64), 2u64);
+        assert_eq!(ctpop8(10), 2);
+        assert_eq!(ctpop16(10), 2);
+        assert_eq!(ctpop32(10), 2);
+        assert_eq!(ctpop64(10), 2);
 
-        assert_eq!(ctpop8(100u8), 3u8);
-        assert_eq!(ctpop16(100u16), 3u16);
-        assert_eq!(ctpop32(100u32), 3u32);
-        assert_eq!(ctpop64(100u64), 3u64);
+        assert_eq!(ctpop8(100), 3);
+        assert_eq!(ctpop16(100), 3);
+        assert_eq!(ctpop32(100), 3);
+        assert_eq!(ctpop64(100), 3);
 
-        assert_eq!(ctpop8(-1u8), 8u8);
-        assert_eq!(ctpop16(-1u16), 16u16);
-        assert_eq!(ctpop32(-1u32), 32u32);
-        assert_eq!(ctpop64(-1u64), 64u64);
+        assert_eq!(ctpop8(-1), 8);
+        assert_eq!(ctpop16(-1), 16);
+        assert_eq!(ctpop32(-1), 32);
+        assert_eq!(ctpop64(-1), 64);
 
-        assert_eq!(ctlz8(0u8), 8u8);
-        assert_eq!(ctlz16(0u16), 16u16);
-        assert_eq!(ctlz32(0u32), 32u32);
-        assert_eq!(ctlz64(0u64), 64u64);
+        assert_eq!(ctlz8(0), 8);
+        assert_eq!(ctlz16(0), 16);
+        assert_eq!(ctlz32(0), 32);
+        assert_eq!(ctlz64(0), 64);
 
-        assert_eq!(ctlz8(1u8), 7u8);
-        assert_eq!(ctlz16(1u16), 15u16);
-        assert_eq!(ctlz32(1u32), 31u32);
-        assert_eq!(ctlz64(1u64), 63u64);
+        assert_eq!(ctlz8(1), 7);
+        assert_eq!(ctlz16(1), 15);
+        assert_eq!(ctlz32(1), 31);
+        assert_eq!(ctlz64(1), 63);
 
-        assert_eq!(ctlz8(10u8), 4u8);
-        assert_eq!(ctlz16(10u16), 12u16);
-        assert_eq!(ctlz32(10u32), 28u32);
-        assert_eq!(ctlz64(10u64), 60u64);
+        assert_eq!(ctlz8(10), 4);
+        assert_eq!(ctlz16(10), 12);
+        assert_eq!(ctlz32(10), 28);
+        assert_eq!(ctlz64(10), 60);
 
-        assert_eq!(ctlz8(100u8), 1u8);
-        assert_eq!(ctlz16(100u16), 9u16);
-        assert_eq!(ctlz32(100u32), 25u32);
-        assert_eq!(ctlz64(100u64), 57u64);
+        assert_eq!(ctlz8(100), 1);
+        assert_eq!(ctlz16(100), 9);
+        assert_eq!(ctlz32(100), 25);
+        assert_eq!(ctlz64(100), 57);
 
-        assert_eq!(cttz8(-1u8), 0u8);
-        assert_eq!(cttz16(-1u16), 0u16);
-        assert_eq!(cttz32(-1u32), 0u32);
-        assert_eq!(cttz64(-1u64), 0u64);
+        assert_eq!(cttz8(-1), 0);
+        assert_eq!(cttz16(-1), 0);
+        assert_eq!(cttz32(-1), 0);
+        assert_eq!(cttz64(-1), 0);
 
-        assert_eq!(cttz8(0u8), 8u8);
-        assert_eq!(cttz16(0u16), 16u16);
-        assert_eq!(cttz32(0u32), 32u32);
-        assert_eq!(cttz64(0u64), 64u64);
+        assert_eq!(cttz8(0), 8);
+        assert_eq!(cttz16(0), 16);
+        assert_eq!(cttz32(0), 32);
+        assert_eq!(cttz64(0), 64);
 
-        assert_eq!(cttz8(1u8), 0u8);
-        assert_eq!(cttz16(1u16), 0u16);
-        assert_eq!(cttz32(1u32), 0u32);
-        assert_eq!(cttz64(1u64), 0u64);
+        assert_eq!(cttz8(1), 0);
+        assert_eq!(cttz16(1), 0);
+        assert_eq!(cttz32(1), 0);
+        assert_eq!(cttz64(1), 0);
 
-        assert_eq!(cttz8(10u8), 1u8);
-        assert_eq!(cttz16(10u16), 1u16);
-        assert_eq!(cttz32(10u32), 1u32);
-        assert_eq!(cttz64(10u64), 1u64);
+        assert_eq!(cttz8(10), 1);
+        assert_eq!(cttz16(10), 1);
+        assert_eq!(cttz32(10), 1);
+        assert_eq!(cttz64(10), 1);
 
-        assert_eq!(cttz8(100u8), 2u8);
-        assert_eq!(cttz16(100u16), 2u16);
-        assert_eq!(cttz32(100u32), 2u32);
-        assert_eq!(cttz64(100u64), 2u64);
+        assert_eq!(cttz8(100), 2);
+        assert_eq!(cttz16(100), 2);
+        assert_eq!(cttz32(100), 2);
+        assert_eq!(cttz64(100), 2);
 
-        assert_eq!(cttz8(-1u8), 0u8);
-        assert_eq!(cttz16(-1u16), 0u16);
-        assert_eq!(cttz32(-1u32), 0u32);
-        assert_eq!(cttz64(-1u64), 0u64);
+        assert_eq!(cttz8(-1), 0);
+        assert_eq!(cttz16(-1), 0);
+        assert_eq!(cttz32(-1), 0);
+        assert_eq!(cttz64(-1), 0);
 
-        assert_eq!(bswap16(0x0A0Bu16), 0x0B0Au16);
-        assert_eq!(bswap32(0x0ABBCC0Du32), 0x0DCCBB0Au32);
-        assert_eq!(bswap64(0x0122334455667708u64), 0x0877665544332201u64);
+        assert_eq!(bswap16(0x0A0B), 0x0B0A);
+        assert_eq!(bswap32(0x0ABBCC0D), 0x0DCCBB0A);
+        assert_eq!(bswap64(0x0122334455667708), 0x0877665544332201);
     }
 }
diff --git a/src/test/run-pass/intrinsics-math.rs b/src/test/run-pass/intrinsics-math.rs
index ed88b3c65e0..ab65f35dd34 100644
--- a/src/test/run-pass/intrinsics-math.rs
+++ b/src/test/run-pass/intrinsics-math.rs
@@ -65,8 +65,8 @@ pub fn main() {
         assert_approx_eq!(sqrtf32(64f32), 8f32);
         assert_approx_eq!(sqrtf64(64f64), 8f64);
 
-        assert_approx_eq!(powif32(25f32, -2i32), 0.0016f32);
-        assert_approx_eq!(powif64(23.2f64, 2i32), 538.24f64);
+        assert_approx_eq!(powif32(25f32, -2), 0.0016f32);
+        assert_approx_eq!(powif64(23.2f64, 2), 538.24f64);
 
         assert_approx_eq!(sinf32(0f32), 0f32);
         assert_approx_eq!(sinf64(f64::consts::PI / 2f64), 1f64);
diff --git a/src/test/run-pass/issue-1112.rs b/src/test/run-pass/issue-1112.rs
index 22c88c874f0..2ade0df7f6b 100644
--- a/src/test/run-pass/issue-1112.rs
+++ b/src/test/run-pass/issue-1112.rs
@@ -24,21 +24,21 @@ struct X<T> {
 pub fn main() {
     let x: X<int> = X {
         a: 12345678,
-        b: 9u8,
+        b: 9,
         c: true,
-        d: 10u8,
-        e: 11u16,
-        f: 12u8,
-        g: 13u8
+        d: 10,
+        e: 11,
+        f: 12,
+        g: 13
     };
     bar(x);
 }
 
 fn bar<T>(x: X<T>) {
-    assert_eq!(x.b, 9u8);
+    assert_eq!(x.b, 9);
     assert_eq!(x.c, true);
-    assert_eq!(x.d, 10u8);
-    assert_eq!(x.e, 11u16);
-    assert_eq!(x.f, 12u8);
-    assert_eq!(x.g, 13u8);
+    assert_eq!(x.d, 10);
+    assert_eq!(x.e, 11);
+    assert_eq!(x.f, 12);
+    assert_eq!(x.g, 13);
 }
diff --git a/src/test/run-pass/issue-11736.rs b/src/test/run-pass/issue-11736.rs
index b901e95ff55..b09d516dd35 100644
--- a/src/test/run-pass/issue-11736.rs
+++ b/src/test/run-pass/issue-11736.rs
@@ -15,7 +15,7 @@ use std::num::Float;
 
 fn main() {
     // Generate sieve of Eratosthenes for n up to 1e6
-    let n = 1000000_usize;
+    let n = 1000000;
     let mut sieve = BitVec::from_elem(n+1, true);
     let limit: uint = (n as f32).sqrt() as uint;
     for i in 2..limit+1 {
diff --git a/src/test/run-pass/issue-11958.rs b/src/test/run-pass/issue-11958.rs
index 00613f35f17..bb34dae77b3 100644
--- a/src/test/run-pass/issue-11958.rs
+++ b/src/test/run-pass/issue-11958.rs
@@ -19,6 +19,6 @@
 use std::thunk::Thunk;
 
 pub fn main() {
-    let mut x = 1i32;
+    let mut x = 1;
     let _thunk = Thunk::new(move|| { x = 2; });
 }
diff --git a/src/test/run-pass/issue-12909.rs b/src/test/run-pass/issue-12909.rs
index b7dc98b92e0..11a2e52cf97 100644
--- a/src/test/run-pass/issue-12909.rs
+++ b/src/test/run-pass/issue-12909.rs
@@ -15,7 +15,7 @@ fn copy<T: Copy>(&x: &T) -> T {
 }
 
 fn main() {
-    let arr = [(1, 1_usize), (2, 2), (3, 3)];
+    let arr = [(1, 1), (2, 2), (3, 3)];
 
     let v1: Vec<&_> = arr.iter().collect();
     let v2: Vec<_> = arr.iter().map(copy).collect();
diff --git a/src/test/run-pass/issue-15571.rs b/src/test/run-pass/issue-15571.rs
index 5b093d16cbf..3dc76f4a089 100644
--- a/src/test/run-pass/issue-15571.rs
+++ b/src/test/run-pass/issue-15571.rs
@@ -47,7 +47,7 @@ fn match_on_binding() {
 }
 
 fn match_on_upvar() {
-    let mut foo: Option<Box<_>> = Some(box 8i32);
+    let mut foo: Option<Box<_>> = Some(box 8);
     let f = move|| {
         match foo {
             None => {},
diff --git a/src/test/run-pass/issue-15673.rs b/src/test/run-pass/issue-15673.rs
index a6b8a04eeb6..227d8f7b8c8 100644
--- a/src/test/run-pass/issue-15673.rs
+++ b/src/test/run-pass/issue-15673.rs
@@ -11,5 +11,5 @@
 use std::iter::AdditiveIterator;
 fn main() {
     let x: [u64; 3] = [1, 2, 3];
-    assert_eq!(6, (0_usize..3).map(|i| x[i]).sum());
+    assert_eq!(6, (0..3).map(|i| x[i]).sum());
 }
diff --git a/src/test/run-pass/issue-15734.rs b/src/test/run-pass/issue-15734.rs
index e66ac8ff53c..18e4190ee45 100644
--- a/src/test/run-pass/issue-15734.rs
+++ b/src/test/run-pass/issue-15734.rs
@@ -53,12 +53,12 @@ impl<T, M: Index<(uint, uint), Output=T>> Index<uint> for Row<M> {
 }
 
 fn main() {
-    let m = Mat::new(vec!(1_usize, 2, 3, 4, 5, 6), 3);
+    let m = Mat::new(vec!(1, 2, 3, 4, 5, 6), 3);
     let r = m.row(1);
 
     assert!(r.index(&2) == &6);
     assert!(r[2] == 6);
-    assert!(r[2_usize] == 6_usize);
+    assert!(r[2] == 6);
     assert!(6 == r[2]);
 
     let e = r[2];
diff --git a/src/test/run-pass/issue-17662.rs b/src/test/run-pass/issue-17662.rs
index 7bd41cc5b52..dbfa91553e6 100644
--- a/src/test/run-pass/issue-17662.rs
+++ b/src/test/run-pass/issue-17662.rs
@@ -17,7 +17,7 @@ use std::marker;
 struct Bar<'a> { m: marker::PhantomData<&'a ()> }
 
 impl<'a> i::Foo<'a, uint> for Bar<'a> {
-    fn foo(&self) -> uint { 5_usize }
+    fn foo(&self) -> uint { 5 }
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/issue-18539.rs b/src/test/run-pass/issue-18539.rs
index ce56f3e8d72..b92cfa1f29b 100644
--- a/src/test/run-pass/issue-18539.rs
+++ b/src/test/run-pass/issue-18539.rs
@@ -19,5 +19,5 @@ fn uint_to_foo(_: uint) -> Foo {
 
 #[allow(unused_must_use)]
 fn main() {
-    (0_usize..10).map(uint_to_foo);
+    (0..10).map(uint_to_foo);
 }
diff --git a/src/test/run-pass/issue-20055-box-trait.rs b/src/test/run-pass/issue-20055-box-trait.rs
index 572a0d82528..7e89cfe24e1 100644
--- a/src/test/run-pass/issue-20055-box-trait.rs
+++ b/src/test/run-pass/issue-20055-box-trait.rs
@@ -41,10 +41,10 @@ pub fn foo(box_1: fn () -> Box<[i8; 1]>,
 }
 
 pub fn main() {
-    fn box_1() -> Box<[i8; 1]> { Box::new( [1i8; 1] ) }
-    fn box_2() -> Box<[i8; 2]> { Box::new( [1i8; 2] ) }
-    fn box_3() -> Box<[i8; 3]> { Box::new( [1i8; 3] ) }
-    fn box_4() -> Box<[i8; 4]> { Box::new( [1i8; 4] ) }
+    fn box_1() -> Box<[i8; 1]> { Box::new( [1; 1] ) }
+    fn box_2() -> Box<[i8; 2]> { Box::new( [1; 2] ) }
+    fn box_3() -> Box<[i8; 3]> { Box::new( [1; 3] ) }
+    fn box_4() -> Box<[i8; 4]> { Box::new( [1; 4] ) }
 
     foo(box_1, box_2, box_3, box_4);
 }
diff --git a/src/test/run-pass/issue-20055-box-unsized-array.rs b/src/test/run-pass/issue-20055-box-unsized-array.rs
index f751be6f13b..5af5186e94f 100644
--- a/src/test/run-pass/issue-20055-box-unsized-array.rs
+++ b/src/test/run-pass/issue-20055-box-unsized-array.rs
@@ -29,10 +29,10 @@ pub fn foo(box_1: fn () -> Box<[i8; 1]>,
 }
 
 pub fn main() {
-    fn box_1() -> Box<[i8; 1]> { Box::new( [1i8] ) }
-    fn box_2() -> Box<[i8; 20]> { Box::new( [1i8; 20] ) }
-    fn box_3() -> Box<[i8; 300]> { Box::new( [1i8; 300] ) }
-    fn box_4() -> Box<[i8; 4000]> { Box::new( [1i8; 4000] ) }
+    fn box_1() -> Box<[i8; 1]> { Box::new( [1] ) }
+    fn box_2() -> Box<[i8; 20]> { Box::new( [1; 20] ) }
+    fn box_3() -> Box<[i8; 300]> { Box::new( [1; 300] ) }
+    fn box_4() -> Box<[i8; 4000]> { Box::new( [1; 4000] ) }
 
     foo(box_1, box_2, box_3, box_4);
 }
diff --git a/src/test/run-pass/issue-20676.rs b/src/test/run-pass/issue-20676.rs
index 01a2322ae93..640774f9d24 100644
--- a/src/test/run-pass/issue-20676.rs
+++ b/src/test/run-pass/issue-20676.rs
@@ -15,6 +15,6 @@
 use std::fmt;
 
 fn main() {
-    let a: &fmt::Debug = &1_i32;
+    let a: &fmt::Debug = &1;
     format!("{:?}", a);
 }
diff --git a/src/test/run-pass/issue-21475.rs b/src/test/run-pass/issue-21475.rs
index 145145af519..29701bd668a 100644
--- a/src/test/run-pass/issue-21475.rs
+++ b/src/test/run-pass/issue-21475.rs
@@ -11,10 +11,10 @@
 use m::{START, END};
 
 fn main() {
-    match 42u32 {
+    match 42 {
         m::START...m::END => {},
-        0u32...m::END => {},
-        m::START...59u32 => {},
+        0...m::END => {},
+        m::START...59 => {},
         _  => {},
     }
 }
diff --git a/src/test/run-pass/issue-2185.rs b/src/test/run-pass/issue-2185.rs
index 20ff8d29b70..3da0a67ea8e 100644
--- a/src/test/run-pass/issue-2185.rs
+++ b/src/test/run-pass/issue-2185.rs
@@ -72,17 +72,17 @@ fn range(lo: uint, hi: uint, it: |uint|) {
     let mut i = lo;
     while i < hi {
         it(i);
-        i += 1_usize;
+        i += 1;
     }
 }
 
 pub fn main() {
-    let range: 'static ||uint|| = |a| range(0_usize, 1000_usize, a);
+    let range: 'static ||uint|| = |a| range(0, 1000, a);
     let filt: 'static ||v: uint|| = |a| filter(
         range,
-        |&&n: uint| n % 3_usize != 0_usize && n % 5_usize != 0_usize,
+        |&&n: uint| n % 3 != 0 && n % 5 != 0,
         a);
-    let sum = foldl(filt, 0_usize, |accum, &&n: uint| accum + n );
+    let sum = foldl(filt, 0, |accum, &&n: uint| accum + n );
 
     println!("{}", sum);
 }
diff --git a/src/test/run-pass/issue-22036.rs b/src/test/run-pass/issue-22036.rs
index c06a29c09f7..7bc6393ef89 100644
--- a/src/test/run-pass/issue-22036.rs
+++ b/src/test/run-pass/issue-22036.rs
@@ -28,6 +28,6 @@ impl<I> DigitCollection for I where I: Iterator<Item=u8> {
 }
 
 fn main() {
-    let xs = vec![1u8, 2, 3, 4, 5];
+    let xs = vec![1, 2, 3, 4, 5];
     assert_eq!(xs.into_iter().digit_sum(), 15);
 }
diff --git a/src/test/run-pass/issue-2550.rs b/src/test/run-pass/issue-2550.rs
index 395b2c4b459..c55de959a94 100644
--- a/src/test/run-pass/issue-2550.rs
+++ b/src/test/run-pass/issue-2550.rs
@@ -22,5 +22,5 @@ fn f<T>(_x: T) {
 }
 
 pub fn main() {
-    f(C(1_usize));
+    f(C(1));
 }
diff --git a/src/test/run-pass/issue-2989.rs b/src/test/run-pass/issue-2989.rs
index 8767d397b64..8b6eb12f102 100644
--- a/src/test/run-pass/issue-2989.rs
+++ b/src/test/run-pass/issue-2989.rs
@@ -21,11 +21,11 @@ impl methods for () {
 // the position of this function is significant! - if it comes before methods
 // then it works, if it comes after it then it doesn't!
 fn to_bools(bitv: Storage) -> Vec<bool> {
-    (0_usize..8).map(|i| {
+    (0..8).map(|i| {
         let w = i / 64;
         let b = i % 64;
-        let x = 1u64 & (bitv.storage[w] >> b);
-        x == 1u64
+        let x = 1 & (bitv.storage[w] >> b);
+        x == 1
     }).collect()
 }
 
@@ -35,7 +35,7 @@ pub fn main() {
     let bools = vec!(false, false, true, false, false, true, true, false);
     let bools2 = to_bools(Storage{storage: vec!(0b01100100)});
 
-    for i in 0_usize..8 {
+    for i in 0..8 {
         println!("{} => {} vs {}", i, bools[i], bools2[i]);
     }
 
diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs
index 28e44536892..b51edcf8bec 100644
--- a/src/test/run-pass/issue-3609.rs
+++ b/src/test/run-pass/issue-3609.rs
@@ -28,7 +28,7 @@ fn foo(name: String, samples_chan: Sender<Msg>) {
 
         // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
         let callback: SamplesFn = Box::new(move |buffer| {
-            for i in 0_usize..buffer.len() {
+            for i in 0..buffer.len() {
                 println!("{}: {}", i, buffer[i])
             }
         });
diff --git a/src/test/run-pass/issue-6130.rs b/src/test/run-pass/issue-6130.rs
index 93429ff10dc..1a1f538a548 100644
--- a/src/test/run-pass/issue-6130.rs
+++ b/src/test/run-pass/issue-6130.rs
@@ -12,9 +12,9 @@
 
 pub fn main() {
     let i: uint = 0;
-    assert!(i <= 0xFFFF_FFFF_usize);
+    assert!(i <= 0xFFFF_FFFF);
 
     let i: int = 0;
-    assert!(i >= -0x8000_0000__isize);
-    assert!(i <= 0x7FFF_FFFF__isize);
+    assert!(i >= -0x8000_0000);
+    assert!(i <= 0x7FFF_FFFF);
 }
diff --git a/src/test/run-pass/issue-6892.rs b/src/test/run-pass/issue-6892.rs
index 557ec82233d..6faca339651 100644
--- a/src/test/run-pass/issue-6892.rs
+++ b/src/test/run-pass/issue-6892.rs
@@ -49,7 +49,7 @@ fn main() {
     assert_eq!(unsafe { NUM_DROPS }, 3);
     { let _x = FooBar::_Foo(Foo); }
     assert_eq!(unsafe { NUM_DROPS }, 5);
-    { let _x = FooBar::_Bar(42_usize); }
+    { let _x = FooBar::_Bar(42); }
     assert_eq!(unsafe { NUM_DROPS }, 6);
 
     { let _ = Foo; }
@@ -60,6 +60,6 @@ fn main() {
     assert_eq!(unsafe { NUM_DROPS }, 9);
     { let _ = FooBar::_Foo(Foo); }
     assert_eq!(unsafe { NUM_DROPS }, 11);
-    { let _ = FooBar::_Bar(42_usize); }
+    { let _ = FooBar::_Bar(42); }
     assert_eq!(unsafe { NUM_DROPS }, 12);
 }
diff --git a/src/test/run-pass/issue-7012.rs b/src/test/run-pass/issue-7012.rs
index 96db28f4a10..3a9864f3a76 100644
--- a/src/test/run-pass/issue-7012.rs
+++ b/src/test/run-pass/issue-7012.rs
@@ -18,11 +18,11 @@ would be printed, however the below prints false.
 struct signature<'a> { pattern : &'a [u32] }
 
 static test1: signature<'static> =  signature {
-  pattern: &[0x243f6a88u32,0x85a308d3u32,0x13198a2eu32,0x03707344u32,0xa4093822u32,0x299f31d0u32]
+  pattern: &[0x243f6a88,0x85a308d3,0x13198a2e,0x03707344,0xa4093822,0x299f31d0]
 };
 
 pub fn main() {
-  let test: &[u32] = &[0x243f6a88u32,0x85a308d3u32,0x13198a2eu32,
-                       0x03707344u32,0xa4093822u32,0x299f31d0u32];
+  let test: &[u32] = &[0x243f6a88,0x85a308d3,0x13198a2e,
+                       0x03707344,0xa4093822,0x299f31d0];
   println!("{}",test==test1.pattern);
 }
diff --git a/src/test/run-pass/issue-8783.rs b/src/test/run-pass/issue-8783.rs
index 815e00e1291..303dd191006 100644
--- a/src/test/run-pass/issue-8783.rs
+++ b/src/test/run-pass/issue-8783.rs
@@ -13,7 +13,7 @@ use std::default::Default;
 struct X { pub x: uint }
 impl Default for X {
     fn default() -> X {
-        X { x: 42_usize }
+        X { x: 42 }
     }
 }
 
diff --git a/src/test/run-pass/issue2170exe.rs b/src/test/run-pass/issue2170exe.rs
index b4a41ef44f8..58424089c5e 100644
--- a/src/test/run-pass/issue2170exe.rs
+++ b/src/test/run-pass/issue2170exe.rs
@@ -12,5 +12,5 @@
 extern crate issue2170lib;
 
 pub fn main() {
-   // let _ = issue2170lib::rsrc(2i32);
+   // let _ = issue2170lib::rsrc(2);
 }
diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs
index dd38a5f8b3b..121338823d2 100644
--- a/src/test/run-pass/ivec-tag.rs
+++ b/src/test/run-pass/ivec-tag.rs
@@ -13,8 +13,8 @@ use std::sync::mpsc::{channel, Sender};
 
 fn producer(tx: &Sender<Vec<u8>>) {
     tx.send(
-         vec!(1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8,
-          13u8)).unwrap();
+         vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+          13)).unwrap();
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs
index 74ddb990c31..45964efad97 100644
--- a/src/test/run-pass/last-use-in-cap-clause.rs
+++ b/src/test/run-pass/last-use-in-cap-clause.rs
@@ -19,8 +19,8 @@ struct A { a: Box<isize> }
 fn foo() -> Box<FnMut() -> isize + 'static> {
     let k: Box<_> = box 22;
     let _u = A {a: k.clone()};
-    // FIXME(#16640) suffix in `22_isize` suffix shouldn't be necessary
-    let result  = || 22_isize;
+    // FIXME(#16640) suffix in `22` suffix shouldn't be necessary
+    let result  = || 22;
     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
     Box::new(result)
 }
diff --git a/src/test/run-pass/macro-interpolation.rs b/src/test/run-pass/macro-interpolation.rs
index 069aeb9220e..1cbd4f6bc70 100644
--- a/src/test/run-pass/macro-interpolation.rs
+++ b/src/test/run-pass/macro-interpolation.rs
@@ -24,6 +24,6 @@ macro_rules! overly_complicated {
 
 pub fn main() {
     assert!(overly_complicated!(f, x, Option<uint>, { return Some(x); },
-                               Some(8_usize), Some(y), y) == 8_usize)
+                               Some(8), Some(y), y) == 8)
 
 }
diff --git a/src/test/run-pass/macro-pat.rs b/src/test/run-pass/macro-pat.rs
index 6f2626a5af5..7a3e55322c8 100644
--- a/src/test/run-pass/macro-pat.rs
+++ b/src/test/run-pass/macro-pat.rs
@@ -47,9 +47,9 @@ fn f(c: Option<char>) -> uint {
 }
 
 pub fn main() {
-    assert_eq!(1_usize, f(Some('x')));
-    assert_eq!(2_usize, f(Some('y')));
-    assert_eq!(3_usize, f(None));
+    assert_eq!(1, f(Some('x')));
+    assert_eq!(2, f(Some('y')));
+    assert_eq!(3, f(None));
 
     assert_eq!(1, match Some('x') {
         Some(char_x!()) => 1,
diff --git a/src/test/run-pass/match-with-ret-arm.rs b/src/test/run-pass/match-with-ret-arm.rs
index d2e27fc822e..79b197f08e2 100644
--- a/src/test/run-pass/match-with-ret-arm.rs
+++ b/src/test/run-pass/match-with-ret-arm.rs
@@ -16,6 +16,6 @@ pub fn main() {
         None => return (),
         Some(num) => num as u32
     };
-    assert_eq!(f, 1234u32);
+    assert_eq!(f, 1234);
     println!("{}", f)
 }
diff --git a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
index 0ad600dd85d..3ffac98418a 100644
--- a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
+++ b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
@@ -38,7 +38,7 @@ impl<'a> MyWriter for &'a mut [u8] {
 }
 
 fn main() {
-    let mut buf = [0_u8; 6];
+    let mut buf = [0; 6];
 
     {
         let mut writer: &mut [_] = &mut buf;
diff --git a/src/test/run-pass/method-self-arg-aux1.rs b/src/test/run-pass/method-self-arg-aux1.rs
index e9a1e19d4bf..81212ee348f 100644
--- a/src/test/run-pass/method-self-arg-aux1.rs
+++ b/src/test/run-pass/method-self-arg-aux1.rs
@@ -26,5 +26,5 @@ fn main() {
 
     x.foo(&x);
 
-    assert!(method_self_arg1::get_count() == 2u64*3*3*3*5*5*5*7*7*7);
+    assert!(method_self_arg1::get_count() == 2*3*3*3*5*5*5*7*7*7);
 }
diff --git a/src/test/run-pass/method-self-arg-aux2.rs b/src/test/run-pass/method-self-arg-aux2.rs
index 7fa810ce154..ca81860dd08 100644
--- a/src/test/run-pass/method-self-arg-aux2.rs
+++ b/src/test/run-pass/method-self-arg-aux2.rs
@@ -30,5 +30,5 @@ fn main() {
 
     x.run_trait();
 
-    assert!(method_self_arg2::get_count() == 2u64*2*3*3*5*5*7*7*11*11*13*13*17);
+    assert!(method_self_arg2::get_count() == 2*2*3*3*5*5*7*7*11*11*13*13*17);
 }
diff --git a/src/test/run-pass/method-self-arg-trait.rs b/src/test/run-pass/method-self-arg-trait.rs
index c79141d9795..17fdd7b45c2 100644
--- a/src/test/run-pass/method-self-arg-trait.rs
+++ b/src/test/run-pass/method-self-arg-trait.rs
@@ -75,5 +75,5 @@ fn main() {
 
     x.baz();
 
-    unsafe { assert!(COUNT == 2u64*2*3*3*5*5*7*7*11*11*13*13*17); }
+    unsafe { assert!(COUNT == 2*2*3*3*5*5*7*7*11*11*13*13*17); }
 }
diff --git a/src/test/run-pass/method-self-arg.rs b/src/test/run-pass/method-self-arg.rs
index de24297c7b5..62b3d52860b 100644
--- a/src/test/run-pass/method-self-arg.rs
+++ b/src/test/run-pass/method-self-arg.rs
@@ -54,5 +54,5 @@ fn main() {
 
     x.foo(&x);
 
-    unsafe { assert!(COUNT == 2_usize*3*3*3*5*5*5*7*7*7); }
+    unsafe { assert!(COUNT == 2*3*3*3*5*5*5*7*7*7); }
 }
diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs
index bb62b1599a4..03027e40d6c 100644
--- a/src/test/run-pass/nullable-pointer-iotareduction.rs
+++ b/src/test/run-pass/nullable-pointer-iotareduction.rs
@@ -55,7 +55,7 @@ macro_rules! check_fancy {
         check_fancy!($e, $T, |ptr| assert!(*ptr == $e));
     }};
     ($e:expr, $T:ty, |$v:ident| $chk:expr) => {{
-        assert!(E::Nothing::<$T>((), ((), ()), [23i8; 0]).is_none());
+        assert!(E::Nothing::<$T>((), ((), ()), [23; 0]).is_none());
         let e = $e;
         let t_ = E::Thing::<$T>(23, e);
         match t_.get_ref() {
diff --git a/src/test/run-pass/object-method-numbering.rs b/src/test/run-pass/object-method-numbering.rs
index 8da753acb96..9c7a925b5bb 100644
--- a/src/test/run-pass/object-method-numbering.rs
+++ b/src/test/run-pass/object-method-numbering.rs
@@ -29,7 +29,7 @@ impl SomeTrait for i32 {
 }
 
 fn main() {
-    let x = 22_i32;
+    let x = 22;
     let x1: &SomeTrait<SomeType=i32> = &x;
     let y = get_int(x1);
     assert_eq!(x, y);
diff --git a/src/test/run-pass/objects-coerce-freeze-borrored.rs b/src/test/run-pass/objects-coerce-freeze-borrored.rs
index 998af27c338..d2523bc4f24 100644
--- a/src/test/run-pass/objects-coerce-freeze-borrored.rs
+++ b/src/test/run-pass/objects-coerce-freeze-borrored.rs
@@ -40,9 +40,9 @@ fn do_it_imm(obj: &Foo, v: uint) {
 }
 
 pub fn main() {
-    let mut x = 22_usize;
+    let mut x = 22;
     let obj = &mut x as &mut Foo;
     do_it_mut(obj);
-    do_it_imm(obj, 23_usize);
+    do_it_imm(obj, 23);
     do_it_mut(obj);
 }
diff --git a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
index 30a8c270bd7..9cee266c4a7 100644
--- a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
+++ b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
@@ -37,7 +37,7 @@ pub fn main() {
         box BarStruct{ x: 2 } as Box<FooTrait>
     );
 
-    for i in 0_usize..foos.len() {
+    for i in 0..foos.len() {
         assert_eq!(i, foos[i].foo());
     }
 }
diff --git a/src/test/run-pass/or-pattern.rs b/src/test/run-pass/or-pattern.rs
index 654d2429a0b..ef399044abc 100644
--- a/src/test/run-pass/or-pattern.rs
+++ b/src/test/run-pass/or-pattern.rs
@@ -16,6 +16,6 @@ fn or_alt(q: blah) -> int {
 
 pub fn main() {
     assert_eq!(or_alt(blah::c), 0);
-    assert_eq!(or_alt(blah::a(10, 100, 0_usize)), 110);
+    assert_eq!(or_alt(blah::a(10, 100, 0)), 110);
     assert_eq!(or_alt(blah::b(20, 200)), 220);
 }
diff --git a/src/test/run-pass/overloaded-calls-param-vtables.rs b/src/test/run-pass/overloaded-calls-param-vtables.rs
index 2ef9e08134c..0ac9c97532b 100644
--- a/src/test/run-pass/overloaded-calls-param-vtables.rs
+++ b/src/test/run-pass/overloaded-calls-param-vtables.rs
@@ -28,5 +28,5 @@ impl<'a, A: Add<i32, Output=i32>> Fn<(A,)> for G<A> {
 
 fn main() {
     // ICE trigger
-    (G(PhantomData))(1_i32);
+    (G(PhantomData))(1);
 }
diff --git a/src/test/run-pass/packed-struct-vec.rs b/src/test/run-pass/packed-struct-vec.rs
index cfe49c38c52..92f57f04b10 100644
--- a/src/test/run-pass/packed-struct-vec.rs
+++ b/src/test/run-pass/packed-struct-vec.rs
@@ -24,7 +24,7 @@ pub fn main() {
 
     assert_eq!(mem::size_of::<[Foo; 10]>(), 90);
 
-    for i in 0_usize..10 {
+    for i in 0..10 {
         assert_eq!(foos[i], Foo { bar: 1, baz: 2});
     }
 
diff --git a/src/test/run-pass/path.rs b/src/test/run-pass/path.rs
index 02d8602d59e..08d00d4dc03 100644
--- a/src/test/run-pass/path.rs
+++ b/src/test/run-pass/path.rs
@@ -14,4 +14,4 @@ mod foo {
     pub fn bar(_offset: uint) { }
 }
 
-pub fn main() { foo::bar(0_usize); }
+pub fn main() { foo::bar(0); }
diff --git a/src/test/run-pass/private-class-field.rs b/src/test/run-pass/private-class-field.rs
index c7380b362fb..b4d04ba18f9 100644
--- a/src/test/run-pass/private-class-field.rs
+++ b/src/test/run-pass/private-class-field.rs
@@ -26,6 +26,6 @@ fn cat(in_x : uint, in_y : int) -> cat {
 }
 
 pub fn main() {
-    let mut nyan : cat = cat(52_usize, 99);
-    assert_eq!(nyan.meow_count(), 52_usize);
+    let mut nyan : cat = cat(52, 99);
+    assert_eq!(nyan.meow_count(), 52);
 }
diff --git a/src/test/run-pass/pure-sum.rs b/src/test/run-pass/pure-sum.rs
index 1fd83041f62..f12cf82f939 100644
--- a/src/test/run-pass/pure-sum.rs
+++ b/src/test/run-pass/pure-sum.rs
@@ -14,31 +14,31 @@
 #![feature(box_syntax)]
 
 fn sums_to(v: Vec<int> , sum: int) -> bool {
-    let mut i = 0_usize;
+    let mut i = 0;
     let mut sum0 = 0;
     while i < v.len() {
         sum0 += v[i];
-        i += 1_usize;
+        i += 1;
     }
     return sum0 == sum;
 }
 
 fn sums_to_using_uniq(v: Vec<int> , sum: int) -> bool {
-    let mut i = 0_usize;
+    let mut i = 0;
     let mut sum0: Box<_> = box 0;
     while i < v.len() {
         *sum0 += v[i];
-        i += 1_usize;
+        i += 1;
     }
     return *sum0 == sum;
 }
 
 fn sums_to_using_rec(v: Vec<int> , sum: int) -> bool {
-    let mut i = 0_usize;
+    let mut i = 0;
     let mut sum0 = F {f: 0};
     while i < v.len() {
         sum0.f += v[i];
-        i += 1_usize;
+        i += 1;
     }
     return sum0.f == sum;
 }
@@ -46,11 +46,11 @@ fn sums_to_using_rec(v: Vec<int> , sum: int) -> bool {
 struct F<T> { f: T }
 
 fn sums_to_using_uniq_rec(v: Vec<int> , sum: int) -> bool {
-    let mut i = 0_usize;
+    let mut i = 0;
     let mut sum0 = F::<Box<_>> {f: box 0};
     while i < v.len() {
         *sum0.f += v[i];
-        i += 1_usize;
+        i += 1;
     }
     return *sum0.f == sum;
 }
diff --git a/src/test/run-pass/ranges-precedence.rs b/src/test/run-pass/ranges-precedence.rs
index db414abb7ff..41ed9a74d13 100644
--- a/src/test/run-pass/ranges-precedence.rs
+++ b/src/test/run-pass/ranges-precedence.rs
@@ -38,7 +38,7 @@ fn main() {
     let x = ..1+3;
     assert!(x == (..4));
 
-    let a = &[0i32, 1, 2, 3, 4, 5, 6];
+    let a = &[0, 1, 2, 3, 4, 5, 6];
     let x = &a[1+1..2+2];
     assert!(x == &a[2..4]);
     let x = &a[..1+2];
diff --git a/src/test/run-pass/realloc-16687.rs b/src/test/run-pass/realloc-16687.rs
index de5b14104c5..e8bcff38131 100644
--- a/src/test/run-pass/realloc-16687.rs
+++ b/src/test/run-pass/realloc-16687.rs
@@ -35,9 +35,9 @@ unsafe fn test_triangle() -> bool {
     // from pairs of rows (where each pair of rows is equally sized),
     // and the elements of the triangle match their row-pair index.
     unsafe fn sanity_check(ascend: &[*mut u8]) {
-        for i in 0_usize..COUNT / 2 {
+        for i in 0..COUNT / 2 {
             let (p0, p1, size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
-            for j in 0_usize..size {
+            for j in 0..size {
                 assert_eq!(*p0.offset(j as int), i as u8);
                 assert_eq!(*p1.offset(j as int), i as u8);
             }
@@ -88,14 +88,14 @@ unsafe fn test_triangle() -> bool {
     // that at least two rows will be allocated near each other, so
     // that we trigger the bug (a buffer overrun) in an observable
     // way.)
-    for i in 0_usize..COUNT / 2 {
+    for i in 0..COUNT / 2 {
         let size = idx_to_size(i);
         ascend[2*i]   = allocate(size, ALIGN);
         ascend[2*i+1] = allocate(size, ALIGN);
     }
 
     // Initialize each pair of rows to distinct value.
-    for i in 0_usize..COUNT / 2 {
+    for i in 0..COUNT / 2 {
         let (p0, p1, size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
         for j in 0..size {
             *p0.offset(j as int) = i as u8;
@@ -109,7 +109,7 @@ unsafe fn test_triangle() -> bool {
     test_3(ascend); // triangle -> square
     test_4(ascend); // square -> triangle
 
-    for i in 0_usize..COUNT / 2 {
+    for i in 0..COUNT / 2 {
         let size = idx_to_size(i);
         deallocate(ascend[2*i], size, ALIGN);
         deallocate(ascend[2*i+1], size, ALIGN);
@@ -123,7 +123,7 @@ unsafe fn test_triangle() -> bool {
     // rows as we go.
     unsafe fn test_1(ascend: &mut [*mut u8]) {
         let new_size = idx_to_size(COUNT-1);
-        for i in 0_usize..COUNT / 2 {
+        for i in 0..COUNT / 2 {
             let (p0, p1, old_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
             assert!(old_size < new_size);
 
@@ -138,7 +138,7 @@ unsafe fn test_triangle() -> bool {
     // Test 2: turn the square back into a triangle, top to bottom.
     unsafe fn test_2(ascend: &mut [*mut u8]) {
         let old_size = idx_to_size(COUNT-1);
-        for i in 0_usize..COUNT / 2 {
+        for i in 0..COUNT / 2 {
             let (p0, p1, new_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
             assert!(new_size < old_size);
 
@@ -153,7 +153,7 @@ unsafe fn test_triangle() -> bool {
     // Test 3: turn triangle into a square, bottom to top.
     unsafe fn test_3(ascend: &mut [*mut u8]) {
         let new_size = idx_to_size(COUNT-1);
-        for i in (0_usize..COUNT / 2).rev() {
+        for i in (0..COUNT / 2).rev() {
             let (p0, p1, old_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
             assert!(old_size < new_size);
 
@@ -168,7 +168,7 @@ unsafe fn test_triangle() -> bool {
     // Test 4: turn the square back into a triangle, bottom to top.
     unsafe fn test_4(ascend: &mut [*mut u8]) {
         let old_size = idx_to_size(COUNT-1);
-        for i in (0_usize..COUNT / 2).rev() {
+        for i in (0..COUNT / 2).rev() {
             let (p0, p1, new_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
             assert!(new_size < old_size);
 
diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs
index 51b800bc9f0..94fe3f1d9ea 100644
--- a/src/test/run-pass/rec-align-u32.rs
+++ b/src/test/run-pass/rec-align-u32.rs
@@ -38,19 +38,19 @@ struct Outer {
 
 #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "aarch64"))]
 mod m {
-    pub fn align() -> uint { 4_usize }
-    pub fn size() -> uint { 8_usize }
+    pub fn align() -> uint { 4 }
+    pub fn size() -> uint { 8 }
 }
 
 #[cfg(target_arch = "x86_64")]
 mod m {
-    pub fn align() -> uint { 4_usize }
-    pub fn size() -> uint { 8_usize }
+    pub fn align() -> uint { 4 }
+    pub fn size() -> uint { 8 }
 }
 
 pub fn main() {
     unsafe {
-        let x = Outer {c8: 22u8, t: Inner {c64: 44u32}};
+        let x = Outer {c8: 22, t: Inner {c64: 44}};
 
         // Send it through the shape code
         let y = format!("{:?}", x);
diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs
index 835b4c40f5c..8b7434ed063 100644
--- a/src/test/run-pass/rec-align-u64.rs
+++ b/src/test/run-pass/rec-align-u64.rs
@@ -44,14 +44,14 @@ struct Outer {
 mod m {
     #[cfg(target_arch = "x86")]
     pub mod m {
-        pub fn align() -> uint { 4_usize }
-        pub fn size() -> uint { 12_usize }
+        pub fn align() -> uint { 4 }
+        pub fn size() -> uint { 12 }
     }
 
     #[cfg(any(target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64"))]
     pub mod m {
-        pub fn align() -> uint { 8_usize }
-        pub fn size() -> uint { 16_usize }
+        pub fn align() -> uint { 8 }
+        pub fn size() -> uint { 16 }
     }
 }
 
@@ -59,8 +59,8 @@ mod m {
 mod m {
     #[cfg(target_arch = "x86_64")]
     pub mod m {
-        pub fn align() -> uint { 8u }
-        pub fn size() -> uint { 16u }
+        pub fn align() -> uint { 8 }
+        pub fn size() -> uint { 16 }
     }
 }
 
@@ -68,14 +68,14 @@ mod m {
 mod m {
     #[cfg(target_arch = "x86")]
     pub mod m {
-        pub fn align() -> uint { 8_usize }
-        pub fn size() -> uint { 16_usize }
+        pub fn align() -> uint { 8 }
+        pub fn size() -> uint { 16 }
     }
 
     #[cfg(target_arch = "x86_64")]
     pub mod m {
-        pub fn align() -> uint { 8_usize }
-        pub fn size() -> uint { 16_usize }
+        pub fn align() -> uint { 8 }
+        pub fn size() -> uint { 16 }
     }
 }
 
@@ -83,14 +83,14 @@ mod m {
 mod m {
     #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
     pub mod m {
-        pub fn align() -> uint { 8_usize }
-        pub fn size() -> uint { 16_usize }
+        pub fn align() -> uint { 8 }
+        pub fn size() -> uint { 16 }
     }
 }
 
 pub fn main() {
     unsafe {
-        let x = Outer {c8: 22u8, t: Inner {c64: 44u64}};
+        let x = Outer {c8: 22, t: Inner {c64: 44}};
 
         let y = format!("{:?}", x);
 
diff --git a/src/test/run-pass/record-pat.rs b/src/test/run-pass/record-pat.rs
index 282a24a407c..b152470fbb6 100644
--- a/src/test/run-pass/record-pat.rs
+++ b/src/test/run-pass/record-pat.rs
@@ -20,6 +20,6 @@ fn m(input: t3) -> int {
 }
 
 pub fn main() {
-    assert_eq!(m(t3::c(T2 {x: t1::a(10), y: 5}, 4_usize)), 10);
-    assert_eq!(m(t3::c(T2 {x: t1::b(10_usize), y: 5}, 4_usize)), 19);
+    assert_eq!(m(t3::c(T2 {x: t1::a(10), y: 5}, 4)), 10);
+    assert_eq!(m(t3::c(T2 {x: t1::b(10), y: 5}, 4)), 19);
 }
diff --git a/src/test/run-pass/regions-borrow-at.rs b/src/test/run-pass/regions-borrow-at.rs
index 1e91ab7e921..56dd386ead1 100644
--- a/src/test/run-pass/regions-borrow-at.rs
+++ b/src/test/run-pass/regions-borrow-at.rs
@@ -16,8 +16,8 @@ fn foo(x: &uint) -> uint {
 }
 
 pub fn main() {
-    let p: Box<_> = box 22_usize;
+    let p: Box<_> = box 22;
     let r = foo(&*p);
     println!("r={}", r);
-    assert_eq!(r, 22_usize);
+    assert_eq!(r, 22);
 }
diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs
index 7c9b1ae226f..0673179eef0 100644
--- a/src/test/run-pass/regions-borrow-uniq.rs
+++ b/src/test/run-pass/regions-borrow-uniq.rs
@@ -16,7 +16,7 @@ fn foo(x: &uint) -> uint {
 }
 
 pub fn main() {
-    let p: Box<_> = box 3_usize;
+    let p: Box<_> = box 3;
     let r = foo(&*p);
-    assert_eq!(r, 3_usize);
+    assert_eq!(r, 3);
 }
diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs
index 3704fc1d8d1..b39343b1f57 100644
--- a/src/test/run-pass/regions-copy-closure.rs
+++ b/src/test/run-pass/regions-copy-closure.rs
@@ -20,7 +20,7 @@ fn box_it<'a>(x: Box<FnMut() + 'a>) -> closure_box<'a> {
 }
 
 pub fn main() {
-    let mut i = 3i32;
+    let mut i = 3;
     assert_eq!(i, 3);
     {
         let cl = || i += 1;
diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs
index 0ca17e218d2..3708d187d71 100644
--- a/src/test/run-pass/regions-escape-into-other-fn.rs
+++ b/src/test/run-pass/regions-escape-into-other-fn.rs
@@ -15,6 +15,6 @@ fn foo(x: &uint) -> &uint { x }
 fn bar(x: &uint) -> uint { *x }
 
 pub fn main() {
-    let p: Box<_> = box 3_usize;
+    let p: Box<_> = box 3;
     assert_eq!(bar(foo(&*p)), 3);
 }
diff --git a/src/test/run-pass/regions-params.rs b/src/test/run-pass/regions-params.rs
index c71953e20f8..181d962cfae 100644
--- a/src/test/run-pass/regions-params.rs
+++ b/src/test/run-pass/regions-params.rs
@@ -21,6 +21,6 @@ fn parameterized(x: &uint) -> uint {
 }
 
 pub fn main() {
-    let x = 3_usize;
-    assert_eq!(parameterized(&x), 3_usize);
+    let x = 3;
+    assert_eq!(parameterized(&x), 3);
 }
diff --git a/src/test/run-pass/regions-refcell.rs b/src/test/run-pass/regions-refcell.rs
index a224017780e..30d8fc34d00 100644
--- a/src/test/run-pass/regions-refcell.rs
+++ b/src/test/run-pass/regions-refcell.rs
@@ -18,7 +18,7 @@ use std::cell::RefCell;
 // This version does not yet work (associated type issues)...
 #[cfg(cannot_use_this_yet)]
 fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) {
-    let one = [1_usize];
+    let one = [1];
     assert_eq!(map.borrow().get("one"), Some(&one[..]));
 }
 
@@ -26,7 +26,7 @@ fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) {
 // ... and this version does not work (the lifetime of `one` is
 // supposed to match the lifetime `'a`) ...
 fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) {
-    let one = [1_usize];
+    let one = [1];
     assert_eq!(map.borrow().get("one"), Some(&one.as_slice()));
 }
 
@@ -41,9 +41,9 @@ fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) {
 }
 
 fn main() {
-    let zer = [0u8];
-    let one = [1u8];
-    let two = [2u8];
+    let zer = [0];
+    let one = [1];
+    let two = [2];
     let mut map = HashMap::new();
     map.insert("zero", &zer[..]);
     map.insert("one",  &one[..]);
diff --git a/src/test/run-pass/regions-trait-object-1.rs b/src/test/run-pass/regions-trait-object-1.rs
index eb3bec77326..807227d47db 100644
--- a/src/test/run-pass/regions-trait-object-1.rs
+++ b/src/test/run-pass/regions-trait-object-1.rs
@@ -37,7 +37,7 @@ fn extension<'e>(x: &'e E<'e>) -> Box<M+'e> {
 }
 
 fn main() {
-    let w = E { f: &10u8 };
+    let w = E { f: &10 };
     let o = extension(&w);
-    assert_eq!(o.n(), 10u8);
+    assert_eq!(o.n(), 10);
 }
diff --git a/src/test/run-pass/rename-directory.rs b/src/test/run-pass/rename-directory.rs
index abe6ffe7d4c..9209db22433 100644
--- a/src/test/run-pass/rename-directory.rs
+++ b/src/test/run-pass/rename-directory.rs
@@ -34,7 +34,7 @@ fn rename_directory() {
         let fromp = CString::new(test_file.as_vec()).unwrap();
         let modebuf = CString::new(b"w+b").unwrap();
         let ostream = libc::fopen(fromp.as_ptr(), modebuf.as_ptr());
-        assert!((ostream as uint != 0_usize));
+        assert!((ostream as uint != 0));
         let s = "hello".to_string();
         let buf = CString::new(b"hello").unwrap();
         let write_len = libc::fwrite(buf.as_ptr() as *mut _,
diff --git a/src/test/run-pass/ret-bang.rs b/src/test/run-pass/ret-bang.rs
index 74227192cab..14b398b3d9a 100644
--- a/src/test/run-pass/ret-bang.rs
+++ b/src/test/run-pass/ret-bang.rs
@@ -14,11 +14,11 @@
 fn my_err(s: String) -> ! { println!("{}", s); panic!(); }
 
 fn okay(i: uint) -> int {
-    if i == 3_usize {
+    if i == 3 {
         my_err("I don't like three".to_string());
     } else {
         return 42;
     }
 }
 
-pub fn main() { okay(4_usize); }
+pub fn main() { okay(4); }
diff --git a/src/test/run-pass/running-with-no-runtime.rs b/src/test/run-pass/running-with-no-runtime.rs
index ec033b74dd1..abb16c39d11 100644
--- a/src/test/run-pass/running-with-no-runtime.rs
+++ b/src/test/run-pass/running-with-no-runtime.rs
@@ -43,15 +43,15 @@ fn start(argc: int, argv: *const *const u8) -> int {
     };
     let me = &*args[0];
 
-    let x: &[u8] = &[1u8];
+    let x: &[u8] = &[1];
     pass(Command::new(me).arg(x).output().unwrap());
-    let x: &[u8] = &[2u8];
+    let x: &[u8] = &[2];
     pass(Command::new(me).arg(x).output().unwrap());
-    let x: &[u8] = &[3u8];
+    let x: &[u8] = &[3];
     pass(Command::new(me).arg(x).output().unwrap());
-    let x: &[u8] = &[4u8];
+    let x: &[u8] = &[4];
     pass(Command::new(me).arg(x).output().unwrap());
-    let x: &[u8] = &[5u8];
+    let x: &[u8] = &[5];
     pass(Command::new(me).arg(x).output().unwrap());
 
     0
diff --git a/src/test/run-pass/sendfn-is-a-block.rs b/src/test/run-pass/sendfn-is-a-block.rs
index 18519573c26..51c20bcd098 100644
--- a/src/test/run-pass/sendfn-is-a-block.rs
+++ b/src/test/run-pass/sendfn-is-a-block.rs
@@ -10,10 +10,10 @@
 
 
 fn test<F>(f: F) -> uint where F: FnOnce(uint) -> uint {
-    return f(22_usize);
+    return f(22);
 }
 
 pub fn main() {
-    let y = test(|x| 4_usize * x);
-    assert_eq!(y, 88_usize);
+    let y = test(|x| 4 * x);
+    assert_eq!(y, 88);
 }
diff --git a/src/test/run-pass/shift-various-types.rs b/src/test/run-pass/shift-various-types.rs
index 2f56e09b2df..26dc6c5316b 100644
--- a/src/test/run-pass/shift-various-types.rs
+++ b/src/test/run-pass/shift-various-types.rs
@@ -25,17 +25,17 @@ struct Panolpy {
 }
 
 fn foo(p: &Panolpy) {
-    assert_eq!(22_i32 >> p.i8, 11_i32);
-    assert_eq!(22_i32 >> p.i16, 11_i32);
-    assert_eq!(22_i32 >> p.i32, 11_i32);
-    assert_eq!(22_i32 >> p.i64, 11_i32);
-    assert_eq!(22_i32 >> p.isize, 11_i32);
+    assert_eq!(22 >> p.i8, 11);
+    assert_eq!(22 >> p.i16, 11);
+    assert_eq!(22 >> p.i32, 11);
+    assert_eq!(22 >> p.i64, 11);
+    assert_eq!(22 >> p.isize, 11);
 
-    assert_eq!(22_i32 >> p.u8, 11_i32);
-    assert_eq!(22_i32 >> p.u16, 11_i32);
-    assert_eq!(22_i32 >> p.u32, 11_i32);
-    assert_eq!(22_i32 >> p.u64, 11_i32);
-    assert_eq!(22_i32 >> p.usize, 11_i32);
+    assert_eq!(22 >> p.u8, 11);
+    assert_eq!(22 >> p.u16, 11);
+    assert_eq!(22 >> p.u32, 11);
+    assert_eq!(22 >> p.u64, 11);
+    assert_eq!(22 >> p.usize, 11);
 }
 
 fn main() {
diff --git a/src/test/run-pass/small-enums-with-fields.rs b/src/test/run-pass/small-enums-with-fields.rs
index 475af8f2b8e..86eed715f32 100644
--- a/src/test/run-pass/small-enums-with-fields.rs
+++ b/src/test/run-pass/small-enums-with-fields.rs
@@ -29,14 +29,14 @@ macro_rules! check {
 pub fn main() {
     check!(Option<u8>, 2,
            None, "None",
-           Some(129u8), "Some(129)");
+           Some(129), "Some(129)");
     check!(Option<i16>, 4,
            None, "None",
-           Some(-20000i16), "Some(-20000)");
+           Some(-20000), "Some(-20000)");
     check!(Either<u8, i8>, 2,
-           Either::Left(132u8), "Left(132)",
-           Either::Right(-32i8), "Right(-32)");
+           Either::Left(132), "Left(132)",
+           Either::Right(-32), "Right(-32)");
     check!(Either<u8, i16>, 4,
-           Either::Left(132u8), "Left(132)",
-           Either::Right(-20000i16), "Right(-20000)");
+           Either::Left(132), "Left(132)",
+           Either::Right(-20000), "Right(-20000)");
 }
diff --git a/src/test/run-pass/static-methods-in-traits.rs b/src/test/run-pass/static-methods-in-traits.rs
index 5f6dc4f2a53..47f46041c22 100644
--- a/src/test/run-pass/static-methods-in-traits.rs
+++ b/src/test/run-pass/static-methods-in-traits.rs
@@ -21,7 +21,7 @@ mod a {
 
     impl Foo for uint {
         fn foo() -> uint {
-            5_usize
+            5
         }
     }
 }
diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs
index 359c14ea7b0..cef7a93aeed 100644
--- a/src/test/run-pass/string-self-append.rs
+++ b/src/test/run-pass/string-self-append.rs
@@ -12,12 +12,12 @@ pub fn main() {
     // Make sure we properly handle repeated self-appends.
     let mut a: String = "A".to_string();
     let mut i = 20;
-    let mut expected_len = 1_usize;
+    let mut expected_len = 1;
     while i > 0 {
         println!("{}", a.len());
         assert_eq!(a.len(), expected_len);
         a = format!("{}{}", a, a);
         i -= 1;
-        expected_len *= 2_usize;
+        expected_len *= 2;
     }
 }
diff --git a/src/test/run-pass/struct-return.rs b/src/test/run-pass/struct-return.rs
index c8768731e2b..d67c6322c61 100644
--- a/src/test/run-pass/struct-return.rs
+++ b/src/test/run-pass/struct-return.rs
@@ -28,19 +28,19 @@ mod rustrt {
 
 fn test1() {
     unsafe {
-        let q = Quad { a: 0xaaaa_aaaa_aaaa_aaaa_u64,
-                 b: 0xbbbb_bbbb_bbbb_bbbb_u64,
-                 c: 0xcccc_cccc_cccc_cccc_u64,
-                 d: 0xdddd_dddd_dddd_dddd_u64 };
+        let q = Quad { a: 0xaaaa_aaaa_aaaa_aaaa,
+                 b: 0xbbbb_bbbb_bbbb_bbbb,
+                 c: 0xcccc_cccc_cccc_cccc,
+                 d: 0xdddd_dddd_dddd_dddd };
         let qq = rustrt::rust_dbg_abi_1(q);
         println!("a: {:x}", qq.a as uint);
         println!("b: {:x}", qq.b as uint);
         println!("c: {:x}", qq.c as uint);
         println!("d: {:x}", qq.d as uint);
-        assert_eq!(qq.a, q.c + 1u64);
-        assert_eq!(qq.b, q.d - 1u64);
-        assert_eq!(qq.c, q.a + 1u64);
-        assert_eq!(qq.d, q.b - 1u64);
+        assert_eq!(qq.a, q.c + 1);
+        assert_eq!(qq.b, q.d - 1);
+        assert_eq!(qq.c, q.a + 1);
+        assert_eq!(qq.d, q.b - 1);
     }
 }
 
@@ -48,14 +48,14 @@ fn test1() {
 fn test2() {
     unsafe {
         let f = Floats { a: 1.234567890e-15_f64,
-                 b: 0b_1010_1010_u8,
+                 b: 0b_1010_1010,
                  c: 1.0987654321e-15_f64 };
         let ff = rustrt::rust_dbg_abi_2(f);
         println!("a: {}", ff.a as f64);
         println!("b: {}", ff.b as uint);
         println!("c: {}", ff.c as f64);
         assert_eq!(ff.a, f.c + 1.0f64);
-        assert_eq!(ff.b, 0xff_u8);
+        assert_eq!(ff.b, 0xff);
         assert_eq!(ff.c, f.a - 1.0f64);
     }
 }
diff --git a/src/test/run-pass/syntax-extension-source-utils.rs b/src/test/run-pass/syntax-extension-source-utils.rs
index ddd8cd8be3d..684ca7fa2b6 100644
--- a/src/test/run-pass/syntax-extension-source-utils.rs
+++ b/src/test/run-pass/syntax-extension-source-utils.rs
@@ -23,7 +23,7 @@ macro_rules! indirect_line { () => ( line!() ) }
 
 pub fn main() {
     assert_eq!(line!(), 25);
-    assert!((column!() == 4u32));
+    assert!((column!() == 4));
     assert_eq!(indirect_line!(), 27);
     assert!((file!().ends_with("syntax-extension-source-utils.rs")));
     assert_eq!(stringify!((2*3) + 5).to_string(), "( 2 * 3 ) + 5".to_string());
diff --git a/src/test/run-pass/tag-align-dyn-u64.rs b/src/test/run-pass/tag-align-dyn-u64.rs
index b7fe4983b01..a50711fc98d 100644
--- a/src/test/run-pass/tag-align-dyn-u64.rs
+++ b/src/test/run-pass/tag-align-dyn-u64.rs
@@ -23,12 +23,12 @@ struct Rec {
 }
 
 fn mk_rec() -> Rec {
-    return Rec { c8:0u8, t:Tag::Tag2(0u64) };
+    return Rec { c8:0, t:Tag::Tag2(0) };
 }
 
 fn is_8_byte_aligned(u: &Tag<u64>) -> bool {
     let p: uint = unsafe { mem::transmute(u) };
-    return (p & 7_usize) == 0_usize;
+    return (p & 7) == 0;
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/tag-align-dyn-variants.rs b/src/test/run-pass/tag-align-dyn-variants.rs
index cb298e720ed..69af882e1fa 100644
--- a/src/test/run-pass/tag-align-dyn-variants.rs
+++ b/src/test/run-pass/tag-align-dyn-variants.rs
@@ -26,12 +26,12 @@ struct Rec<A,B> {
 }
 
 fn mk_rec<A,B>(a: A, b: B) -> Rec<A,B> {
-    Rec { chA:0u8, tA:Tag::VarA(a), chB:1u8, tB:Tag::VarB(b) }
+    Rec { chA:0, tA:Tag::VarA(a), chB:1, tB:Tag::VarB(b) }
 }
 
 fn is_aligned<A>(amnt: uint, u: &A) -> bool {
     let p: uint = unsafe { mem::transmute(u) };
-    return (p & (amnt-1_usize)) == 0_usize;
+    return (p & (amnt-1)) == 0;
 }
 
 fn variant_data_is_aligned<A,B>(amnt: uint, u: &Tag<A,B>) -> bool {
@@ -42,33 +42,33 @@ fn variant_data_is_aligned<A,B>(amnt: uint, u: &Tag<A,B>) -> bool {
 }
 
 pub fn main() {
-    let x = mk_rec(22u64, 23u64);
-    assert!(is_aligned(8_usize, &x.tA));
-    assert!(variant_data_is_aligned(8_usize, &x.tA));
-    assert!(is_aligned(8_usize, &x.tB));
-    assert!(variant_data_is_aligned(8_usize, &x.tB));
+    let x = mk_rec(22, 23);
+    assert!(is_aligned(8, &x.tA));
+    assert!(variant_data_is_aligned(8, &x.tA));
+    assert!(is_aligned(8, &x.tB));
+    assert!(variant_data_is_aligned(8, &x.tB));
 
-    let x = mk_rec(22u64, 23u32);
-    assert!(is_aligned(8_usize, &x.tA));
-    assert!(variant_data_is_aligned(8_usize, &x.tA));
-    assert!(is_aligned(8_usize, &x.tB));
-    assert!(variant_data_is_aligned(4_usize, &x.tB));
+    let x = mk_rec(22, 23);
+    assert!(is_aligned(8, &x.tA));
+    assert!(variant_data_is_aligned(8, &x.tA));
+    assert!(is_aligned(8, &x.tB));
+    assert!(variant_data_is_aligned(4, &x.tB));
 
-    let x = mk_rec(22u32, 23u64);
-    assert!(is_aligned(8_usize, &x.tA));
-    assert!(variant_data_is_aligned(4_usize, &x.tA));
-    assert!(is_aligned(8_usize, &x.tB));
-    assert!(variant_data_is_aligned(8_usize, &x.tB));
+    let x = mk_rec(22, 23);
+    assert!(is_aligned(8, &x.tA));
+    assert!(variant_data_is_aligned(4, &x.tA));
+    assert!(is_aligned(8, &x.tB));
+    assert!(variant_data_is_aligned(8, &x.tB));
 
-    let x = mk_rec(22u32, 23u32);
-    assert!(is_aligned(4_usize, &x.tA));
-    assert!(variant_data_is_aligned(4_usize, &x.tA));
-    assert!(is_aligned(4_usize, &x.tB));
-    assert!(variant_data_is_aligned(4_usize, &x.tB));
+    let x = mk_rec(22, 23);
+    assert!(is_aligned(4, &x.tA));
+    assert!(variant_data_is_aligned(4, &x.tA));
+    assert!(is_aligned(4, &x.tB));
+    assert!(variant_data_is_aligned(4, &x.tB));
 
     let x = mk_rec(22f64, 23f64);
-    assert!(is_aligned(8_usize, &x.tA));
-    assert!(variant_data_is_aligned(8_usize, &x.tA));
-    assert!(is_aligned(8_usize, &x.tB));
-    assert!(variant_data_is_aligned(8_usize, &x.tB));
+    assert!(is_aligned(8, &x.tA));
+    assert!(variant_data_is_aligned(8, &x.tA));
+    assert!(is_aligned(8, &x.tB));
+    assert!(variant_data_is_aligned(8, &x.tB));
 }
diff --git a/src/test/run-pass/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs
index cc0a75181db..5db886c815b 100644
--- a/src/test/run-pass/tag-align-shape.rs
+++ b/src/test/run-pass/tag-align-shape.rs
@@ -20,7 +20,7 @@ struct t_rec {
 }
 
 pub fn main() {
-    let x = t_rec {c8: 22u8, t: a_tag::a_tag_var(44u64)};
+    let x = t_rec {c8: 22, t: a_tag::a_tag_var(44)};
     let y = format!("{:?}", x);
     println!("y = {:?}", y);
     assert_eq!(y, "t_rec { c8: 22, t: a_tag_var(44) }".to_string());
diff --git a/src/test/run-pass/tag-align-u64.rs b/src/test/run-pass/tag-align-u64.rs
index 713f55cc10c..e5fd11ff9db 100644
--- a/src/test/run-pass/tag-align-u64.rs
+++ b/src/test/run-pass/tag-align-u64.rs
@@ -23,12 +23,12 @@ struct Rec {
 }
 
 fn mk_rec() -> Rec {
-    return Rec { c8:0u8, t:Tag::TagInner(0u64) };
+    return Rec { c8:0, t:Tag::TagInner(0) };
 }
 
 fn is_8_byte_aligned(u: &Tag) -> bool {
     let p: uint = unsafe { mem::transmute(u) };
-    return (p & 7_usize) == 0_usize;
+    return (p & 7) == 0;
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs
index 1d297c04c82..ca009677ee9 100644
--- a/src/test/run-pass/task-comm-16.rs
+++ b/src/test/run-pass/task-comm-16.rs
@@ -16,12 +16,12 @@ fn test_rec() {
     struct R {val0: int, val1: u8, val2: char}
 
     let (tx, rx) = channel();
-    let r0: R = R {val0: 0, val1: 1u8, val2: '2'};
+    let r0: R = R {val0: 0, val1: 1, val2: '2'};
     tx.send(r0).unwrap();
     let mut r1: R;
     r1 = rx.recv().unwrap();
     assert_eq!(r1.val0, 0);
-    assert_eq!(r1.val1, 1u8);
+    assert_eq!(r1.val1, 1);
     assert_eq!(r1.val2, '2');
 }
 
@@ -84,14 +84,14 @@ fn test_tag() {
     let (tx, rx) = channel();
     tx.send(t::tag1).unwrap();
     tx.send(t::tag2(10)).unwrap();
-    tx.send(t::tag3(10, 11u8, 'A')).unwrap();
+    tx.send(t::tag3(10, 11, 'A')).unwrap();
     let mut t1: t;
     t1 = rx.recv().unwrap();
     assert_eq!(t1, t::tag1);
     t1 = rx.recv().unwrap();
     assert_eq!(t1, t::tag2(10));
     t1 = rx.recv().unwrap();
-    assert_eq!(t1, t::tag3(10, 11u8, 'A'));
+    assert_eq!(t1, t::tag3(10, 11, 'A'));
 }
 
 fn test_chan() {
diff --git a/src/test/run-pass/tcp-stress.rs b/src/test/run-pass/tcp-stress.rs
index 82584c83de0..23ea998c026 100644
--- a/src/test/run-pass/tcp-stress.rs
+++ b/src/test/run-pass/tcp-stress.rs
@@ -52,7 +52,7 @@ fn main() {
     let addr = rx.recv().unwrap();
 
     let (tx, rx) = channel();
-    for _ in 0_usize..1000 {
+    for _ in 0..1000 {
         let tx = tx.clone();
         Builder::new().stack_size(64 * 1024).spawn(move|| {
             match TcpStream::connect(addr) {
@@ -71,7 +71,7 @@ fn main() {
     // Wait for all clients to exit, but don't wait for the server to exit. The
     // server just runs infinitely.
     drop(tx);
-    for _ in 0_usize..1000 {
+    for _ in 0..1000 {
         rx.recv().unwrap();
     }
     unsafe { libc::exit(0) }
diff --git a/src/test/run-pass/trait-default-method-bound-subst4.rs b/src/test/run-pass/trait-default-method-bound-subst4.rs
index 383849ca512..acaa74373f0 100644
--- a/src/test/run-pass/trait-default-method-bound-subst4.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst4.rs
@@ -21,6 +21,6 @@ fn f<T, V: A<T>>(i: V, j: uint) -> uint {
 }
 
 pub fn main () {
-    assert_eq!(f::<f64, int>(0, 2_usize), 2_usize);
-    assert_eq!(f::<uint, int>(0, 2_usize), 2_usize);
+    assert_eq!(f::<f64, int>(0, 2), 2);
+    assert_eq!(f::<uint, int>(0, 2), 2);
 }
diff --git a/src/test/run-pass/trait-object-generics.rs b/src/test/run-pass/trait-object-generics.rs
index 6f89490716f..18097b59b08 100644
--- a/src/test/run-pass/trait-object-generics.rs
+++ b/src/test/run-pass/trait-object-generics.rs
@@ -49,5 +49,5 @@ impl<V> Trait<u8,V> for () {
 
 pub fn main() {
     let a = box() () as Box<Trait<u8, u8>>;
-    assert_eq!(a.method(Type::Constant((1u8, 2u8))), 0);
+    assert_eq!(a.method(Type::Constant((1, 2))), 0);
 }
diff --git a/src/test/run-pass/trait-object-with-lifetime-bound.rs b/src/test/run-pass/trait-object-with-lifetime-bound.rs
index 4e481910aa9..99910f15738 100644
--- a/src/test/run-pass/trait-object-with-lifetime-bound.rs
+++ b/src/test/run-pass/trait-object-with-lifetime-bound.rs
@@ -36,7 +36,7 @@ fn extension<'e>(x: &'e E<'e>) -> Box<M+'e> {
 }
 
 fn main() {
-    let w = E { f: &10u8 };
+    let w = E { f: &10 };
     let o = extension(&w);
-    assert_eq!(o.n(), 10u8);
+    assert_eq!(o.n(), 10);
 }
diff --git a/src/test/run-pass/type-params-in-for-each.rs b/src/test/run-pass/type-params-in-for-each.rs
index cf8a09998da..5d80cec2a05 100644
--- a/src/test/run-pass/type-params-in-for-each.rs
+++ b/src/test/run-pass/type-params-in-for-each.rs
@@ -16,11 +16,11 @@ struct S<T> {
 
 fn range_<F>(lo: uint, hi: uint, mut it: F) where F: FnMut(uint) {
     let mut lo_ = lo;
-    while lo_ < hi { it(lo_); lo_ += 1_usize; }
+    while lo_ < hi { it(lo_); lo_ += 1; }
 }
 
 fn create_index<T>(_index: Vec<S<T>> , _hash_fn: extern fn(T) -> uint) {
-    range_(0_usize, 256_usize, |_i| {
+    range_(0, 256, |_i| {
         let _bucket: Vec<T> = Vec::new();
     })
 }
diff --git a/src/test/run-pass/typeck_type_placeholder_1.rs b/src/test/run-pass/typeck_type_placeholder_1.rs
index 48dc9443821..c850c01753b 100644
--- a/src/test/run-pass/typeck_type_placeholder_1.rs
+++ b/src/test/run-pass/typeck_type_placeholder_1.rs
@@ -21,17 +21,17 @@ static CONSTEXPR: TestStruct = TestStruct{x: &413 as *const _};
 
 
 pub fn main() {
-    let x: Vec<_> = (0_usize..5).collect();
+    let x: Vec<_> = (0..5).collect();
     let expected: &[uint] = &[0,1,2,3,4];
     assert_eq!(x, expected);
 
-    let x = (0_usize..5).collect::<Vec<_>>();
+    let x = (0..5).collect::<Vec<_>>();
     assert_eq!(x, expected);
 
     let y: _ = "hello";
     assert_eq!(y.len(), 5);
 
-    let ptr = &5_usize;
+    let ptr = &5;
     let ptr2 = ptr as *const _;
 
     assert_eq!(ptr as *const uint as uint, ptr2 as uint);
diff --git a/src/test/run-pass/u32-decr.rs b/src/test/run-pass/u32-decr.rs
index 6ad320580df..027bd7ca680 100644
--- a/src/test/run-pass/u32-decr.rs
+++ b/src/test/run-pass/u32-decr.rs
@@ -12,7 +12,7 @@
 
 
 pub fn main() {
-    let mut word: u32 = 200000u32;
-    word = word - 1u32;
-    assert_eq!(word, 199999u32);
+    let mut word: u32 = 200000;
+    word = word - 1;
+    assert_eq!(word, 199999);
 }
diff --git a/src/test/run-pass/u8-incr-decr.rs b/src/test/run-pass/u8-incr-decr.rs
index 0a178b250af..ff25d95d1fd 100644
--- a/src/test/run-pass/u8-incr-decr.rs
+++ b/src/test/run-pass/u8-incr-decr.rs
@@ -15,13 +15,13 @@
 // These constants were chosen because they aren't used anywhere
 // in the rest of the generated code so they're easily grep-able.
 pub fn main() {
-    let mut x: u8 = 19u8; // 0x13
+    let mut x: u8 = 19; // 0x13
 
-    let mut y: u8 = 35u8; // 0x23
+    let mut y: u8 = 35; // 0x23
 
-    x = x + 7u8; // 0x7
+    x = x + 7; // 0x7
 
-    y = y - 9u8; // 0x9
+    y = y - 9; // 0x9
 
     assert_eq!(x, y);
 }
diff --git a/src/test/run-pass/u8-incr.rs b/src/test/run-pass/u8-incr.rs
index 90ed3a5eec3..7f69d078134 100644
--- a/src/test/run-pass/u8-incr.rs
+++ b/src/test/run-pass/u8-incr.rs
@@ -12,12 +12,12 @@
 
 
 pub fn main() {
-    let mut x: u8 = 12u8;
-    let y: u8 = 12u8;
-    x = x + 1u8;
-    x = x - 1u8;
+    let mut x: u8 = 12;
+    let y: u8 = 12;
+    x = x + 1;
+    x = x - 1;
     assert_eq!(x, y);
-    // x = 14u8;
-    // x = x + 1u8;
+    // x = 14;
+    // x = x + 1;
 
 }
diff --git a/src/test/run-pass/ufcs-trait-object.rs b/src/test/run-pass/ufcs-trait-object.rs
index 2ae63040d17..34cf44bba2e 100644
--- a/src/test/run-pass/ufcs-trait-object.rs
+++ b/src/test/run-pass/ufcs-trait-object.rs
@@ -20,6 +20,6 @@ impl Foo for i32 {
 }
 
 fn main() {
-    let a: &Foo = &22_i32;
+    let a: &Foo = &22;
     assert_eq!(Foo::test(a), 22);
 }
diff --git a/src/test/run-pass/unboxed-closures-unique-type-id.rs b/src/test/run-pass/unboxed-closures-unique-type-id.rs
index 5c36832d9f6..ce05f077357 100644
--- a/src/test/run-pass/unboxed-closures-unique-type-id.rs
+++ b/src/test/run-pass/unboxed-closures-unique-type-id.rs
@@ -12,8 +12,8 @@
 //
 //    error: internal compiler error: get_unique_type_id_of_type() -
 //    unexpected type: closure,
-//    ty_closure(syntax::ast::DefId{krate: 0u32, node: 66u32},
-//    ReScope(63u32))
+//    ty_closure(syntax::ast::DefId{krate: 0, node: 66},
+//    ReScope(63))
 //
 // This is a regression test for issue #17021.
 //
@@ -28,8 +28,8 @@ pub fn replace_map<'a, T, F>(src: &mut T, prod: F) where F: FnOnce(T) -> T {
 }
 
 pub fn main() {
-    let mut a = 7_usize;
+    let mut a = 7;
     let b = &mut a;
     replace_map(b, |x: uint| x * 2);
-    assert_eq!(*b, 14_usize);
+    assert_eq!(*b, 14);
 }
diff --git a/src/test/run-pass/unique-pat-2.rs b/src/test/run-pass/unique-pat-2.rs
index 5db96bc3564..8141e3bce3c 100644
--- a/src/test/run-pass/unique-pat-2.rs
+++ b/src/test/run-pass/unique-pat-2.rs
@@ -17,7 +17,7 @@ struct Foo {a: int, b: uint}
 enum bar { u(Box<Foo>), w(int), }
 
 pub fn main() {
-    assert!(match bar::u(box Foo{a: 10, b: 40_usize}) {
+    assert!(match bar::u(box Foo{a: 10, b: 40}) {
               bar::u(box Foo{a: a, b: b}) => { a + (b as int) }
               _ => { 66 }
             } == 50);
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index 43824812ec5..654ac9a095c 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -20,9 +20,9 @@ fn child(tx: &Sender<Box<uint>>, i: uint) {
 
 pub fn main() {
     let (tx, rx) = channel();
-    let n = 100_usize;
-    let mut expected = 0_usize;
-    let _t = (0_usize..n).map(|i| {
+    let n = 100;
+    let mut expected = 0;
+    let _t = (0..n).map(|i| {
         expected += i;
         let tx = tx.clone();
         thread::spawn(move|| {
@@ -30,8 +30,8 @@ pub fn main() {
         })
     }).collect::<Vec<_>>();
 
-    let mut actual = 0_usize;
-    for _ in 0_usize..n {
+    let mut actual = 0;
+    for _ in 0..n {
         let j = rx.recv().unwrap();
         actual += *j;
     }
diff --git a/src/test/run-pass/unsized3.rs b/src/test/run-pass/unsized3.rs
index c9a9d6ad147..5bd76d093d4 100644
--- a/src/test/run-pass/unsized3.rs
+++ b/src/test/run-pass/unsized3.rs
@@ -66,12 +66,10 @@ pub fn main() {
             f: [T; 3]
         }
 
-        let data: Box<_> = box Foo_{f: [1i32, 2, 3] };
+        let data: Box<Foo_<i32>> = box Foo_{f: [1, 2, 3] };
         let x: &Foo<i32> = mem::transmute(raw::Slice { len: 3, data: &*data });
         assert!(x.f.len() == 3);
         assert!(x.f[0] == 1);
-        assert!(x.f[1] == 2);
-        assert!(x.f[2] == 3);
 
         struct Baz_ {
             f1: uint,
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index 84f605eef57..88369f2e500 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -18,26 +18,26 @@ pub fn main() {
     let s: String = chs.iter().cloned().collect();
     let schs: Vec<char> = s.chars().collect();
 
-    assert!(s.len() == 10_usize);
-    assert!(s.chars().count() == 4_usize);
-    assert!(schs.len() == 4_usize);
+    assert!(s.len() == 10);
+    assert!(s.chars().count() == 4);
+    assert!(schs.len() == 4);
     assert!(schs.iter().cloned().collect::<String>() == s);
-    assert!(s.char_at(0_usize) == 'e');
-    assert!(s.char_at(1_usize) == 'é');
+    assert!(s.char_at(0) == 'e');
+    assert!(s.char_at(1) == 'é');
 
     assert!((str::from_utf8(s.as_bytes()).is_ok()));
     // invalid prefix
-    assert!((!str::from_utf8(&[0x80_u8]).is_ok()));
+    assert!((!str::from_utf8(&[0x80]).is_ok()));
     // invalid 2 byte prefix
-    assert!((!str::from_utf8(&[0xc0_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xc0_u8, 0x10_u8]).is_ok()));
+    assert!((!str::from_utf8(&[0xc0]).is_ok()));
+    assert!((!str::from_utf8(&[0xc0, 0x10]).is_ok()));
     // invalid 3 byte prefix
-    assert!((!str::from_utf8(&[0xe0_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xe0_u8, 0x10_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xe0_u8, 0xff_u8, 0x10_u8]).is_ok()));
+    assert!((!str::from_utf8(&[0xe0]).is_ok()));
+    assert!((!str::from_utf8(&[0xe0, 0x10]).is_ok()));
+    assert!((!str::from_utf8(&[0xe0, 0xff, 0x10]).is_ok()));
     // invalid 4 byte prefix
-    assert!((!str::from_utf8(&[0xf0_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xf0_u8, 0x10_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xf0_u8, 0xff_u8, 0x10_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xf0_u8, 0xff_u8, 0xff_u8, 0x10_u8]).is_ok()));
+    assert!((!str::from_utf8(&[0xf0]).is_ok()));
+    assert!((!str::from_utf8(&[0xf0, 0x10]).is_ok()));
+    assert!((!str::from_utf8(&[0xf0, 0xff, 0x10]).is_ok()));
+    assert!((!str::from_utf8(&[0xf0, 0xff, 0xff, 0x10]).is_ok()));
 }
diff --git a/src/test/run-pass/vec-fixed-length.rs b/src/test/run-pass/vec-fixed-length.rs
index 015baea5fb5..a0b3564d84e 100644
--- a/src/test/run-pass/vec-fixed-length.rs
+++ b/src/test/run-pass/vec-fixed-length.rs
@@ -17,11 +17,11 @@ pub fn main() {
     assert_eq!(x[2], 3);
     assert_eq!(x[3], 4);
 
-    assert_eq!(size_of::<[u8; 4]>(), 4_usize);
+    assert_eq!(size_of::<[u8; 4]>(), 4);
 
     // FIXME #10183
     // FIXME #18069
     //if cfg!(target_pointer_width = "64") {
-    //    assert_eq!(size_of::<[u8; (1 << 32)]>(), (1_usize << 32));
+    //    assert_eq!(size_of::<[u8; (1 << 32)]>(), (1 << 32));
     //}
 }
diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs
index baea1b8826a..20e42575b27 100644
--- a/src/test/run-pass/weird-exprs.rs
+++ b/src/test/run-pass/weird-exprs.rs
@@ -65,7 +65,7 @@ fn canttouchthis() -> uint {
     fn p() -> bool { true }
     let _a = (assert!((true)) == (assert!(p())));
     let _c = (assert!((p())) == ());
-    let _b: bool = (println!("{}", 0) == (return 0_usize));
+    let _b: bool = (println!("{}", 0) == (return 0));
 }
 
 fn angrydome() {
diff --git a/src/test/run-pass/where-for-self.rs b/src/test/run-pass/where-for-self.rs
index 1fd223b0dd3..67757d7efa8 100644
--- a/src/test/run-pass/where-for-self.rs
+++ b/src/test/run-pass/where-for-self.rs
@@ -55,7 +55,7 @@ fn foo2<T>(x: &T)
 }
 
 fn main() {
-    let x = 42u32;
+    let x = 42;
     foo1(&x);
     foo2(&x);
     unsafe {
diff --git a/src/test/run-pass/x86stdcall.rs b/src/test/run-pass/x86stdcall.rs
index dea58c8e86f..b884adb7a6e 100644
--- a/src/test/run-pass/x86stdcall.rs
+++ b/src/test/run-pass/x86stdcall.rs
@@ -22,7 +22,7 @@ mod kernel32 {
 #[cfg(windows)]
 pub fn main() {
     unsafe {
-        let expected = 1234_usize;
+        let expected = 1234;
         kernel32::SetLastError(expected);
         let actual = kernel32::GetLastError();
         println!("actual = {}", actual);
diff --git a/src/test/run-pass/x86stdcall2.rs b/src/test/run-pass/x86stdcall2.rs
index 86c1ae0f51f..b5b9d95d87f 100644
--- a/src/test/run-pass/x86stdcall2.rs
+++ b/src/test/run-pass/x86stdcall2.rs
@@ -30,10 +30,10 @@ mod kernel32 {
 #[cfg(windows)]
 pub fn main() {
     let heap = unsafe { kernel32::GetProcessHeap() };
-    let mem = unsafe { kernel32::HeapAlloc(heap, 0u32, 100u32) };
-    assert!(mem != 0_usize);
-    let res = unsafe { kernel32::HeapFree(heap, 0u32, mem) };
-    assert!(res != 0u8);
+    let mem = unsafe { kernel32::HeapAlloc(heap, 0, 100) };
+    assert!(mem != 0);
+    let res = unsafe { kernel32::HeapFree(heap, 0, mem) };
+    assert!(res != 0);
 }
 
 #[cfg(not(windows))]

From 1c2dc1a0ebfbb644a9bf7b8292a03798561fc36f Mon Sep 17 00:00:00 2001
From: Dave Huseby <dhuseby@mozilla.com>
Date: Tue, 3 Mar 2015 14:04:13 -0800
Subject: [PATCH 15/34] updating llvm submodule to include bitrig support

---
 src/llvm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm b/src/llvm
index b89c3f039b6..bff69076975 160000
--- a/src/llvm
+++ b/src/llvm
@@ -1 +1 @@
-Subproject commit b89c3f039b61edbb077771eda2ee8a718dbec7e0
+Subproject commit bff69076975642c64e76dbeaa53476bfa7212086

From 6d36a1495da4441416e2caba2c56da64f8589925 Mon Sep 17 00:00:00 2001
From: Dave Huseby <dhuseby@mozilla.com>
Date: Tue, 3 Mar 2015 16:03:21 -0800
Subject: [PATCH 16/34] bumping the jemalloc revision to include the bitrig
 changes

---
 src/jemalloc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/jemalloc b/src/jemalloc
index b001609960c..c30cf42aeca 160000
--- a/src/jemalloc
+++ b/src/jemalloc
@@ -1 +1 @@
-Subproject commit b001609960ca33047e5cbc5a231c1e24b6041d4b
+Subproject commit c30cf42aeca7f4f7996a88763a4fb1c9807afc7a

From 2361ec30bf7a752d93e151c875cb0e2e2321c210 Mon Sep 17 00:00:00 2001
From: Dave Huseby <dhuseby@mozilla.com>
Date: Tue, 3 Mar 2015 16:17:20 -0800
Subject: [PATCH 17/34] bumping again to get the updated configure

---
 src/jemalloc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/jemalloc b/src/jemalloc
index c30cf42aeca..e24a1a025a1 160000
--- a/src/jemalloc
+++ b/src/jemalloc
@@ -1 +1 @@
-Subproject commit c30cf42aeca7f4f7996a88763a4fb1c9807afc7a
+Subproject commit e24a1a025a1f214e40eedafe3b9c7b1d69937922

From bcd6076fa462e5d40ac53567206d6e078f29d894 Mon Sep 17 00:00:00 2001
From: Dave Huseby <dhuseby@mozilla.com>
Date: Tue, 3 Mar 2015 22:51:36 -0800
Subject: [PATCH 18/34] adding bitrig snapshot to snapshots file

---
 src/snapshots.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/snapshots.txt b/src/snapshots.txt
index 318f66b9465..5e85e3dff6a 100644
--- a/src/snapshots.txt
+++ b/src/snapshots.txt
@@ -1,4 +1,5 @@
 S 2015-02-25 880fb89
+  bitrig-x86_64 8cdc4ca0a80103100f46cbf8caa9fe497df048c5
   freebsd-x86_64 f4cbe4227739de986444211f8ee8d74745ab8f7f
   linux-i386 3278ebbce8cb269acc0614dac5ddac07eab6a99c
   linux-x86_64 72287d0d88de3e5a53bae78ac0d958e1a7637d73

From 4486d78b933c220c1425687b12e0f9c17639d192 Mon Sep 17 00:00:00 2001
From: Fenhl <fenhl@fenhl.net>
Date: Wed, 4 Mar 2015 12:16:37 +0000
Subject: [PATCH 19/34] Fix Duration::weeks docs

The docs for `std::duration::Duration::weeks` were formatted incorrectly.
---
 src/libstd/time/duration.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libstd/time/duration.rs b/src/libstd/time/duration.rs
index 42ef3459a0e..958417d864c 100644
--- a/src/libstd/time/duration.rs
+++ b/src/libstd/time/duration.rs
@@ -68,7 +68,7 @@ pub const MAX: Duration = Duration {
 
 impl Duration {
     /// Makes a new `Duration` with given number of weeks.
-    /// Equivalent to `Duration::seconds(weeks * 7 * 24 * 60 * 60), with overflow checks.
+    /// Equivalent to `Duration::seconds(weeks * 7 * 24 * 60 * 60)` with overflow checks.
     /// Panics when the duration is out of bounds.
     #[inline]
     #[unstable(feature = "std_misc")]

From 48fba76c7db0273e5d0b9353cd593330f8e73461 Mon Sep 17 00:00:00 2001
From: Eduard Burtescu <edy.burt@gmail.com>
Date: Wed, 4 Mar 2015 15:48:33 +0200
Subject: [PATCH 20/34] Fix compile-fail error messages after integer suffix
 removal.

---
 src/test/compile-fail/array-not-vector.rs                 | 2 +-
 src/test/compile-fail/bad-const-type.rs                   | 4 ++--
 src/test/compile-fail/binop-logic-int.rs                  | 2 +-
 src/test/compile-fail/coercion-slice.rs                   | 2 +-
 src/test/compile-fail/issue-13058.rs                      | 2 +-
 src/test/compile-fail/issue-13466.rs                      | 4 ++--
 src/test/compile-fail/issue-13482-2.rs                    | 2 +-
 src/test/compile-fail/issue-14845.rs                      | 2 +-
 src/test/compile-fail/issue-17651.rs                      | 2 +-
 src/test/compile-fail/issue-19991.rs                      | 4 ++--
 src/test/compile-fail/issue-7867.rs                       | 4 ++--
 src/test/compile-fail/method-self-arg-1.rs                | 4 ++--
 src/test/compile-fail/mut-pattern-mismatched.rs           | 4 ++--
 .../compile-fail/structure-constructor-type-mismatch.rs   | 8 ++++----
 src/test/compile-fail/tuple-index-out-of-bounds.rs        | 2 +-
 src/test/compile-fail/type-mismatch-multiple.rs           | 4 ++--
 16 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/test/compile-fail/array-not-vector.rs b/src/test/compile-fail/array-not-vector.rs
index 81883108a2b..6c9b8f81b2f 100644
--- a/src/test/compile-fail/array-not-vector.rs
+++ b/src/test/compile-fail/array-not-vector.rs
@@ -12,7 +12,7 @@ fn main() {
     let _x: i32 = [1, 2, 3];
     //~^ ERROR mismatched types
     //~| expected `i32`
-    //~| found `[i32; 3]`
+    //~| found `[_; 3]`
     //~| expected i32
     //~| found array of 3 elements
 
diff --git a/src/test/compile-fail/bad-const-type.rs b/src/test/compile-fail/bad-const-type.rs
index 93ff7c08f79..a9e5c957b89 100644
--- a/src/test/compile-fail/bad-const-type.rs
+++ b/src/test/compile-fail/bad-const-type.rs
@@ -11,7 +11,7 @@
 static i: String = 10;
 //~^ ERROR mismatched types
 //~| expected `collections::string::String`
-//~| found `i32`
+//~| found `_`
 //~| expected struct `collections::string::String`
-//~| found i32
+//~| found integral variable
 fn main() { println!("{}", i); }
diff --git a/src/test/compile-fail/binop-logic-int.rs b/src/test/compile-fail/binop-logic-int.rs
index 1a3db388877..d5dd9e00902 100644
--- a/src/test/compile-fail/binop-logic-int.rs
+++ b/src/test/compile-fail/binop-logic-int.rs
@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern:`&&` cannot be applied to type `i32`
+// error-pattern:`&&` cannot be applied to type `_`
 
 fn main() { let x = 1 && 2; }
diff --git a/src/test/compile-fail/coercion-slice.rs b/src/test/compile-fail/coercion-slice.rs
index 40fbcd556b0..bb4d1693af7 100644
--- a/src/test/compile-fail/coercion-slice.rs
+++ b/src/test/compile-fail/coercion-slice.rs
@@ -14,7 +14,7 @@ fn main() {
     let _: &[i32] = [0];
     //~^ ERROR mismatched types
     //~| expected `&[i32]`
-    //~| found `[i32; 1]`
+    //~| found `[_; 1]`
     //~| expected &-ptr
     //~| found array of 1 elements
 }
diff --git a/src/test/compile-fail/issue-13058.rs b/src/test/compile-fail/issue-13058.rs
index 6f024fc5382..50c4ac94d90 100644
--- a/src/test/compile-fail/issue-13058.rs
+++ b/src/test/compile-fail/issue-13058.rs
@@ -37,7 +37,7 @@ fn main() {
     check((3, 5));
 //~^ ERROR mismatched types
 //~| expected `&_`
-//~| found `(usize, usize)`
+//~| found `(_, _)`
 //~| expected &-ptr
 //~| found tuple
 }
diff --git a/src/test/compile-fail/issue-13466.rs b/src/test/compile-fail/issue-13466.rs
index 3eb42f902f9..a29a83c4306 100644
--- a/src/test/compile-fail/issue-13466.rs
+++ b/src/test/compile-fail/issue-13466.rs
@@ -17,14 +17,14 @@ pub fn main() {
     let _x: usize = match Some(1) {
         Ok(u) => u,
         //~^ ERROR mismatched types
-        //~| expected `core::option::Option<usize>`
+        //~| expected `core::option::Option<_>`
         //~| found `core::result::Result<_, _>`
         //~| expected enum `core::option::Option`
         //~| found enum `core::result::Result`
 
         Err(e) => panic!(e)
         //~^ ERROR mismatched types
-        //~| expected `core::option::Option<usize>`
+        //~| expected `core::option::Option<_>`
         //~| found `core::result::Result<_, _>`
         //~| expected enum `core::option::Option`
         //~| found enum `core::result::Result`
diff --git a/src/test/compile-fail/issue-13482-2.rs b/src/test/compile-fail/issue-13482-2.rs
index 7af10aa13a8..86a79416c77 100644
--- a/src/test/compile-fail/issue-13482-2.rs
+++ b/src/test/compile-fail/issue-13482-2.rs
@@ -15,7 +15,7 @@ fn main() {
     let y = match x {
         [] => None,
 //~^ ERROR mismatched types
-//~| expected `[_#0; 2]`
+//~| expected `[_#0i; 2]`
 //~| found `[_#7t; 0]`
 //~| expected an array with a fixed size of 2 elements
 //~| found one with 0 elements
diff --git a/src/test/compile-fail/issue-14845.rs b/src/test/compile-fail/issue-14845.rs
index 3381b930714..d7bb806999c 100644
--- a/src/test/compile-fail/issue-14845.rs
+++ b/src/test/compile-fail/issue-14845.rs
@@ -26,7 +26,7 @@ fn main() {
     let _v = &local as *mut u8;
     //~^ ERROR mismatched types
     //~| expected `*mut u8`
-    //~| found `&[u8; 1]`
+    //~| found `&[_; 1]`
     //~| expected u8,
     //~| found array of 1 elements
 }
diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs
index 723b4ca03e7..8ebf80a8db0 100644
--- a/src/test/compile-fail/issue-17651.rs
+++ b/src/test/compile-fail/issue-17651.rs
@@ -14,5 +14,5 @@
 fn main() {
     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
     (|| Box::new(*[0].as_slice()))();
-    //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[usize]`
+    //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[_]`
 }
diff --git a/src/test/compile-fail/issue-19991.rs b/src/test/compile-fail/issue-19991.rs
index 7c1e18ba997..6c9b0004f77 100644
--- a/src/test/compile-fail/issue-19991.rs
+++ b/src/test/compile-fail/issue-19991.rs
@@ -14,9 +14,9 @@
 fn main() {
     if let Some(homura) = Some("madoka") { //~  ERROR missing an else clause
                                            //~| expected `()`
-                                           //~| found `i32`
+                                           //~| found `_`
                                            //~| expected ()
-                                           //~| found i32
+                                           //~| found integral variable
         765
     };
 }
diff --git a/src/test/compile-fail/issue-7867.rs b/src/test/compile-fail/issue-7867.rs
index 1eaa85c3b7e..400806c3a5f 100644
--- a/src/test/compile-fail/issue-7867.rs
+++ b/src/test/compile-fail/issue-7867.rs
@@ -26,13 +26,13 @@ fn main() {
     match &Some(42) {
         Some(x) => (),
         //~^ ERROR mismatched types
-        //~| expected `&core::option::Option<i32>`
+        //~| expected `&core::option::Option<_>`
         //~| found `core::option::Option<_>`
         //~| expected &-ptr
         //~| found enum `core::option::Option`
         None => ()
         //~^ ERROR mismatched types
-        //~| expected `&core::option::Option<i32>`
+        //~| expected `&core::option::Option<_>`
         //~| found `core::option::Option<_>`
         //~| expected &-ptr
         //~| found enum `core::option::Option`
diff --git a/src/test/compile-fail/method-self-arg-1.rs b/src/test/compile-fail/method-self-arg-1.rs
index 666812c98bc..57a96bb9a26 100644
--- a/src/test/compile-fail/method-self-arg-1.rs
+++ b/src/test/compile-fail/method-self-arg-1.rs
@@ -25,7 +25,7 @@ fn main() {
                  //~| found struct `Foo`
     Foo::bar(&42); //~  ERROR mismatched types
                       //~| expected `&Foo`
-                      //~| found `&i32`
+                      //~| found `&_`
                       //~| expected struct `Foo`
-                      //~| found i32
+                      //~| found integral variable
 }
diff --git a/src/test/compile-fail/mut-pattern-mismatched.rs b/src/test/compile-fail/mut-pattern-mismatched.rs
index 1b748624491..9eb24c81960 100644
--- a/src/test/compile-fail/mut-pattern-mismatched.rs
+++ b/src/test/compile-fail/mut-pattern-mismatched.rs
@@ -14,7 +14,7 @@ fn main() {
     // (separate lines to ensure the spans are accurate)
 
      let &_ //~  ERROR mismatched types
-            //~| expected `&mut i32`
+            //~| expected `&mut _`
             //~| found `&_`
             //~| values differ in mutability
         = foo;
@@ -23,7 +23,7 @@ fn main() {
     let bar = &1;
     let &_ = bar;
     let &mut _ //~  ERROR mismatched types
-               //~| expected `&i32`
+               //~| expected `&_`
                //~| found `&mut _`
                //~| values differ in mutability
          = bar;
diff --git a/src/test/compile-fail/structure-constructor-type-mismatch.rs b/src/test/compile-fail/structure-constructor-type-mismatch.rs
index 4a0006338e6..ea6d63ca540 100644
--- a/src/test/compile-fail/structure-constructor-type-mismatch.rs
+++ b/src/test/compile-fail/structure-constructor-type-mismatch.rs
@@ -26,7 +26,7 @@ fn main() {
     let pt = PointF {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
-        //~| found i32
+        //~| found integral variable
         x: 1,
         y: 2,
     };
@@ -34,7 +34,7 @@ fn main() {
     let pt2 = Point::<f32> {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
-        //~| found i32
+        //~| found integral variable
         x: 3,
         y: 4,
     };
@@ -42,7 +42,7 @@ fn main() {
     let pair = PairF {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
-        //~| found i32
+        //~| found integral variable
         x: 5,
         y: 6,
     };
@@ -50,7 +50,7 @@ fn main() {
     let pair2 = PairF::<i32> {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
-        //~| found i32
+        //~| found integral variable
         x: 7,
         y: 8,
     };
diff --git a/src/test/compile-fail/tuple-index-out-of-bounds.rs b/src/test/compile-fail/tuple-index-out-of-bounds.rs
index e2a951cab72..c2c41fbbb2a 100644
--- a/src/test/compile-fail/tuple-index-out-of-bounds.rs
+++ b/src/test/compile-fail/tuple-index-out-of-bounds.rs
@@ -20,5 +20,5 @@ fn main() {
     tuple.0;
     tuple.1;
     tuple.2;
-    //~^ ERROR attempted out-of-bounds tuple index `2` on type `(i32, i32)`
+    //~^ ERROR attempted out-of-bounds tuple index `2` on type `(_, _)`
 }
diff --git a/src/test/compile-fail/type-mismatch-multiple.rs b/src/test/compile-fail/type-mismatch-multiple.rs
index a51a8172543..627300a0377 100644
--- a/src/test/compile-fail/type-mismatch-multiple.rs
+++ b/src/test/compile-fail/type-mismatch-multiple.rs
@@ -13,9 +13,9 @@
 fn main() { let a: bool = 1; let b: i32 = true; }
 //~^ ERROR mismatched types
 //~| expected `bool`
-//~| found `i32`
+//~| found `_`
 //~| expected bool
-//~| found i32
+//~| found integral variable
 //~| ERROR mismatched types
 //~| expected `i32`
 //~| found `bool`

From 6de0dc4ce3c35c3ecd60b75519ba8060c59fe7e1 Mon Sep 17 00:00:00 2001
From: Valerii Hiora <valerii.hiora@gmail.com>
Date: Wed, 4 Mar 2015 14:18:40 +0200
Subject: [PATCH 21/34] iOS: fallout of env stab

---
 src/libstd/env.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/libstd/env.rs b/src/libstd/env.rs
index 1968ca4b9e7..c052a69bc34 100644
--- a/src/libstd/env.rs
+++ b/src/libstd/env.rs
@@ -616,6 +616,9 @@ mod os {
 mod os {
     pub const FAMILY: &'static str = "unix";
     pub const OS: &'static str = "ios";
+    pub const DLL_PREFIX: &'static str = "lib";
+    pub const DLL_SUFFIX: &'static str = ".dylib";
+    pub const DLL_EXTENSION: &'static str = "dylib";
     pub const EXE_SUFFIX: &'static str = "";
     pub const EXE_EXTENSION: &'static str = "";
 }

From e0a0b4683e0e6a5b55038c26de87ec95ea7bc8c8 Mon Sep 17 00:00:00 2001
From: Dave Huseby <dhuseby@mozilla.com>
Date: Wed, 4 Mar 2015 07:50:34 -0800
Subject: [PATCH 22/34] updating llvm-auto-clean-trigger too

---
 src/rustllvm/llvm-auto-clean-trigger | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rustllvm/llvm-auto-clean-trigger b/src/rustllvm/llvm-auto-clean-trigger
index 2cd7ed6c155..1ea40fc46a5 100644
--- a/src/rustllvm/llvm-auto-clean-trigger
+++ b/src/rustllvm/llvm-auto-clean-trigger
@@ -1,4 +1,4 @@
 # If this file is modified, then llvm will be forcibly cleaned and then rebuilt.
 # The actual contents of this file do not matter, but to trigger a change on the
 # build bots then the contents should be changed so git updates the mtime.
-2015-02-19
+2015-03-04

From 433392afd85a183080577f92ce395ea262d0b1dd Mon Sep 17 00:00:00 2001
From: Matt Cox <mattcoxpdx@gmail.com>
Date: Wed, 4 Mar 2015 08:15:58 -0800
Subject: [PATCH 23/34] Reword str docs and include links to StrExt

---
 src/libcollections/str.rs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 599b92d05dd..7941283287e 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -10,12 +10,15 @@
 //
 // ignore-lexer-test FIXME #15679
 
-//! Unicode string manipulation (the `str` type).
+//! Unicode string manipulation (the [`str`](../primitive.str.html) type).
 //!
-//! Rust's `str` type is one of the core primitive types of the language. `&str` is the borrowed
-//! string type. This type of string can only be created from other strings, unless it is a static
-//! string (see below). As the word "borrowed" implies, this type of string is owned elsewhere, and
-//! this string cannot be moved out of.
+//! Rust's [`str`](../primitive.str.html) type is one of the core primitive types of the
+//! language. `&str` is the borrowed string type. This type of string can only be created
+//! from other strings, unless it is a `&'static str` (see below). It is not possible to
+//! move out of borrowed strings because they are owned elsewhere.
+//!
+//! Basic operations are implemented directly by the compiler, but more advanced operations are
+//! defined on the [`StrExt`](trait.StrExt.html) trait.
 //!
 //! # Examples
 //!

From 299b594fde2e0e1b98a7e08acfa81a7e5c715d95 Mon Sep 17 00:00:00 2001
From: Peter Elmers <peter.elmers@yahoo.com>
Date: Wed, 4 Mar 2015 11:02:31 -0600
Subject: [PATCH 24/34] Fix grammar nits in compound-data-types.md

I came across a couple of grammar mistakes when refreshing myself on enums.
---
 src/doc/trpl/compound-data-types.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/doc/trpl/compound-data-types.md b/src/doc/trpl/compound-data-types.md
index 85d67262c40..e09922fd390 100644
--- a/src/doc/trpl/compound-data-types.md
+++ b/src/doc/trpl/compound-data-types.md
@@ -6,8 +6,8 @@ strings, but next, let's talk about some more complicated ways of storing data.
 
 ## Tuples
 
-The first compound data type we're going to talk about are called *tuples*.
-Tuples are an ordered list of a fixed size. Like this:
+The first compound data type we're going to talk about is called the *tuple*.
+A tuple is an ordered list of fixed size. Like this:
 
 ```rust
 let x = (1, "hello");
@@ -229,7 +229,7 @@ enum Character {
 ```
 
 An `enum` variant can be defined as most normal types. Below are some example
-types have been listed which also would be allowed in an `enum`.
+types which also would be allowed in an `enum`.
 
 ```rust
 struct Empty;

From 951118b74f0cd6f61116ba9d21bb08e6af49cdf0 Mon Sep 17 00:00:00 2001
From: Seo Sanghyeon <sanxiyn@gmail.com>
Date: Wed, 4 Mar 2015 14:58:35 +0900
Subject: [PATCH 25/34] Fix quoting of ?Sized

---
 src/libsyntax/ext/quote.rs                 | 3 ++-
 src/test/run-pass-fulldeps/quote-tokens.rs | 4 +++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index 2599a53e313..737648cd90c 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -676,9 +676,10 @@ fn expr_mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> {
         token::FatArrow     => "FatArrow",
         token::Pound        => "Pound",
         token::Dollar       => "Dollar",
+        token::Question     => "Question",
         token::Underscore   => "Underscore",
         token::Eof          => "Eof",
-        _                   => panic!(),
+        _                   => panic!("unhandled token in quote!"),
     };
     mk_token_path(cx, sp, name)
 }
diff --git a/src/test/run-pass-fulldeps/quote-tokens.rs b/src/test/run-pass-fulldeps/quote-tokens.rs
index 4e6f9b46402..a9b77419b9a 100644
--- a/src/test/run-pass-fulldeps/quote-tokens.rs
+++ b/src/test/run-pass-fulldeps/quote-tokens.rs
@@ -1,4 +1,4 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -43,6 +43,8 @@ fn syntax_extension(cx: &ExtCtxt) {
 
     let _m: Vec<syntax::ast::TokenTree> = quote_matcher!(cx, $($foo:tt,)* bar);
     let _n: syntax::ast::Attribute = quote_attr!(cx, #![cfg(foo, bar = "baz")]);
+
+    let _o: Option<P<syntax::ast::Item>> = quote_item!(cx, fn foo<T: ?Sized>() {});
 }
 
 fn main() {

From e64670888a2839ba75237b1934c440c4c319b1bb Mon Sep 17 00:00:00 2001
From: Eduard Burtescu <edy.burt@gmail.com>
Date: Tue, 3 Mar 2015 10:42:26 +0200
Subject: [PATCH 26/34] Remove integer suffixes where the types in compiled
 code are identical.

---
 src/liballoc/boxed.rs                         |   2 +-
 src/liballoc/boxed_test.rs                    |   4 +-
 src/libcollections/bit.rs                     |  24 ++--
 src/libcollections/fmt.rs                     |   2 +-
 src/libcollections/slice.rs                   |  10 +-
 src/libcollections/str.rs                     |  10 +-
 src/libcollections/string.rs                  |  72 +++++-----
 src/libcore/char.rs                           |  42 +++---
 src/libcore/fmt/float.rs                      |   6 +-
 src/libcore/fmt/mod.rs                        |   4 +-
 src/libcore/fmt/num.rs                        |   2 +-
 src/libcore/hash/sip.rs                       |   2 +-
 src/libcore/intrinsics.rs                     |   2 +-
 src/libcore/iter.rs                           |   2 +-
 src/libcore/macros.rs                         |   2 +-
 src/libcore/option.rs                         |   2 +-
 src/libcore/str/mod.rs                        |   8 +-
 src/libcoretest/char.rs                       |   4 +-
 src/libcoretest/hash/mod.rs                   |   4 +-
 src/libcoretest/hash/sip.rs                   |   8 +-
 src/libcoretest/iter.rs                       |   8 +-
 src/libcoretest/mem.rs                        |   2 +-
 src/libcoretest/num/mod.rs                    |   8 +-
 src/libcoretest/ptr.rs                        |   6 +-
 src/liblibc/lib.rs                            |  50 +++----
 src/librand/chacha.rs                         |   6 +-
 src/librand/distributions/range.rs            |   4 +-
 src/librand/isaac.rs                          |   4 +-
 src/librand/lib.rs                            |   2 +-
 src/librand/reseeding.rs                      |   2 +-
 src/librbml/lib.rs                            |  46 +++----
 src/librustc/middle/const_eval.rs             |   2 +-
 src/librustc/util/lev_distance.rs             |   2 +-
 src/librustc_back/sha2.rs                     |  12 +-
 src/librustc_bitflags/lib.rs                  |   8 +-
 src/librustc_trans/trans/base.rs              |   4 +-
 src/librustc_trans/trans/cabi_aarch64.rs      |   2 +-
 src/libserialize/hex.rs                       |   2 +-
 src/libserialize/json.rs                      |   2 +-
 src/libstd/ascii.rs                           |  12 +-
 src/libstd/collections/hash/table.rs          |   4 +-
 src/libstd/fs/mod.rs                          |   4 +-
 src/libstd/io/buffered.rs                     |   4 +-
 src/libstd/io/cursor.rs                       |  14 +-
 src/libstd/net/addr.rs                        |   6 +-
 src/libstd/net/parser.rs                      |  10 +-
 src/libstd/num/f32.rs                         |  16 +--
 src/libstd/num/f64.rs                         |  14 +-
 src/libstd/num/mod.rs                         |  18 +--
 src/libstd/num/strconv.rs                     |  14 +-
 src/libstd/old_io/buffered.rs                 |   4 +-
 src/libstd/old_io/comm_adapters.rs            |  14 +-
 src/libstd/old_io/extensions.rs               |   8 +-
 src/libstd/old_io/fs.rs                       |   4 +-
 src/libstd/old_io/mod.rs                      |   8 +-
 src/libstd/old_io/net/ip.rs                   |  28 ++--
 src/libstd/old_io/net/tcp.rs                  |   6 +-
 src/libstd/old_io/test.rs                     |   4 +-
 src/libstd/old_io/util.rs                     |   4 +-
 src/libstd/rand/mod.rs                        |   2 +-
 src/libstd/rand/os.rs                         |  16 +--
 src/libstd/rand/reader.rs                     |  22 +--
 src/libstd/rt/util.rs                         |   2 +-
 src/libstd/sys/common/wtf8.rs                 |   4 +-
 src/libstd/sys/unix/fs.rs                     |   2 +-
 src/libstd/thread.rs                          |   2 +-
 src/libstd/tuple.rs                           |   2 +-
 src/libsyntax/ast_util.rs                     |  16 +--
 src/libterm/lib.rs                            |  32 ++---
 src/libterm/terminfo/parm.rs                  |   4 +-
 src/libtest/lib.rs                            |   4 +-
 src/libunicode/u_str.rs                       |   2 +-
 src/test/auxiliary/cci_class_3.rs             |   2 +-
 src/test/auxiliary/cci_class_4.rs             |   4 +-
 src/test/auxiliary/cci_class_cast.rs          |   4 +-
 src/test/auxiliary/cci_impl_lib.rs            |   2 +-
 src/test/auxiliary/cci_iter_lib.rs            |   4 +-
 src/test/auxiliary/cci_no_inline_lib.rs       |   4 +-
 src/test/auxiliary/macro_reexport_1.rs        |   2 +-
 src/test/auxiliary/roman_numerals.rs          |   2 +-
 .../auxiliary/unboxed-closures-cross-crate.rs |   4 +-
 src/test/bench/noise.rs                       |   2 +-
 src/test/bench/shootout-chameneos-redux.rs    |   2 +-
 src/test/bench/shootout-fannkuch-redux.rs     |   4 +-
 src/test/bench/shootout-fasta-redux.rs        |   2 +-
 src/test/bench/shootout-fasta.rs              |   2 +-
 src/test/bench/shootout-k-nucleotide.rs       |   4 +-
 src/test/bench/shootout-meteor.rs             |   4 +-
 src/test/bench/sudoku.rs                      | 114 ++++++++--------
 src/test/compile-fail-fulldeps/issue-18986.rs |   2 +-
 src/test/compile-fail/array-not-vector.rs     |   4 +-
 src/test/compile-fail/asm-in-bad-modifier.rs  |   4 +-
 src/test/compile-fail/asm-out-assign-imm.rs   |   2 +-
 src/test/compile-fail/asm-out-no-modifier.rs  |   2 +-
 src/test/compile-fail/assign-to-method.rs     |   4 +-
 src/test/compile-fail/bad-bang-ann-3.rs       |   2 +-
 src/test/compile-fail/bad-bang-ann.rs         |   2 +-
 src/test/compile-fail/bad-const-type.rs       |   2 +-
 .../compile-fail/bad-method-typaram-kind.rs   |   2 +-
 src/test/compile-fail/binop-logic-int.rs      |   2 +-
 .../borrow-immutable-upvar-mutation.rs        |  12 +-
 .../borrowck-move-error-with-note.rs          |   2 +-
 .../borrowck-report-with-custom-diagnostic.rs |   6 +-
 src/test/compile-fail/class-method-missing.rs |   2 +-
 src/test/compile-fail/class-missing-self.rs   |   2 +-
 src/test/compile-fail/coercion-slice.rs       |   2 +-
 .../const-block-non-item-statement.rs         |   4 +-
 src/test/compile-fail/deriving-non-type.rs    |   4 +-
 .../compile-fail/destructor-restrictions.rs   |   4 +-
 .../feature-gated-feature-in-macro-arg.rs     |   2 +-
 src/test/compile-fail/import-glob-circular.rs |   4 +-
 src/test/compile-fail/index-bot.rs            |   2 +-
 .../compile-fail/infinite-instantiation.rs    |   6 +-
 src/test/compile-fail/issue-11714.rs          |   2 +-
 src/test/compile-fail/issue-13058.rs          |   4 +-
 src/test/compile-fail/issue-13466.rs          |   2 +-
 src/test/compile-fail/issue-13482-2.rs        |   2 +-
 src/test/compile-fail/issue-14845.rs          |   2 +-
 src/test/compile-fail/issue-17283.rs          |   2 +-
 src/test/compile-fail/issue-17651.rs          |   2 +-
 src/test/compile-fail/issue-17718-patterns.rs |   2 +-
 src/test/compile-fail/issue-17933.rs          |   4 +-
 src/test/compile-fail/issue-18107.rs          |   2 +-
 src/test/compile-fail/issue-18252.rs          |   2 +-
 src/test/compile-fail/issue-18566.rs          |   2 +-
 src/test/compile-fail/issue-18783.rs          |   4 +-
 src/test/compile-fail/issue-18959.rs          |   2 +-
 src/test/compile-fail/issue-19991.rs          |   2 +-
 src/test/compile-fail/issue-20801.rs          |   4 +-
 src/test/compile-fail/issue-2150.rs           |   2 +-
 src/test/compile-fail/issue-4517.rs           |   2 +-
 src/test/compile-fail/issue-7575.rs           |   6 +-
 src/test/compile-fail/issue-7867.rs           |   2 +-
 src/test/compile-fail/kindck-nonsendable-1.rs |   2 +-
 ...me-inference-give-expl-lifetime-param-2.rs |   2 +-
 src/test/compile-fail/lint-dead-code-4.rs     |   2 +-
 .../liveness-return-last-stmt-semi.rs         |   2 +-
 .../macro-no-implicit-reexport.rs             |   2 +-
 .../macro-reexport-not-locally-visible.rs     |   2 +-
 src/test/compile-fail/method-self-arg-1.rs    |   2 +-
 .../compile-fail/mut-pattern-mismatched.rs    |   4 +-
 .../compile-fail/mutable-class-fields-2.rs    |   2 +-
 src/test/compile-fail/mutable-class-fields.rs |   2 +-
 .../non-exhaustive-pattern-witness.rs         |   2 +-
 src/test/compile-fail/or-patter-mismatch.rs   |   2 +-
 src/test/compile-fail/private-method.rs       |   2 +-
 .../private-struct-field-cross-crate.rs       |   4 +-
 src/test/compile-fail/range-1.rs              |   2 +-
 src/test/compile-fail/regions-addr-of-self.rs |   6 +-
 .../regions-addr-of-upvar-self.rs             |   2 +-
 .../compile-fail/regions-creating-enums.rs    |   4 +-
 .../regions-pattern-typing-issue-19997.rs     |   4 +-
 ...regions-return-ref-to-upvar-issue-17403.rs |   2 +-
 src/test/compile-fail/regions-trait-1.rs      |   4 +-
 .../structure-constructor-type-mismatch.rs    |  20 +--
 src/test/compile-fail/tail-typeck.rs          |   2 +-
 ...traits-multidispatch-convert-ambig-dest.rs |   2 +-
 .../compile-fail/tuple-index-out-of-bounds.rs |   4 +-
 .../compile-fail/type-mismatch-multiple.rs    |   2 +-
 .../type-params-in-different-spaces-1.rs      |   2 +-
 .../typeck_type_placeholder_item.rs           |   4 +-
 .../unboxed-closure-illegal-move.rs           |  12 +-
 .../unboxed-closure-immutable-capture.rs      |   2 +-
 .../compile-fail/unboxed-closure-region.rs    |   2 +-
 .../unboxed-closures-borrow-conflict.rs       |   2 +-
 .../unboxed-closures-mutate-upvar.rs          |  12 +-
 ...-closures-mutated-upvar-from-fn-closure.rs |   2 +-
 src/test/compile-fail/unreachable-arm.rs      |   2 +-
 .../unsafe-fn-assign-deref-ptr.rs             |   2 +-
 src/test/compile-fail/variance-issue-20533.rs |   6 +-
 .../compile-fail/vtable-res-trait-param.rs    |   2 +-
 src/test/debuginfo/associated-types.rs        |  14 +-
 src/test/debuginfo/recursive-struct.rs        |   4 +-
 src/test/debuginfo/simd.rs                    |  20 +--
 .../parse-fail/class-implements-bad-trait.rs  |   2 +-
 src/test/parse-fail/issue-5544-b.rs           |   2 +-
 .../parse-fail/lex-bad-numeric-literals.rs    |   2 +-
 src/test/parse-fail/regions-trait-2.rs        |   2 +-
 src/test/pretty/empty-lines.rs                |   2 +-
 src/test/pretty/issue-4264.pp                 |   4 +-
 src/test/pretty/issue-4264.rs                 |   4 +-
 src/test/run-fail/extern-panic.rs             |   8 +-
 src/test/run-fail/if-check-panic.rs           |   6 +-
 .../graphviz-flowgraph/f20.dot-expected.dot   |  18 +--
 src/test/run-make/graphviz-flowgraph/f20.rs   |   4 +-
 src/test/run-make/save-analysis/foo.rs        |   6 +-
 .../run-make/symbols-are-reasonable/lib.rs    |   2 +-
 src/test/run-pass/alias-uninit-value.rs       |   2 +-
 .../associated-types-constant-type.rs         |   2 +-
 src/test/run-pass/associated-types-return.rs  |   2 +-
 .../associated-types-struct-field-named.rs    |   4 +-
 .../associated-types-struct-field-numbered.rs |   4 +-
 .../run-pass/associated-types-sugar-path.rs   |   2 +-
 src/test/run-pass/auto-encode.rs              |  10 +-
 .../run-pass/autoderef-method-on-trait.rs     |   6 +-
 .../run-pass/autoderef-method-priority.rs     |   6 +-
 .../autoderef-method-twice-but-not-thrice.rs  |   6 +-
 src/test/run-pass/autoderef-method-twice.rs   |   6 +-
 src/test/run-pass/autoderef-method.rs         |   6 +-
 .../autoref-intermediate-types-issue-3585.rs  |   2 +-
 src/test/run-pass/big-literals.rs             |  10 +-
 src/test/run-pass/block-arg-call-as.rs        |   4 +-
 src/test/run-pass/block-iter-1.rs             |   4 +-
 src/test/run-pass/block-iter-2.rs             |   2 +-
 .../run-pass/borrowck-closures-two-imm.rs     |   6 +-
 src/test/run-pass/borrowck-mut-uniq.rs        |   2 +-
 .../capture-clauses-unboxed-closures.rs       |   4 +-
 src/test/run-pass/cast.rs                     |   2 +-
 src/test/run-pass/cci_borrow.rs               |   4 +-
 src/test/run-pass/cci_impl_exe.rs             |   2 +-
 src/test/run-pass/cci_iter_exe.rs             |   4 +-
 src/test/run-pass/cci_no_inline_exe.rs        |   2 +-
 .../class-cast-to-trait-cross-crate-2.rs      |   2 +-
 src/test/run-pass/class-cast-to-trait.rs      |   6 +-
 src/test/run-pass/class-dtor.rs               |   2 +-
 src/test/run-pass/class-exports.rs            |   2 +-
 src/test/run-pass/class-method-cross-crate.rs |   4 +-
 .../run-pass/class-methods-cross-crate.rs     |   6 +-
 src/test/run-pass/class-methods.rs            |   8 +-
 src/test/run-pass/class-poly-methods.rs       |   8 +-
 src/test/run-pass/class-separate-impl.rs      |   6 +-
 src/test/run-pass/class-typarams.rs           |   6 +-
 .../run-pass/classes-simple-cross-crate.rs    |   4 +-
 src/test/run-pass/classes-simple-method.rs    |   4 +-
 src/test/run-pass/classes-simple.rs           |   4 +-
 .../run-pass/coerce-reborrow-imm-vec-rcvr.rs  |   2 +-
 src/test/run-pass/concat.rs                   |   4 +-
 src/test/run-pass/const-block.rs              |   4 +-
 src/test/run-pass/const-bound.rs              |   2 +-
 src/test/run-pass/double-ref.rs               |  28 ++--
 src/test/run-pass/drop-trait-enum.rs          |   6 +-
 src/test/run-pass/extern-pass-char.rs         |   2 +-
 src/test/run-pass/extern-pass-u32.rs          |   2 +-
 src/test/run-pass/extern-pass-u64.rs          |   2 +-
 src/test/run-pass/foreign-fn-linkname.rs      |   2 +-
 src/test/run-pass/i32-sub.rs                  |   2 +-
 src/test/run-pass/i8-incr.rs                  |   8 +-
 src/test/run-pass/if-check.rs                 |   6 +-
 src/test/run-pass/intrinsic-alignment.rs      |  24 ++--
 src/test/run-pass/intrinsics-integer.rs       | 126 +++++++++---------
 src/test/run-pass/intrinsics-math.rs          |   4 +-
 src/test/run-pass/issue-1112.rs               |  20 +--
 src/test/run-pass/issue-11736.rs              |   2 +-
 src/test/run-pass/issue-11958.rs              |   2 +-
 src/test/run-pass/issue-12909.rs              |   2 +-
 src/test/run-pass/issue-15571.rs              |   2 +-
 src/test/run-pass/issue-15673.rs              |   2 +-
 src/test/run-pass/issue-15734.rs              |   4 +-
 src/test/run-pass/issue-17662.rs              |   2 +-
 src/test/run-pass/issue-18539.rs              |   2 +-
 src/test/run-pass/issue-20055-box-trait.rs    |   8 +-
 .../run-pass/issue-20055-box-unsized-array.rs |   8 +-
 src/test/run-pass/issue-20676.rs              |   2 +-
 src/test/run-pass/issue-21475.rs              |   6 +-
 src/test/run-pass/issue-2185.rs               |   8 +-
 src/test/run-pass/issue-22036.rs              |   2 +-
 src/test/run-pass/issue-2550.rs               |   2 +-
 src/test/run-pass/issue-2989.rs               |   8 +-
 src/test/run-pass/issue-3609.rs               |   2 +-
 src/test/run-pass/issue-6130.rs               |   6 +-
 src/test/run-pass/issue-6892.rs               |   4 +-
 src/test/run-pass/issue-7012.rs               |   6 +-
 src/test/run-pass/issue-8783.rs               |   2 +-
 src/test/run-pass/issue2170exe.rs             |   2 +-
 src/test/run-pass/ivec-tag.rs                 |   4 +-
 src/test/run-pass/last-use-in-cap-clause.rs   |   4 +-
 src/test/run-pass/macro-interpolation.rs      |   2 +-
 src/test/run-pass/macro-pat.rs                |   6 +-
 src/test/run-pass/match-with-ret-arm.rs       |   2 +-
 ...thod-mut-self-modifies-mut-slice-lvalue.rs |   2 +-
 src/test/run-pass/method-self-arg-aux1.rs     |   2 +-
 src/test/run-pass/method-self-arg-aux2.rs     |   2 +-
 src/test/run-pass/method-self-arg-trait.rs    |   2 +-
 src/test/run-pass/method-self-arg.rs          |   2 +-
 .../nullable-pointer-iotareduction.rs         |   2 +-
 src/test/run-pass/object-method-numbering.rs  |   2 +-
 .../objects-coerce-freeze-borrored.rs         |   4 +-
 ...owned-object-borrowed-method-headerless.rs |   2 +-
 src/test/run-pass/or-pattern.rs               |   2 +-
 .../overloaded-calls-param-vtables.rs         |   2 +-
 src/test/run-pass/packed-struct-vec.rs        |   2 +-
 src/test/run-pass/path.rs                     |   2 +-
 src/test/run-pass/private-class-field.rs      |   4 +-
 src/test/run-pass/pure-sum.rs                 |  16 +--
 src/test/run-pass/ranges-precedence.rs        |   2 +-
 src/test/run-pass/realloc-16687.rs            |  18 +--
 src/test/run-pass/rec-align-u32.rs            |  10 +-
 src/test/run-pass/rec-align-u64.rs            |  26 ++--
 src/test/run-pass/record-pat.rs               |   4 +-
 src/test/run-pass/regions-borrow-at.rs        |   4 +-
 src/test/run-pass/regions-borrow-uniq.rs      |   4 +-
 src/test/run-pass/regions-copy-closure.rs     |   2 +-
 .../run-pass/regions-escape-into-other-fn.rs  |   2 +-
 src/test/run-pass/regions-params.rs           |   4 +-
 src/test/run-pass/regions-refcell.rs          |  10 +-
 src/test/run-pass/regions-trait-object-1.rs   |   4 +-
 src/test/run-pass/rename-directory.rs         |   2 +-
 src/test/run-pass/ret-bang.rs                 |   4 +-
 src/test/run-pass/running-with-no-runtime.rs  |  10 +-
 src/test/run-pass/sendfn-is-a-block.rs        |   6 +-
 src/test/run-pass/shift-various-types.rs      |  20 +--
 src/test/run-pass/small-enums-with-fields.rs  |  12 +-
 src/test/run-pass/static-methods-in-traits.rs |   2 +-
 src/test/run-pass/string-self-append.rs       |   4 +-
 src/test/run-pass/struct-return.rs            |  20 +--
 .../run-pass/syntax-extension-source-utils.rs |   2 +-
 src/test/run-pass/tag-align-dyn-u64.rs        |   4 +-
 src/test/run-pass/tag-align-dyn-variants.rs   |  52 ++++----
 src/test/run-pass/tag-align-shape.rs          |   2 +-
 src/test/run-pass/tag-align-u64.rs            |   4 +-
 src/test/run-pass/task-comm-16.rs             |   8 +-
 src/test/run-pass/tcp-stress.rs               |   4 +-
 .../trait-default-method-bound-subst4.rs      |   4 +-
 src/test/run-pass/trait-object-generics.rs    |   2 +-
 .../trait-object-with-lifetime-bound.rs       |   4 +-
 src/test/run-pass/type-params-in-for-each.rs  |   4 +-
 .../run-pass/typeck_type_placeholder_1.rs     |   6 +-
 src/test/run-pass/u32-decr.rs                 |   6 +-
 src/test/run-pass/u8-incr-decr.rs             |   8 +-
 src/test/run-pass/u8-incr.rs                  |  12 +-
 src/test/run-pass/ufcs-trait-object.rs        |   2 +-
 .../unboxed-closures-unique-type-id.rs        |   8 +-
 src/test/run-pass/unique-pat-2.rs             |   2 +-
 src/test/run-pass/unique-send-2.rs            |  10 +-
 src/test/run-pass/unsized3.rs                 |   4 +-
 src/test/run-pass/utf8_chars.rs               |  30 ++---
 src/test/run-pass/vec-fixed-length.rs         |   4 +-
 src/test/run-pass/weird-exprs.rs              |   2 +-
 src/test/run-pass/where-for-self.rs           |   2 +-
 src/test/run-pass/x86stdcall.rs               |   2 +-
 src/test/run-pass/x86stdcall2.rs              |   8 +-
 331 files changed, 1072 insertions(+), 1074 deletions(-)

diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 630ca837daa..9351b110100 100644
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -42,7 +42,7 @@
 //! }
 //! ```
 //!
-//! This will print `Cons(1i32, Box(Cons(2i32, Box(Nil))))`.
+//! This will print `Cons(1, Box(Cons(2, Box(Nil))))`.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
diff --git a/src/liballoc/boxed_test.rs b/src/liballoc/boxed_test.rs
index b7bacaa0cae..bb1ff9428a7 100644
--- a/src/liballoc/boxed_test.rs
+++ b/src/liballoc/boxed_test.rs
@@ -72,13 +72,13 @@ fn test_show() {
 #[test]
 fn deref() {
     fn homura<T: Deref<Target=i32>>(_: T) { }
-    homura(Box::new(765i32));
+    homura(Box::new(765));
 }
 
 #[test]
 fn raw_sized() {
     unsafe {
-        let x = Box::new(17i32);
+        let x = Box::new(17);
         let p = boxed::into_raw(x);
         assert_eq!(17, *p);
         *p = 19;
diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs
index b0490b287ad..7524fb6cf18 100644
--- a/src/libcollections/bit.rs
+++ b/src/libcollections/bit.rs
@@ -118,11 +118,11 @@ fn match_words <'a,'b>(a: &'a BitVec, b: &'b BitVec) -> (MatchWords<'a>, MatchWo
 
     // have to uselessly pretend to pad the longer one for type matching
     if a_len < b_len {
-        (a.blocks().enumerate().chain(iter::repeat(0u32).enumerate().take(b_len).skip(a_len)),
-         b.blocks().enumerate().chain(iter::repeat(0u32).enumerate().take(0).skip(0)))
+        (a.blocks().enumerate().chain(iter::repeat(0).enumerate().take(b_len).skip(a_len)),
+         b.blocks().enumerate().chain(iter::repeat(0).enumerate().take(0).skip(0)))
     } else {
-        (a.blocks().enumerate().chain(iter::repeat(0u32).enumerate().take(0).skip(0)),
-         b.blocks().enumerate().chain(iter::repeat(0u32).enumerate().take(a_len).skip(b_len)))
+        (a.blocks().enumerate().chain(iter::repeat(0).enumerate().take(0).skip(0)),
+         b.blocks().enumerate().chain(iter::repeat(0).enumerate().take(a_len).skip(b_len)))
     }
 }
 
@@ -199,7 +199,7 @@ fn blocks_for_bits(bits: usize) -> usize {
 /// Computes the bitmask for the final word of the vector
 fn mask_for_bits(bits: usize) -> u32 {
     // Note especially that a perfect multiple of u32::BITS should mask all 1s.
-    !0u32 >> (u32::BITS as usize - bits % u32::BITS as usize) % u32::BITS as usize
+    !0 >> (u32::BITS as usize - bits % u32::BITS as usize) % u32::BITS as usize
 }
 
 impl BitVec {
@@ -275,7 +275,7 @@ impl BitVec {
     pub fn from_elem(nbits: usize, bit: bool) -> BitVec {
         let nblocks = blocks_for_bits(nbits);
         let mut bit_vec = BitVec {
-            storage: repeat(if bit { !0u32 } else { 0u32 }).take(nblocks).collect(),
+            storage: repeat(if bit { !0 } else { 0 }).take(nblocks).collect(),
             nbits: nbits
         };
         bit_vec.fix_last_block();
@@ -330,7 +330,7 @@ impl BitVec {
         }
 
         if extra_bytes > 0 {
-            let mut last_word = 0u32;
+            let mut last_word = 0;
             for (i, &byte) in bytes[complete_words*4..].iter().enumerate() {
                 last_word |= (reverse_bits(byte) as u32) << (i * 8);
             }
@@ -431,7 +431,7 @@ impl BitVec {
     /// ```
     #[inline]
     pub fn set_all(&mut self) {
-        for w in &mut self.storage { *w = !0u32; }
+        for w in &mut self.storage { *w = !0; }
         self.fix_last_block();
     }
 
@@ -566,12 +566,12 @@ impl BitVec {
     /// assert_eq!(bv.all(), false);
     /// ```
     pub fn all(&self) -> bool {
-        let mut last_word = !0u32;
+        let mut last_word = !0;
         // Check that every block but the last is all-ones...
         self.blocks().all(|elem| {
             let tmp = last_word;
             last_word = elem;
-            tmp == !0u32
+            tmp == !0
         // and then check the last one has enough ones
         }) && (last_word == mask_for_bits(self.nbits))
     }
@@ -912,7 +912,7 @@ impl BitVec {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn clear(&mut self) {
-        for w in &mut self.storage { *w = 0u32; }
+        for w in &mut self.storage { *w = 0; }
     }
 }
 
@@ -2313,7 +2313,7 @@ mod tests {
 
         assert_eq!(bit_vec.iter().collect::<Vec<bool>>(), bools);
 
-        let long: Vec<_> = (0i32..10000).map(|i| i % 2 == 0).collect();
+        let long: Vec<_> = (0..10000).map(|i| i % 2 == 0).collect();
         let bit_vec: BitVec = long.iter().map(|n| *n).collect();
         assert_eq!(bit_vec.iter().collect::<Vec<bool>>(), long)
     }
diff --git a/src/libcollections/fmt.rs b/src/libcollections/fmt.rs
index 5a20ba4b49f..c88be80679d 100644
--- a/src/libcollections/fmt.rs
+++ b/src/libcollections/fmt.rs
@@ -226,7 +226,7 @@
 //! Some examples of the output from both traits:
 //!
 //! ```
-//! assert_eq!(format!("{} {:?}", 3i32, 4i32), "3 4");
+//! assert_eq!(format!("{} {:?}", 3, 4), "3 4");
 //! assert_eq!(format!("{} {:?}", 'a', 'b'), "a 'b'");
 //! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\"");
 //! ```
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 23b256568da..abcb996e3ed 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -2639,7 +2639,7 @@ mod tests {
     #[test]
     fn test_bytes_set_memory() {
         use slice::bytes::MutableByteVector;
-        let mut values = [1u8,2,3,4,5];
+        let mut values = [1,2,3,4,5];
         values[0..5].set_memory(0xAB);
         assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]);
         values[2..4].set_memory(0xFF);
@@ -2809,26 +2809,26 @@ mod tests {
     fn test_mut_chunks() {
         use core::iter::ExactSizeIterator;
 
-        let mut v = [0u8, 1, 2, 3, 4, 5, 6];
+        let mut v = [0, 1, 2, 3, 4, 5, 6];
         assert_eq!(v.chunks_mut(2).len(), 4);
         for (i, chunk) in v.chunks_mut(3).enumerate() {
             for x in chunk {
                 *x = i as u8;
             }
         }
-        let result = [0u8, 0, 0, 1, 1, 1, 2];
+        let result = [0, 0, 0, 1, 1, 1, 2];
         assert!(v == result);
     }
 
     #[test]
     fn test_mut_chunks_rev() {
-        let mut v = [0u8, 1, 2, 3, 4, 5, 6];
+        let mut v = [0, 1, 2, 3, 4, 5, 6];
         for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
             for x in chunk {
                 *x = i as u8;
             }
         }
-        let result = [2u8, 2, 2, 1, 1, 1, 0];
+        let result = [2, 2, 2, 1, 1, 1, 0];
         assert!(v == result);
     }
 
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 599b92d05dd..7ea5b3fe9c0 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -383,7 +383,7 @@ macro_rules! utf8_first_byte {
 
 // return the value of $ch updated with continuation byte $byte
 macro_rules! utf8_acc_cont_byte {
-    ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as u32)
+    ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63) as u32)
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -2300,8 +2300,8 @@ mod tests {
 
     #[test]
     fn test_chars_decoding() {
-        let mut bytes = [0u8; 4];
-        for c in (0u32..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
+        let mut bytes = [0; 4];
+        for c in (0..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
             let len = c.encode_utf8(&mut bytes).unwrap_or(0);
             let s = ::core::str::from_utf8(&bytes[..len]).unwrap();
             if Some(c) != s.chars().next() {
@@ -2312,8 +2312,8 @@ mod tests {
 
     #[test]
     fn test_chars_rev_decoding() {
-        let mut bytes = [0u8; 4];
-        for c in (0u32..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
+        let mut bytes = [0; 4];
+        for c in (0..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
             let len = c.encode_utf8(&mut bytes).unwrap_or(0);
             let s = ::core::str::from_utf8(&bytes[..len]).unwrap();
             if Some(c) != s.chars().rev().next() {
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index 33189bd68bd..d6ec8f0d979 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -153,7 +153,7 @@ impl String {
             }
         }
 
-        const TAG_CONT_U8: u8 = 128u8;
+        const TAG_CONT_U8: u8 = 128;
         const REPLACEMENT: &'static [u8] = b"\xEF\xBF\xBD"; // U+FFFD in UTF-8
         let total = v.len();
         fn unsafe_get(xs: &[u8], i: usize) -> u8 {
@@ -195,14 +195,14 @@ impl String {
                 }
             })}
 
-            if byte < 128u8 {
+            if byte < 128 {
                 // subseqidx handles this
             } else {
                 let w = unicode_str::utf8_char_width(byte);
 
                 match w {
                     2 => {
-                        if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 {
+                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
                             error!();
                             continue;
                         }
@@ -220,7 +220,7 @@ impl String {
                             }
                         }
                         i += 1;
-                        if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 {
+                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
                             error!();
                             continue;
                         }
@@ -237,12 +237,12 @@ impl String {
                             }
                         }
                         i += 1;
-                        if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 {
+                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
                             error!();
                             continue;
                         }
                         i += 1;
-                        if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 {
+                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
                             error!();
                             continue;
                         }
@@ -1084,40 +1084,40 @@ mod tests {
     fn test_from_utf16() {
         let pairs =
             [(String::from_str("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"),
-              vec![0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16,
-                0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16,
-                0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16,
-                0xd800_u16, 0xdf30_u16, 0x000a_u16]),
+              vec![0xd800, 0xdf45, 0xd800, 0xdf3f,
+                0xd800, 0xdf3b, 0xd800, 0xdf46,
+                0xd800, 0xdf39, 0xd800, 0xdf3b,
+                0xd800, 0xdf30, 0x000a]),
 
              (String::from_str("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"),
-              vec![0xd801_u16, 0xdc12_u16, 0xd801_u16,
-                0xdc49_u16, 0xd801_u16, 0xdc2e_u16, 0xd801_u16,
-                0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16,
-                0xdc4b_u16, 0x0020_u16, 0xd801_u16, 0xdc0f_u16,
-                0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4d_u16,
-                0x000a_u16]),
+              vec![0xd801, 0xdc12, 0xd801,
+                0xdc49, 0xd801, 0xdc2e, 0xd801,
+                0xdc40, 0xd801, 0xdc32, 0xd801,
+                0xdc4b, 0x0020, 0xd801, 0xdc0f,
+                0xd801, 0xdc32, 0xd801, 0xdc4d,
+                0x000a]),
 
              (String::from_str("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
-              vec![0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16,
-                0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16,
-                0xd800_u16, 0xdf11_u16, 0xd800_u16, 0xdf09_u16,
-                0x00b7_u16, 0xd800_u16, 0xdf0c_u16, 0xd800_u16,
-                0xdf04_u16, 0xd800_u16, 0xdf15_u16, 0xd800_u16,
-                0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16,
-                0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]),
+              vec![0xd800, 0xdf00, 0xd800, 0xdf16,
+                0xd800, 0xdf0b, 0xd800, 0xdf04,
+                0xd800, 0xdf11, 0xd800, 0xdf09,
+                0x00b7, 0xd800, 0xdf0c, 0xd800,
+                0xdf04, 0xd800, 0xdf15, 0xd800,
+                0xdf04, 0xd800, 0xdf0b, 0xd800,
+                0xdf09, 0xd800, 0xdf11, 0x000a ]),
 
              (String::from_str("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
-              vec![0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16,
-                0xd801_u16, 0xdc88_u16, 0xd801_u16, 0xdc91_u16,
-                0xd801_u16, 0xdc9b_u16, 0xd801_u16, 0xdc92_u16,
-                0x0020_u16, 0xd801_u16, 0xdc95_u16, 0xd801_u16,
-                0xdc93_u16, 0x0020_u16, 0xd801_u16, 0xdc88_u16,
-                0xd801_u16, 0xdc9a_u16, 0xd801_u16, 0xdc8d_u16,
-                0x0020_u16, 0xd801_u16, 0xdc8f_u16, 0xd801_u16,
-                0xdc9c_u16, 0xd801_u16, 0xdc92_u16, 0xd801_u16,
-                0xdc96_u16, 0xd801_u16, 0xdc86_u16, 0x0020_u16,
-                0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
-                0x000a_u16 ]),
+              vec![0xd801, 0xdc8b, 0xd801, 0xdc98,
+                0xd801, 0xdc88, 0xd801, 0xdc91,
+                0xd801, 0xdc9b, 0xd801, 0xdc92,
+                0x0020, 0xd801, 0xdc95, 0xd801,
+                0xdc93, 0x0020, 0xd801, 0xdc88,
+                0xd801, 0xdc9a, 0xd801, 0xdc8d,
+                0x0020, 0xd801, 0xdc8f, 0xd801,
+                0xdc9c, 0xd801, 0xdc92, 0xd801,
+                0xdc96, 0xd801, 0xdc86, 0x0020,
+                0xd801, 0xdc95, 0xd801, 0xdc86,
+                0x000a ]),
              // Issue #12318, even-numbered non-BMP planes
              (String::from_str("\u{20000}"),
               vec![0xD840, 0xDC00])];
@@ -1303,7 +1303,7 @@ mod tests {
         assert_eq!(1.to_string(), "1");
         assert_eq!((-1).to_string(), "-1");
         assert_eq!(200.to_string(), "200");
-        assert_eq!(2u8.to_string(), "2");
+        assert_eq!(2.to_string(), "2");
         assert_eq!(true.to_string(), "true");
         assert_eq!(false.to_string(), "false");
         assert_eq!(("hi".to_string()).to_string(), "hi");
@@ -1421,7 +1421,7 @@ mod tests {
 
     #[bench]
     fn from_utf8_lossy_100_invalid(b: &mut Bencher) {
-        let s = repeat(0xf5u8).take(100).collect::<Vec<_>>();
+        let s = repeat(0xf5).take(100).collect::<Vec<_>>();
         b.iter(|| {
             let _ = String::from_utf8_lossy(&s);
         });
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 8e27ae1cea9..973070677d8 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -22,13 +22,13 @@ use option::Option;
 use slice::SliceExt;
 
 // UTF-8 ranges and tags for encoding characters
-const TAG_CONT: u8    = 0b1000_0000u8;
-const TAG_TWO_B: u8   = 0b1100_0000u8;
-const TAG_THREE_B: u8 = 0b1110_0000u8;
-const TAG_FOUR_B: u8  = 0b1111_0000u8;
-const MAX_ONE_B: u32   =     0x80u32;
-const MAX_TWO_B: u32   =    0x800u32;
-const MAX_THREE_B: u32 =  0x10000u32;
+const TAG_CONT: u8    = 0b1000_0000;
+const TAG_TWO_B: u8   = 0b1100_0000;
+const TAG_THREE_B: u8 = 0b1110_0000;
+const TAG_FOUR_B: u8  = 0b1111_0000;
+const MAX_ONE_B: u32   =     0x80;
+const MAX_TWO_B: u32   =    0x800;
+const MAX_THREE_B: u32 =  0x10000;
 
 /*
     Lu  Uppercase_Letter        an uppercase letter
@@ -413,7 +413,7 @@ impl CharExt for char {
     #[stable(feature = "rust1", since = "1.0.0")]
     fn len_utf16(self) -> usize {
         let ch = self as u32;
-        if (ch & 0xFFFF_u32) == ch { 1 } else { 2 }
+        if (ch & 0xFFFF) == ch { 1 } else { 2 }
     }
 
     #[inline]
@@ -444,19 +444,19 @@ pub fn encode_utf8_raw(code: u32, dst: &mut [u8]) -> Option<usize> {
         dst[0] = code as u8;
         Some(1)
     } else if code < MAX_TWO_B && dst.len() >= 2 {
-        dst[0] = (code >> 6 & 0x1F_u32) as u8 | TAG_TWO_B;
-        dst[1] = (code & 0x3F_u32) as u8 | TAG_CONT;
+        dst[0] = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
+        dst[1] = (code & 0x3F) as u8 | TAG_CONT;
         Some(2)
     } else if code < MAX_THREE_B && dst.len() >= 3  {
-        dst[0] = (code >> 12 & 0x0F_u32) as u8 | TAG_THREE_B;
-        dst[1] = (code >>  6 & 0x3F_u32) as u8 | TAG_CONT;
-        dst[2] = (code & 0x3F_u32) as u8 | TAG_CONT;
+        dst[0] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+        dst[1] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
+        dst[2] = (code & 0x3F) as u8 | TAG_CONT;
         Some(3)
     } else if dst.len() >= 4 {
-        dst[0] = (code >> 18 & 0x07_u32) as u8 | TAG_FOUR_B;
-        dst[1] = (code >> 12 & 0x3F_u32) as u8 | TAG_CONT;
-        dst[2] = (code >>  6 & 0x3F_u32) as u8 | TAG_CONT;
-        dst[3] = (code & 0x3F_u32) as u8 | TAG_CONT;
+        dst[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
+        dst[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+        dst[2] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
+        dst[3] = (code & 0x3F) as u8 | TAG_CONT;
         Some(4)
     } else {
         None
@@ -472,15 +472,15 @@ pub fn encode_utf8_raw(code: u32, dst: &mut [u8]) -> Option<usize> {
 #[unstable(feature = "core")]
 pub fn encode_utf16_raw(mut ch: u32, dst: &mut [u16]) -> Option<usize> {
     // Marked #[inline] to allow llvm optimizing it away
-    if (ch & 0xFFFF_u32) == ch  && dst.len() >= 1 {
+    if (ch & 0xFFFF) == ch  && dst.len() >= 1 {
         // The BMP falls through (assuming non-surrogate, as it should)
         dst[0] = ch as u16;
         Some(1)
     } else if dst.len() >= 2 {
         // Supplementary planes break into surrogates.
-        ch -= 0x1_0000_u32;
-        dst[0] = 0xD800_u16 | ((ch >> 10) as u16);
-        dst[1] = 0xDC00_u16 | ((ch as u16) & 0x3FF_u16);
+        ch -= 0x1_0000;
+        dst[0] = 0xD800 | ((ch >> 10) as u16);
+        dst[1] = 0xDC00 | ((ch as u16) & 0x3FF);
         Some(2)
     } else {
         None
diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
index 2eeb564859c..0df04c296c8 100644
--- a/src/libcore/fmt/float.rs
+++ b/src/libcore/fmt/float.rs
@@ -123,13 +123,13 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
     // For an f64 the exponent is in the range of [-1022, 1023] for base 2, so
     // we may have up to that many digits. Give ourselves some extra wiggle room
     // otherwise as well.
-    let mut buf = [0u8; 1536];
+    let mut buf = [0; 1536];
     let mut end = 0;
     let radix_gen: T = cast(radix as int).unwrap();
 
     let (num, exp) = match exp_format {
-        ExpNone => (num, 0i32),
-        ExpDec if num == _0 => (num, 0i32),
+        ExpNone => (num, 0),
+        ExpDec if num == _0 => (num, 0),
         ExpDec => {
             let (exp, exp_base) = match exp_format {
                 ExpDec => (num.abs().log10().floor(), cast::<f64, T>(10.0f64).unwrap()),
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 9544fbaa55b..e640bf02f5a 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -565,7 +565,7 @@ impl<'a> Formatter<'a> {
             Alignment::Center => (padding / 2, (padding + 1) / 2),
         };
 
-        let mut fill = [0u8; 4];
+        let mut fill = [0; 4];
         let len = self.fill.encode_utf8(&mut fill).unwrap_or(0);
         let fill = unsafe { str::from_utf8_unchecked(&fill[..len]) };
 
@@ -689,7 +689,7 @@ impl Debug for char {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Display for char {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        let mut utf8 = [0u8; 4];
+        let mut utf8 = [0; 4];
         let amt = self.encode_utf8(&mut utf8).unwrap_or(0);
         let s: &str = unsafe { mem::transmute(&utf8[..amt]) };
         Display::fmt(s, f)
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 045442e28ac..b3f2302bb3e 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -38,7 +38,7 @@ trait GenericRadix {
         // characters for a base 2 number.
         let zero = Int::zero();
         let is_positive = x >= zero;
-        let mut buf = [0u8; 64];
+        let mut buf = [0; 64];
         let mut curr = buf.len();
         let base = cast(self.base()).unwrap();
         if is_positive {
diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs
index df0008c500b..bd1516e0cfc 100644
--- a/src/libcore/hash/sip.rs
+++ b/src/libcore/hash/sip.rs
@@ -60,7 +60,7 @@ macro_rules! u8to64_le {
     ($buf:expr, $i:expr, $len:expr) =>
     ({
         let mut t = 0;
-        let mut out = 0u64;
+        let mut out = 0;
         while t < $len {
             out |= ($buf[t+$i] as u64) << t*8;
             t += 1;
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index ed129136091..c6fc8ba5867 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -230,7 +230,7 @@ extern "rust-intrinsic" {
     /// use std::mem;
     ///
     /// let v: &[u8] = unsafe { mem::transmute("L") };
-    /// assert!(v == [76u8]);
+    /// assert!(v == [76]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn transmute<T,U>(e: T) -> U;
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 767828408be..16e652fcc9a 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -1149,7 +1149,7 @@ pub trait AdditiveIterator<A> {
     /// ```
     /// use std::iter::AdditiveIterator;
     ///
-    /// let a = [1i32, 2, 3, 4, 5];
+    /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().cloned();
     /// assert!(it.sum() == 15);
     /// ```
diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs
index 94ca9ec37b4..f56206e8782 100644
--- a/src/libcore/macros.rs
+++ b/src/libcore/macros.rs
@@ -227,7 +227,7 @@ macro_rules! writeln {
 ///
 /// ```rust
 /// fn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3
-///     for i in std::iter::count(0_u32, 1) {
+///     for i in std::iter::count(0, 1) {
 ///         if 3*i < i { panic!("u32 overflow"); }
 ///         if x < 3*i { return i-1; }
 ///     }
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 1ecbd8fae8c..5343cdaaf08 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -385,7 +385,7 @@ impl<T> Option<T> {
     /// # Example
     ///
     /// ```
-    /// let k = 10i32;
+    /// let k = 10;
     /// assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4);
     /// assert_eq!(None.unwrap_or_else(|| 2 * k), 20);
     /// ```
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 4f4164f673b..1d4b81512dd 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -1119,9 +1119,9 @@ pub struct CharRange {
 }
 
 /// Mask of the value bits of a continuation byte
-const CONT_MASK: u8 = 0b0011_1111u8;
+const CONT_MASK: u8 = 0b0011_1111;
 /// Value of the tag bits (tag mask is !CONT_MASK) of a continuation byte
-const TAG_CONT_U8: u8 = 0b1000_0000u8;
+const TAG_CONT_U8: u8 = 0b1000_0000;
 
 /*
 Section: Trait implementations
@@ -1568,7 +1568,7 @@ impl StrExt for str {
         if index == self.len() { return true; }
         match self.as_bytes().get(index) {
             None => false,
-            Some(&b) => b < 128u8 || b >= 192u8,
+            Some(&b) => b < 128 || b >= 192,
         }
     }
 
@@ -1680,7 +1680,7 @@ impl StrExt for str {
 #[inline]
 #[unstable(feature = "core")]
 pub fn char_range_at_raw(bytes: &[u8], i: usize) -> (u32, usize) {
-    if bytes[i] < 128u8 {
+    if bytes[i] < 128 {
         return (bytes[i] as u32, i + 1);
     }
 
diff --git a/src/libcoretest/char.rs b/src/libcoretest/char.rs
index 32dc6440b13..46d1f7ff3ae 100644
--- a/src/libcoretest/char.rs
+++ b/src/libcoretest/char.rs
@@ -165,7 +165,7 @@ fn test_escape_unicode() {
 #[test]
 fn test_encode_utf8() {
     fn check(input: char, expect: &[u8]) {
-        let mut buf = [0u8; 4];
+        let mut buf = [0; 4];
         let n = input.encode_utf8(&mut buf).unwrap_or(0);
         assert_eq!(&buf[..n], expect);
     }
@@ -179,7 +179,7 @@ fn test_encode_utf8() {
 #[test]
 fn test_encode_utf16() {
     fn check(input: char, expect: &[u16]) {
-        let mut buf = [0u16; 2];
+        let mut buf = [0; 2];
         let n = input.encode_utf16(&mut buf).unwrap_or(0);
         assert_eq!(&buf[..n], expect);
     }
diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs
index 3433813e7b5..5c11f0196ae 100644
--- a/src/libcoretest/hash/mod.rs
+++ b/src/libcoretest/hash/mod.rs
@@ -62,10 +62,10 @@ fn test_writer_hasher() {
     // FIXME (#18283) Enable test
     //let s: Box<str> = box "a";
     //assert_eq!(hasher.hash(& s), 97 + 0xFF);
-    let cs: &[u8] = &[1u8, 2u8, 3u8];
+    let cs: &[u8] = &[1, 2, 3];
     assert_eq!(hash(& cs), 9);
     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
-    let cs: Box<[u8]> = Box::new([1u8, 2u8, 3u8]);
+    let cs: Box<[u8]> = Box::new([1, 2, 3]);
     assert_eq!(hash(& cs), 9);
 
     // FIXME (#18248) Add tests for hashing Rc<str> and Rc<[T]>
diff --git a/src/libcoretest/hash/sip.rs b/src/libcoretest/hash/sip.rs
index 248cad32ef4..8289d06d04c 100644
--- a/src/libcoretest/hash/sip.rs
+++ b/src/libcoretest/hash/sip.rs
@@ -100,8 +100,8 @@ fn test_siphash() {
         [ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, ]
     ];
 
-    let k0 = 0x_07_06_05_04_03_02_01_00_u64;
-    let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08_u64;
+    let k0 = 0x_07_06_05_04_03_02_01_00;
+    let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
     let mut buf = Vec::new();
     let mut t = 0;
     let mut state_inc = SipState::new_with_keys(k0, k1);
@@ -230,8 +230,8 @@ fn test_hash_no_concat_alias() {
     assert!(s != t && t != u);
     assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u));
 
-    let v: (&[u8], &[u8], &[u8]) = (&[1u8], &[0u8, 0], &[0u8]);
-    let w: (&[u8], &[u8], &[u8]) = (&[1u8, 0, 0, 0], &[], &[]);
+    let v: (&[u8], &[u8], &[u8]) = (&[1], &[0, 0], &[0]);
+    let w: (&[u8], &[u8], &[u8]) = (&[1, 0, 0, 0], &[], &[]);
 
     assert!(v != w);
     assert!(hash(&v) != hash(&w));
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
index b1b10b582e5..91d1ea27476 100644
--- a/src/libcoretest/iter.rs
+++ b/src/libcoretest/iter.rs
@@ -778,9 +778,9 @@ fn test_range_step() {
     assert_eq!(range_step(0, 20, 5).collect::<Vec<int>>(), [0, 5, 10, 15]);
     assert_eq!(range_step(20, 0, -5).collect::<Vec<int>>(), [20, 15, 10, 5]);
     assert_eq!(range_step(20, 0, -6).collect::<Vec<int>>(), [20, 14, 8, 2]);
-    assert_eq!(range_step(200u8, 255, 50).collect::<Vec<u8>>(), [200u8, 250]);
-    assert_eq!(range_step(200i, -5, 1).collect::<Vec<int>>(), []);
-    assert_eq!(range_step(200i, 200, 1).collect::<Vec<int>>(), []);
+    assert_eq!(range_step(200, 255, 50).collect::<Vec<u8>>(), [200, 250]);
+    assert_eq!(range_step(200, -5, 1).collect::<Vec<int>>(), []);
+    assert_eq!(range_step(200, 200, 1).collect::<Vec<int>>(), []);
 }
 
 #[test]
@@ -788,7 +788,7 @@ fn test_range_step_inclusive() {
     assert_eq!(range_step_inclusive(0, 20, 5).collect::<Vec<int>>(), [0, 5, 10, 15, 20]);
     assert_eq!(range_step_inclusive(20, 0, -5).collect::<Vec<int>>(), [20, 15, 10, 5, 0]);
     assert_eq!(range_step_inclusive(20, 0, -6).collect::<Vec<int>>(), [20, 14, 8, 2]);
-    assert_eq!(range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>(), [200u8, 250]);
+    assert_eq!(range_step_inclusive(200, 255, 50).collect::<Vec<u8>>(), [200, 250]);
     assert_eq!(range_step_inclusive(200, -5, 1).collect::<Vec<int>>(), []);
     assert_eq!(range_step_inclusive(200, 200, 1).collect::<Vec<int>>(), [200]);
 }
diff --git a/src/libcoretest/mem.rs b/src/libcoretest/mem.rs
index 73000670c61..bf3e1cf03cb 100644
--- a/src/libcoretest/mem.rs
+++ b/src/libcoretest/mem.rs
@@ -103,7 +103,7 @@ fn test_transmute() {
     }
 
     unsafe {
-        assert_eq!([76u8], transmute::<_, Vec<u8>>("L".to_string()));
+        assert_eq!([76], transmute::<_, Vec<u8>>("L".to_string()));
     }
 }
 
diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs
index 721354b6a44..9087b87f640 100644
--- a/src/libcoretest/num/mod.rs
+++ b/src/libcoretest/num/mod.rs
@@ -88,7 +88,7 @@ mod test {
 
     #[test]
     fn test_int_from_str_overflow() {
-        let mut i8_val: i8 = 127_i8;
+        let mut i8_val: i8 = 127;
         assert_eq!("127".parse::<i8>().ok(), Some(i8_val));
         assert_eq!("128".parse::<i8>().ok(), None);
 
@@ -96,7 +96,7 @@ mod test {
         assert_eq!("-128".parse::<i8>().ok(), Some(i8_val));
         assert_eq!("-129".parse::<i8>().ok(), None);
 
-        let mut i16_val: i16 = 32_767_i16;
+        let mut i16_val: i16 = 32_767;
         assert_eq!("32767".parse::<i16>().ok(), Some(i16_val));
         assert_eq!("32768".parse::<i16>().ok(), None);
 
@@ -104,7 +104,7 @@ mod test {
         assert_eq!("-32768".parse::<i16>().ok(), Some(i16_val));
         assert_eq!("-32769".parse::<i16>().ok(), None);
 
-        let mut i32_val: i32 = 2_147_483_647_i32;
+        let mut i32_val: i32 = 2_147_483_647;
         assert_eq!("2147483647".parse::<i32>().ok(), Some(i32_val));
         assert_eq!("2147483648".parse::<i32>().ok(), None);
 
@@ -112,7 +112,7 @@ mod test {
         assert_eq!("-2147483648".parse::<i32>().ok(), Some(i32_val));
         assert_eq!("-2147483649".parse::<i32>().ok(), None);
 
-        let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
+        let mut i64_val: i64 = 9_223_372_036_854_775_807;
         assert_eq!("9223372036854775807".parse::<i64>().ok(), Some(i64_val));
         assert_eq!("9223372036854775808".parse::<i64>().ok(), None);
 
diff --git a/src/libcoretest/ptr.rs b/src/libcoretest/ptr.rs
index c8a54ef59ab..6a25c8be14e 100644
--- a/src/libcoretest/ptr.rs
+++ b/src/libcoretest/ptr.rs
@@ -139,12 +139,12 @@ fn test_ptr_addition() {
 fn test_ptr_subtraction() {
     unsafe {
         let xs = vec![0,1,2,3,4,5,6,7,8,9];
-        let mut idx = 9i8;
+        let mut idx = 9;
         let ptr = xs.as_ptr();
 
-        while idx >= 0i8 {
+        while idx >= 0 {
             assert_eq!(*(ptr.offset(idx as int)), idx as int);
-            idx = idx - 1i8;
+            idx = idx - 1;
         }
 
         let mut xs_mut = xs;
diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs
index 42143b06ca0..7a91e692775 100644
--- a/src/liblibc/lib.rs
+++ b/src/liblibc/lib.rs
@@ -2203,11 +2203,11 @@ pub mod consts {
             pub const _IOFBF : c_int = 0;
             pub const _IONBF : c_int = 4;
             pub const _IOLBF : c_int = 64;
-            pub const BUFSIZ : c_uint = 512_u32;
-            pub const FOPEN_MAX : c_uint = 20_u32;
-            pub const FILENAME_MAX : c_uint = 260_u32;
-            pub const L_tmpnam : c_uint = 16_u32;
-            pub const TMP_MAX : c_uint = 32767_u32;
+            pub const BUFSIZ : c_uint = 512;
+            pub const FOPEN_MAX : c_uint = 20;
+            pub const FILENAME_MAX : c_uint = 260;
+            pub const L_tmpnam : c_uint = 16;
+            pub const TMP_MAX : c_uint = 32767;
 
             pub const WSAEINTR: c_int = 10004;
             pub const WSAEBADF: c_int = 10009;
@@ -2584,11 +2584,11 @@ pub mod consts {
             pub const _IOFBF : c_int = 0;
             pub const _IONBF : c_int = 2;
             pub const _IOLBF : c_int = 1;
-            pub const BUFSIZ : c_uint = 8192_u32;
-            pub const FOPEN_MAX : c_uint = 16_u32;
-            pub const FILENAME_MAX : c_uint = 4096_u32;
-            pub const L_tmpnam : c_uint = 20_u32;
-            pub const TMP_MAX : c_uint = 238328_u32;
+            pub const BUFSIZ : c_uint = 8192;
+            pub const FOPEN_MAX : c_uint = 16;
+            pub const FILENAME_MAX : c_uint = 4096;
+            pub const L_tmpnam : c_uint = 20;
+            pub const TMP_MAX : c_uint = 238328;
         }
         pub mod c99 {
         }
@@ -3450,11 +3450,11 @@ pub mod consts {
             pub const _IOFBF : c_int = 0;
             pub const _IONBF : c_int = 2;
             pub const _IOLBF : c_int = 1;
-            pub const BUFSIZ : c_uint = 1024_u32;
-            pub const FOPEN_MAX : c_uint = 20_u32;
-            pub const FILENAME_MAX : c_uint = 1024_u32;
-            pub const L_tmpnam : c_uint = 1024_u32;
-            pub const TMP_MAX : c_uint = 308915776_u32;
+            pub const BUFSIZ : c_uint = 1024;
+            pub const FOPEN_MAX : c_uint = 20;
+            pub const FILENAME_MAX : c_uint = 1024;
+            pub const L_tmpnam : c_uint = 1024;
+            pub const TMP_MAX : c_uint = 308915776;
         }
         pub mod c99 {
         }
@@ -3858,11 +3858,11 @@ pub mod consts {
             pub const _IOFBF : c_int = 0;
             pub const _IONBF : c_int = 2;
             pub const _IOLBF : c_int = 1;
-            pub const BUFSIZ : c_uint = 1024_u32;
-            pub const FOPEN_MAX : c_uint = 20_u32;
-            pub const FILENAME_MAX : c_uint = 1024_u32;
-            pub const L_tmpnam : c_uint = 1024_u32;
-            pub const TMP_MAX : c_uint = 308915776_u32;
+            pub const BUFSIZ : c_uint = 1024;
+            pub const FOPEN_MAX : c_uint = 20;
+            pub const FILENAME_MAX : c_uint = 1024;
+            pub const L_tmpnam : c_uint = 1024;
+            pub const TMP_MAX : c_uint = 308915776;
         }
         pub mod c99 {
         }
@@ -4236,11 +4236,11 @@ pub mod consts {
             pub const _IOFBF : c_int = 0;
             pub const _IONBF : c_int = 2;
             pub const _IOLBF : c_int = 1;
-            pub const BUFSIZ : c_uint = 1024_u32;
-            pub const FOPEN_MAX : c_uint = 20_u32;
-            pub const FILENAME_MAX : c_uint = 1024_u32;
-            pub const L_tmpnam : c_uint = 1024_u32;
-            pub const TMP_MAX : c_uint = 308915776_u32;
+            pub const BUFSIZ : c_uint = 1024;
+            pub const FOPEN_MAX : c_uint = 20;
+            pub const FILENAME_MAX : c_uint = 1024;
+            pub const L_tmpnam : c_uint = 1024;
+            pub const TMP_MAX : c_uint = 308915776;
         }
         pub mod c99 {
         }
diff --git a/src/librand/chacha.rs b/src/librand/chacha.rs
index 71ace016d6b..d54f1837074 100644
--- a/src/librand/chacha.rs
+++ b/src/librand/chacha.rs
@@ -173,7 +173,7 @@ impl<'a> SeedableRng<&'a [u32]> for ChaChaRng {
 
     fn reseed(&mut self, seed: &'a [u32]) {
         // reset state
-        self.init(&[0u32; KEY_WORDS]);
+        self.init(&[0; KEY_WORDS]);
         // set key in place
         let key = &mut self.state[4 .. 4+KEY_WORDS];
         for (k, s) in key.iter_mut().zip(seed.iter()) {
@@ -245,7 +245,7 @@ mod test {
     fn test_rng_true_values() {
         // Test vectors 1 and 2 from
         // http://tools.ietf.org/html/draft-nir-cfrg-chacha20-poly1305-04
-        let seed : &[_] = &[0u32; 8];
+        let seed : &[_] = &[0; 8];
         let mut ra: ChaChaRng = SeedableRng::from_seed(seed);
 
         let v = (0..16).map(|_| ra.next_u32()).collect::<Vec<_>>();
@@ -285,7 +285,7 @@ mod test {
 
     #[test]
     fn test_rng_clone() {
-        let seed : &[_] = &[0u32; 8];
+        let seed : &[_] = &[0; 8];
         let mut rng: ChaChaRng = SeedableRng::from_seed(seed);
         let mut clone = rng.clone();
         for _ in 0..16 {
diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs
index fb73a44c2b9..4afc67d63c8 100644
--- a/src/librand/distributions/range.rs
+++ b/src/librand/distributions/range.rs
@@ -23,8 +23,8 @@ use distributions::{Sample, IndependentSample};
 ///
 /// This gives a uniform distribution (assuming the RNG used to sample
 /// it is itself uniform & the `SampleRange` implementation for the
-/// given type is correct), even for edge cases like `low = 0u8`,
-/// `high = 170u8`, for which a naive modulo operation would return
+/// given type is correct), even for edge cases like `low = 0`,
+/// `high = 170`, for which a naive modulo operation would return
 /// numbers less than 85 with double the probability to those greater
 /// than 85.
 ///
diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs
index 28f1ea872d7..5532e41028a 100644
--- a/src/librand/isaac.rs
+++ b/src/librand/isaac.rs
@@ -217,7 +217,7 @@ impl<'a> SeedableRng<&'a [u32]> for IsaacRng {
     fn reseed(&mut self, seed: &'a [u32]) {
         // make the seed into [seed[0], seed[1], ..., seed[seed.len()
         // - 1], 0, 0, ...], to fill rng.rsl.
-        let seed_iter = seed.iter().cloned().chain(repeat(0u32));
+        let seed_iter = seed.iter().cloned().chain(repeat(0));
 
         for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) {
             *rsl_elem = seed_elem;
@@ -460,7 +460,7 @@ impl<'a> SeedableRng<&'a [u64]> for Isaac64Rng {
     fn reseed(&mut self, seed: &'a [u64]) {
         // make the seed into [seed[0], seed[1], ..., seed[seed.len()
         // - 1], 0, 0, ...], to fill rng.rsl.
-        let seed_iter = seed.iter().cloned().chain(repeat(0u64));
+        let seed_iter = seed.iter().cloned().chain(repeat(0));
 
         for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) {
             *rsl_elem = seed_elem;
diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index 3458d519af5..c92f6c5e52d 100644
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -149,7 +149,7 @@ pub trait Rng : Sized {
     /// ```rust
     /// use std::rand::{thread_rng, Rng};
     ///
-    /// let mut v = [0u8; 13579];
+    /// let mut v = [0; 13579];
     /// thread_rng().fill_bytes(&mut v);
     /// println!("{:?}", v.as_slice());
     /// ```
diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs
index 0072c555d14..22b77a75931 100644
--- a/src/librand/reseeding.rs
+++ b/src/librand/reseeding.rs
@@ -215,7 +215,7 @@ mod test {
     const FILL_BYTES_V_LEN: uint = 13579;
     #[test]
     fn test_rng_fill_bytes() {
-        let mut v = repeat(0u8).take(FILL_BYTES_V_LEN).collect::<Vec<_>>();
+        let mut v = repeat(0).take(FILL_BYTES_V_LEN).collect::<Vec<_>>();
         ::test::rng().fill_bytes(&mut v);
 
         // Sanity test: if we've gotten here, `fill_bytes` has not infinitely
diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs
index 844d097bdaf..f0b79640f7d 100644
--- a/src/librbml/lib.rs
+++ b/src/librbml/lib.rs
@@ -290,22 +290,22 @@ pub mod reader {
     #[inline(never)]
     fn vuint_at_slow(data: &[u8], start: uint) -> DecodeResult<Res> {
         let a = data[start];
-        if a & 0x80u8 != 0u8 {
-            return Ok(Res {val: (a & 0x7fu8) as uint, next: start + 1});
+        if a & 0x80 != 0 {
+            return Ok(Res {val: (a & 0x7f) as uint, next: start + 1});
         }
-        if a & 0x40u8 != 0u8 {
-            return Ok(Res {val: ((a & 0x3fu8) as uint) << 8 |
+        if a & 0x40 != 0 {
+            return Ok(Res {val: ((a & 0x3f) as uint) << 8 |
                         (data[start + 1] as uint),
                     next: start + 2});
         }
-        if a & 0x20u8 != 0u8 {
-            return Ok(Res {val: ((a & 0x1fu8) as uint) << 16 |
+        if a & 0x20 != 0 {
+            return Ok(Res {val: ((a & 0x1f) as uint) << 16 |
                         (data[start + 1] as uint) << 8 |
                         (data[start + 2] as uint),
                     next: start + 3});
         }
-        if a & 0x10u8 != 0u8 {
-            return Ok(Res {val: ((a & 0x0fu8) as uint) << 24 |
+        if a & 0x10 != 0 {
+            return Ok(Res {val: ((a & 0x0f) as uint) << 24 |
                         (data[start + 1] as uint) << 16 |
                         (data[start + 2] as uint) << 8 |
                         (data[start + 3] as uint),
@@ -877,11 +877,11 @@ pub mod writer {
 
     fn write_sized_vuint<W: Writer>(w: &mut W, n: uint, size: uint) -> EncodeResult {
         match size {
-            1 => w.write_all(&[0x80u8 | (n as u8)]),
-            2 => w.write_all(&[0x40u8 | ((n >> 8) as u8), n as u8]),
-            3 => w.write_all(&[0x20u8 | ((n >> 16) as u8), (n >> 8) as u8,
+            1 => w.write_all(&[0x80 | (n as u8)]),
+            2 => w.write_all(&[0x40 | ((n >> 8) as u8), n as u8]),
+            3 => w.write_all(&[0x20 | ((n >> 16) as u8), (n >> 8) as u8,
                             n as u8]),
-            4 => w.write_all(&[0x10u8 | ((n >> 24) as u8), (n >> 16) as u8,
+            4 => w.write_all(&[0x10 | ((n >> 24) as u8), (n >> 16) as u8,
                             (n >> 8) as u8, n as u8]),
             _ => Err(old_io::IoError {
                 kind: old_io::OtherIoError,
@@ -930,7 +930,7 @@ pub mod writer {
 
             // Write a placeholder four-byte size.
             self.size_positions.push(try!(self.writer.tell()) as uint);
-            let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8];
+            let zeroes: &[u8] = &[0, 0, 0, 0];
             self.writer.write_all(zeroes)
         }
 
@@ -1422,9 +1422,9 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_A_aligned(b: &mut Bencher) {
-        let data = (0i32..4*100).map(|i| {
+        let data = (0..4*100).map(|i| {
             match i % 2 {
-              0 => 0x80u8,
+              0 => 0x80,
               _ => i as u8,
             }
         }).collect::<Vec<_>>();
@@ -1440,9 +1440,9 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_A_unaligned(b: &mut Bencher) {
-        let data = (0i32..4*100+1).map(|i| {
+        let data = (0..4*100+1).map(|i| {
             match i % 2 {
-              1 => 0x80u8,
+              1 => 0x80,
               _ => i as u8
             }
         }).collect::<Vec<_>>();
@@ -1458,11 +1458,11 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_D_aligned(b: &mut Bencher) {
-        let data = (0i32..4*100).map(|i| {
+        let data = (0..4*100).map(|i| {
             match i % 4 {
-              0 => 0x10u8,
+              0 => 0x10,
               3 => i as u8,
-              _ => 0u8
+              _ => 0
             }
         }).collect::<Vec<_>>();
         let mut sum = 0;
@@ -1477,11 +1477,11 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_D_unaligned(b: &mut Bencher) {
-        let data = (0i32..4*100+1).map(|i| {
+        let data = (0..4*100+1).map(|i| {
             match i % 4 {
-              1 => 0x10u8,
+              1 => 0x10,
               0 => i as u8,
-              _ => 0u8
+              _ => 0
             }
         }).collect::<Vec<_>>();
         let mut sum = 0;
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index ae43738d471..896a0010e7e 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -537,7 +537,7 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
       ast::ExprBlock(ref block) => {
         match block.expr {
             Some(ref expr) => try!(eval_const_expr_partial(tcx, &**expr, ety)),
-            None => const_int(0i64)
+            None => const_int(0)
         }
       }
       ast::ExprTupField(ref base, index) => {
diff --git a/src/librustc/util/lev_distance.rs b/src/librustc/util/lev_distance.rs
index 10a7b2abea8..d3b9b07ea41 100644
--- a/src/librustc/util/lev_distance.rs
+++ b/src/librustc/util/lev_distance.rs
@@ -45,7 +45,7 @@ pub fn lev_distance(me: &str, t: &str) -> uint {
 fn test_lev_distance() {
     use std::char::{ from_u32, MAX };
     // Test bytelength agnosticity
-    for c in (0u32..MAX as u32)
+    for c in (0..MAX as u32)
              .filter_map(|i| from_u32(i))
              .map(|i| i.to_string()) {
         assert_eq!(lev_distance(&c[..], &c[..]), 0);
diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs
index 844920ad5ec..482c710149c 100644
--- a/src/librustc_back/sha2.rs
+++ b/src/librustc_back/sha2.rs
@@ -119,7 +119,7 @@ impl FixedBuffer64 {
     /// Create a new FixedBuffer64
     fn new() -> FixedBuffer64 {
         return FixedBuffer64 {
-            buffer: [0u8; 64],
+            buffer: [0; 64],
             buffer_idx: 0
         };
     }
@@ -258,7 +258,7 @@ pub trait Digest {
     /// Convenience function that retrieves the result of a digest as a
     /// newly allocated vec of bytes.
     fn result_bytes(&mut self) -> Vec<u8> {
-        let mut buf: Vec<u8> = repeat(0u8).take((self.output_bits()+7)/8).collect();
+        let mut buf: Vec<u8> = repeat(0).take((self.output_bits()+7)/8).collect();
         self.result(&mut buf);
         buf
     }
@@ -342,7 +342,7 @@ impl Engine256State {
         let mut g = self.h6;
         let mut h = self.h7;
 
-        let mut w = [0u32; 64];
+        let mut w = [0; 64];
 
         // Sha-512 and Sha-256 use basically the same calculations which are implemented
         // by these macros. Inlining the calculations seems to result in better generated code.
@@ -660,7 +660,7 @@ mod bench {
     #[bench]
     pub fn sha256_10(b: &mut Bencher) {
         let mut sh = Sha256::new();
-        let bytes = [1u8; 10];
+        let bytes = [1; 10];
         b.iter(|| {
             sh.input(&bytes);
         });
@@ -670,7 +670,7 @@ mod bench {
     #[bench]
     pub fn sha256_1k(b: &mut Bencher) {
         let mut sh = Sha256::new();
-        let bytes = [1u8; 1024];
+        let bytes = [1; 1024];
         b.iter(|| {
             sh.input(&bytes);
         });
@@ -680,7 +680,7 @@ mod bench {
     #[bench]
     pub fn sha256_64k(b: &mut Bencher) {
         let mut sh = Sha256::new();
-        let bytes = [1u8; 65536];
+        let bytes = [1; 65536];
         b.iter(|| {
             sh.input(&bytes);
         });
diff --git a/src/librustc_bitflags/lib.rs b/src/librustc_bitflags/lib.rs
index 370a5d48dec..2199beb7a20 100644
--- a/src/librustc_bitflags/lib.rs
+++ b/src/librustc_bitflags/lib.rs
@@ -316,7 +316,7 @@ mod tests {
 
     bitflags! {
         flags AnotherSetOfFlags: i8 {
-            const AnotherFlag = -1_i8,
+            const AnotherFlag = -1,
         }
     }
 
@@ -327,7 +327,7 @@ mod tests {
         assert_eq!(FlagABC.bits(), 0b00000111);
 
         assert_eq!(AnotherSetOfFlags::empty().bits(), 0b00);
-        assert_eq!(AnotherFlag.bits(), !0_i8);
+        assert_eq!(AnotherFlag.bits(), !0);
     }
 
     #[test]
@@ -338,7 +338,7 @@ mod tests {
         assert!(Flags::from_bits(0b11) == Some(FlagA | FlagB));
         assert!(Flags::from_bits(0b1000) == None);
 
-        assert!(AnotherSetOfFlags::from_bits(!0_i8) == Some(AnotherFlag));
+        assert!(AnotherSetOfFlags::from_bits(!0) == Some(AnotherFlag));
     }
 
     #[test]
@@ -350,7 +350,7 @@ mod tests {
         assert!(Flags::from_bits_truncate(0b1000) == Flags::empty());
         assert!(Flags::from_bits_truncate(0b1001) == FlagA);
 
-        assert!(AnotherSetOfFlags::from_bits_truncate(0_i8) == AnotherSetOfFlags::empty());
+        assert!(AnotherSetOfFlags::from_bits_truncate(0) == AnotherSetOfFlags::empty());
     }
 
     #[test]
diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs
index 13f882bc363..8302d0abe21 100644
--- a/src/librustc_trans/trans/base.rs
+++ b/src/librustc_trans/trans/base.rs
@@ -833,11 +833,11 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>(
 
     let (is_zero, is_signed) = match rhs_t.sty {
         ty::ty_int(t) => {
-            let zero = C_integral(Type::int_from_ty(cx.ccx(), t), 0u64, false);
+            let zero = C_integral(Type::int_from_ty(cx.ccx(), t), 0, false);
             (ICmp(cx, llvm::IntEQ, rhs, zero, debug_loc), true)
         }
         ty::ty_uint(t) => {
-            let zero = C_integral(Type::uint_from_ty(cx.ccx(), t), 0u64, false);
+            let zero = C_integral(Type::uint_from_ty(cx.ccx(), t), 0, false);
             (ICmp(cx, llvm::IntEQ, rhs, zero, debug_loc), false)
         }
         _ => {
diff --git a/src/librustc_trans/trans/cabi_aarch64.rs b/src/librustc_trans/trans/cabi_aarch64.rs
index 5d1e6d2c9e8..03496a966bf 100644
--- a/src/librustc_trans/trans/cabi_aarch64.rs
+++ b/src/librustc_trans/trans/cabi_aarch64.rs
@@ -117,7 +117,7 @@ fn classify_arg_ty(ccx: &CrateContext, ty: Type) -> ArgType {
     let size = ty_size(ty);
     if size <= 16 {
         let llty = if size == 0 {
-            Type::array(&Type::i64(ccx), 0u64)
+            Type::array(&Type::i64(ccx), 0)
         } else if size == 1 {
             Type::i8(ccx)
         } else if size == 2 {
diff --git a/src/libserialize/hex.rs b/src/libserialize/hex.rs
index 970ae06763c..6f3d90d45b0 100644
--- a/src/libserialize/hex.rs
+++ b/src/libserialize/hex.rs
@@ -117,7 +117,7 @@ impl FromHex for str {
         // This may be an overestimate if there is any whitespace
         let mut b = Vec::with_capacity(self.len() / 2);
         let mut modulus = 0;
-        let mut buf = 0u8;
+        let mut buf = 0;
 
         for (idx, byte) in self.bytes().enumerate() {
             buf <<= 4;
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index bf4d006fcfa..0d445739b39 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -1653,7 +1653,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
 
     fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
         let mut i = 0;
-        let mut n = 0u16;
+        let mut n = 0;
         while i < 4 && !self.eof() {
             self.bump();
             n = match self.ch_or_null() {
diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index 94457a5d714..8b275d1bc4a 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -186,7 +186,7 @@ impl OwnedAsciiExt for Vec<u8> {
 impl AsciiExt for u8 {
     type Owned = u8;
     #[inline]
-    fn is_ascii(&self) -> bool { *self & 128 == 0u8 }
+    fn is_ascii(&self) -> bool { *self & 128 == 0 }
     #[inline]
     fn to_ascii_uppercase(&self) -> u8 { ASCII_UPPERCASE_MAP[*self as usize] }
     #[inline]
@@ -398,7 +398,7 @@ mod tests {
         assert_eq!("url()URL()uRl()ürl".to_ascii_uppercase(), "URL()URL()URL()üRL");
         assert_eq!("hıKß".to_ascii_uppercase(), "HıKß");
 
-        for i in 0u32..501 {
+        for i in 0..501 {
             let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
                         else { i };
             assert_eq!((from_u32(i).unwrap()).to_string().to_ascii_uppercase(),
@@ -412,7 +412,7 @@ mod tests {
         // Dotted capital I, Kelvin sign, Sharp S.
         assert_eq!("HİKß".to_ascii_lowercase(), "hİKß");
 
-        for i in 0u32..501 {
+        for i in 0..501 {
             let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
                         else { i };
             assert_eq!((from_u32(i).unwrap()).to_string().to_ascii_lowercase(),
@@ -426,7 +426,7 @@ mod tests {
                    "URL()URL()URL()üRL".to_string());
         assert_eq!(("hıKß".to_string()).into_ascii_uppercase(), "HıKß");
 
-        for i in 0u32..501 {
+        for i in 0..501 {
             let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
                         else { i };
             assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_uppercase(),
@@ -441,7 +441,7 @@ mod tests {
         // Dotted capital I, Kelvin sign, Sharp S.
         assert_eq!(("HİKß".to_string()).into_ascii_lowercase(), "hİKß");
 
-        for i in 0u32..501 {
+        for i in 0..501 {
             let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
                         else { i };
             assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_lowercase(),
@@ -459,7 +459,7 @@ mod tests {
         assert!(!"K".eq_ignore_ascii_case("k"));
         assert!(!"ß".eq_ignore_ascii_case("s"));
 
-        for i in 0u32..501 {
+        for i in 0..501 {
             let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
                         else { i };
             assert!((from_u32(i).unwrap()).to_string().eq_ignore_ascii_case(
diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
index 2670cd0c003..69fd0a57d5f 100644
--- a/src/libstd/collections/hash/table.rs
+++ b/src/libstd/collections/hash/table.rs
@@ -28,7 +28,7 @@ use ptr::{self, PtrExt, Unique};
 use rt::heap::{allocate, deallocate, EMPTY};
 use collections::hash_state::HashState;
 
-const EMPTY_BUCKET: u64 = 0u64;
+const EMPTY_BUCKET: u64 = 0;
 
 /// The raw hashtable, providing safe-ish access to the unzipped and highly
 /// optimized arrays of hashes, keys, and values.
@@ -149,7 +149,7 @@ pub fn make_hash<T: ?Sized, S>(hash_state: &S, t: &T) -> SafeHash
 {
     let mut state = hash_state.hasher();
     t.hash(&mut state);
-    // We need to avoid 0u64 in order to prevent collisions with
+    // We need to avoid 0 in order to prevent collisions with
     // EMPTY_HASH. We can maintain our precious uniform distribution
     // of initial indexes by unconditionally setting the MSB,
     // effectively reducing 64-bits hashes to 63 bits.
diff --git a/src/libstd/fs/mod.rs b/src/libstd/fs/mod.rs
index 64ec025a5c4..565c0b13efe 100644
--- a/src/libstd/fs/mod.rs
+++ b/src/libstd/fs/mod.rs
@@ -1053,7 +1053,7 @@ mod tests {
             check!(w.write(msg));
         }
         let files = check!(fs::read_dir(dir));
-        let mut mem = [0u8; 4];
+        let mut mem = [0; 4];
         for f in files {
             let f = f.unwrap().path();
             {
@@ -1083,7 +1083,7 @@ mod tests {
         check!(File::create(&dir2.join("14")));
 
         let files = check!(fs::walk_dir(dir));
-        let mut cur = [0u8; 2];
+        let mut cur = [0; 2];
         for f in files {
             let f = f.unwrap().path();
             let stem = f.file_stem().unwrap().to_str().unwrap();
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 11356099590..3603f127504 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -616,14 +616,14 @@ mod tests {
 
     #[test]
     fn read_char_buffered() {
-        let buf = [195u8, 159u8];
+        let buf = [195, 159];
         let reader = BufReader::with_capacity(1, &buf[..]);
         assert_eq!(reader.chars().next(), Some(Ok('ß')));
     }
 
     #[test]
     fn test_chars() {
-        let buf = [195u8, 159u8, b'a'];
+        let buf = [195, 159, b'a'];
         let reader = BufReader::with_capacity(1, &buf[..]);
         let mut it = reader.chars();
         assert_eq!(it.next(), Some(Ok('ß')));
diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs
index b1779587528..8a841742de4 100644
--- a/src/libstd/io/cursor.rs
+++ b/src/libstd/io/cursor.rs
@@ -237,7 +237,7 @@ mod tests {
 
     #[test]
     fn test_mem_reader() {
-        let mut reader = Cursor::new(vec!(0u8, 1, 2, 3, 4, 5, 6, 7));
+        let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         let mut buf = [];
         assert_eq!(reader.read(&mut buf), Ok(0));
         assert_eq!(reader.position(), 0);
@@ -259,7 +259,7 @@ mod tests {
 
     #[test]
     fn read_to_end() {
-        let mut reader = Cursor::new(vec!(0u8, 1, 2, 3, 4, 5, 6, 7));
+        let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         let mut v = Vec::new();
         reader.read_to_end(&mut v).ok().unwrap();
         assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
@@ -267,7 +267,7 @@ mod tests {
 
     #[test]
     fn test_slice_reader() {
-        let in_buf = vec![0u8, 1, 2, 3, 4, 5, 6, 7];
+        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
         let mut reader = &mut in_buf.as_slice();
         let mut buf = [];
         assert_eq!(reader.read(&mut buf), Ok(0));
@@ -289,7 +289,7 @@ mod tests {
 
     #[test]
     fn test_buf_reader() {
-        let in_buf = vec![0u8, 1, 2, 3, 4, 5, 6, 7];
+        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
         let mut reader = Cursor::new(in_buf.as_slice());
         let mut buf = [];
         assert_eq!(reader.read(&mut buf), Ok(0));
@@ -335,7 +335,7 @@ mod tests {
         assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
         assert_eq!(r.read(&mut [0]), Ok(0));
 
-        let mut r = Cursor::new(vec!(10u8));
+        let mut r = Cursor::new(vec!(10));
         assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
         assert_eq!(r.read(&mut [0]), Ok(0));
 
@@ -347,11 +347,11 @@ mod tests {
 
     #[test]
     fn seek_before_0() {
-        let buf = [0xff_u8];
+        let buf = [0xff];
         let mut r = Cursor::new(&buf[..]);
         assert!(r.seek(SeekFrom::End(-2)).is_err());
 
-        let mut r = Cursor::new(vec!(10u8));
+        let mut r = Cursor::new(vec!(10));
         assert!(r.seek(SeekFrom::End(-2)).is_err());
 
         let mut buf = [0];
diff --git a/src/libstd/net/addr.rs b/src/libstd/net/addr.rs
index f16f501c46a..916abe78eb3 100644
--- a/src/libstd/net/addr.rs
+++ b/src/libstd/net/addr.rs
@@ -562,7 +562,7 @@ mod tests {
     #[test]
     fn to_socket_addr_ipaddr_u16() {
         let a = IpAddr::new_v4(77, 88, 21, 11);
-        let p = 12345u16;
+        let p = 12345;
         let e = SocketAddr::new(a, p);
         assert_eq!(Ok(vec![e]), tsa((a, p)));
     }
@@ -570,13 +570,13 @@ mod tests {
     #[test]
     fn to_socket_addr_str_u16() {
         let a = SocketAddr::new(IpAddr::new_v4(77, 88, 21, 11), 24352);
-        assert_eq!(Ok(vec![a]), tsa(("77.88.21.11", 24352u16)));
+        assert_eq!(Ok(vec![a]), tsa(("77.88.21.11", 24352)));
 
         let a = SocketAddr::new(IpAddr::new_v6(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 53);
         assert_eq!(Ok(vec![a]), tsa(("2a02:6b8:0:1::1", 53)));
 
         let a = SocketAddr::new(IpAddr::new_v4(127, 0, 0, 1), 23924);
-        assert!(tsa(("localhost", 23924u16)).unwrap().contains(&a));
+        assert!(tsa(("localhost", 23924)).unwrap().contains(&a));
     }
 
     #[test]
diff --git a/src/libstd/net/parser.rs b/src/libstd/net/parser.rs
index e82dc88cddd..aa54a432d62 100644
--- a/src/libstd/net/parser.rs
+++ b/src/libstd/net/parser.rs
@@ -136,7 +136,7 @@ impl<'a> Parser<'a> {
     }
 
     fn read_number_impl(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
-        let mut r = 0u32;
+        let mut r = 0;
         let mut digit_count = 0;
         loop {
             match self.read_digit(radix) {
@@ -164,7 +164,7 @@ impl<'a> Parser<'a> {
     }
 
     fn read_ipv4_addr_impl(&mut self) -> Option<Ipv4Addr> {
-        let mut bs = [0u8; 4];
+        let mut bs = [0; 4];
         let mut i = 0;
         while i < 4 {
             if i != 0 && self.read_given_char('.').is_none() {
@@ -189,7 +189,7 @@ impl<'a> Parser<'a> {
     fn read_ipv6_addr_impl(&mut self) -> Option<Ipv6Addr> {
         fn ipv6_addr_from_head_tail(head: &[u16], tail: &[u16]) -> Ipv6Addr {
             assert!(head.len() + tail.len() <= 8);
-            let mut gs = [0u16; 8];
+            let mut gs = [0; 8];
             gs.clone_from_slice(head);
             gs[(8 - tail.len()) .. 8].clone_from_slice(tail);
             Ipv6Addr::new(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
@@ -231,7 +231,7 @@ impl<'a> Parser<'a> {
             (i, false)
         }
 
-        let mut head = [0u16; 8];
+        let mut head = [0; 8];
         let (head_size, head_ipv4) = read_groups(self, &mut head, 8);
 
         if head_size == 8 {
@@ -250,7 +250,7 @@ impl<'a> Parser<'a> {
             return None;
         }
 
-        let mut tail = [0u16; 8];
+        let mut tail = [0; 8];
         let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
         Some(ipv6_addr_from_head_tail(&head[..head_size], &tail[..tail_size]))
     }
diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs
index 7d15a16309e..093cde55bbb 100644
--- a/src/libstd/num/f32.rs
+++ b/src/libstd/num/f32.rs
@@ -824,14 +824,14 @@ mod tests {
 
     #[test]
     fn test_integer_decode() {
-        assert_eq!(3.14159265359f32.integer_decode(), (13176795u64, -22i16, 1i8));
-        assert_eq!((-8573.5918555f32).integer_decode(), (8779358u64, -10i16, -1i8));
-        assert_eq!(2f32.powf(100.0).integer_decode(), (8388608u64, 77i16, 1i8));
-        assert_eq!(0f32.integer_decode(), (0u64, -150i16, 1i8));
-        assert_eq!((-0f32).integer_decode(), (0u64, -150i16, -1i8));
-        assert_eq!(INFINITY.integer_decode(), (8388608u64, 105i16, 1i8));
-        assert_eq!(NEG_INFINITY.integer_decode(), (8388608u64, 105i16, -1i8));
-        assert_eq!(NAN.integer_decode(), (12582912u64, 105i16, 1i8));
+        assert_eq!(3.14159265359f32.integer_decode(), (13176795, -22, 1));
+        assert_eq!((-8573.5918555f32).integer_decode(), (8779358, -10, -1));
+        assert_eq!(2f32.powf(100.0).integer_decode(), (8388608, 77, 1));
+        assert_eq!(0f32.integer_decode(), (0, -150, 1));
+        assert_eq!((-0f32).integer_decode(), (0, -150, -1));
+        assert_eq!(INFINITY.integer_decode(), (8388608, 105, 1));
+        assert_eq!(NEG_INFINITY.integer_decode(), (8388608, 105, -1));
+        assert_eq!(NAN.integer_decode(), (12582912, 105, 1));
     }
 
     #[test]
diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs
index 0ce56371c77..a7bdad70a36 100644
--- a/src/libstd/num/f64.rs
+++ b/src/libstd/num/f64.rs
@@ -826,14 +826,14 @@ mod tests {
 
     #[test]
     fn test_integer_decode() {
-        assert_eq!(3.14159265359f64.integer_decode(), (7074237752028906u64, -51i16, 1i8));
-        assert_eq!((-8573.5918555f64).integer_decode(), (4713381968463931u64, -39i16, -1i8));
-        assert_eq!(2f64.powf(100.0).integer_decode(), (4503599627370496u64, 48i16, 1i8));
-        assert_eq!(0f64.integer_decode(), (0u64, -1075i16, 1i8));
-        assert_eq!((-0f64).integer_decode(), (0u64, -1075i16, -1i8));
-        assert_eq!(INFINITY.integer_decode(), (4503599627370496u64, 972i16, 1i8));
+        assert_eq!(3.14159265359f64.integer_decode(), (7074237752028906, -51, 1));
+        assert_eq!((-8573.5918555f64).integer_decode(), (4713381968463931, -39, -1));
+        assert_eq!(2f64.powf(100.0).integer_decode(), (4503599627370496, 48, 1));
+        assert_eq!(0f64.integer_decode(), (0, -1075, 1));
+        assert_eq!((-0f64).integer_decode(), (0, -1075, -1));
+        assert_eq!(INFINITY.integer_decode(), (4503599627370496, 972, 1));
         assert_eq!(NEG_INFINITY.integer_decode(), (4503599627370496, 972, -1));
-        assert_eq!(NAN.integer_decode(), (6755399441055744u64, 972i16, 1i8));
+        assert_eq!(NAN.integer_decode(), (6755399441055744, 972, 1));
     }
 
     #[test]
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index 0bca60ed1a0..9458ed1d353 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -312,7 +312,7 @@ pub trait Float
     ///
     /// let num = 2.0f32;
     ///
-    /// // (8388608u64, -22i16, 1i8)
+    /// // (8388608, -22, 1)
     /// let (mantissa, exponent, sign) = num.integer_decode();
     /// let sign_f = sign as f32;
     /// let mantissa_f = mantissa as f32;
@@ -1755,25 +1755,25 @@ mod tests {
 
     #[test]
     fn test_uint_to_str_overflow() {
-        let mut u8_val: u8 = 255_u8;
+        let mut u8_val: u8 = 255;
         assert_eq!(u8_val.to_string(), "255");
 
         u8_val = u8_val.wrapping_add(1);
         assert_eq!(u8_val.to_string(), "0");
 
-        let mut u16_val: u16 = 65_535_u16;
+        let mut u16_val: u16 = 65_535;
         assert_eq!(u16_val.to_string(), "65535");
 
         u16_val = u16_val.wrapping_add(1);
         assert_eq!(u16_val.to_string(), "0");
 
-        let mut u32_val: u32 = 4_294_967_295_u32;
+        let mut u32_val: u32 = 4_294_967_295;
         assert_eq!(u32_val.to_string(), "4294967295");
 
         u32_val = u32_val.wrapping_add(1);
         assert_eq!(u32_val.to_string(), "0");
 
-        let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
+        let mut u64_val: u64 = 18_446_744_073_709_551_615;
         assert_eq!(u64_val.to_string(), "18446744073709551615");
 
         u64_val = u64_val.wrapping_add(1);
@@ -1786,7 +1786,7 @@ mod tests {
 
     #[test]
     fn test_uint_from_str_overflow() {
-        let mut u8_val: u8 = 255_u8;
+        let mut u8_val: u8 = 255;
         assert_eq!(from_str::<u8>("255"), Some(u8_val));
         assert_eq!(from_str::<u8>("256"), None);
 
@@ -1794,7 +1794,7 @@ mod tests {
         assert_eq!(from_str::<u8>("0"), Some(u8_val));
         assert_eq!(from_str::<u8>("-1"), None);
 
-        let mut u16_val: u16 = 65_535_u16;
+        let mut u16_val: u16 = 65_535;
         assert_eq!(from_str::<u16>("65535"), Some(u16_val));
         assert_eq!(from_str::<u16>("65536"), None);
 
@@ -1802,7 +1802,7 @@ mod tests {
         assert_eq!(from_str::<u16>("0"), Some(u16_val));
         assert_eq!(from_str::<u16>("-1"), None);
 
-        let mut u32_val: u32 = 4_294_967_295_u32;
+        let mut u32_val: u32 = 4_294_967_295;
         assert_eq!(from_str::<u32>("4294967295"), Some(u32_val));
         assert_eq!(from_str::<u32>("4294967296"), None);
 
@@ -1810,7 +1810,7 @@ mod tests {
         assert_eq!(from_str::<u32>("0"), Some(u32_val));
         assert_eq!(from_str::<u32>("-1"), None);
 
-        let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
+        let mut u64_val: u64 = 18_446_744_073_709_551_615;
         assert_eq!(from_str::<u64>("18446744073709551615"), Some(u64_val));
         assert_eq!(from_str::<u64>("18446744073709551616"), None);
 
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index b38c52dad1a..5fdd42dbc7a 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -104,7 +104,7 @@ fn int_to_str_bytes_common<T, F>(num: T, radix: uint, sign: SignFormat, mut f: F
     // This is just for integral types, the largest of which is a u64. The
     // smallest base that we can have is 2, so the most number of digits we're
     // ever going to have is 64
-    let mut buf = [0u8; 64];
+    let mut buf = [0; 64];
     let mut cur = 0;
 
     // Loop at least once to make sure at least a `0` gets emitted.
@@ -221,10 +221,10 @@ pub fn float_to_str_bytes_common<T: Float>(
     let radix_gen: T = num::cast(radix as int).unwrap();
 
     let (num, exp) = match exp_format {
-        ExpNone => (num, 0i32),
+        ExpNone => (num, 0),
         ExpDec | ExpBin => {
             if num == _0 {
-                (num, 0i32)
+                (num, 0)
             } else {
                 let (exp, exp_base) = match exp_format {
                     ExpDec => (num.abs().log10().floor(), num::cast::<f64, T>(10.0f64).unwrap()),
@@ -432,25 +432,25 @@ mod tests {
 
     #[test]
     fn test_int_to_str_overflow() {
-        let mut i8_val: i8 = 127_i8;
+        let mut i8_val: i8 = 127;
         assert_eq!(i8_val.to_string(), "127");
 
         i8_val = i8_val.wrapping_add(1);
         assert_eq!(i8_val.to_string(), "-128");
 
-        let mut i16_val: i16 = 32_767_i16;
+        let mut i16_val: i16 = 32_767;
         assert_eq!(i16_val.to_string(), "32767");
 
         i16_val = i16_val.wrapping_add(1);
         assert_eq!(i16_val.to_string(), "-32768");
 
-        let mut i32_val: i32 = 2_147_483_647_i32;
+        let mut i32_val: i32 = 2_147_483_647;
         assert_eq!(i32_val.to_string(), "2147483647");
 
         i32_val = i32_val.wrapping_add(1);
         assert_eq!(i32_val.to_string(), "-2147483648");
 
-        let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
+        let mut i64_val: i64 = 9_223_372_036_854_775_807;
         assert_eq!(i64_val.to_string(), "9223372036854775807");
 
         i64_val = i64_val.wrapping_add(1);
diff --git a/src/libstd/old_io/buffered.rs b/src/libstd/old_io/buffered.rs
index 2d2d0d8b33a..fe2510b668f 100644
--- a/src/libstd/old_io/buffered.rs
+++ b/src/libstd/old_io/buffered.rs
@@ -642,14 +642,14 @@ mod test {
 
     #[test]
     fn read_char_buffered() {
-        let buf = [195u8, 159u8];
+        let buf = [195, 159];
         let mut reader = BufferedReader::with_capacity(1, &buf[..]);
         assert_eq!(reader.read_char(), Ok('ß'));
     }
 
     #[test]
     fn test_chars() {
-        let buf = [195u8, 159u8, b'a'];
+        let buf = [195, 159, b'a'];
         let mut reader = BufferedReader::with_capacity(1, &buf[..]);
         let mut it = reader.chars();
         assert_eq!(it.next(), Some(Ok('ß')));
diff --git a/src/libstd/old_io/comm_adapters.rs b/src/libstd/old_io/comm_adapters.rs
index 207d3d39167..dec1ae98ba0 100644
--- a/src/libstd/old_io/comm_adapters.rs
+++ b/src/libstd/old_io/comm_adapters.rs
@@ -30,7 +30,7 @@ use vec::Vec;
 /// # drop(tx);
 /// let mut reader = ChanReader::new(rx);
 ///
-/// let mut buf = [0u8; 100];
+/// let mut buf = [0; 100];
 /// match reader.read(&mut buf) {
 ///     Ok(nread) => println!("Read {} bytes", nread),
 ///     Err(e) => println!("read error: {}", e),
@@ -167,15 +167,15 @@ mod test {
     fn test_rx_reader() {
         let (tx, rx) = channel();
         thread::spawn(move|| {
-          tx.send(vec![1u8, 2u8]).unwrap();
+          tx.send(vec![1, 2]).unwrap();
           tx.send(vec![]).unwrap();
-          tx.send(vec![3u8, 4u8]).unwrap();
-          tx.send(vec![5u8, 6u8]).unwrap();
-          tx.send(vec![7u8, 8u8]).unwrap();
+          tx.send(vec![3, 4]).unwrap();
+          tx.send(vec![5, 6]).unwrap();
+          tx.send(vec![7, 8]).unwrap();
         });
 
         let mut reader = ChanReader::new(rx);
-        let mut buf = [0u8; 3];
+        let mut buf = [0; 3];
 
         assert_eq!(Ok(0), reader.read(&mut []));
 
@@ -233,7 +233,7 @@ mod test {
         let mut writer = ChanWriter::new(tx);
         writer.write_be_u32(42).unwrap();
 
-        let wanted = vec![0u8, 0u8, 0u8, 42u8];
+        let wanted = vec![0, 0, 0, 42];
         let got = thread::scoped(move|| { rx.recv().unwrap() }).join();
         assert_eq!(wanted, got);
 
diff --git a/src/libstd/old_io/extensions.rs b/src/libstd/old_io/extensions.rs
index 45a86a9fde7..a2bc28962c3 100644
--- a/src/libstd/old_io/extensions.rs
+++ b/src/libstd/old_io/extensions.rs
@@ -101,7 +101,7 @@ pub fn u64_to_le_bytes<T, F>(n: u64, size: uint, f: F) -> T where
         let mut i = size;
         let mut n = n;
         while i > 0 {
-            bytes.push((n & 255_u64) as u8);
+            bytes.push((n & 255) as u8);
             n >>= 8;
             i -= 1;
         }
@@ -170,7 +170,7 @@ pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
         panic!("index out of bounds");
     }
 
-    let mut buf = [0u8; 8];
+    let mut buf = [0; 8];
     unsafe {
         let ptr = data.as_ptr().offset(start as int);
         let out = buf.as_mut_ptr();
@@ -522,8 +522,8 @@ mod bench {
         ({
             use super::u64_from_be_bytes;
 
-            let data = (0u8..$stride*100+$start_index).collect::<Vec<_>>();
-            let mut sum = 0u64;
+            let data = (0..$stride*100+$start_index).collect::<Vec<_>>();
+            let mut sum = 0;
             $b.iter(|| {
                 let mut i = $start_index;
                 while i < data.len() {
diff --git a/src/libstd/old_io/fs.rs b/src/libstd/old_io/fs.rs
index 9a34ec4b026..afffed2278b 100644
--- a/src/libstd/old_io/fs.rs
+++ b/src/libstd/old_io/fs.rs
@@ -1166,7 +1166,7 @@ mod test {
             check!(w.write(msg));
         }
         let files = check!(readdir(dir));
-        let mut mem = [0u8; 4];
+        let mut mem = [0; 4];
         for f in &files {
             {
                 let n = f.filestem_str();
@@ -1198,7 +1198,7 @@ mod test {
         check!(File::create(&dir2.join("14")));
 
         let mut files = check!(walk_dir(dir));
-        let mut cur = [0u8; 2];
+        let mut cur = [0; 2];
         for f in files {
             let stem = f.filestem_str().unwrap();
             let root = stem.as_bytes()[0] - b'0';
diff --git a/src/libstd/old_io/mod.rs b/src/libstd/old_io/mod.rs
index 728a5dac4e4..9ce888efceb 100644
--- a/src/libstd/old_io/mod.rs
+++ b/src/libstd/old_io/mod.rs
@@ -670,7 +670,7 @@ pub trait Reader {
     fn read_le_uint_n(&mut self, nbytes: uint) -> IoResult<u64> {
         assert!(nbytes > 0 && nbytes <= 8);
 
-        let mut val = 0u64;
+        let mut val = 0;
         let mut pos = 0;
         let mut i = nbytes;
         while i > 0 {
@@ -694,7 +694,7 @@ pub trait Reader {
     fn read_be_uint_n(&mut self, nbytes: uint) -> IoResult<u64> {
         assert!(nbytes > 0 && nbytes <= 8);
 
-        let mut val = 0u64;
+        let mut val = 0;
         let mut i = nbytes;
         while i > 0 {
             i -= 1;
@@ -1078,7 +1078,7 @@ pub trait Writer {
     /// Write a single char, encoded as UTF-8.
     #[inline]
     fn write_char(&mut self, c: char) -> IoResult<()> {
-        let mut buf = [0u8; 4];
+        let mut buf = [0; 4];
         let n = c.encode_utf8(&mut buf).unwrap_or(0);
         self.write_all(&buf[..n])
     }
@@ -1896,7 +1896,7 @@ mod tests {
     fn test_read_at_least() {
         let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
                                    vec![GoodBehavior(usize::MAX)]);
-        let buf = &mut [0u8; 5];
+        let buf = &mut [0; 5];
         assert!(r.read_at_least(1, buf).unwrap() >= 1);
         assert!(r.read_exact(5).unwrap().len() == 5); // read_exact uses read_at_least
         assert!(r.read_at_least(0, buf).is_ok());
diff --git a/src/libstd/old_io/net/ip.rs b/src/libstd/old_io/net/ip.rs
index f1634cd4229..6e2f491262d 100644
--- a/src/libstd/old_io/net/ip.rs
+++ b/src/libstd/old_io/net/ip.rs
@@ -198,7 +198,7 @@ impl<'a> Parser<'a> {
     }
 
     fn read_number_impl(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
-        let mut r = 0u32;
+        let mut r = 0;
         let mut digit_count = 0;
         loop {
             match self.read_digit(radix) {
@@ -226,7 +226,7 @@ impl<'a> Parser<'a> {
     }
 
     fn read_ipv4_addr_impl(&mut self) -> Option<IpAddr> {
-        let mut bs = [0u8; 4];
+        let mut bs = [0; 4];
         let mut i = 0;
         while i < 4 {
             if i != 0 && self.read_given_char('.').is_none() {
@@ -251,7 +251,7 @@ impl<'a> Parser<'a> {
     fn read_ipv6_addr_impl(&mut self) -> Option<IpAddr> {
         fn ipv6_addr_from_head_tail(head: &[u16], tail: &[u16]) -> IpAddr {
             assert!(head.len() + tail.len() <= 8);
-            let mut gs = [0u16; 8];
+            let mut gs = [0; 8];
             gs.clone_from_slice(head);
             gs[(8 - tail.len()) .. 8].clone_from_slice(tail);
             Ipv6Addr(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
@@ -294,7 +294,7 @@ impl<'a> Parser<'a> {
             (i, false)
         }
 
-        let mut head = [0u16; 8];
+        let mut head = [0; 8];
         let (head_size, head_ipv4) = read_groups(self, &mut head, 8);
 
         if head_size == 8 {
@@ -313,7 +313,7 @@ impl<'a> Parser<'a> {
             return None;
         }
 
-        let mut tail = [0u16; 8];
+        let mut tail = [0; 8];
         let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
         Some(ipv6_addr_from_head_tail(&head[..head_size], &tail[..tail_size]))
     }
@@ -425,17 +425,17 @@ pub struct ParseError;
 ///     // The following lines are equivalent modulo possible "localhost" name resolution
 ///     // differences
 ///     let tcp_s = TcpStream::connect(SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 12345 });
-///     let tcp_s = TcpStream::connect((Ipv4Addr(127, 0, 0, 1), 12345u16));
-///     let tcp_s = TcpStream::connect(("127.0.0.1", 12345u16));
-///     let tcp_s = TcpStream::connect(("localhost", 12345u16));
+///     let tcp_s = TcpStream::connect((Ipv4Addr(127, 0, 0, 1), 12345));
+///     let tcp_s = TcpStream::connect(("127.0.0.1", 12345));
+///     let tcp_s = TcpStream::connect(("localhost", 12345));
 ///     let tcp_s = TcpStream::connect("127.0.0.1:12345");
 ///     let tcp_s = TcpStream::connect("localhost:12345");
 ///
 ///     // TcpListener::bind(), UdpSocket::bind() and UdpSocket::send_to() behave similarly
 ///     let tcp_l = TcpListener::bind("localhost:12345");
 ///
-///     let mut udp_s = UdpSocket::bind(("127.0.0.1", 23451u16)).unwrap();
-///     udp_s.send_to([7u8, 7u8, 7u8].as_slice(), (Ipv4Addr(127, 0, 0, 1), 23451u16));
+///     let mut udp_s = UdpSocket::bind(("127.0.0.1", 23451)).unwrap();
+///     udp_s.send_to([7, 7, 7].as_slice(), (Ipv4Addr(127, 0, 0, 1), 23451));
 /// }
 /// ```
 pub trait ToSocketAddr {
@@ -674,7 +674,7 @@ mod test {
     #[test]
     fn to_socket_addr_ipaddr_u16() {
         let a = Ipv4Addr(77, 88, 21, 11);
-        let p = 12345u16;
+        let p = 12345;
         let e = SocketAddr { ip: a, port: p };
         assert_eq!(Ok(e), (a, p).to_socket_addr());
         assert_eq!(Ok(vec![e]), (a, p).to_socket_addr_all());
@@ -683,15 +683,15 @@ mod test {
     #[test]
     fn to_socket_addr_str_u16() {
         let a = SocketAddr { ip: Ipv4Addr(77, 88, 21, 11), port: 24352 };
-        assert_eq!(Ok(a), ("77.88.21.11", 24352u16).to_socket_addr());
-        assert_eq!(Ok(vec![a]), ("77.88.21.11", 24352u16).to_socket_addr_all());
+        assert_eq!(Ok(a), ("77.88.21.11", 24352).to_socket_addr());
+        assert_eq!(Ok(vec![a]), ("77.88.21.11", 24352).to_socket_addr_all());
 
         let a = SocketAddr { ip: Ipv6Addr(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), port: 53 };
         assert_eq!(Ok(a), ("2a02:6b8:0:1::1", 53).to_socket_addr());
         assert_eq!(Ok(vec![a]), ("2a02:6b8:0:1::1", 53).to_socket_addr_all());
 
         let a = SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 23924 };
-        assert!(("localhost", 23924u16).to_socket_addr_all().unwrap().contains(&a));
+        assert!(("localhost", 23924).to_socket_addr_all().unwrap().contains(&a));
     }
 
     #[test]
diff --git a/src/libstd/old_io/net/tcp.rs b/src/libstd/old_io/net/tcp.rs
index 19a6f6e3def..73ef21fa3aa 100644
--- a/src/libstd/old_io/net/tcp.rs
+++ b/src/libstd/old_io/net/tcp.rs
@@ -1162,7 +1162,7 @@ mod test {
                 tx.send(TcpStream::connect(addr).unwrap()).unwrap();
             });
             let _l = rx.recv().unwrap();
-            for i in 0i32..1001 {
+            for i in 0..1001 {
                 match a.accept() {
                     Ok(..) => break,
                     Err(ref e) if e.kind == TimedOut => {}
@@ -1262,7 +1262,7 @@ mod test {
         assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         s.set_timeout(Some(20));
-        for i in 0i32..1001 {
+        for i in 0..1001 {
             match s.write(&[0; 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
@@ -1320,7 +1320,7 @@ mod test {
 
         let mut s = a.accept().unwrap();
         s.set_write_timeout(Some(20));
-        for i in 0i32..1001 {
+        for i in 0..1001 {
             match s.write(&[0; 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
diff --git a/src/libstd/old_io/test.rs b/src/libstd/old_io/test.rs
index 43c0b9268a2..9fbdac84a80 100644
--- a/src/libstd/old_io/test.rs
+++ b/src/libstd/old_io/test.rs
@@ -73,8 +73,8 @@ it is running in and assigns a port range based on it.
 */
 fn base_port() -> u16 {
 
-    let base = 9600u16;
-    let range = 1000u16;
+    let base = 9600;
+    let range = 1000;
 
     let bases = [
         ("32-opt", base + range * 1),
diff --git a/src/libstd/old_io/util.rs b/src/libstd/old_io/util.rs
index 8e49335ed54..5283b28e20d 100644
--- a/src/libstd/old_io/util.rs
+++ b/src/libstd/old_io/util.rs
@@ -418,7 +418,7 @@ mod test {
 
     #[test]
     fn test_iter_reader() {
-        let mut r = IterReader::new(0u8..8);
+        let mut r = IterReader::new(0..8);
         let mut buf = [0, 0, 0];
         let len = r.read(&mut buf).unwrap();
         assert_eq!(len, 3);
@@ -437,7 +437,7 @@ mod test {
 
     #[test]
     fn iter_reader_zero_length() {
-        let mut r = IterReader::new(0u8..8);
+        let mut r = IterReader::new(0..8);
         let mut buf = [];
         assert_eq!(Ok(0), r.read(&mut buf));
     }
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index a49db012882..4ed1520ed03 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -468,7 +468,7 @@ mod test {
         let lengths = [0, 1, 2, 3, 4, 5, 6, 7,
                        80, 81, 82, 83, 84, 85, 86, 87];
         for &n in &lengths {
-            let mut v = repeat(0u8).take(n).collect::<Vec<_>>();
+            let mut v = repeat(0).take(n).collect::<Vec<_>>();
             r.fill_bytes(&mut v);
 
             // use this to get nicer error messages.
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index c2ead267578..6cb3eb4d16e 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -80,13 +80,13 @@ mod imp {
     }
 
     fn getrandom_next_u32() -> u32 {
-        let mut buf: [u8; 4] = [0u8; 4];
+        let mut buf: [u8; 4] = [0; 4];
         getrandom_fill_bytes(&mut buf);
         unsafe { mem::transmute::<[u8; 4], u32>(buf) }
     }
 
     fn getrandom_next_u64() -> u64 {
-        let mut buf: [u8; 8] = [0u8; 8];
+        let mut buf: [u8; 8] = [0; 8];
         getrandom_fill_bytes(&mut buf);
         unsafe { mem::transmute::<[u8; 8], u64>(buf) }
     }
@@ -231,12 +231,12 @@ mod imp {
 
     impl Rng for OsRng {
         fn next_u32(&mut self) -> u32 {
-            let mut v = [0u8; 4];
+            let mut v = [0; 4];
             self.fill_bytes(&mut v);
             unsafe { mem::transmute(v) }
         }
         fn next_u64(&mut self) -> u64 {
-            let mut v = [0u8; 8];
+            let mut v = [0; 8];
             self.fill_bytes(&mut v);
             unsafe { mem::transmute(v) }
         }
@@ -318,12 +318,12 @@ mod imp {
 
     impl Rng for OsRng {
         fn next_u32(&mut self) -> u32 {
-            let mut v = [0u8; 4];
+            let mut v = [0; 4];
             self.fill_bytes(&mut v);
             unsafe { mem::transmute(v) }
         }
         fn next_u64(&mut self) -> u64 {
-            let mut v = [0u8; 8];
+            let mut v = [0; 8];
             self.fill_bytes(&mut v);
             unsafe { mem::transmute(v) }
         }
@@ -366,7 +366,7 @@ mod test {
         r.next_u32();
         r.next_u64();
 
-        let mut v = [0u8; 1000];
+        let mut v = [0; 1000];
         r.fill_bytes(&mut v);
     }
 
@@ -386,7 +386,7 @@ mod test {
                 // as possible (XXX: is this a good test?)
                 let mut r = OsRng::new().unwrap();
                 thread::yield_now();
-                let mut v = [0u8; 1000];
+                let mut v = [0; 1000];
 
                 for _ in 0..100 {
                     r.next_u32();
diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs
index b71e8b4fd61..ba1ebc2ab22 100644
--- a/src/libstd/rand/reader.rs
+++ b/src/libstd/rand/reader.rs
@@ -84,28 +84,28 @@ mod test {
     #[test]
     fn test_reader_rng_u64() {
         // transmute from the target to avoid endianness concerns.
-        let v = vec![0u8, 0, 0, 0, 0, 0, 0, 1,
+        let v = vec![0, 0, 0, 0, 0, 0, 0, 1,
                      0  , 0, 0, 0, 0, 0, 0, 2,
                      0,   0, 0, 0, 0, 0, 0, 3];
         let mut rng = ReaderRng::new(MemReader::new(v));
 
-        assert_eq!(rng.next_u64(), 1_u64.to_be());
-        assert_eq!(rng.next_u64(), 2_u64.to_be());
-        assert_eq!(rng.next_u64(), 3_u64.to_be());
+        assert_eq!(rng.next_u64(), 1.to_be());
+        assert_eq!(rng.next_u64(), 2.to_be());
+        assert_eq!(rng.next_u64(), 3.to_be());
     }
     #[test]
     fn test_reader_rng_u32() {
-        let v = vec![0u8, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3];
+        let v = vec![0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3];
         let mut rng = ReaderRng::new(MemReader::new(v));
 
-        assert_eq!(rng.next_u32(), 1_u32.to_be());
-        assert_eq!(rng.next_u32(), 2_u32.to_be());
-        assert_eq!(rng.next_u32(), 3_u32.to_be());
+        assert_eq!(rng.next_u32(), 1.to_be());
+        assert_eq!(rng.next_u32(), 2.to_be());
+        assert_eq!(rng.next_u32(), 3.to_be());
     }
     #[test]
     fn test_reader_rng_fill_bytes() {
-        let v = [1u8, 2, 3, 4, 5, 6, 7, 8];
-        let mut w = [0u8; 8];
+        let v = [1, 2, 3, 4, 5, 6, 7, 8];
+        let mut w = [0; 8];
 
         let mut rng = ReaderRng::new(MemReader::new(v.to_vec()));
         rng.fill_bytes(&mut w);
@@ -117,7 +117,7 @@ mod test {
     #[should_fail]
     fn test_reader_rng_insufficient_bytes() {
         let mut rng = ReaderRng::new(MemReader::new(vec!()));
-        let mut v = [0u8; 3];
+        let mut v = [0; 3];
         rng.fill_bytes(&mut v);
     }
 }
diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs
index a304f1f844d..dc557403153 100644
--- a/src/libstd/rt/util.rs
+++ b/src/libstd/rt/util.rs
@@ -139,7 +139,7 @@ pub fn abort(args: fmt::Arguments) -> ! {
     }
 
     // Convert the arguments into a stack-allocated string
-    let mut msg = [0u8; 512];
+    let mut msg = [0; 512];
     let mut w = BufWriter { buf: &mut msg, pos: 0 };
     let _ = write!(&mut w, "{}", args);
     let msg = str::from_utf8(&w.buf[..w.pos]).unwrap_or("aborted");
diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs
index 31bdaee1e34..719c74179ac 100644
--- a/src/libstd/sys/common/wtf8.rs
+++ b/src/libstd/sys/common/wtf8.rs
@@ -714,7 +714,7 @@ pub fn is_code_point_boundary(slice: &Wtf8, index: uint) -> bool {
     if index == slice.len() { return true; }
     match slice.bytes.get(index) {
         None => false,
-        Some(&b) => b < 128u8 || b >= 192u8,
+        Some(&b) => b < 128 || b >= 192,
     }
 }
 
@@ -776,7 +776,7 @@ impl<'a> Iterator for EncodeWide<'a> {
             return Some(tmp);
         }
 
-        let mut buf = [0u16; 2];
+        let mut buf = [0; 2];
         self.code_points.next().map(|code_point| {
             let n = encode_utf16_raw(code_point.value, &mut buf)
                 .unwrap_or(0);
diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs
index 71b6214460f..3d490380bfd 100644
--- a/src/libstd/sys/unix/fs.rs
+++ b/src/libstd/sys/unix/fs.rs
@@ -389,7 +389,7 @@ mod tests {
         let mut writer = FileDesc::new(writer, true);
 
         writer.write(b"test").ok().unwrap();
-        let mut buf = [0u8; 4];
+        let mut buf = [0; 4];
         match reader.read(&mut buf) {
             Ok(4) => {
                 assert_eq!(buf[0], 't' as u8);
diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs
index 9be77e78ed1..0ce3ca1f97a 100644
--- a/src/libstd/thread.rs
+++ b/src/libstd/thread.rs
@@ -901,7 +901,7 @@ mod test {
                 assert!(e.is::<T>());
                 let any = e.downcast::<T>().ok().unwrap();
                 assert!(any.is::<u16>());
-                assert_eq!(*any.downcast::<u16>().ok().unwrap(), 413u16);
+                assert_eq!(*any.downcast::<u16>().ok().unwrap(), 413);
             }
             Ok(()) => panic!()
         }
diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs
index 988b13cd160..41b70889c9f 100644
--- a/src/libstd/tuple.rs
+++ b/src/libstd/tuple.rs
@@ -53,7 +53,7 @@
 //! assert!(b == c);
 //!
 //! let d : (u32, f32) = Default::default();
-//! assert_eq!(d, (0u32, 0.0f32));
+//! assert_eq!(d, (0, 0.0f32));
 //! ```
 
 #![doc(primitive = "tuple")]
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 264e05f5c8d..26d7562cdb2 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -159,10 +159,10 @@ pub fn int_ty_to_string(t: IntTy, val: Option<i64>) -> String {
 
 pub fn int_ty_max(t: IntTy) -> u64 {
     match t {
-        TyI8 => 0x80u64,
-        TyI16 => 0x8000u64,
-        TyIs(_) | TyI32 => 0x80000000u64, // actually ni about TyIs
-        TyI64 => 0x8000000000000000u64
+        TyI8 => 0x80,
+        TyI16 => 0x8000,
+        TyIs(_) | TyI32 => 0x80000000, // actually ni about TyIs
+        TyI64 => 0x8000000000000000
     }
 }
 
@@ -185,10 +185,10 @@ pub fn uint_ty_to_string(t: UintTy, val: Option<u64>) -> String {
 
 pub fn uint_ty_max(t: UintTy) -> u64 {
     match t {
-        TyU8 => 0xffu64,
-        TyU16 => 0xffffu64,
-        TyUs(_) | TyU32 => 0xffffffffu64, // actually ni about TyUs
-        TyU64 => 0xffffffffffffffffu64
+        TyU8 => 0xff,
+        TyU16 => 0xffff,
+        TyUs(_) | TyU32 => 0xffffffff, // actually ni about TyUs
+        TyU64 => 0xffffffffffffffff
     }
 }
 
diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs
index ba9860ee31f..d3f23196817 100644
--- a/src/libterm/lib.rs
+++ b/src/libterm/lib.rs
@@ -154,23 +154,23 @@ pub mod color {
     /// Number for a terminal color
     pub type Color = u16;
 
-    pub const BLACK:   Color = 0u16;
-    pub const RED:     Color = 1u16;
-    pub const GREEN:   Color = 2u16;
-    pub const YELLOW:  Color = 3u16;
-    pub const BLUE:    Color = 4u16;
-    pub const MAGENTA: Color = 5u16;
-    pub const CYAN:    Color = 6u16;
-    pub const WHITE:   Color = 7u16;
+    pub const BLACK:   Color = 0;
+    pub const RED:     Color = 1;
+    pub const GREEN:   Color = 2;
+    pub const YELLOW:  Color = 3;
+    pub const BLUE:    Color = 4;
+    pub const MAGENTA: Color = 5;
+    pub const CYAN:    Color = 6;
+    pub const WHITE:   Color = 7;
 
-    pub const BRIGHT_BLACK:   Color = 8u16;
-    pub const BRIGHT_RED:     Color = 9u16;
-    pub const BRIGHT_GREEN:   Color = 10u16;
-    pub const BRIGHT_YELLOW:  Color = 11u16;
-    pub const BRIGHT_BLUE:    Color = 12u16;
-    pub const BRIGHT_MAGENTA: Color = 13u16;
-    pub const BRIGHT_CYAN:    Color = 14u16;
-    pub const BRIGHT_WHITE:   Color = 15u16;
+    pub const BRIGHT_BLACK:   Color = 8;
+    pub const BRIGHT_RED:     Color = 9;
+    pub const BRIGHT_GREEN:   Color = 10;
+    pub const BRIGHT_YELLOW:  Color = 11;
+    pub const BRIGHT_BLUE:    Color = 12;
+    pub const BRIGHT_MAGENTA: Color = 13;
+    pub const BRIGHT_CYAN:    Color = 14;
+    pub const BRIGHT_WHITE:   Color = 15;
 }
 
 /// Terminal attributes
diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs
index 112525fcce9..30b732781db 100644
--- a/src/libterm/terminfo/parm.rs
+++ b/src/libterm/terminfo/parm.rs
@@ -128,7 +128,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
                             // if c is 0, use 0200 (128) for ncurses compatibility
                             Number(c) => {
                                 output.push(if c == 0 {
-                                    128u8
+                                    128
                                 } else {
                                     c as u8
                                 })
@@ -647,7 +647,7 @@ mod test {
 
     #[test]
     fn test_comparison_ops() {
-        let v = [('<', [1u8, 0u8, 0u8]), ('=', [0u8, 1u8, 0u8]), ('>', [0u8, 0u8, 1u8])];
+        let v = [('<', [1, 0, 0]), ('=', [0, 1, 0]), ('>', [0, 0, 1])];
         for &(op, bs) in &v {
             let s = format!("%{{1}}%{{2}}%{}%d", op);
             let res = expand(s.as_bytes(), &[], &mut Variables::new());
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
index e309e7a6c22..a855d80f42a 100644
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@@ -1024,7 +1024,7 @@ impl Bencher {
     pub fn iter<T, F>(&mut self, mut inner: F) where F: FnMut() -> T {
         self.dur = Duration::span(|| {
             let k = self.iterations;
-            for _ in 0u64..k {
+            for _ in 0..k {
                 black_box(inner());
             }
         });
@@ -1050,7 +1050,7 @@ impl Bencher {
     // This is a more statistics-driven benchmark algorithm
     pub fn auto_bench<F>(&mut self, mut f: F) -> stats::Summary<f64> where F: FnMut(&mut Bencher) {
         // Initial bench run to get ballpark figure.
-        let mut n = 1_u64;
+        let mut n = 1;
         self.bench_n(n, |x| f(x));
 
         // Try to estimate iter count for 1ms falling back to 1m
diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs
index 38cbe5c7dea..57439addeaa 100644
--- a/src/libunicode/u_str.rs
+++ b/src/libunicode/u_str.rs
@@ -525,7 +525,7 @@ impl<I> Iterator for Utf16Encoder<I> where I: Iterator<Item=char> {
             return Some(tmp);
         }
 
-        let mut buf = [0u16; 2];
+        let mut buf = [0; 2];
         self.chars.next().map(|ch| {
             let n = CharExt::encode_utf16(ch, &mut buf).unwrap_or(0);
             if n == 2 { self.extra = buf[1]; }
diff --git a/src/test/auxiliary/cci_class_3.rs b/src/test/auxiliary/cci_class_3.rs
index 98881eb09bf..44d3a69fde4 100644
--- a/src/test/auxiliary/cci_class_3.rs
+++ b/src/test/auxiliary/cci_class_3.rs
@@ -16,7 +16,7 @@ pub mod kitties {
     }
 
     impl cat {
-        pub fn speak(&mut self) { self.meows += 1_usize; }
+        pub fn speak(&mut self) { self.meows += 1; }
         pub fn meow_count(&mut self) -> uint { self.meows }
     }
 
diff --git a/src/test/auxiliary/cci_class_4.rs b/src/test/auxiliary/cci_class_4.rs
index 9d7905cdebd..c10ef805a65 100644
--- a/src/test/auxiliary/cci_class_4.rs
+++ b/src/test/auxiliary/cci_class_4.rs
@@ -34,8 +34,8 @@ pub mod kitties {
     impl cat {
         pub fn meow(&mut self) {
             println!("Meow");
-            self.meows += 1_usize;
-            if self.meows % 5_usize == 0_usize {
+            self.meows += 1;
+            if self.meows % 5 == 0 {
                 self.how_hungry += 1;
             }
         }
diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs
index 96a06968c5f..28fa354fef3 100644
--- a/src/test/auxiliary/cci_class_cast.rs
+++ b/src/test/auxiliary/cci_class_cast.rs
@@ -26,8 +26,8 @@ pub mod kitty {
     impl cat {
         fn meow(&mut self) {
             println!("Meow");
-            self.meows += 1_usize;
-            if self.meows % 5_usize == 0_usize {
+            self.meows += 1;
+            if self.meows % 5 == 0 {
                 self.how_hungry += 1;
             }
         }
diff --git a/src/test/auxiliary/cci_impl_lib.rs b/src/test/auxiliary/cci_impl_lib.rs
index 6ee497370e8..a650b30e593 100644
--- a/src/test/auxiliary/cci_impl_lib.rs
+++ b/src/test/auxiliary/cci_impl_lib.rs
@@ -20,7 +20,7 @@ impl uint_helpers for uint {
         let mut i = *self;
         while i < v {
             f(i);
-            i += 1_usize;
+            i += 1;
         }
     }
 }
diff --git a/src/test/auxiliary/cci_iter_lib.rs b/src/test/auxiliary/cci_iter_lib.rs
index 8e00b0dc7be..07d03b4c759 100644
--- a/src/test/auxiliary/cci_iter_lib.rs
+++ b/src/test/auxiliary/cci_iter_lib.rs
@@ -12,10 +12,10 @@
 
 #[inline]
 pub fn iter<T, F>(v: &[T], mut f: F) where F: FnMut(&T) {
-    let mut i = 0_usize;
+    let mut i = 0;
     let n = v.len();
     while i < n {
         f(&v[i]);
-        i += 1_usize;
+        i += 1;
     }
 }
diff --git a/src/test/auxiliary/cci_no_inline_lib.rs b/src/test/auxiliary/cci_no_inline_lib.rs
index ce041118906..f3ad2a3aeb9 100644
--- a/src/test/auxiliary/cci_no_inline_lib.rs
+++ b/src/test/auxiliary/cci_no_inline_lib.rs
@@ -13,10 +13,10 @@
 
 // same as cci_iter_lib, more-or-less, but not marked inline
 pub fn iter<F>(v: Vec<uint> , mut f: F) where F: FnMut(uint) {
-    let mut i = 0_usize;
+    let mut i = 0;
     let n = v.len();
     while i < n {
         f(v[i]);
-        i += 1_usize;
+        i += 1;
     }
 }
diff --git a/src/test/auxiliary/macro_reexport_1.rs b/src/test/auxiliary/macro_reexport_1.rs
index 9c72cb1a680..aaeccc6e898 100644
--- a/src/test/auxiliary/macro_reexport_1.rs
+++ b/src/test/auxiliary/macro_reexport_1.rs
@@ -11,5 +11,5 @@
 #![crate_type = "dylib"]
 #[macro_export]
 macro_rules! reexported {
-    () => ( 3_usize )
+    () => ( 3 )
 }
diff --git a/src/test/auxiliary/roman_numerals.rs b/src/test/auxiliary/roman_numerals.rs
index e5c42111105..0ea7c000570 100644
--- a/src/test/auxiliary/roman_numerals.rs
+++ b/src/test/auxiliary/roman_numerals.rs
@@ -47,7 +47,7 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
     };
 
     let mut text = &*text;
-    let mut total = 0_usize;
+    let mut total = 0;
     while !text.is_empty() {
         match NUMERALS.iter().find(|&&(rn, _)| text.starts_with(rn)) {
             Some(&(rn, val)) => {
diff --git a/src/test/auxiliary/unboxed-closures-cross-crate.rs b/src/test/auxiliary/unboxed-closures-cross-crate.rs
index a5178c03443..26925a35067 100644
--- a/src/test/auxiliary/unboxed-closures-cross-crate.rs
+++ b/src/test/auxiliary/unboxed-closures-cross-crate.rs
@@ -14,9 +14,9 @@ use std::ops::Add;
 
 #[inline]
 pub fn has_closures() -> uint {
-    let x = 1_usize;
+    let x = 1;
     let mut f = move || x;
-    let y = 1_usize;
+    let y = 1;
     let g = || y;
     f() + g()
 }
diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs
index 53c52ae3019..de88c7733b3 100644
--- a/src/test/bench/noise.rs
+++ b/src/test/bench/noise.rs
@@ -49,7 +49,7 @@ impl Noise2DContext {
             *x = random_gradient(&mut rng);
         }
 
-        let mut permutations = [0i32; 256];
+        let mut permutations = [0; 256];
         for (i, x) in permutations.iter_mut().enumerate() {
             *x = i as i32;
         }
diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs
index 73e7c8eb073..4a8bb24270d 100644
--- a/src/test/bench/shootout-chameneos-redux.rs
+++ b/src/test/bench/shootout-chameneos-redux.rs
@@ -145,7 +145,7 @@ fn creature(
     to_rendezvous: Sender<CreatureInfo>,
     to_rendezvous_log: Sender<String>
 ) {
-    let mut creatures_met = 0i32;
+    let mut creatures_met = 0;
     let mut evil_clones_met = 0;
     let mut rendezvous = from_rendezvous.iter();
 
diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs
index f7de935d08f..3688c224a7d 100644
--- a/src/test/bench/shootout-fannkuch-redux.rs
+++ b/src/test/bench/shootout-fannkuch-redux.rs
@@ -91,7 +91,7 @@ impl Perm {
     }
 
     fn get(&mut self, mut idx: i32) -> P {
-        let mut pp = [0u8; 16];
+        let mut pp = [0; 16];
         self.permcount = idx as u32;
         for (i, place) in self.perm.p.iter_mut().enumerate() {
             *place = i as i32 + 1;
@@ -183,7 +183,7 @@ fn main() {
     let n = std::env::args()
         .nth(1)
         .and_then(|arg| arg.parse().ok())
-        .unwrap_or(2i32);
+        .unwrap_or(2);
 
     let (checksum, maxflips) = fannkuch(n);
     println!("{}\nPfannkuchen({}) = {}", checksum, n, maxflips);
diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index 277c3ee73df..9cee75757aa 100644
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -121,7 +121,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> {
 
     fn make(&mut self, n: usize) -> IoResult<()> {
         let alu_len = self.alu.len();
-        let mut buf = repeat(0u8).take(alu_len + LINE_LEN).collect::<Vec<_>>();
+        let mut buf = repeat(0).take(alu_len + LINE_LEN).collect::<Vec<_>>();
         let alu: &[u8] = self.alu.as_bytes();
 
         copy_memory(&mut buf, alu);
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 2c640c4b092..e15f9d99ff6 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -89,7 +89,7 @@ fn make_fasta<W: Writer, I: Iterator<Item=u8>>(
     -> std::old_io::IoResult<()>
 {
     try!(wr.write(header.as_bytes()));
-    let mut line = [0u8; LINE_LENGTH + 1];
+    let mut line = [0; LINE_LENGTH + 1];
     while n > 0 {
         let nb = min(LINE_LENGTH, n);
         for i in 0..nb {
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 5cfe62d967c..9e5885041b6 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -78,11 +78,11 @@ impl Code {
     }
 
     fn rotate(&self, c: u8, frame: usize) -> Code {
-        Code(self.push_char(c).hash() & ((1u64 << (2 * frame)) - 1))
+        Code(self.push_char(c).hash() & ((1 << (2 * frame)) - 1))
     }
 
     fn pack(string: &str) -> Code {
-        string.bytes().fold(Code(0u64), |a, b| a.push_char(b))
+        string.bytes().fold(Code(0), |a, b| a.push_char(b))
     }
 
     fn unpack(&self, frame: usize) -> String {
diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs
index a94fe0ccd95..79a5245a408 100644
--- a/src/test/bench/shootout-meteor.rs
+++ b/src/test/bench/shootout-meteor.rs
@@ -169,7 +169,7 @@ fn make_masks() -> Vec<Vec<Vec<u64> > > {
         .map(|(id, p)| transform(p, id != 3))
         .collect();
 
-    (0i32..50).map(|yx| {
+    (0..50).map(|yx| {
         transforms.iter().enumerate().map(|(id, t)| {
             t.iter().filter_map(|p| mask(yx / 5, yx % 5, id, p)).collect()
         }).collect()
@@ -211,7 +211,7 @@ fn filter_masks(masks: &mut Vec<Vec<Vec<u64>>>) {
 
 // Gets the identifier of a mask.
 fn get_id(m: u64) -> u8 {
-    for id in 0u8..10 {
+    for id in 0..10 {
         if m & (1 << (id + 50) as usize) != 0 {return id;}
     }
     panic!("{:016x} does not have a valid identifier", m);
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index f308743ad13..9a82614510e 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -60,7 +60,7 @@ impl Sudoku {
         reader.read_line(&mut s).unwrap();
         assert_eq!(s, "9,9\n");
 
-        let mut g = repeat(vec![0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])
+        let mut g = repeat(vec![0, 0, 0, 0, 0, 0, 0, 0, 0])
                           .take(10).collect::<Vec<_>>();
         for line in reader.lines() {
             let line = line.unwrap();
@@ -94,10 +94,10 @@ impl Sudoku {
     // solve sudoku grid
     pub fn solve(&mut self) {
         let mut work: Vec<(u8, u8)> = Vec::new(); /* queue of uncolored fields */
-        for row in 0u8..9u8 {
-            for col in 0u8..9u8 {
+        for row in 0..9 {
+            for col in 0..9 {
                 let color = self.grid[row as usize][col as usize];
-                if color == 0u8 {
+                if color == 0 {
                     work.push((row, col));
                 }
             }
@@ -122,7 +122,7 @@ impl Sudoku {
     }
 
     fn next_color(&mut self, row: u8, col: u8, start_color: u8) -> bool {
-        if start_color < 10u8 {
+        if start_color < 10 {
             // colors not yet used
             let mut avail: Box<_> = box Colors::new(start_color);
 
@@ -132,15 +132,15 @@ impl Sudoku {
             // find first remaining color that is available
             let next = avail.next();
             self.grid[row as usize][col as usize] = next;
-            return 0u8 != next;
+            return 0 != next;
         }
-        self.grid[row as usize][col as usize] = 0u8;
+        self.grid[row as usize][col as usize] = 0;
         return false;
     }
 
     // find colors available in neighbourhood of (row, col)
     fn drop_colors(&mut self, avail: &mut Colors, row: u8, col: u8) {
-        for idx in 0u8..9u8 {
+        for idx in 0..9 {
             /* check same column fields */
             avail.remove(self.grid[idx as usize][col as usize]);
             /* check same row fields */
@@ -148,10 +148,10 @@ impl Sudoku {
         }
 
         // check same block fields
-        let row0 = (row / 3u8) * 3u8;
-        let col0 = (col / 3u8) * 3u8;
-        for alt_row in row0..row0 + 3u8 {
-            for alt_col in col0..col0 + 3u8 {
+        let row0 = (row / 3) * 3;
+        let col0 = (col / 3) * 3;
+        for alt_row in row0..row0 + 3 {
+            for alt_col in col0..col0 + 3 {
                 avail.remove(self.grid[alt_row as usize][alt_col as usize]);
             }
         }
@@ -161,29 +161,29 @@ impl Sudoku {
 // Stores available colors as simple bitfield, bit 0 is always unset
 struct Colors(u16);
 
-static HEADS: u16 = (1u16 << 10) - 1; /* bits 9..0 */
+static HEADS: u16 = (1 << 10) - 1; /* bits 9..0 */
 
 impl Colors {
     fn new(start_color: u8) -> Colors {
         // Sets bits 9..start_color
-        let tails = !0u16 << start_color as usize;
+        let tails = !0 << start_color as usize;
         return Colors(HEADS & tails);
     }
 
     fn next(&self) -> u8 {
         let Colors(c) = *self;
         let val = c & HEADS;
-        if 0u16 == val {
-            return 0u8;
+        if 0 == val {
+            return 0;
         } else {
             return val.trailing_zeros() as u8
         }
     }
 
     fn remove(&mut self, color: u8) {
-        if color != 0u8 {
+        if color != 0 {
             let Colors(val) = *self;
-            let mask = !(1u16 << color as usize);
+            let mask = !(1 << color as usize);
             *self    = Colors(val & mask);
         }
     }
@@ -191,57 +191,57 @@ impl Colors {
 
 static DEFAULT_SUDOKU: [[u8;9];9] = [
          /* 0    1    2    3    4    5    6    7    8    */
-  /* 0 */  [0u8, 4u8, 0u8, 6u8, 0u8, 0u8, 0u8, 3u8, 2u8],
-  /* 1 */  [0u8, 0u8, 8u8, 0u8, 2u8, 0u8, 0u8, 0u8, 0u8],
-  /* 2 */  [7u8, 0u8, 0u8, 8u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-  /* 3 */  [0u8, 0u8, 0u8, 5u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-  /* 4 */  [0u8, 5u8, 0u8, 0u8, 0u8, 3u8, 6u8, 0u8, 0u8],
-  /* 5 */  [6u8, 8u8, 0u8, 0u8, 0u8, 0u8, 0u8, 9u8, 0u8],
-  /* 6 */  [0u8, 9u8, 5u8, 0u8, 0u8, 6u8, 0u8, 7u8, 0u8],
-  /* 7 */  [0u8, 0u8, 0u8, 0u8, 4u8, 0u8, 0u8, 6u8, 0u8],
-  /* 8 */  [4u8, 0u8, 0u8, 0u8, 0u8, 7u8, 2u8, 0u8, 3u8]
+  /* 0 */  [0, 4, 0, 6, 0, 0, 0, 3, 2],
+  /* 1 */  [0, 0, 8, 0, 2, 0, 0, 0, 0],
+  /* 2 */  [7, 0, 0, 8, 0, 0, 0, 0, 0],
+  /* 3 */  [0, 0, 0, 5, 0, 0, 0, 0, 0],
+  /* 4 */  [0, 5, 0, 0, 0, 3, 6, 0, 0],
+  /* 5 */  [6, 8, 0, 0, 0, 0, 0, 9, 0],
+  /* 6 */  [0, 9, 5, 0, 0, 6, 0, 7, 0],
+  /* 7 */  [0, 0, 0, 0, 4, 0, 0, 6, 0],
+  /* 8 */  [4, 0, 0, 0, 0, 7, 2, 0, 3]
 ];
 
 #[cfg(test)]
 static DEFAULT_SOLUTION: [[u8;9];9] = [
          /* 0    1    2    3    4    5    6    7    8    */
-  /* 0 */  [1u8, 4u8, 9u8, 6u8, 7u8, 5u8, 8u8, 3u8, 2u8],
-  /* 1 */  [5u8, 3u8, 8u8, 1u8, 2u8, 9u8, 7u8, 4u8, 6u8],
-  /* 2 */  [7u8, 2u8, 6u8, 8u8, 3u8, 4u8, 1u8, 5u8, 9u8],
-  /* 3 */  [9u8, 1u8, 4u8, 5u8, 6u8, 8u8, 3u8, 2u8, 7u8],
-  /* 4 */  [2u8, 5u8, 7u8, 4u8, 9u8, 3u8, 6u8, 1u8, 8u8],
-  /* 5 */  [6u8, 8u8, 3u8, 7u8, 1u8, 2u8, 5u8, 9u8, 4u8],
-  /* 6 */  [3u8, 9u8, 5u8, 2u8, 8u8, 6u8, 4u8, 7u8, 1u8],
-  /* 7 */  [8u8, 7u8, 2u8, 3u8, 4u8, 1u8, 9u8, 6u8, 5u8],
-  /* 8 */  [4u8, 6u8, 1u8, 9u8, 5u8, 7u8, 2u8, 8u8, 3u8]
+  /* 0 */  [1, 4, 9, 6, 7, 5, 8, 3, 2],
+  /* 1 */  [5, 3, 8, 1, 2, 9, 7, 4, 6],
+  /* 2 */  [7, 2, 6, 8, 3, 4, 1, 5, 9],
+  /* 3 */  [9, 1, 4, 5, 6, 8, 3, 2, 7],
+  /* 4 */  [2, 5, 7, 4, 9, 3, 6, 1, 8],
+  /* 5 */  [6, 8, 3, 7, 1, 2, 5, 9, 4],
+  /* 6 */  [3, 9, 5, 2, 8, 6, 4, 7, 1],
+  /* 7 */  [8, 7, 2, 3, 4, 1, 9, 6, 5],
+  /* 8 */  [4, 6, 1, 9, 5, 7, 2, 8, 3]
 ];
 
 #[test]
 fn colors_new_works() {
-    assert_eq!(*Colors::new(1), 1022u16);
-    assert_eq!(*Colors::new(2), 1020u16);
-    assert_eq!(*Colors::new(3), 1016u16);
-    assert_eq!(*Colors::new(4), 1008u16);
-    assert_eq!(*Colors::new(5), 992u16);
-    assert_eq!(*Colors::new(6), 960u16);
-    assert_eq!(*Colors::new(7), 896u16);
-    assert_eq!(*Colors::new(8), 768u16);
-    assert_eq!(*Colors::new(9), 512u16);
+    assert_eq!(*Colors::new(1), 1022);
+    assert_eq!(*Colors::new(2), 1020);
+    assert_eq!(*Colors::new(3), 1016);
+    assert_eq!(*Colors::new(4), 1008);
+    assert_eq!(*Colors::new(5), 992);
+    assert_eq!(*Colors::new(6), 960);
+    assert_eq!(*Colors::new(7), 896);
+    assert_eq!(*Colors::new(8), 768);
+    assert_eq!(*Colors::new(9), 512);
 }
 
 #[test]
 fn colors_next_works() {
-    assert_eq!(Colors(0).next(), 0u8);
-    assert_eq!(Colors(2).next(), 1u8);
-    assert_eq!(Colors(4).next(), 2u8);
-    assert_eq!(Colors(8).next(), 3u8);
-    assert_eq!(Colors(16).next(), 4u8);
-    assert_eq!(Colors(32).next(), 5u8);
-    assert_eq!(Colors(64).next(), 6u8);
-    assert_eq!(Colors(128).next(), 7u8);
-    assert_eq!(Colors(256).next(), 8u8);
-    assert_eq!(Colors(512).next(), 9u8);
-    assert_eq!(Colors(1024).next(), 0u8);
+    assert_eq!(Colors(0).next(), 0);
+    assert_eq!(Colors(2).next(), 1);
+    assert_eq!(Colors(4).next(), 2);
+    assert_eq!(Colors(8).next(), 3);
+    assert_eq!(Colors(16).next(), 4);
+    assert_eq!(Colors(32).next(), 5);
+    assert_eq!(Colors(64).next(), 6);
+    assert_eq!(Colors(128).next(), 7);
+    assert_eq!(Colors(256).next(), 8);
+    assert_eq!(Colors(512).next(), 9);
+    assert_eq!(Colors(1024).next(), 0);
 }
 
 #[test]
@@ -253,7 +253,7 @@ fn colors_remove_works() {
     colors.remove(1);
 
     // THEN
-    assert_eq!(colors.next(), 2u8);
+    assert_eq!(colors.next(), 2);
 }
 
 #[test]
diff --git a/src/test/compile-fail-fulldeps/issue-18986.rs b/src/test/compile-fail-fulldeps/issue-18986.rs
index 9b696e05c50..06fc3db58c1 100644
--- a/src/test/compile-fail-fulldeps/issue-18986.rs
+++ b/src/test/compile-fail-fulldeps/issue-18986.rs
@@ -15,6 +15,6 @@ pub use use_from_trait_xc::Trait;
 
 fn main() {
     match () {
-        Trait { x: 42_usize } => () //~ ERROR use of trait `Trait` in a struct pattern
+        Trait { x: 42 } => () //~ ERROR use of trait `Trait` in a struct pattern
     }
 }
diff --git a/src/test/compile-fail/array-not-vector.rs b/src/test/compile-fail/array-not-vector.rs
index 7111c00d124..81883108a2b 100644
--- a/src/test/compile-fail/array-not-vector.rs
+++ b/src/test/compile-fail/array-not-vector.rs
@@ -9,14 +9,14 @@
 // except according to those terms.
 
 fn main() {
-    let _x: i32 = [1i32, 2, 3];
+    let _x: i32 = [1, 2, 3];
     //~^ ERROR mismatched types
     //~| expected `i32`
     //~| found `[i32; 3]`
     //~| expected i32
     //~| found array of 3 elements
 
-    let x: &[i32] = &[1i32, 2, 3];
+    let x: &[i32] = &[1, 2, 3];
     let _y: &i32 = x;
     //~^ ERROR mismatched types
     //~| expected `&i32`
diff --git a/src/test/compile-fail/asm-in-bad-modifier.rs b/src/test/compile-fail/asm-in-bad-modifier.rs
index 01481af817b..3cb608a9c5e 100644
--- a/src/test/compile-fail/asm-in-bad-modifier.rs
+++ b/src/test/compile-fail/asm-in-bad-modifier.rs
@@ -20,8 +20,8 @@ pub fn main() {
     let x: isize;
     let y: isize;
     unsafe {
-        asm!("mov $1, $0" : "=r"(x) : "=r"(5_usize)); //~ ERROR operand constraint contains '='
-        asm!("mov $1, $0" : "=r"(y) : "+r"(5_usize)); //~ ERROR operand constraint contains '+'
+        asm!("mov $1, $0" : "=r"(x) : "=r"(5)); //~ ERROR operand constraint contains '='
+        asm!("mov $1, $0" : "=r"(y) : "+r"(5)); //~ ERROR operand constraint contains '+'
     }
     foo(x);
     foo(y);
diff --git a/src/test/compile-fail/asm-out-assign-imm.rs b/src/test/compile-fail/asm-out-assign-imm.rs
index ff56fb14f7d..8c8451623d5 100644
--- a/src/test/compile-fail/asm-out-assign-imm.rs
+++ b/src/test/compile-fail/asm-out-assign-imm.rs
@@ -21,7 +21,7 @@ pub fn main() {
     x = 1; //~ NOTE prior assignment occurs here
     foo(x);
     unsafe {
-        asm!("mov $1, $0" : "=r"(x) : "r"(5_usize));
+        asm!("mov $1, $0" : "=r"(x) : "r"(5));
         //~^ ERROR re-assignment of immutable variable `x`
     }
     foo(x);
diff --git a/src/test/compile-fail/asm-out-no-modifier.rs b/src/test/compile-fail/asm-out-no-modifier.rs
index 17c19c77ab9..9cf43bebe65 100644
--- a/src/test/compile-fail/asm-out-no-modifier.rs
+++ b/src/test/compile-fail/asm-out-no-modifier.rs
@@ -19,7 +19,7 @@ fn foo(x: isize) { println!("{}", x); }
 pub fn main() {
     let x: isize;
     unsafe {
-        asm!("mov $1, $0" : "r"(x) : "r"(5_usize)); //~ ERROR output operand constraint lacks '='
+        asm!("mov $1, $0" : "r"(x) : "r"(5)); //~ ERROR output operand constraint lacks '='
     }
     foo(x);
 }
diff --git a/src/test/compile-fail/assign-to-method.rs b/src/test/compile-fail/assign-to-method.rs
index d32ea327d0a..4518ce36b6d 100644
--- a/src/test/compile-fail/assign-to-method.rs
+++ b/src/test/compile-fail/assign-to-method.rs
@@ -15,7 +15,7 @@ struct cat {
 }
 
 impl cat {
-    pub fn speak(&self) { self.meows += 1_usize; }
+    pub fn speak(&self) { self.meows += 1; }
 }
 
 fn cat(in_x : usize, in_y : isize) -> cat {
@@ -26,6 +26,6 @@ fn cat(in_x : usize, in_y : isize) -> cat {
 }
 
 fn main() {
-  let nyan : cat = cat(52_usize, 99);
+  let nyan : cat = cat(52, 99);
   nyan.speak = || println!("meow"); //~ ERROR attempted to take value of method
 }
diff --git a/src/test/compile-fail/bad-bang-ann-3.rs b/src/test/compile-fail/bad-bang-ann-3.rs
index 58a8314af21..de315a41361 100644
--- a/src/test/compile-fail/bad-bang-ann-3.rs
+++ b/src/test/compile-fail/bad-bang-ann-3.rs
@@ -11,7 +11,7 @@
 // Tests that a function with a ! annotation always actually fails
 
 fn bad_bang(i: usize) -> ! {
-    return 7_usize; //~ ERROR `return` in a function declared as diverging [E0166]
+    return 7; //~ ERROR `return` in a function declared as diverging [E0166]
 }
 
 fn main() { bad_bang(5); }
diff --git a/src/test/compile-fail/bad-bang-ann.rs b/src/test/compile-fail/bad-bang-ann.rs
index 03c24c2fa3d..f0ecf31fd10 100644
--- a/src/test/compile-fail/bad-bang-ann.rs
+++ b/src/test/compile-fail/bad-bang-ann.rs
@@ -11,7 +11,7 @@
 // Tests that a function with a ! annotation always actually fails
 
 fn bad_bang(i: usize) -> ! { //~ ERROR computation may converge in a function marked as diverging
-    if i < 0_usize { } else { panic!(); }
+    if i < 0 { } else { panic!(); }
 }
 
 fn main() { bad_bang(5); }
diff --git a/src/test/compile-fail/bad-const-type.rs b/src/test/compile-fail/bad-const-type.rs
index 7e3c356b870..93ff7c08f79 100644
--- a/src/test/compile-fail/bad-const-type.rs
+++ b/src/test/compile-fail/bad-const-type.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static i: String = 10i32;
+static i: String = 10;
 //~^ ERROR mismatched types
 //~| expected `collections::string::String`
 //~| found `i32`
diff --git a/src/test/compile-fail/bad-method-typaram-kind.rs b/src/test/compile-fail/bad-method-typaram-kind.rs
index a97cf5d41e8..2129d4fbd50 100644
--- a/src/test/compile-fail/bad-method-typaram-kind.rs
+++ b/src/test/compile-fail/bad-method-typaram-kind.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn foo<T:'static>() {
-    1_usize.bar::<T>(); //~ ERROR `core::marker::Send` is not implemented
+    1.bar::<T>(); //~ ERROR `core::marker::Send` is not implemented
 }
 
 trait bar {
diff --git a/src/test/compile-fail/binop-logic-int.rs b/src/test/compile-fail/binop-logic-int.rs
index 2217cf5e4da..1a3db388877 100644
--- a/src/test/compile-fail/binop-logic-int.rs
+++ b/src/test/compile-fail/binop-logic-int.rs
@@ -10,4 +10,4 @@
 
 // error-pattern:`&&` cannot be applied to type `i32`
 
-fn main() { let x = 1i32 && 2i32; }
+fn main() { let x = 1 && 2; }
diff --git a/src/test/compile-fail/borrow-immutable-upvar-mutation.rs b/src/test/compile-fail/borrow-immutable-upvar-mutation.rs
index a82aa12dc80..00f51973a41 100644
--- a/src/test/compile-fail/borrow-immutable-upvar-mutation.rs
+++ b/src/test/compile-fail/borrow-immutable-upvar-mutation.rs
@@ -21,25 +21,25 @@ fn to_fn_mut<A,F:FnMut<A>>(f: F) -> F { f }
 fn main() {
     // By-ref captures
     {
-        let mut x = 0_usize;
+        let mut x = 0;
         let _f = to_fn(|| x = 42); //~ ERROR cannot assign
 
-        let mut y = 0_usize;
+        let mut y = 0;
         let _g = to_fn(|| set(&mut y)); //~ ERROR cannot borrow
 
-        let mut z = 0_usize;
+        let mut z = 0;
         let _h = to_fn_mut(|| { set(&mut z); to_fn(|| z = 42); }); //~ ERROR cannot assign
     }
 
     // By-value captures
     {
-        let mut x = 0_usize;
+        let mut x = 0;
         let _f = to_fn(move || x = 42); //~ ERROR cannot assign
 
-        let mut y = 0_usize;
+        let mut y = 0;
         let _g = to_fn(move || set(&mut y)); //~ ERROR cannot borrow
 
-        let mut z = 0_usize;
+        let mut z = 0;
         let _h = to_fn_mut(move || { set(&mut z); to_fn(move || z = 42); }); //~ ERROR cannot assign
     }
 }
diff --git a/src/test/compile-fail/borrowck-move-error-with-note.rs b/src/test/compile-fail/borrowck-move-error-with-note.rs
index 2d82c8be519..e4b9fb26711 100644
--- a/src/test/compile-fail/borrowck-move-error-with-note.rs
+++ b/src/test/compile-fail/borrowck-move-error-with-note.rs
@@ -17,7 +17,7 @@ enum Foo {
 }
 
 fn blah() {
-    let f = &Foo::Foo1(box 1u32, box 2u32);
+    let f = &Foo::Foo1(box 1, box 2);
     match *f {             //~ ERROR cannot move out of
         Foo::Foo1(num1,         //~ NOTE attempting to move value to here
                   num2) => (),  //~ NOTE and here
diff --git a/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs b/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs
index 21637370724..61bf2c11a1f 100644
--- a/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs
+++ b/src/test/compile-fail/borrowck-report-with-custom-diagnostic.rs
@@ -11,7 +11,7 @@
 #![allow(dead_code)]
 fn main() {
     // Original borrow ends at end of function
-    let mut x = 1_usize;
+    let mut x = 1;
     let y = &mut x;
     let z = &x; //~ ERROR cannot borrow
 }
@@ -21,7 +21,7 @@ fn foo() {
     match true {
         true => {
             // Original borrow ends at end of match arm
-            let mut x = 1_usize;
+            let mut x = 1;
             let y = &x;
             let z = &mut x; //~ ERROR cannot borrow
         }
@@ -33,7 +33,7 @@ fn foo() {
 fn bar() {
     // Original borrow ends at end of closure
     || {
-        let mut x = 1_usize;
+        let mut x = 1;
         let y = &mut x;
         let z = &mut x; //~ ERROR cannot borrow
     };
diff --git a/src/test/compile-fail/class-method-missing.rs b/src/test/compile-fail/class-method-missing.rs
index ada45e8c1fc..46b100a4d39 100644
--- a/src/test/compile-fail/class-method-missing.rs
+++ b/src/test/compile-fail/class-method-missing.rs
@@ -27,5 +27,5 @@ fn cat(in_x : usize) -> cat {
 }
 
 fn main() {
-  let nyan = cat(0_usize);
+  let nyan = cat(0);
 }
diff --git a/src/test/compile-fail/class-missing-self.rs b/src/test/compile-fail/class-missing-self.rs
index f25b2e65388..ab76af1cbe6 100644
--- a/src/test/compile-fail/class-missing-self.rs
+++ b/src/test/compile-fail/class-missing-self.rs
@@ -16,7 +16,7 @@ impl cat {
     fn sleep(&self) { loop{} }
     fn meow(&self) {
       println!("Meow");
-      meows += 1_usize; //~ ERROR unresolved name
+      meows += 1; //~ ERROR unresolved name
       sleep();     //~ ERROR unresolved name
     }
 
diff --git a/src/test/compile-fail/coercion-slice.rs b/src/test/compile-fail/coercion-slice.rs
index aac180f9ad7..40fbcd556b0 100644
--- a/src/test/compile-fail/coercion-slice.rs
+++ b/src/test/compile-fail/coercion-slice.rs
@@ -11,7 +11,7 @@
 // Tests that we forbid coercion from `[T; n]` to `&[T]`
 
 fn main() {
-    let _: &[i32] = [0i32];
+    let _: &[i32] = [0];
     //~^ ERROR mismatched types
     //~| expected `&[i32]`
     //~| found `[i32; 1]`
diff --git a/src/test/compile-fail/const-block-non-item-statement.rs b/src/test/compile-fail/const-block-non-item-statement.rs
index fa63b16afa6..5ccfb1ddec7 100644
--- a/src/test/compile-fail/const-block-non-item-statement.rs
+++ b/src/test/compile-fail/const-block-non-item-statement.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-const A: usize = { 1_usize; 2 };
+const A: usize = { 1; 2 };
 //~^ ERROR: blocks in constants are limited to items and tail expressions
 
 const B: usize = { { } 2 };
@@ -19,7 +19,7 @@ macro_rules! foo {
 }
 const C: usize = { foo!(); 2 };
 
-const D: usize = { let x = 4_usize; 2 };
+const D: usize = { let x = 4; 2 };
 //~^ ERROR: blocks in constants are limited to items and tail expressions
 
 pub fn main() {
diff --git a/src/test/compile-fail/deriving-non-type.rs b/src/test/compile-fail/deriving-non-type.rs
index 966e28a789c..5b215f3ccd9 100644
--- a/src/test/compile-fail/deriving-non-type.rs
+++ b/src/test/compile-fail/deriving-non-type.rs
@@ -22,10 +22,10 @@ impl S { }
 impl T for S { }
 
 #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums
-static s: usize = 0_usize;
+static s: usize = 0;
 
 #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums
-const c: usize = 0_usize;
+const c: usize = 0;
 
 #[derive(PartialEq)] //~ ERROR: `derive` may only be applied to structs and enums
 mod m { }
diff --git a/src/test/compile-fail/destructor-restrictions.rs b/src/test/compile-fail/destructor-restrictions.rs
index 0836cd1695d..22f615cafd7 100644
--- a/src/test/compile-fail/destructor-restrictions.rs
+++ b/src/test/compile-fail/destructor-restrictions.rs
@@ -14,8 +14,8 @@ use std::cell::RefCell;
 
 fn main() {
     let b = {
-        let a = Box::new(RefCell::new(4i8));
-        *a.borrow() + 1i8    //~ ERROR `*a` does not live long enough
+        let a = Box::new(RefCell::new(4));
+        *a.borrow() + 1    //~ ERROR `*a` does not live long enough
     };
     println!("{}", b);
 }
diff --git a/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs b/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs
index 1e15e67876e..54bdaf011c8 100644
--- a/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs
+++ b/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs
@@ -21,7 +21,7 @@
 // test. Not ideal, but oh well :(
 
 fn main() {
-    let a = &[1i32, 2, 3];
+    let a = &[1, 2, 3];
     println!("{}", {
         extern "rust-intrinsic" { //~ ERROR intrinsics are subject to change
             fn atomic_fence();
diff --git a/src/test/compile-fail/import-glob-circular.rs b/src/test/compile-fail/import-glob-circular.rs
index f38172db444..67834a99969 100644
--- a/src/test/compile-fail/import-glob-circular.rs
+++ b/src/test/compile-fail/import-glob-circular.rs
@@ -13,13 +13,13 @@
 mod circ1 {
     pub use circ2::f2;
     pub fn f1() { println!("f1"); }
-    pub fn common() -> usize { return 0_usize; }
+    pub fn common() -> usize { return 0; }
 }
 
 mod circ2 {
     pub use circ1::f1;
     pub fn f2() { println!("f2"); }
-    pub fn common() -> usize { return 1_usize; }
+    pub fn common() -> usize { return 1; }
 }
 
 mod test {
diff --git a/src/test/compile-fail/index-bot.rs b/src/test/compile-fail/index-bot.rs
index b28f2a746fd..70c362303ae 100644
--- a/src/test/compile-fail/index-bot.rs
+++ b/src/test/compile-fail/index-bot.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    (return)[0_usize]; //~ ERROR the type of this value must be known in this context
+    (return)[0]; //~ ERROR the type of this value must be known in this context
 }
diff --git a/src/test/compile-fail/infinite-instantiation.rs b/src/test/compile-fail/infinite-instantiation.rs
index d39efa3c2ab..559e0e9a292 100644
--- a/src/test/compile-fail/infinite-instantiation.rs
+++ b/src/test/compile-fail/infinite-instantiation.rs
@@ -32,13 +32,13 @@ impl<T:Clone> ToOpt for Option<T> {
 }
 
 fn function<T:ToOpt + Clone>(counter: usize, t: T) {
-    if counter > 0_usize {
-        function(counter - 1_usize, t.to_option());
+    if counter > 0 {
+        function(counter - 1, t.to_option());
         // FIXME(#4287) Error message should be here. It should be
         // a type error to instantiate `test` at a type other than T.
     }
 }
 
 fn main() {
-    function(22_usize, 22_usize);
+    function(22, 22);
 }
diff --git a/src/test/compile-fail/issue-11714.rs b/src/test/compile-fail/issue-11714.rs
index d307352517f..998576097a0 100644
--- a/src/test/compile-fail/issue-11714.rs
+++ b/src/test/compile-fail/issue-11714.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn blah() -> i32 { //~ ERROR not all control paths return a value
-    1i32
+    1
 
     ; //~ HELP consider removing this semicolon:
 }
diff --git a/src/test/compile-fail/issue-13058.rs b/src/test/compile-fail/issue-13058.rs
index 06f14158b91..6f024fc5382 100644
--- a/src/test/compile-fail/issue-13058.rs
+++ b/src/test/compile-fail/issue-13058.rs
@@ -24,7 +24,7 @@ fn check<'r, I: Iterator<Item=usize>, T: Itble<'r, usize, I>>(cont: &T) -> bool
 {
     let cont_iter = cont.iter();
 //~^ ERROR cannot infer an appropriate lifetime for autoref due to conflicting requirements
-    let result = cont_iter.fold(Some(0u16), |state, val| {
+    let result = cont_iter.fold(Some(0), |state, val| {
         state.map_or(None, |mask| {
             let bit = 1 << val;
             if mask & bit == 0 {Some(mask|bit)} else {None}
@@ -34,7 +34,7 @@ fn check<'r, I: Iterator<Item=usize>, T: Itble<'r, usize, I>>(cont: &T) -> bool
 }
 
 fn main() {
-    check((3_usize, 5_usize));
+    check((3, 5));
 //~^ ERROR mismatched types
 //~| expected `&_`
 //~| found `(usize, usize)`
diff --git a/src/test/compile-fail/issue-13466.rs b/src/test/compile-fail/issue-13466.rs
index 16128e52d64..3eb42f902f9 100644
--- a/src/test/compile-fail/issue-13466.rs
+++ b/src/test/compile-fail/issue-13466.rs
@@ -14,7 +14,7 @@ pub fn main() {
     // The expected arm type `Option<T>` has one type parameter, while
     // the actual arm `Result<T, E>` has two. typeck should not be
     // tricked into looking up a non-existing second type parameter.
-    let _x: usize = match Some(1_usize) {
+    let _x: usize = match Some(1) {
         Ok(u) => u,
         //~^ ERROR mismatched types
         //~| expected `core::option::Option<usize>`
diff --git a/src/test/compile-fail/issue-13482-2.rs b/src/test/compile-fail/issue-13482-2.rs
index 86a79416c77..7af10aa13a8 100644
--- a/src/test/compile-fail/issue-13482-2.rs
+++ b/src/test/compile-fail/issue-13482-2.rs
@@ -15,7 +15,7 @@ fn main() {
     let y = match x {
         [] => None,
 //~^ ERROR mismatched types
-//~| expected `[_#0i; 2]`
+//~| expected `[_#0; 2]`
 //~| found `[_#7t; 0]`
 //~| expected an array with a fixed size of 2 elements
 //~| found one with 0 elements
diff --git a/src/test/compile-fail/issue-14845.rs b/src/test/compile-fail/issue-14845.rs
index d7ff6f2fe63..3381b930714 100644
--- a/src/test/compile-fail/issue-14845.rs
+++ b/src/test/compile-fail/issue-14845.rs
@@ -22,7 +22,7 @@ fn main() {
     //~| expected u8
     //~| found array of 1 elements
 
-    let local = [0u8];
+    let local = [0];
     let _v = &local as *mut u8;
     //~^ ERROR mismatched types
     //~| expected `*mut u8`
diff --git a/src/test/compile-fail/issue-17283.rs b/src/test/compile-fail/issue-17283.rs
index 65731379094..a481fec6bf9 100644
--- a/src/test/compile-fail/issue-17283.rs
+++ b/src/test/compile-fail/issue-17283.rs
@@ -16,7 +16,7 @@ struct Foo {
 }
 
 fn main() {
-    let x = 1_usize;
+    let x = 1;
     let y: Foo;
 
     // `x { ... }` should not be interpreted as a struct literal here
diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs
index d6471ca018d..723b4ca03e7 100644
--- a/src/test/compile-fail/issue-17651.rs
+++ b/src/test/compile-fail/issue-17651.rs
@@ -13,6 +13,6 @@
 
 fn main() {
     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
-    (|| Box::new(*[0_usize].as_slice()))();
+    (|| Box::new(*[0].as_slice()))();
     //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[usize]`
 }
diff --git a/src/test/compile-fail/issue-17718-patterns.rs b/src/test/compile-fail/issue-17718-patterns.rs
index b7f58791bfc..4e63f667d26 100644
--- a/src/test/compile-fail/issue-17718-patterns.rs
+++ b/src/test/compile-fail/issue-17718-patterns.rs
@@ -13,7 +13,7 @@ static mut A2: usize = 1;
 const A3: usize = 1;
 
 fn main() {
-    match 1_usize {
+    match 1 {
         A1 => {} //~ ERROR: static variables cannot be referenced in a pattern
         A2 => {} //~ ERROR: static variables cannot be referenced in a pattern
         A3 => {}
diff --git a/src/test/compile-fail/issue-17933.rs b/src/test/compile-fail/issue-17933.rs
index bd047408498..657b31fa83c 100644
--- a/src/test/compile-fail/issue-17933.rs
+++ b/src/test/compile-fail/issue-17933.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub static X: usize = 1_usize;
+pub static X: usize = 1;
 
 fn main() {
-    match 1_usize {
+    match 1 {
         self::X => { },
         //~^ ERROR static variables cannot be referenced in a pattern, use a `const` instead
         _       => { },
diff --git a/src/test/compile-fail/issue-18107.rs b/src/test/compile-fail/issue-18107.rs
index d5fb22bdebd..60ab616d598 100644
--- a/src/test/compile-fail/issue-18107.rs
+++ b/src/test/compile-fail/issue-18107.rs
@@ -16,7 +16,7 @@ fn _create_render(_: &()) ->
     AbstractRenderer
 //~^ ERROR: the trait `core::marker::Sized` is not implemented
 {
-    match 0_usize {
+    match 0 {
         _ => unimplemented!()
     }
 }
diff --git a/src/test/compile-fail/issue-18252.rs b/src/test/compile-fail/issue-18252.rs
index 54c51405bd7..e3e56c7f97a 100644
--- a/src/test/compile-fail/issue-18252.rs
+++ b/src/test/compile-fail/issue-18252.rs
@@ -13,5 +13,5 @@ enum Foo {
 }
 
 fn main() {
-    let f = Foo::Variant(42_usize); //~ ERROR uses it like a function
+    let f = Foo::Variant(42); //~ ERROR uses it like a function
 }
diff --git a/src/test/compile-fail/issue-18566.rs b/src/test/compile-fail/issue-18566.rs
index dd3844b1a0e..41e82d0cd89 100644
--- a/src/test/compile-fail/issue-18566.rs
+++ b/src/test/compile-fail/issue-18566.rs
@@ -28,7 +28,7 @@ impl Tr for usize {
 }
 
 fn main() {
-    let s = &mut 1_usize;
+    let s = &mut 1;
 
     MyPtr(s).poke(s);
     //~^ ERROR cannot borrow `*s` as mutable more than once at a time
diff --git a/src/test/compile-fail/issue-18783.rs b/src/test/compile-fail/issue-18783.rs
index f6a3da81857..5eb3c439df2 100644
--- a/src/test/compile-fail/issue-18783.rs
+++ b/src/test/compile-fail/issue-18783.rs
@@ -13,7 +13,7 @@ use std::cell::RefCell;
 // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
 
 fn main() {
-    let mut y = 1_usize;
+    let mut y = 1;
     let c = RefCell::new(vec![]);
     c.push(Box::new(|| y = 0));
     c.push(Box::new(|| y = 0));
@@ -21,7 +21,7 @@ fn main() {
 }
 
 fn ufcs() {
-    let mut y = 1_usize;
+    let mut y = 1;
     let c = RefCell::new(vec![]);
 
     Push::push(&c, Box::new(|| y = 0));
diff --git a/src/test/compile-fail/issue-18959.rs b/src/test/compile-fail/issue-18959.rs
index 8fb543fb967..ebda2481803 100644
--- a/src/test/compile-fail/issue-18959.rs
+++ b/src/test/compile-fail/issue-18959.rs
@@ -19,7 +19,7 @@ impl Foo for Thing {
 
 #[inline(never)]
 fn foo(b: &Bar) {
-    b.foo(&0usize)
+    b.foo(&0)
     //~^ ERROR the trait `Foo` is not implemented for the type `Bar`
 }
 
diff --git a/src/test/compile-fail/issue-19991.rs b/src/test/compile-fail/issue-19991.rs
index 2d73b98ec1e..7c1e18ba997 100644
--- a/src/test/compile-fail/issue-19991.rs
+++ b/src/test/compile-fail/issue-19991.rs
@@ -17,6 +17,6 @@ fn main() {
                                            //~| found `i32`
                                            //~| expected ()
                                            //~| found i32
-        765i32
+        765
     };
 }
diff --git a/src/test/compile-fail/issue-20801.rs b/src/test/compile-fail/issue-20801.rs
index 929c8ec0fd6..fe7807042e5 100644
--- a/src/test/compile-fail/issue-20801.rs
+++ b/src/test/compile-fail/issue-20801.rs
@@ -25,11 +25,11 @@ fn mut_ref() -> &'static mut T {
 }
 
 fn mut_ptr() -> *mut T {
-    unsafe { 0u8 as *mut T }
+    unsafe { 0 as *mut T }
 }
 
 fn const_ptr() -> *const T {
-    unsafe { 0u8 as *const T }
+    unsafe { 0 as *const T }
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/issue-2150.rs b/src/test/compile-fail/issue-2150.rs
index 505885e6c41..8b109b0a5c0 100644
--- a/src/test/compile-fail/issue-2150.rs
+++ b/src/test/compile-fail/issue-2150.rs
@@ -15,7 +15,7 @@
 fn fail_len(v: Vec<isize> ) -> usize {
     let mut i = 3;
     panic!();
-    for x in &v { i += 1_usize; }
+    for x in &v { i += 1; }
     //~^ ERROR: unreachable statement
     return i;
 }
diff --git a/src/test/compile-fail/issue-4517.rs b/src/test/compile-fail/issue-4517.rs
index 6d4777be40b..a1804b5a268 100644
--- a/src/test/compile-fail/issue-4517.rs
+++ b/src/test/compile-fail/issue-4517.rs
@@ -11,7 +11,7 @@
 fn bar(int_param: usize) {}
 
 fn main() {
-    let foo: [u8; 4] = [1u8; 4_usize];
+    let foo: [u8; 4] = [1; 4];
     bar(foo);
     //~^ ERROR mismatched types
     //~| expected `usize`
diff --git a/src/test/compile-fail/issue-7575.rs b/src/test/compile-fail/issue-7575.rs
index b6643f43952..9c019f6ec47 100644
--- a/src/test/compile-fail/issue-7575.rs
+++ b/src/test/compile-fail/issue-7575.rs
@@ -32,17 +32,17 @@ trait UnusedTrait : MarkerTrait {
 
 impl CtxtFn for usize {
     fn f8(self, i: usize) -> usize {
-        i * 4_usize
+        i * 4
     }
 
     fn f9(i: usize) -> usize {
-        i * 4_usize
+        i * 4
     }
 }
 
 impl OtherTrait for usize {
     fn f9(i: usize) -> usize {
-        i * 8_usize
+        i * 8
     }
 }
 
diff --git a/src/test/compile-fail/issue-7867.rs b/src/test/compile-fail/issue-7867.rs
index 7bb4aac23d6..1eaa85c3b7e 100644
--- a/src/test/compile-fail/issue-7867.rs
+++ b/src/test/compile-fail/issue-7867.rs
@@ -23,7 +23,7 @@ fn main() {
         _ => ()
     }
 
-    match &Some(42i32) {
+    match &Some(42) {
         Some(x) => (),
         //~^ ERROR mismatched types
         //~| expected `&core::option::Option<i32>`
diff --git a/src/test/compile-fail/kindck-nonsendable-1.rs b/src/test/compile-fail/kindck-nonsendable-1.rs
index e6041cddead..c370aa4b8fb 100644
--- a/src/test/compile-fail/kindck-nonsendable-1.rs
+++ b/src/test/compile-fail/kindck-nonsendable-1.rs
@@ -16,7 +16,7 @@ fn foo(_x: Rc<usize>) {}
 fn bar<F:FnOnce() + Send>(_: F) { }
 
 fn main() {
-    let x = Rc::new(3_usize);
+    let x = Rc::new(3);
     bar(move|| foo(x));
     //~^ ERROR `core::marker::Send` is not implemented
 }
diff --git a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs
index fac518c7635..0a8e4514b43 100644
--- a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs
+++ b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs
@@ -24,7 +24,7 @@ impl<'r> Itble<'r, usize, Range<usize>> for (usize, usize) {
 fn check<'r, I: Iterator<Item=usize>, T: Itble<'r, usize, I>>(cont: &T) -> bool {
 //~^ HELP: consider using an explicit lifetime parameter as shown: fn check<'r, I: Iterator<Item = usize>, T: Itble<'r, usize, I>>(cont: &'r T)
     let cont_iter = cont.iter(); //~ ERROR: cannot infer
-    let result = cont_iter.fold(Some(0u16), |state, val| {
+    let result = cont_iter.fold(Some(0), |state, val| {
         state.map_or(None, |mask| {
             let bit = 1 << val;
             if mask & bit == 0 {Some(mask|bit)} else {None}
diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs
index f304c26efb5..8441fb3ade9 100644
--- a/src/test/compile-fail/lint-dead-code-4.rs
+++ b/src/test/compile-fail/lint-dead-code-4.rs
@@ -63,6 +63,6 @@ fn field_match_in_let(f: Bar) -> bool {
 fn main() {
     field_read(Foo { x: 1, b: false, marker: std::marker::NoCopy });
     field_match_in_patterns(XYZ::Z);
-    field_match_in_let(Bar { x: 42_usize, b: true, _guard: () });
+    field_match_in_let(Bar { x: 42, b: true, _guard: () });
     let _ = Baz { x: 0 };
 }
diff --git a/src/test/compile-fail/liveness-return-last-stmt-semi.rs b/src/test/compile-fail/liveness-return-last-stmt-semi.rs
index 57252dd58d7..a4eb1630afe 100644
--- a/src/test/compile-fail/liveness-return-last-stmt-semi.rs
+++ b/src/test/compile-fail/liveness-return-last-stmt-semi.rs
@@ -10,7 +10,7 @@
 //
 // regression test for #8005
 
-macro_rules! test { () => { fn foo() -> i32 { 1i32; } } }
+macro_rules! test { () => { fn foo() -> i32 { 1; } } }
                                            //~^ ERROR not all control paths return a value
                                            //~^^ HELP consider removing this semicolon
 
diff --git a/src/test/compile-fail/macro-no-implicit-reexport.rs b/src/test/compile-fail/macro-no-implicit-reexport.rs
index 13dbab12b77..e8d9f444cef 100644
--- a/src/test/compile-fail/macro-no-implicit-reexport.rs
+++ b/src/test/compile-fail/macro-no-implicit-reexport.rs
@@ -16,5 +16,5 @@
 extern crate macro_non_reexport_2;
 
 fn main() {
-    assert_eq!(reexported!(), 3_usize);  //~ ERROR macro undefined
+    assert_eq!(reexported!(), 3);  //~ ERROR macro undefined
 }
diff --git a/src/test/compile-fail/macro-reexport-not-locally-visible.rs b/src/test/compile-fail/macro-reexport-not-locally-visible.rs
index dc8f4fadc76..26de51a7cf8 100644
--- a/src/test/compile-fail/macro-reexport-not-locally-visible.rs
+++ b/src/test/compile-fail/macro-reexport-not-locally-visible.rs
@@ -18,5 +18,5 @@
 extern crate macro_reexport_1;
 
 fn main() {
-    assert_eq!(reexported!(), 3_usize);  //~ ERROR macro undefined
+    assert_eq!(reexported!(), 3);  //~ ERROR macro undefined
 }
diff --git a/src/test/compile-fail/method-self-arg-1.rs b/src/test/compile-fail/method-self-arg-1.rs
index 7b6868af805..666812c98bc 100644
--- a/src/test/compile-fail/method-self-arg-1.rs
+++ b/src/test/compile-fail/method-self-arg-1.rs
@@ -23,7 +23,7 @@ fn main() {
                  //~| found `Foo`
                  //~| expected &-ptr
                  //~| found struct `Foo`
-    Foo::bar(&42i32); //~  ERROR mismatched types
+    Foo::bar(&42); //~  ERROR mismatched types
                       //~| expected `&Foo`
                       //~| found `&i32`
                       //~| expected struct `Foo`
diff --git a/src/test/compile-fail/mut-pattern-mismatched.rs b/src/test/compile-fail/mut-pattern-mismatched.rs
index 6de69a9adb0..1b748624491 100644
--- a/src/test/compile-fail/mut-pattern-mismatched.rs
+++ b/src/test/compile-fail/mut-pattern-mismatched.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let foo = &mut 1i32;
+    let foo = &mut 1;
 
     // (separate lines to ensure the spans are accurate)
 
@@ -20,7 +20,7 @@ fn main() {
         = foo;
     let &mut _ = foo;
 
-    let bar = &1i32;
+    let bar = &1;
     let &_ = bar;
     let &mut _ //~  ERROR mismatched types
                //~| expected `&i32`
diff --git a/src/test/compile-fail/mutable-class-fields-2.rs b/src/test/compile-fail/mutable-class-fields-2.rs
index b6744d4b33a..46af3a862c2 100644
--- a/src/test/compile-fail/mutable-class-fields-2.rs
+++ b/src/test/compile-fail/mutable-class-fields-2.rs
@@ -29,6 +29,6 @@ fn cat(in_x : usize, in_y : isize) -> cat {
 }
 
 fn main() {
-  let nyan : cat = cat(52_usize, 99);
+  let nyan : cat = cat(52, 99);
   nyan.eat();
 }
diff --git a/src/test/compile-fail/mutable-class-fields.rs b/src/test/compile-fail/mutable-class-fields.rs
index 94b1047f85e..c163dc2b4d2 100644
--- a/src/test/compile-fail/mutable-class-fields.rs
+++ b/src/test/compile-fail/mutable-class-fields.rs
@@ -21,6 +21,6 @@ fn cat(in_x : usize, in_y : isize) -> cat {
 }
 
 fn main() {
-  let nyan : cat = cat(52_usize, 99);
+  let nyan : cat = cat(52, 99);
   nyan.how_hungry = 0; //~ ERROR cannot assign
 }
diff --git a/src/test/compile-fail/non-exhaustive-pattern-witness.rs b/src/test/compile-fail/non-exhaustive-pattern-witness.rs
index 0eb91e0419a..3ed91459ae9 100644
--- a/src/test/compile-fail/non-exhaustive-pattern-witness.rs
+++ b/src/test/compile-fail/non-exhaustive-pattern-witness.rs
@@ -27,7 +27,7 @@ fn struct_with_a_nested_enum_and_vector() {
         Foo { first: true, second: None } => (),
         Foo { first: true, second: Some(_) } => (),
         Foo { first: false, second: None } => (),
-        Foo { first: false, second: Some([1_usize, 2_usize, 3_usize, 4_usize]) } => ()
+        Foo { first: false, second: Some([1, 2, 3, 4]) } => ()
     }
 }
 
diff --git a/src/test/compile-fail/or-patter-mismatch.rs b/src/test/compile-fail/or-patter-mismatch.rs
index 4b261d89888..59508d6ac95 100644
--- a/src/test/compile-fail/or-patter-mismatch.rs
+++ b/src/test/compile-fail/or-patter-mismatch.rs
@@ -12,4 +12,4 @@
 
 enum blah { a(isize, isize, usize), b(isize, isize), }
 
-fn main() { match blah::a(1, 1, 2_usize) { blah::a(_, x, y) | blah::b(x, y) => { } } }
+fn main() { match blah::a(1, 1, 2) { blah::a(_, x, y) | blah::b(x, y) => { } } }
diff --git a/src/test/compile-fail/private-method.rs b/src/test/compile-fail/private-method.rs
index ccbdd52a983..16510c2c8c9 100644
--- a/src/test/compile-fail/private-method.rs
+++ b/src/test/compile-fail/private-method.rs
@@ -30,6 +30,6 @@ mod kitties {
 }
 
 fn main() {
-  let nyan : kitties::cat = kitties::cat(52_usize, 99);
+  let nyan : kitties::cat = kitties::cat(52, 99);
   nyan.nap();
 }
diff --git a/src/test/compile-fail/private-struct-field-cross-crate.rs b/src/test/compile-fail/private-struct-field-cross-crate.rs
index 243d835d46e..fb4491a6375 100644
--- a/src/test/compile-fail/private-struct-field-cross-crate.rs
+++ b/src/test/compile-fail/private-struct-field-cross-crate.rs
@@ -13,7 +13,7 @@ extern crate cci_class;
 use cci_class::kitties::cat;
 
 fn main() {
-  let nyan : cat = cat(52_usize, 99);
-  assert!((nyan.meows == 52_usize));
+  let nyan : cat = cat(52, 99);
+  assert!((nyan.meows == 52));
   //~^ ERROR field `meows` of struct `cci_class::kitties::cat` is private
 }
diff --git a/src/test/compile-fail/range-1.rs b/src/test/compile-fail/range-1.rs
index a8b6e399418..e7b34d6d1bc 100644
--- a/src/test/compile-fail/range-1.rs
+++ b/src/test/compile-fail/range-1.rs
@@ -20,7 +20,7 @@ pub fn main() {
     //~^ ERROR the trait `core::num::Int` is not implemented for the type `f32`
 
     // Unsized type.
-    let arr: &[_] = &[1u32, 2, 3];
+    let arr: &[_] = &[1, 2, 3];
     let range = *arr..;
     //~^ ERROR the trait `core::marker::Sized` is not implemented
 }
diff --git a/src/test/compile-fail/regions-addr-of-self.rs b/src/test/compile-fail/regions-addr-of-self.rs
index 45e468b3ab0..04ee0526403 100644
--- a/src/test/compile-fail/regions-addr-of-self.rs
+++ b/src/test/compile-fail/regions-addr-of-self.rs
@@ -15,18 +15,18 @@ struct dog {
 impl dog {
     pub fn chase_cat(&mut self) {
         let p: &'static mut usize = &mut self.cats_chased; //~ ERROR cannot infer
-        *p += 1_usize;
+        *p += 1;
     }
 
     pub fn chase_cat_2(&mut self) {
         let p: &mut usize = &mut self.cats_chased;
-        *p += 1_usize;
+        *p += 1;
     }
 }
 
 fn dog() -> dog {
     dog {
-        cats_chased: 0_usize
+        cats_chased: 0
     }
 }
 
diff --git a/src/test/compile-fail/regions-addr-of-upvar-self.rs b/src/test/compile-fail/regions-addr-of-upvar-self.rs
index 8cc2dd6afc6..28491f1155c 100644
--- a/src/test/compile-fail/regions-addr-of-upvar-self.rs
+++ b/src/test/compile-fail/regions-addr-of-upvar-self.rs
@@ -18,7 +18,7 @@ impl dog {
     pub fn chase_cat(&mut self) {
         let _f = || {
             let p: &'static mut usize = &mut self.food; //~ ERROR cannot infer
-            *p = 3_usize;
+            *p = 3;
         };
     }
 }
diff --git a/src/test/compile-fail/regions-creating-enums.rs b/src/test/compile-fail/regions-creating-enums.rs
index 4c361427bf3..ad2dc28afef 100644
--- a/src/test/compile-fail/regions-creating-enums.rs
+++ b/src/test/compile-fail/regions-creating-enums.rs
@@ -14,8 +14,8 @@ enum ast<'a> {
 }
 
 fn build() {
-    let x = ast::num(3_usize);
-    let y = ast::num(4_usize);
+    let x = ast::num(3);
+    let y = ast::num(4);
     let z = ast::add(&x, &y);
     compute(&z);
 }
diff --git a/src/test/compile-fail/regions-pattern-typing-issue-19997.rs b/src/test/compile-fail/regions-pattern-typing-issue-19997.rs
index da839d72172..ae9ceb600d4 100644
--- a/src/test/compile-fail/regions-pattern-typing-issue-19997.rs
+++ b/src/test/compile-fail/regions-pattern-typing-issue-19997.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 fn main() {
-    let a0 = 0u8;
-    let f = 1u8;
+    let a0 = 0;
+    let f = 1;
     let mut a1 = &a0;
     match (&a1,) {
         (&ref b0,) => {
diff --git a/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs b/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs
index aa20efa5a12..1e2224eafae 100644
--- a/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs
+++ b/src/test/compile-fail/regions-return-ref-to-upvar-issue-17403.rs
@@ -15,7 +15,7 @@
 fn main() {
     // Unboxed closure case
     {
-        let mut x = 0_usize;
+        let mut x = 0;
         let mut f = || &mut x; //~ ERROR cannot infer
         let x = f();
         let y = f();
diff --git a/src/test/compile-fail/regions-trait-1.rs b/src/test/compile-fail/regions-trait-1.rs
index b45a37d26e5..01439ce5e68 100644
--- a/src/test/compile-fail/regions-trait-1.rs
+++ b/src/test/compile-fail/regions-trait-1.rs
@@ -34,7 +34,7 @@ fn get_v(gc: Box<get_ctxt>) -> usize {
 }
 
 fn main() {
-    let ctxt = ctxt { v: 22_usize };
+    let ctxt = ctxt { v: 22 };
     let hc = has_ctxt { c: &ctxt };
-    assert_eq!(get_v(box hc as Box<get_ctxt>), 22_usize);
+    assert_eq!(get_v(box hc as Box<get_ctxt>), 22);
 }
diff --git a/src/test/compile-fail/structure-constructor-type-mismatch.rs b/src/test/compile-fail/structure-constructor-type-mismatch.rs
index c276228b18e..4a0006338e6 100644
--- a/src/test/compile-fail/structure-constructor-type-mismatch.rs
+++ b/src/test/compile-fail/structure-constructor-type-mismatch.rs
@@ -27,39 +27,39 @@ fn main() {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
         //~| found i32
-        x: 1i32,
-        y: 2i32,
+        x: 1,
+        y: 2,
     };
 
     let pt2 = Point::<f32> {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
         //~| found i32
-        x: 3i32,
-        y: 4i32,
+        x: 3,
+        y: 4,
     };
 
     let pair = PairF {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
         //~| found i32
-        x: 5i32,
-        y: 6i32,
+        x: 5,
+        y: 6,
     };
 
     let pair2 = PairF::<i32> {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
         //~| found i32
-        x: 7i32,
-        y: 8i32,
+        x: 7,
+        y: 8,
     };
 
     let pt3 = PointF::<i32> {
         //~^ ERROR wrong number of type arguments
         //~| ERROR structure constructor specifies a structure of type
-        x: 9i32,
-        y: 10i32,
+        x: 9,
+        y: 10,
     };
 }
 
diff --git a/src/test/compile-fail/tail-typeck.rs b/src/test/compile-fail/tail-typeck.rs
index 9c1d318d588..5c1270aa0e4 100644
--- a/src/test/compile-fail/tail-typeck.rs
+++ b/src/test/compile-fail/tail-typeck.rs
@@ -12,6 +12,6 @@
 
 fn f() -> isize { return g(); }
 
-fn g() -> usize { return 0_usize; }
+fn g() -> usize { return 0; }
 
 fn main() { let y = f(); }
diff --git a/src/test/compile-fail/traits-multidispatch-convert-ambig-dest.rs b/src/test/compile-fail/traits-multidispatch-convert-ambig-dest.rs
index 0a5aa1b7bd3..8fe1f4d2371 100644
--- a/src/test/compile-fail/traits-multidispatch-convert-ambig-dest.rs
+++ b/src/test/compile-fail/traits-multidispatch-convert-ambig-dest.rs
@@ -33,7 +33,7 @@ where T : Convert<U>
 }
 
 fn a() {
-    test(22_i32, std::default::Default::default()); //~ ERROR type annotations required
+    test(22, std::default::Default::default()); //~ ERROR type annotations required
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/tuple-index-out-of-bounds.rs b/src/test/compile-fail/tuple-index-out-of-bounds.rs
index 54b8d551f20..e2a951cab72 100644
--- a/src/test/compile-fail/tuple-index-out-of-bounds.rs
+++ b/src/test/compile-fail/tuple-index-out-of-bounds.rs
@@ -11,12 +11,12 @@
 struct Point(i32, i32);
 
 fn main() {
-    let origin = Point(0i32, 0i32);
+    let origin = Point(0, 0);
     origin.0;
     origin.1;
     origin.2;
     //~^ ERROR attempted out-of-bounds tuple index `2` on type `Point`
-    let tuple = (0i32, 0i32);
+    let tuple = (0, 0);
     tuple.0;
     tuple.1;
     tuple.2;
diff --git a/src/test/compile-fail/type-mismatch-multiple.rs b/src/test/compile-fail/type-mismatch-multiple.rs
index 3bf0896d990..a51a8172543 100644
--- a/src/test/compile-fail/type-mismatch-multiple.rs
+++ b/src/test/compile-fail/type-mismatch-multiple.rs
@@ -10,7 +10,7 @@
 
 // Checking that the compiler reports multiple type errors at once
 
-fn main() { let a: bool = 1i32; let b: i32 = true; }
+fn main() { let a: bool = 1; let b: i32 = true; }
 //~^ ERROR mismatched types
 //~| expected `bool`
 //~| found `i32`
diff --git a/src/test/compile-fail/type-params-in-different-spaces-1.rs b/src/test/compile-fail/type-params-in-different-spaces-1.rs
index de9623de7cd..88d8788d63a 100644
--- a/src/test/compile-fail/type-params-in-different-spaces-1.rs
+++ b/src/test/compile-fail/type-params-in-different-spaces-1.rs
@@ -23,7 +23,7 @@ trait BrokenAdd: Int {
 impl<T: Int> BrokenAdd for T {}
 
 pub fn main() {
-    let foo: u8 = 0u8;
+    let foo: u8 = 0;
     let x: u8 = foo.broken_add("hello darkness my old friend".to_string());
     println!("{}", x);
 }
diff --git a/src/test/compile-fail/typeck_type_placeholder_item.rs b/src/test/compile-fail/typeck_type_placeholder_item.rs
index 5bfad94867e..d4f3cdfd8b7 100644
--- a/src/test/compile-fail/typeck_type_placeholder_item.rs
+++ b/src/test/compile-fail/typeck_type_placeholder_item.rs
@@ -21,7 +21,7 @@ fn test2() -> (_, _) { (5, 5) }
 static TEST3: _ = "test";
 //~^ ERROR the type placeholder `_` is not allowed within types on item signatures
 
-static TEST4: _ = 145u16;
+static TEST4: _ = 145;
 //~^ ERROR the type placeholder `_` is not allowed within types on item signatures
 
 static TEST5: (_, _) = (1, 2);
@@ -74,7 +74,7 @@ pub fn main() {
     static FN_TEST3: _ = "test";
     //~^ ERROR the type placeholder `_` is not allowed within types on item signatures
 
-    static FN_TEST4: _ = 145u16;
+    static FN_TEST4: _ = 145;
     //~^ ERROR the type placeholder `_` is not allowed within types on item signatures
 
     static FN_TEST5: (_, _) = (1, 2);
diff --git a/src/test/compile-fail/unboxed-closure-illegal-move.rs b/src/test/compile-fail/unboxed-closure-illegal-move.rs
index 86e326f3c5a..564b1b4669f 100644
--- a/src/test/compile-fail/unboxed-closure-illegal-move.rs
+++ b/src/test/compile-fail/unboxed-closure-illegal-move.rs
@@ -23,28 +23,28 @@ fn to_fn_once<A,F:FnOnce<A>>(f: F) -> F { f }
 fn main() {
     // By-ref cases
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn(|| drop(x)); //~ ERROR cannot move
     }
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn_mut(|| drop(x)); //~ ERROR cannot move
     }
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn_once(|| drop(x)); // OK -- FnOnce
     }
     // By-value cases
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn(move || drop(x)); //~ ERROR cannot move
     }
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn_mut(move || drop(x)); //~ ERROR cannot move
     }
     {
-        let x = Box::new(0_usize);
+        let x = Box::new(0);
         let f = to_fn_once(move || drop(x)); // this one is ok
     }
 }
diff --git a/src/test/compile-fail/unboxed-closure-immutable-capture.rs b/src/test/compile-fail/unboxed-closure-immutable-capture.rs
index b40a91181ad..5be2738b47e 100644
--- a/src/test/compile-fail/unboxed-closure-immutable-capture.rs
+++ b/src/test/compile-fail/unboxed-closure-immutable-capture.rs
@@ -17,7 +17,7 @@
 fn set(x: &mut usize) { *x = 0; }
 
 fn main() {
-    let x = 0_usize;
+    let x = 0;
     move || x = 1; //~ ERROR cannot assign
     move || set(&mut x); //~ ERROR cannot borrow
     move || x = 1; //~ ERROR cannot assign
diff --git a/src/test/compile-fail/unboxed-closure-region.rs b/src/test/compile-fail/unboxed-closure-region.rs
index 5f4bf0d33be..eee1b6ce30b 100644
--- a/src/test/compile-fail/unboxed-closure-region.rs
+++ b/src/test/compile-fail/unboxed-closure-region.rs
@@ -14,7 +14,7 @@
 // reference cannot escape the region of that variable.
 fn main() {
     let _f = {
-        let x = 0_usize;
+        let x = 0;
         || x //~ ERROR `x` does not live long enough
     };
 }
diff --git a/src/test/compile-fail/unboxed-closures-borrow-conflict.rs b/src/test/compile-fail/unboxed-closures-borrow-conflict.rs
index 1191cfa2600..372f3277931 100644
--- a/src/test/compile-fail/unboxed-closures-borrow-conflict.rs
+++ b/src/test/compile-fail/unboxed-closures-borrow-conflict.rs
@@ -14,7 +14,7 @@
 // cause borrow conflicts.
 
 fn main() {
-    let mut x = 0_usize;
+    let mut x = 0;
     let f = || x += 1;
     let _y = x; //~ ERROR cannot use `x` because it was mutably borrowed
 }
diff --git a/src/test/compile-fail/unboxed-closures-mutate-upvar.rs b/src/test/compile-fail/unboxed-closures-mutate-upvar.rs
index 650bb17bb77..35052ec0bd5 100644
--- a/src/test/compile-fail/unboxed-closures-mutate-upvar.rs
+++ b/src/test/compile-fail/unboxed-closures-mutate-upvar.rs
@@ -20,21 +20,21 @@ fn to_fn<A,F:Fn<A>>(f: F) -> F { f }
 fn to_fn_mut<A,F:FnMut<A>>(f: F) -> F { f }
 
 fn a() {
-    let n = 0u8;
+    let n = 0;
     let mut f = to_fn_mut(|| { //~ ERROR closure cannot assign
         n += 1;
     });
 }
 
 fn b() {
-    let mut n = 0u8;
+    let mut n = 0;
     let mut f = to_fn_mut(|| {
         n += 1; // OK
     });
 }
 
 fn c() {
-    let n = 0u8;
+    let n = 0;
     let mut f = to_fn_mut(move || {
         // If we just did a straight-forward desugaring, this would
         // compile, but we do something a bit more subtle, and hence
@@ -44,21 +44,21 @@ fn c() {
 }
 
 fn d() {
-    let mut n = 0u8;
+    let mut n = 0;
     let mut f = to_fn_mut(move || {
         n += 1; // OK
     });
 }
 
 fn e() {
-    let n = 0u8;
+    let n = 0;
     let mut f = to_fn(move || {
         n += 1; //~ ERROR cannot assign
     });
 }
 
 fn f() {
-    let mut n = 0u8;
+    let mut n = 0;
     let mut f = to_fn(move || {
         n += 1; //~ ERROR cannot assign
     });
diff --git a/src/test/compile-fail/unboxed-closures-mutated-upvar-from-fn-closure.rs b/src/test/compile-fail/unboxed-closures-mutated-upvar-from-fn-closure.rs
index 2345a86595e..432c7fa5d1b 100644
--- a/src/test/compile-fail/unboxed-closures-mutated-upvar-from-fn-closure.rs
+++ b/src/test/compile-fail/unboxed-closures-mutated-upvar-from-fn-closure.rs
@@ -16,7 +16,7 @@ fn call<F>(f: F) where F : Fn() {
 }
 
 fn main() {
-    let mut counter = 0_u32;
+    let mut counter = 0;
     call(|| {
         counter += 1;
         //~^ ERROR cannot assign to data in a captured outer variable in an `Fn` closure
diff --git a/src/test/compile-fail/unreachable-arm.rs b/src/test/compile-fail/unreachable-arm.rs
index eb5ffeaf888..bc93b86a391 100644
--- a/src/test/compile-fail/unreachable-arm.rs
+++ b/src/test/compile-fail/unreachable-arm.rs
@@ -15,4 +15,4 @@
 
 enum foo { a(Box<foo>, isize), b(usize), }
 
-fn main() { match foo::b(1_usize) { foo::b(_) | foo::a(box _, 1) => { } foo::a(_, 1) => { } } }
+fn main() { match foo::b(1) { foo::b(_) | foo::a(box _, 1) => { } foo::a(_, 1) => { } } }
diff --git a/src/test/compile-fail/unsafe-fn-assign-deref-ptr.rs b/src/test/compile-fail/unsafe-fn-assign-deref-ptr.rs
index 97908118e35..4ea7051775e 100644
--- a/src/test/compile-fail/unsafe-fn-assign-deref-ptr.rs
+++ b/src/test/compile-fail/unsafe-fn-assign-deref-ptr.rs
@@ -10,7 +10,7 @@
 
 
 fn f(p: *const u8) {
-    *p = 0u8; //~ ERROR dereference of unsafe pointer requires unsafe function or block
+    *p = 0; //~ ERROR dereference of unsafe pointer requires unsafe function or block
     return;
 }
 
diff --git a/src/test/compile-fail/variance-issue-20533.rs b/src/test/compile-fail/variance-issue-20533.rs
index 0254f56bd1a..e5473f12bf2 100644
--- a/src/test/compile-fail/variance-issue-20533.rs
+++ b/src/test/compile-fail/variance-issue-20533.rs
@@ -33,19 +33,19 @@ struct AffineU32(u32);
 
 fn main() {
     {
-        let a = AffineU32(1_u32);
+        let a = AffineU32(1);
         let x = foo(&a);
         drop(a); //~ ERROR cannot move out of `a`
         drop(x);
     }
     {
-        let a = AffineU32(1_u32);
+        let a = AffineU32(1);
         let x = bar(&a);
         drop(a); //~ ERROR cannot move out of `a`
         drop(x);
     }
     {
-        let a = AffineU32(1_u32);
+        let a = AffineU32(1);
         let x = baz(&a);
         drop(a); //~ ERROR cannot move out of `a`
         drop(x);
diff --git a/src/test/compile-fail/vtable-res-trait-param.rs b/src/test/compile-fail/vtable-res-trait-param.rs
index cc6ff2d8ebc..654272f5bc6 100644
--- a/src/test/compile-fail/vtable-res-trait-param.rs
+++ b/src/test/compile-fail/vtable-res-trait-param.rs
@@ -23,7 +23,7 @@ impl TraitB for isize {
 }
 
 fn call_it<B:TraitB>(b: B)  -> isize {
-    let y = 4_usize;
+    let y = 4;
     b.gimme_an_a(y) //~ ERROR the trait `TraitA` is not implemented
 }
 
diff --git a/src/test/debuginfo/associated-types.rs b/src/test/debuginfo/associated-types.rs
index 26117e7a13b..63132d91327 100644
--- a/src/test/debuginfo/associated-types.rs
+++ b/src/test/debuginfo/associated-types.rs
@@ -139,13 +139,13 @@ fn assoc_enum<T: TraitWithAssocType>(arg: Enum<T>) {
 }
 
 fn main() {
-    assoc_struct(Struct { b: -1i32, b1: 0i64 });
-    assoc_local(1i32);
-    assoc_arg::<i32>(2i64);
-    assoc_return_value(3i32);
-    assoc_tuple((4i32, 5i64));
-    assoc_enum(Enum::Variant1(6i32, 7i64));
-    assoc_enum(Enum::Variant2(8i64, 9i32));
+    assoc_struct(Struct { b: -1, b1: 0 });
+    assoc_local(1);
+    assoc_arg::<i32>(2);
+    assoc_return_value(3);
+    assoc_tuple((4, 5));
+    assoc_enum(Enum::Variant1(6, 7));
+    assoc_enum(Enum::Variant2(8, 9));
 }
 
 fn zzz() { () }
diff --git a/src/test/debuginfo/recursive-struct.rs b/src/test/debuginfo/recursive-struct.rs
index 3b1979337d5..25afd3514b0 100644
--- a/src/test/debuginfo/recursive-struct.rs
+++ b/src/test/debuginfo/recursive-struct.rs
@@ -128,10 +128,10 @@ fn main() {
         next: Val {
             val: box UniqueNode {
                 next: Empty,
-                value: 1_u16,
+                value: 1,
             }
         },
-        value: 0_u16,
+        value: 0,
     };
 
     let unique_unique: Box<UniqueNode<u32>> = box UniqueNode {
diff --git a/src/test/debuginfo/simd.rs b/src/test/debuginfo/simd.rs
index 161392c94c8..12c7b146342 100644
--- a/src/test/debuginfo/simd.rs
+++ b/src/test/debuginfo/simd.rs
@@ -47,18 +47,18 @@ use std::simd::{i8x16, i16x8,i32x4,i64x2,u8x16,u16x8,u32x4,u64x2,f32x4,f64x2};
 
 fn main() {
 
-    let vi8x16 = i8x16(0i8, 1i8, 2i8, 3i8, 4i8, 5i8, 6i8, 7i8,
-                      8i8, 9i8, 10i8, 11i8, 12i8, 13i8, 14i8, 15i8);
+    let vi8x16 = i8x16(0, 1, 2, 3, 4, 5, 6, 7,
+                      8, 9, 10, 11, 12, 13, 14, 15);
 
-    let vi16x8 = i16x8(16i16, 17i16, 18i16, 19i16, 20i16, 21i16, 22i16, 23i16);
-    let vi32x4 = i32x4(24i32, 25i32, 26i32, 27i32);
-    let vi64x2 = i64x2(28i64, 29i64);
+    let vi16x8 = i16x8(16, 17, 18, 19, 20, 21, 22, 23);
+    let vi32x4 = i32x4(24, 25, 26, 27);
+    let vi64x2 = i64x2(28, 29);
 
-    let vu8x16 = u8x16(30u8, 31u8, 32u8, 33u8, 34u8, 35u8, 36u8, 37u8,
-                      38u8, 39u8, 40u8, 41u8, 42u8, 43u8, 44u8, 45u8);
-    let vu16x8 = u16x8(46u16, 47u16, 48u16, 49u16, 50u16, 51u16, 52u16, 53u16);
-    let vu32x4 = u32x4(54u32, 55u32, 56u32, 57u32);
-    let vu64x2 = u64x2(58u64, 59u64);
+    let vu8x16 = u8x16(30, 31, 32, 33, 34, 35, 36, 37,
+                      38, 39, 40, 41, 42, 43, 44, 45);
+    let vu16x8 = u16x8(46, 47, 48, 49, 50, 51, 52, 53);
+    let vu32x4 = u32x4(54, 55, 56, 57);
+    let vu64x2 = u64x2(58, 59);
 
     let vf32x4 = f32x4(60.5f32, 61.5f32, 62.5f32, 63.5f32);
     let vf64x2 = f64x2(64.5f64, 65.5f64);
diff --git a/src/test/parse-fail/class-implements-bad-trait.rs b/src/test/parse-fail/class-implements-bad-trait.rs
index d709ffdc3fc..7de51c1ea75 100644
--- a/src/test/parse-fail/class-implements-bad-trait.rs
+++ b/src/test/parse-fail/class-implements-bad-trait.rs
@@ -15,5 +15,5 @@ class cat : nonexistent {
 }
 
 fn main() {
-  let nyan = cat(0us);
+  let nyan = cat(0);
 }
diff --git a/src/test/parse-fail/issue-5544-b.rs b/src/test/parse-fail/issue-5544-b.rs
index afff5984b46..9c35d77baf0 100644
--- a/src/test/parse-fail/issue-5544-b.rs
+++ b/src/test/parse-fail/issue-5544-b.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 fn main() {
-    let __isize = 0xff_ffff_ffff_ffff_ffff__isize;
+    let __isize = 0xff_ffff_ffff_ffff_ffff;
     //~^ ERROR int literal is too large
 }
diff --git a/src/test/parse-fail/lex-bad-numeric-literals.rs b/src/test/parse-fail/lex-bad-numeric-literals.rs
index 9a490be6a01..62b87e3f480 100644
--- a/src/test/parse-fail/lex-bad-numeric-literals.rs
+++ b/src/test/parse-fail/lex-bad-numeric-literals.rs
@@ -22,7 +22,7 @@ fn main() {
     1e+; //~ ERROR: expected at least one digit in exponent
     0x539.0; //~ ERROR: hexadecimal float literal is not supported
     99999999999999999999999999999999; //~ ERROR: int literal is too large
-    99999999999999999999999999999999u32; //~ ERROR: int literal is too large
+    99999999999999999999999999999999; //~ ERROR: int literal is too large
     0x; //~ ERROR: no valid digits
     0xu32; //~ ERROR: no valid digits
     0ou32; //~ ERROR: no valid digits
diff --git a/src/test/parse-fail/regions-trait-2.rs b/src/test/parse-fail/regions-trait-2.rs
index 8b36e87db3e..7a7113cd594 100644
--- a/src/test/parse-fail/regions-trait-2.rs
+++ b/src/test/parse-fail/regions-trait-2.rs
@@ -26,7 +26,7 @@ impl<'a> get_ctxt for has_ctxt<'a> {
 }
 
 fn make_gc() -> @get_ctxt  {
-    let ctxt = ctxt { v: 22us };
+    let ctxt = ctxt { v: 22 };
     let hc = has_ctxt { c: &ctxt };
     return @hc as @get_ctxt;
     //~^ ERROR source contains reference
diff --git a/src/test/pretty/empty-lines.rs b/src/test/pretty/empty-lines.rs
index 58f6ae960b1..6a9cbef1015 100644
--- a/src/test/pretty/empty-lines.rs
+++ b/src/test/pretty/empty-lines.rs
@@ -13,5 +13,5 @@
 
 fn a() -> uint {
 
-    1usize
+    1
 }
diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index 83ee2bd08f4..58cd19059c0 100644
--- a/src/test/pretty/issue-4264.pp
+++ b/src/test/pretty/issue-4264.pp
@@ -26,12 +26,12 @@ pub fn bar() {
     const FOO: usize = ((5 as usize) - (4 as usize) as usize);
     let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]);
 
-    let _: [(); (1usize as usize)] = ([(() as ())] as [(); 1]);
+    let _: [(); (1 as usize)] = ([(() as ())] as [(); 1]);
 
     let _ =
         (((&((([(1 as i32), (2 as i32), (3 as i32)] as [i32; 3])) as [i32; 3])
               as &[i32; 3]) as *const _ as *const [i32; 3]) as
-            *const [i32; (3usize as usize)] as *const [i32; 3]);
+            *const [i32; (3 as usize)] as *const [i32; 3]);
 
 
 
diff --git a/src/test/pretty/issue-4264.rs b/src/test/pretty/issue-4264.rs
index 3aa2f4826b2..90757c92c4c 100644
--- a/src/test/pretty/issue-4264.rs
+++ b/src/test/pretty/issue-4264.rs
@@ -20,9 +20,9 @@ pub fn bar() {
     const FOO: usize = 5 - 4;
     let _: [(); FOO] = [()];
 
-    let _ : [(); 1usize] = [()];
+    let _ : [(); 1] = [()];
 
-    let _ = &([1,2,3]) as *const _ as *const [i32; 3usize];
+    let _ = &([1,2,3]) as *const _ as *const [i32; 3];
 
     format!("test");
 }
diff --git a/src/test/run-fail/extern-panic.rs b/src/test/run-fail/extern-panic.rs
index 225ce5a741b..127700e963a 100644
--- a/src/test/run-fail/extern-panic.rs
+++ b/src/test/run-fail/extern-panic.rs
@@ -26,10 +26,10 @@ mod rustrt {
 }
 
 extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
-    if data == 1_usize {
+    if data == 1 {
         data
     } else {
-        count(data - 1_usize) + count(data - 1_usize)
+        count(data - 1) + count(data - 1)
     }
 }
 
@@ -41,9 +41,9 @@ fn count(n: uint) -> uint {
 }
 
 fn main() {
-    for _ in 0..10_usize {
+    for _ in 0..10 {
         task::spawn(move|| {
-            let result = count(5_usize);
+            let result = count(5);
             println!("result = %?", result);
             panic!();
         });
diff --git a/src/test/run-fail/if-check-panic.rs b/src/test/run-fail/if-check-panic.rs
index 19a57db5ec7..e3af5b2bbf5 100644
--- a/src/test/run-fail/if-check-panic.rs
+++ b/src/test/run-fail/if-check-panic.rs
@@ -10,9 +10,9 @@
 
 // error-pattern:Number is odd
 fn even(x: uint) -> bool {
-    if x < 2_usize {
+    if x < 2 {
         return false;
-    } else if x == 2_usize { return true; } else { return even(x - 2_usize); }
+    } else if x == 2 { return true; } else { return even(x - 2); }
 }
 
 fn foo(x: uint) {
@@ -23,4 +23,4 @@ fn foo(x: uint) {
     }
 }
 
-fn main() { foo(3_usize); }
+fn main() { foo(3); }
diff --git a/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot
index b4ec986ef25..21e84fb858b 100644
--- a/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot
+++ b/src/test/run-make/graphviz-flowgraph/f20.dot-expected.dot
@@ -1,17 +1,17 @@
 digraph block {
     N0[label="entry"];
     N1[label="exit"];
-    N2[label="expr 2usize"];
-    N3[label="expr 0usize"];
-    N4[label="expr 20usize"];
-    N5[label="expr [2usize, 0usize, 20usize]"];
+    N2[label="expr 2"];
+    N3[label="expr 0"];
+    N4[label="expr 20"];
+    N5[label="expr [2, 0, 20]"];
     N6[label="local v"];
-    N7[label="stmt let v = [2usize, 0usize, 20usize];"];
+    N7[label="stmt let v = [2, 0, 20];"];
     N8[label="expr v"];
-    N9[label="expr 20usize"];
-    N10[label="expr v[20usize]"];
-    N11[label="stmt v[20usize];"];
-    N12[label="block { let v = [2usize, 0usize, 20usize]; v[20usize]; }"];
+    N9[label="expr 20"];
+    N10[label="expr v[20]"];
+    N11[label="stmt v[20];"];
+    N12[label="block { let v = [2, 0, 20]; v[20]; }"];
     N0 -> N2;
     N2 -> N3;
     N3 -> N4;
diff --git a/src/test/run-make/graphviz-flowgraph/f20.rs b/src/test/run-make/graphviz-flowgraph/f20.rs
index d65de18b547..d7349932355 100644
--- a/src/test/run-make/graphviz-flowgraph/f20.rs
+++ b/src/test/run-make/graphviz-flowgraph/f20.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 pub fn expr_index_20() {
-    let v = [2_usize, 0_usize, 20_usize];
-    v[20_usize];
+    let v = [2, 0, 20];
+    v[20];
 }
diff --git a/src/test/run-make/save-analysis/foo.rs b/src/test/run-make/save-analysis/foo.rs
index 7d94f4c7b17..2e2b8d2578e 100644
--- a/src/test/run-make/save-analysis/foo.rs
+++ b/src/test/run-make/save-analysis/foo.rs
@@ -39,17 +39,17 @@ static bob: Option<&'static [isize]> = None;
 // buglink test - see issue #1337.
 
 fn test_alias<I: Iterator>(i: Option<<I as Iterator>::Item>) {
-    let s = sub_struct{ field2: 45u32, };
+    let s = sub_struct{ field2: 45, };
 
     // import tests
     fn foo(x: &Float) {}
     let _: Option<u8> = from_i32(45);
 
-    let x = 42_usize;
+    let x = 42;
 
     myflate::deflate_bytes(&[]);
 
-    let x = (3, 4_usize);
+    let x = (3, 4);
     let y = x.1;
 }
 
diff --git a/src/test/run-make/symbols-are-reasonable/lib.rs b/src/test/run-make/symbols-are-reasonable/lib.rs
index e1f36ecda53..f81d4803f8f 100644
--- a/src/test/run-make/symbols-are-reasonable/lib.rs
+++ b/src/test/run-make/symbols-are-reasonable/lib.rs
@@ -16,5 +16,5 @@ impl Foo for uint {}
 
 pub fn dummy() {
     // force the vtable to be created
-    let _x = &1_usize as &Foo;
+    let _x = &1 as &Foo;
 }
diff --git a/src/test/run-pass/alias-uninit-value.rs b/src/test/run-pass/alias-uninit-value.rs
index b1bebf0b3e6..45dd213d71f 100644
--- a/src/test/run-pass/alias-uninit-value.rs
+++ b/src/test/run-pass/alias-uninit-value.rs
@@ -17,7 +17,7 @@ enum sty { ty_nil, }
 struct RawT {struct_: sty, cname: Option<String>, hash: uint}
 
 fn mk_raw_ty(st: sty, cname: Option<String>) -> RawT {
-    return RawT {struct_: st, cname: cname, hash: 0_usize};
+    return RawT {struct_: st, cname: cname, hash: 0};
 }
 
 pub fn main() { mk_raw_ty(sty::ty_nil, None::<String>); }
diff --git a/src/test/run-pass/associated-types-constant-type.rs b/src/test/run-pass/associated-types-constant-type.rs
index 57e9230336c..299225e3a47 100644
--- a/src/test/run-pass/associated-types-constant-type.rs
+++ b/src/test/run-pass/associated-types-constant-type.rs
@@ -35,5 +35,5 @@ fn get(x: int) -> <int as SignedUnsigned>::Opposite {
 
 fn main() {
     let x = get(22);
-    assert_eq!(22_usize, x);
+    assert_eq!(22, x);
 }
diff --git a/src/test/run-pass/associated-types-return.rs b/src/test/run-pass/associated-types-return.rs
index 8ae550be3fc..e7ab910bc95 100644
--- a/src/test/run-pass/associated-types-return.rs
+++ b/src/test/run-pass/associated-types-return.rs
@@ -43,7 +43,7 @@ fn foo2<I: Foo>(x: I) -> <I as Foo>::A {
 
 pub fn main() {
     let a = 42;
-    assert!(foo2(a) == 42_usize);
+    assert!(foo2(a) == 42);
 
     let a = Bar;
     assert!(foo2(a) == 43);
diff --git a/src/test/run-pass/associated-types-struct-field-named.rs b/src/test/run-pass/associated-types-struct-field-named.rs
index 8667f6c8430..a63274beb0e 100644
--- a/src/test/run-pass/associated-types-struct-field-named.rs
+++ b/src/test/run-pass/associated-types-struct-field-named.rs
@@ -36,8 +36,8 @@ impl UnifyKey for u32 {
 
 pub fn main() {
     let node: Node<i32> = Node { key: 1, value: Some(22) };
-    assert_eq!(foo(&node), Some(22_u32));
+    assert_eq!(foo(&node), Some(22));
 
     let node: Node<u32> = Node { key: 1, value: Some(22) };
-    assert_eq!(foo(&node), Some(22_i32));
+    assert_eq!(foo(&node), Some(22));
 }
diff --git a/src/test/run-pass/associated-types-struct-field-numbered.rs b/src/test/run-pass/associated-types-struct-field-numbered.rs
index 9503f78a71b..3be2623185b 100644
--- a/src/test/run-pass/associated-types-struct-field-numbered.rs
+++ b/src/test/run-pass/associated-types-struct-field-numbered.rs
@@ -33,8 +33,8 @@ impl UnifyKey for u32 {
 
 pub fn main() {
     let node: Node<i32> = Node(1, Some(22));
-    assert_eq!(foo(&node), Some(22_u32));
+    assert_eq!(foo(&node), Some(22));
 
     let node: Node<u32> = Node(1, Some(22));
-    assert_eq!(foo(&node), Some(22_i32));
+    assert_eq!(foo(&node), Some(22));
 }
diff --git a/src/test/run-pass/associated-types-sugar-path.rs b/src/test/run-pass/associated-types-sugar-path.rs
index c068065ac6a..7e7299961d8 100644
--- a/src/test/run-pass/associated-types-sugar-path.rs
+++ b/src/test/run-pass/associated-types-sugar-path.rs
@@ -41,5 +41,5 @@ impl<T: Foo> C for B<T> {
 }
 
 pub fn main() {
-    let z: uint = bar(2, 4_usize);
+    let z: uint = bar(2, 4);
 }
diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs
index 7c126fc420a..2b84adcb15c 100644
--- a/src/test/run-pass/auto-encode.rs
+++ b/src/test/run-pass/auto-encode.rs
@@ -131,19 +131,19 @@ enum Quark<T> {
 enum CLike { A, B, C }
 
 pub fn main() {
-    let a = &Plus(@Minus(@Val(3_usize), @Val(10_usize)), @Plus(@Val(22_usize), @Val(5_usize)));
+    let a = &Plus(@Minus(@Val(3), @Val(10)), @Plus(@Val(22), @Val(5)));
     test_rbml(a);
 
-    let a = &Spanned {lo: 0_usize, hi: 5_usize, node: 22_usize};
+    let a = &Spanned {lo: 0, hi: 5, node: 22};
     test_rbml(a);
 
-    let a = &Point {x: 3_usize, y: 5_usize};
+    let a = &Point {x: 3, y: 5};
     test_rbml(a);
 
-    let a = &Top(22_usize);
+    let a = &Top(22);
     test_rbml(a);
 
-    let a = &Bottom(222_usize);
+    let a = &Bottom(222);
     test_rbml(a);
 
     let a = &A;
diff --git a/src/test/run-pass/autoderef-method-on-trait.rs b/src/test/run-pass/autoderef-method-on-trait.rs
index 8121edfd2cc..6a90fa47e58 100644
--- a/src/test/run-pass/autoderef-method-on-trait.rs
+++ b/src/test/run-pass/autoderef-method-on-trait.rs
@@ -16,10 +16,10 @@ trait double {
 }
 
 impl double for uint {
-    fn double(self: Box<uint>) -> uint { *self * 2_usize }
+    fn double(self: Box<uint>) -> uint { *self * 2 }
 }
 
 pub fn main() {
-    let x: Box<_> = box() (box 3_usize as Box<double>);
-    assert_eq!(x.double(), 6_usize);
+    let x: Box<_> = box() (box 3 as Box<double>);
+    assert_eq!(x.double(), 6);
 }
diff --git a/src/test/run-pass/autoderef-method-priority.rs b/src/test/run-pass/autoderef-method-priority.rs
index 537894bfd15..cadce45b18d 100644
--- a/src/test/run-pass/autoderef-method-priority.rs
+++ b/src/test/run-pass/autoderef-method-priority.rs
@@ -20,10 +20,10 @@ impl double for uint {
 }
 
 impl double for Box<uint> {
-    fn double(self) -> uint { *self * 2_usize }
+    fn double(self) -> uint { *self * 2 }
 }
 
 pub fn main() {
-    let x: Box<_> = box 3_usize;
-    assert_eq!(x.double(), 6_usize);
+    let x: Box<_> = box 3;
+    assert_eq!(x.double(), 6);
 }
diff --git a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
index 2ffdd576ffb..746107803c9 100644
--- a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
+++ b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
@@ -16,10 +16,10 @@ trait double {
 }
 
 impl double for Box<uint> {
-    fn double(self: Box<Box<uint>>) -> uint { **self * 2_usize }
+    fn double(self: Box<Box<uint>>) -> uint { **self * 2 }
 }
 
 pub fn main() {
-    let x: Box<Box<Box<Box<Box<_>>>>> = box box box box box 3_usize;
-    assert_eq!(x.double(), 6_usize);
+    let x: Box<Box<Box<Box<Box<_>>>>> = box box box box box 3;
+    assert_eq!(x.double(), 6);
 }
diff --git a/src/test/run-pass/autoderef-method-twice.rs b/src/test/run-pass/autoderef-method-twice.rs
index 82510aea162..51b5c98816a 100644
--- a/src/test/run-pass/autoderef-method-twice.rs
+++ b/src/test/run-pass/autoderef-method-twice.rs
@@ -16,10 +16,10 @@ trait double {
 }
 
 impl double for uint {
-    fn double(self: Box<uint>) -> uint { *self * 2_usize }
+    fn double(self: Box<uint>) -> uint { *self * 2 }
 }
 
 pub fn main() {
-    let x: Box<Box<_>> = box box 3_usize;
-    assert_eq!(x.double(), 6_usize);
+    let x: Box<Box<_>> = box box 3;
+    assert_eq!(x.double(), 6);
 }
diff --git a/src/test/run-pass/autoderef-method.rs b/src/test/run-pass/autoderef-method.rs
index c9aa1133101..61e704276af 100644
--- a/src/test/run-pass/autoderef-method.rs
+++ b/src/test/run-pass/autoderef-method.rs
@@ -16,10 +16,10 @@ trait double {
 }
 
 impl double for uint {
-    fn double(self: Box<uint>) -> uint { *self * 2_usize }
+    fn double(self: Box<uint>) -> uint { *self * 2 }
 }
 
 pub fn main() {
-    let x: Box<_> = box 3_usize;
-    assert_eq!(x.double(), 6_usize);
+    let x: Box<_> = box 3;
+    assert_eq!(x.double(), 6);
 }
diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
index 6e6e58a7ddf..86d6a91e75b 100644
--- a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
+++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
@@ -29,6 +29,6 @@ impl Foo for uint {
 }
 
 pub fn main() {
-    let x: Box<_> = box 3_usize;
+    let x: Box<_> = box 3;
     assert_eq!(x.foo(), "box 3".to_string());
 }
diff --git a/src/test/run-pass/big-literals.rs b/src/test/run-pass/big-literals.rs
index 8afb33c7669..01ac2fc20bf 100644
--- a/src/test/run-pass/big-literals.rs
+++ b/src/test/run-pass/big-literals.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 pub fn main() {
-    assert_eq!(0xffffffffu32, (-1 as u32));
-    assert_eq!(4294967295u32, (-1 as u32));
-    assert_eq!(0xffffffffffffffffu64, (-1 as u64));
-    assert_eq!(18446744073709551615u64, (-1 as u64));
+    assert_eq!(0xffffffff, (-1 as u32));
+    assert_eq!(4294967295, (-1 as u32));
+    assert_eq!(0xffffffffffffffff, (-1 as u64));
+    assert_eq!(18446744073709551615, (-1 as u64));
 
-    assert_eq!(-2147483648i32 - 1i32, 2147483647i32);
+    assert_eq!(-2147483648 - 1, 2147483647);
 }
diff --git a/src/test/run-pass/block-arg-call-as.rs b/src/test/run-pass/block-arg-call-as.rs
index d319aaa2f8e..8be6d1bd35a 100644
--- a/src/test/run-pass/block-arg-call-as.rs
+++ b/src/test/run-pass/block-arg-call-as.rs
@@ -13,6 +13,6 @@ fn asBlock<F>(f: F) -> uint where F: FnOnce() -> uint {
 }
 
 pub fn main() {
-   let x = asBlock(|| 22_usize);
-   assert_eq!(x, 22_usize);
+   let x = asBlock(|| 22);
+   assert_eq!(x, 22);
 }
diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs
index d5d26f42ef0..7cbe8104deb 100644
--- a/src/test/run-pass/block-iter-1.rs
+++ b/src/test/run-pass/block-iter-1.rs
@@ -11,8 +11,8 @@
 fn iter_vec<T, F>(v: Vec<T> , mut f: F) where F: FnMut(&T) { for x in &v { f(x); } }
 
 pub fn main() {
-    let v = vec![1i32, 2, 3, 4, 5, 6, 7];
-    let mut odds = 0i32;
+    let v = vec![1, 2, 3, 4, 5, 6, 7];
+    let mut odds = 0;
     iter_vec(v, |i| {
         if *i % 2 == 1 {
             odds += 1;
diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs
index 8c079ca4b07..7701f6114ca 100644
--- a/src/test/run-pass/block-iter-2.rs
+++ b/src/test/run-pass/block-iter-2.rs
@@ -11,7 +11,7 @@
 fn iter_vec<T, F>(v: Vec<T>, mut f: F) where F: FnMut(&T) { for x in &v { f(x); } }
 
 pub fn main() {
-    let v = vec![1i32, 2, 3, 4, 5];
+    let v = vec![1, 2, 3, 4, 5];
     let mut sum = 0;
     iter_vec(v.clone(), |i| {
         iter_vec(v.clone(), |j| {
diff --git a/src/test/run-pass/borrowck-closures-two-imm.rs b/src/test/run-pass/borrowck-closures-two-imm.rs
index c907778339e..75161d16bc0 100644
--- a/src/test/run-pass/borrowck-closures-two-imm.rs
+++ b/src/test/run-pass/borrowck-closures-two-imm.rs
@@ -15,7 +15,7 @@
 // the closures are in scope. Issue #6801.
 
 fn a() -> i32 {
-    let mut x = 3i32;
+    let mut x = 3;
     x += 1;
     let c1 = || x * 4;
     let c2 = || x * 5;
@@ -27,7 +27,7 @@ fn get(x: &i32) -> i32 {
 }
 
 fn b() -> i32 {
-    let mut x = 3i32;
+    let mut x = 3;
     x += 1;
     let c1 = || get(&x);
     let c2 = || get(&x);
@@ -35,7 +35,7 @@ fn b() -> i32 {
 }
 
 fn c() -> i32 {
-    let mut x = 3i32;
+    let mut x = 3;
     x += 1;
     let c1 = || x * 5;
     let c2 = || get(&x);
diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs
index 499650a6e51..d35600ef22e 100644
--- a/src/test/run-pass/borrowck-mut-uniq.rs
+++ b/src/test/run-pass/borrowck-mut-uniq.rs
@@ -26,7 +26,7 @@ fn add_int(x: &mut Ints, v: int) {
 
 fn iter_ints<F>(x: &Ints, mut f: F) -> bool where F: FnMut(&int) -> bool {
     let l = x.values.len();
-    (0_usize..l).all(|i| f(&x.values[i]))
+    (0..l).all(|i| f(&x.values[i]))
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/capture-clauses-unboxed-closures.rs b/src/test/run-pass/capture-clauses-unboxed-closures.rs
index dd417f1a9eb..19316590c26 100644
--- a/src/test/run-pass/capture-clauses-unboxed-closures.rs
+++ b/src/test/run-pass/capture-clauses-unboxed-closures.rs
@@ -17,8 +17,8 @@ fn each<'a,T,F:FnMut(&'a T)>(x: &'a [T], mut f: F) {
 }
 
 fn main() {
-    let mut sum = 0_usize;
-    let elems = [ 1_usize, 2, 3, 4, 5 ];
+    let mut sum = 0;
+    let elems = [ 1, 2, 3, 4, 5 ];
     each(&elems, |val: &uint| sum += *val);
     assert_eq!(sum, 15);
 }
diff --git a/src/test/run-pass/cast.rs b/src/test/run-pass/cast.rs
index f8a680b2a97..fc71e6c59fc 100644
--- a/src/test/run-pass/cast.rs
+++ b/src/test/run-pass/cast.rs
@@ -16,6 +16,6 @@ pub fn main() {
     assert_eq!(u, 'Q' as u32);
     assert_eq!(i as u8, 'Q' as u8);
     assert_eq!(i as u8 as i8, 'Q' as u8 as i8);
-    assert_eq!(0x51u8 as char, 'Q');
+    assert_eq!(0x51 as char, 'Q');
     assert_eq!(0 as u32, false as u32);
 }
diff --git a/src/test/run-pass/cci_borrow.rs b/src/test/run-pass/cci_borrow.rs
index 89babb8f722..cd8f783a2e5 100644
--- a/src/test/run-pass/cci_borrow.rs
+++ b/src/test/run-pass/cci_borrow.rs
@@ -17,8 +17,8 @@ extern crate cci_borrow_lib;
 use cci_borrow_lib::foo;
 
 pub fn main() {
-    let p: Box<_> = box 22_usize;
+    let p: Box<_> = box 22;
     let r = foo(&*p);
     println!("r={}", r);
-    assert_eq!(r, 22_usize);
+    assert_eq!(r, 22);
 }
diff --git a/src/test/run-pass/cci_impl_exe.rs b/src/test/run-pass/cci_impl_exe.rs
index c4b55b9962f..bda3b73e29c 100644
--- a/src/test/run-pass/cci_impl_exe.rs
+++ b/src/test/run-pass/cci_impl_exe.rs
@@ -17,7 +17,7 @@ pub fn main() {
     //let bt0 = sys::frame_address();
     //println!("%?", bt0);
 
-    3_usize.to(10_usize, |i| {
+    3.to(10, |i| {
         println!("{}", i);
 
         //let bt1 = sys::frame_address();
diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs
index e4b26ba74be..5b91af7a194 100644
--- a/src/test/run-pass/cci_iter_exe.rs
+++ b/src/test/run-pass/cci_iter_exe.rs
@@ -13,10 +13,10 @@
 extern crate cci_iter_lib;
 
 pub fn main() {
-    //let bt0 = sys::rusti::frame_address(1u32);
+    //let bt0 = sys::rusti::frame_address(1);
     //println!("%?", bt0);
     cci_iter_lib::iter(&[1, 2, 3], |i| {
         println!("{}", *i);
-        //assert!(bt0 == sys::rusti::frame_address(2u32));
+        //assert!(bt0 == sys::rusti::frame_address(2));
     })
 }
diff --git a/src/test/run-pass/cci_no_inline_exe.rs b/src/test/run-pass/cci_no_inline_exe.rs
index 2040bd7ad71..cc76ed530c4 100644
--- a/src/test/run-pass/cci_no_inline_exe.rs
+++ b/src/test/run-pass/cci_no_inline_exe.rs
@@ -21,7 +21,7 @@ pub fn main() {
     // actually working.
     //let bt0 = sys::frame_address();
     //println!("%?", bt0);
-    iter(vec!(1_usize, 2_usize, 3_usize), |i| {
+    iter(vec!(1, 2, 3), |i| {
         println!("{}", i);
 
         //let bt1 = sys::frame_address();
diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
index 9a388c9bc24..da51ad761c7 100644
--- a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
+++ b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
@@ -25,6 +25,6 @@ fn print_out(thing: Box<ToString>, expected: String) {
 }
 
 pub fn main() {
-  let nyan: Box<ToString> = box cat(0_usize, 2, "nyan".to_string()) as Box<ToString>;
+  let nyan: Box<ToString> = box cat(0, 2, "nyan".to_string()) as Box<ToString>;
   print_out(nyan, "nyan".to_string());
 }
diff --git a/src/test/run-pass/class-cast-to-trait.rs b/src/test/run-pass/class-cast-to-trait.rs
index 476594c270e..01513ab6f47 100644
--- a/src/test/run-pass/class-cast-to-trait.rs
+++ b/src/test/run-pass/class-cast-to-trait.rs
@@ -42,8 +42,8 @@ impl cat {
 impl cat {
     fn meow(&mut self) {
       println!("Meow");
-      self.meows += 1_usize;
-      if self.meows % 5_usize == 0_usize {
+      self.meows += 1;
+      if self.meows % 5 == 0 {
           self.how_hungry += 1;
       }
     }
@@ -59,7 +59,7 @@ fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
 
 
 pub fn main() {
-    let mut nyan = cat(0_usize, 2, "nyan".to_string());
+    let mut nyan = cat(0, 2, "nyan".to_string());
     let mut nyan: &mut noisy = &mut nyan;
     nyan.speak();
 }
diff --git a/src/test/run-pass/class-dtor.rs b/src/test/run-pass/class-dtor.rs
index 14247ad7754..c98e53c8a95 100644
--- a/src/test/run-pass/class-dtor.rs
+++ b/src/test/run-pass/class-dtor.rs
@@ -21,7 +21,7 @@ impl Drop for cat {
 
 fn cat(done: extern fn(uint)) -> cat {
     cat {
-        meows: 0_usize,
+        meows: 0,
         done: done
     }
 }
diff --git a/src/test/run-pass/class-exports.rs b/src/test/run-pass/class-exports.rs
index 4c7d0e6951a..1cf4c35ee96 100644
--- a/src/test/run-pass/class-exports.rs
+++ b/src/test/run-pass/class-exports.rs
@@ -27,7 +27,7 @@ mod kitty {
     pub fn cat(in_name: String) -> cat {
         cat {
             name: in_name,
-            meows: 0_usize
+            meows: 0
         }
     }
 }
diff --git a/src/test/run-pass/class-method-cross-crate.rs b/src/test/run-pass/class-method-cross-crate.rs
index 47cc500e44e..55acd2e040d 100644
--- a/src/test/run-pass/class-method-cross-crate.rs
+++ b/src/test/run-pass/class-method-cross-crate.rs
@@ -13,8 +13,8 @@ extern crate cci_class_2;
 use cci_class_2::kitties::cat;
 
 pub fn main() {
-  let nyan : cat = cat(52_usize, 99);
-  let kitty = cat(1000_usize, 2);
+  let nyan : cat = cat(52, 99);
+  let kitty = cat(1000, 2);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
   nyan.speak();
diff --git a/src/test/run-pass/class-methods-cross-crate.rs b/src/test/run-pass/class-methods-cross-crate.rs
index d62a726dcdd..34c309780b1 100644
--- a/src/test/run-pass/class-methods-cross-crate.rs
+++ b/src/test/run-pass/class-methods-cross-crate.rs
@@ -13,10 +13,10 @@ extern crate cci_class_3;
 use cci_class_3::kitties::cat;
 
 pub fn main() {
-    let mut nyan : cat = cat(52_usize, 99);
-    let kitty = cat(1000_usize, 2);
+    let mut nyan : cat = cat(52, 99);
+    let kitty = cat(1000, 2);
     assert_eq!(nyan.how_hungry, 99);
     assert_eq!(kitty.how_hungry, 2);
     nyan.speak();
-    assert_eq!(nyan.meow_count(), 53_usize);
+    assert_eq!(nyan.meow_count(), 53);
 }
diff --git a/src/test/run-pass/class-methods.rs b/src/test/run-pass/class-methods.rs
index 18fb03ec935..8fa76342286 100644
--- a/src/test/run-pass/class-methods.rs
+++ b/src/test/run-pass/class-methods.rs
@@ -15,7 +15,7 @@ struct cat {
 }
 
 impl cat {
-    pub fn speak(&mut self) { self.meows += 1_usize; }
+    pub fn speak(&mut self) { self.meows += 1; }
     pub fn meow_count(&mut self) -> uint { self.meows }
 }
 
@@ -27,10 +27,10 @@ fn cat(in_x: uint, in_y: int) -> cat {
 }
 
 pub fn main() {
-  let mut nyan: cat = cat(52_usize, 99);
-  let kitty = cat(1000_usize, 2);
+  let mut nyan: cat = cat(52, 99);
+  let kitty = cat(1000, 2);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
   nyan.speak();
-  assert_eq!(nyan.meow_count(), 53_usize);
+  assert_eq!(nyan.meow_count(), 53);
 }
diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs
index b529b0a0772..557f9986238 100644
--- a/src/test/run-pass/class-poly-methods.rs
+++ b/src/test/run-pass/class-poly-methods.rs
@@ -32,12 +32,12 @@ fn cat<U>(in_x : uint, in_y : int, in_info: Vec<U> ) -> cat<U> {
 }
 
 pub fn main() {
-  let mut nyan : cat<int> = cat::<int>(52_usize, 99, vec!(9));
-  let mut kitty = cat(1000_usize, 2, vec!("tabby".to_string()));
+  let mut nyan : cat<int> = cat::<int>(52, 99, vec!(9));
+  let mut kitty = cat(1000, 2, vec!("tabby".to_string()));
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
   nyan.speak(vec!(1,2,3));
-  assert_eq!(nyan.meow_count(), 55_usize);
+  assert_eq!(nyan.meow_count(), 55);
   kitty.speak(vec!("meow".to_string(), "mew".to_string(), "purr".to_string(), "chirp".to_string()));
-  assert_eq!(kitty.meow_count(), 1004_usize);
+  assert_eq!(kitty.meow_count(), 1004);
 }
diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs
index daff321efcf..2bdc053675f 100644
--- a/src/test/run-pass/class-separate-impl.rs
+++ b/src/test/run-pass/class-separate-impl.rs
@@ -39,8 +39,8 @@ impl cat {
 impl cat {
     fn meow(&mut self) {
         println!("Meow");
-        self.meows += 1_usize;
-        if self.meows % 5_usize == 0_usize {
+        self.meows += 1;
+        if self.meows % 5 == 0 {
             self.how_hungry += 1;
         }
     }
@@ -67,6 +67,6 @@ fn print_out(thing: Box<ToString>, expected: String) {
 }
 
 pub fn main() {
-  let nyan: Box<ToString> = box cat(0_usize, 2, "nyan".to_string()) as Box<ToString>;
+  let nyan: Box<ToString> = box cat(0, 2, "nyan".to_string()) as Box<ToString>;
   print_out(nyan, "nyan".to_string());
 }
diff --git a/src/test/run-pass/class-typarams.rs b/src/test/run-pass/class-typarams.rs
index b56a749d33b..c50a8cc83a5 100644
--- a/src/test/run-pass/class-typarams.rs
+++ b/src/test/run-pass/class-typarams.rs
@@ -17,7 +17,7 @@ struct cat<U> {
 }
 
 impl<U> cat<U> {
-    pub fn speak(&mut self) { self.meows += 1_usize; }
+    pub fn speak(&mut self) { self.meows += 1; }
     pub fn meow_count(&mut self) -> uint { self.meows }
 }
 
@@ -31,6 +31,6 @@ fn cat<U>(in_x : uint, in_y : int) -> cat<U> {
 
 
 pub fn main() {
-  let _nyan : cat<int> = cat::<int>(52_usize, 99);
-  //  let mut kitty = cat(1000_usize, 2);
+  let _nyan : cat<int> = cat::<int>(52, 99);
+  //  let mut kitty = cat(1000, 2);
 }
diff --git a/src/test/run-pass/classes-simple-cross-crate.rs b/src/test/run-pass/classes-simple-cross-crate.rs
index 8037d77807d..09660454648 100644
--- a/src/test/run-pass/classes-simple-cross-crate.rs
+++ b/src/test/run-pass/classes-simple-cross-crate.rs
@@ -13,8 +13,8 @@ extern crate cci_class;
 use cci_class::kitties::cat;
 
 pub fn main() {
-  let nyan : cat = cat(52_usize, 99);
-  let kitty = cat(1000_usize, 2);
+  let nyan : cat = cat(52, 99);
+  let kitty = cat(1000, 2);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
 }
diff --git a/src/test/run-pass/classes-simple-method.rs b/src/test/run-pass/classes-simple-method.rs
index b15d6544fed..502fa73ed93 100644
--- a/src/test/run-pass/classes-simple-method.rs
+++ b/src/test/run-pass/classes-simple-method.rs
@@ -26,8 +26,8 @@ fn cat(in_x : uint, in_y : int) -> cat {
 }
 
 pub fn main() {
-  let mut nyan : cat = cat(52_usize, 99);
-  let kitty = cat(1000_usize, 2);
+  let mut nyan : cat = cat(52, 99);
+  let kitty = cat(1000, 2);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
   nyan.speak();
diff --git a/src/test/run-pass/classes-simple.rs b/src/test/run-pass/classes-simple.rs
index 9bf8df3ce4b..3cf529f2958 100644
--- a/src/test/run-pass/classes-simple.rs
+++ b/src/test/run-pass/classes-simple.rs
@@ -22,8 +22,8 @@ fn cat(in_x : uint, in_y : int) -> cat {
 }
 
 pub fn main() {
-  let nyan : cat = cat(52_usize, 99);
-  let kitty = cat(1000_usize, 2);
+  let nyan : cat = cat(52, 99);
+  let kitty = cat(1000, 2);
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
 }
diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
index ade18a71259..32230c82a72 100644
--- a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
@@ -18,7 +18,7 @@ fn bip(v: &[uint]) -> Vec<uint> {
 }
 
 pub fn main() {
-    let mut the_vec = vec!(1_usize, 2, 3, 100);
+    let mut the_vec = vec!(1, 2, 3, 100);
     assert_eq!(the_vec.clone(), bar(&mut the_vec));
     assert_eq!(the_vec.clone(), bip(&the_vec));
 }
diff --git a/src/test/run-pass/concat.rs b/src/test/run-pass/concat.rs
index b0c3a5922b6..2de881993f1 100644
--- a/src/test/run-pass/concat.rs
+++ b/src/test/run-pass/concat.rs
@@ -15,12 +15,12 @@ pub fn main() {
     assert_eq!(concat!("qux", "quux",).to_string(), "quxquux".to_string());
 
     assert_eq!(
-        concat!(1, 2, 3_usize, 4f32, 4.0, 'a', true),
+        concat!(1, 2, 3, 4f32, 4.0, 'a', true),
         "12344.0atrue"
     );
 
     assert!(match "12344.0atrue" {
-        concat!(1, 2, 3_usize, 4f32, 4.0, 'a', true) => true,
+        concat!(1, 2, 3, 4f32, 4.0, 'a', true) => true,
         _ => false
     })
 }
diff --git a/src/test/run-pass/const-block.rs b/src/test/run-pass/const-block.rs
index cdb96e5dcbf..bdde0cf02c9 100644
--- a/src/test/run-pass/const-block.rs
+++ b/src/test/run-pass/const-block.rs
@@ -58,6 +58,6 @@ pub fn main() {
     assert_eq!(BLOCK_FN(300), 300);
     assert_eq!(BLOCK_ENUM_CONSTRUCTOR(200), Some(200));
     // FIXME #13972
-    // assert_eq!(BLOCK_UNSAFE_SAFE_PTR as *const isize as usize, 0xdeadbeef_us);
-    // assert_eq!(BLOCK_UNSAFE_SAFE_PTR_2 as *const isize as usize, 0xdeadbeef_us);
+    // assert_eq!(BLOCK_UNSAFE_SAFE_PTR as *const isize as usize, 0xdeadbeef);
+    // assert_eq!(BLOCK_UNSAFE_SAFE_PTR_2 as *const isize as usize, 0xdeadbeef);
 }
diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs
index 3a64f53dbb0..9b0e7e4e75e 100644
--- a/src/test/run-pass/const-bound.rs
+++ b/src/test/run-pass/const-bound.rs
@@ -20,7 +20,7 @@ pub fn main() {
     foo("hi".to_string());
     foo(~[1, 2, 3]);
     foo(F{field: 42});
-    foo((1, 2_usize));
+    foo((1, 2));
     foo(@1);*/
     foo(Box::new(1));
 }
diff --git a/src/test/run-pass/double-ref.rs b/src/test/run-pass/double-ref.rs
index 8018f681f38..0cb48670f23 100644
--- a/src/test/run-pass/double-ref.rs
+++ b/src/test/run-pass/double-ref.rs
@@ -9,23 +9,23 @@
 // except according to those terms.
 
 fn check_expr() {
-    let _:         & uint =     &1_usize;
-    let _:       & & uint =    &&1_usize;
-    let _:     & & & uint =   &&&1_usize;
-    let _:     & & & uint =  & &&1_usize;
-    let _:   & & & & uint =  &&&&1_usize;
-    let _:   & & & & uint = & &&&1_usize;
-    let _: & & & & & uint = &&&&&1_usize;
+    let _:         & uint =     &1;
+    let _:       & & uint =    &&1;
+    let _:     & & & uint =   &&&1;
+    let _:     & & & uint =  & &&1;
+    let _:   & & & & uint =  &&&&1;
+    let _:   & & & & uint = & &&&1;
+    let _: & & & & & uint = &&&&&1;
 }
 
 fn check_ty() {
-    let _:     &uint =         & 1_usize;
-    let _:    &&uint =       & & 1_usize;
-    let _:   &&&uint =     & & & 1_usize;
-    let _:  & &&uint =     & & & 1_usize;
-    let _:  &&&&uint =   & & & & 1_usize;
-    let _: & &&&uint =   & & & & 1_usize;
-    let _: &&&&&uint = & & & & & 1_usize;
+    let _:     &uint =         & 1;
+    let _:    &&uint =       & & 1;
+    let _:   &&&uint =     & & & 1;
+    let _:  & &&uint =     & & & 1;
+    let _:  &&&&uint =   & & & & 1;
+    let _: & &&&uint =   & & & & 1;
+    let _: &&&&&uint = & & & & & 1;
 }
 
 fn check_pat() {
diff --git a/src/test/run-pass/drop-trait-enum.rs b/src/test/run-pass/drop-trait-enum.rs
index f94da9fc747..353bd7a9ce0 100644
--- a/src/test/run-pass/drop-trait-enum.rs
+++ b/src/test/run-pass/drop-trait-enum.rs
@@ -62,7 +62,7 @@ pub fn main() {
 
     let (sender, receiver) = channel();
     {
-        let v = Foo::NestedVariant(box 42_usize, SendOnDrop { sender: sender.clone() }, sender);
+        let v = Foo::NestedVariant(box 42, SendOnDrop { sender: sender.clone() }, sender);
     }
     assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
     assert_eq!(receiver.recv().unwrap(), Message::Dropped);
@@ -79,10 +79,10 @@ pub fn main() {
     let (sender, receiver) = channel();
     let t = {
         thread::spawn(move|| {
-            let mut v = Foo::NestedVariant(box 42usize, SendOnDrop {
+            let mut v = Foo::NestedVariant(box 42, SendOnDrop {
                 sender: sender.clone()
             }, sender.clone());
-            v = Foo::NestedVariant(box 42_usize,
+            v = Foo::NestedVariant(box 42,
                                    SendOnDrop { sender: sender.clone() },
                                    sender.clone());
             v = Foo::SimpleVariant(sender.clone());
diff --git a/src/test/run-pass/extern-pass-char.rs b/src/test/run-pass/extern-pass-char.rs
index 49c3bf62dbc..2e86b3774c8 100644
--- a/src/test/run-pass/extern-pass-char.rs
+++ b/src/test/run-pass/extern-pass-char.rs
@@ -17,6 +17,6 @@ extern {
 
 pub fn main() {
     unsafe {
-        assert_eq!(22_u8, rust_dbg_extern_identity_u8(22_u8));
+        assert_eq!(22, rust_dbg_extern_identity_u8(22));
     }
 }
diff --git a/src/test/run-pass/extern-pass-u32.rs b/src/test/run-pass/extern-pass-u32.rs
index 07c04af8e1b..2c018084407 100644
--- a/src/test/run-pass/extern-pass-u32.rs
+++ b/src/test/run-pass/extern-pass-u32.rs
@@ -17,6 +17,6 @@ extern {
 
 pub fn main() {
     unsafe {
-        assert_eq!(22_u32, rust_dbg_extern_identity_u32(22_u32));
+        assert_eq!(22, rust_dbg_extern_identity_u32(22));
     }
 }
diff --git a/src/test/run-pass/extern-pass-u64.rs b/src/test/run-pass/extern-pass-u64.rs
index e19c73ebe20..e72e87d3d93 100644
--- a/src/test/run-pass/extern-pass-u64.rs
+++ b/src/test/run-pass/extern-pass-u64.rs
@@ -17,6 +17,6 @@ extern {
 
 pub fn main() {
     unsafe {
-        assert_eq!(22_u64, rust_dbg_extern_identity_u64(22_u64));
+        assert_eq!(22, rust_dbg_extern_identity_u64(22));
     }
 }
diff --git a/src/test/run-pass/foreign-fn-linkname.rs b/src/test/run-pass/foreign-fn-linkname.rs
index 24b711328a1..1c36ad73238 100644
--- a/src/test/run-pass/foreign-fn-linkname.rs
+++ b/src/test/run-pass/foreign-fn-linkname.rs
@@ -32,5 +32,5 @@ fn strlen(str: String) -> uint {
 
 pub fn main() {
     let len = strlen("Rust".to_string());
-    assert_eq!(len, 4_usize);
+    assert_eq!(len, 4);
 }
diff --git a/src/test/run-pass/i32-sub.rs b/src/test/run-pass/i32-sub.rs
index e5451431ade..cebfd89d8aa 100644
--- a/src/test/run-pass/i32-sub.rs
+++ b/src/test/run-pass/i32-sub.rs
@@ -11,4 +11,4 @@
 
 
 
-pub fn main() { let mut x: i32 = -400_i32; x = 0_i32 - x; assert!((x == 400_i32)); }
+pub fn main() { let mut x: i32 = -400; x = 0 - x; assert!((x == 400)); }
diff --git a/src/test/run-pass/i8-incr.rs b/src/test/run-pass/i8-incr.rs
index fbb4e446dd5..c91e738b822 100644
--- a/src/test/run-pass/i8-incr.rs
+++ b/src/test/run-pass/i8-incr.rs
@@ -12,9 +12,9 @@
 
 
 pub fn main() {
-    let mut x: i8 = -12i8;
-    let y: i8 = -12i8;
-    x = x + 1i8;
-    x = x - 1i8;
+    let mut x: i8 = -12;
+    let y: i8 = -12;
+    x = x + 1;
+    x = x - 1;
     assert_eq!(x, y);
 }
diff --git a/src/test/run-pass/if-check.rs b/src/test/run-pass/if-check.rs
index d2a1a3c71a5..766cced4c26 100644
--- a/src/test/run-pass/if-check.rs
+++ b/src/test/run-pass/if-check.rs
@@ -9,9 +9,9 @@
 // except according to those terms.
 
 fn even(x: uint) -> bool {
-    if x < 2_usize {
+    if x < 2 {
         return false;
-    } else if x == 2_usize { return true; } else { return even(x - 2_usize); }
+    } else if x == 2 { return true; } else { return even(x - 2); }
 }
 
 fn foo(x: uint) {
@@ -22,4 +22,4 @@ fn foo(x: uint) {
     }
 }
 
-pub fn main() { foo(2_usize); }
+pub fn main() { foo(2); }
diff --git a/src/test/run-pass/intrinsic-alignment.rs b/src/test/run-pass/intrinsic-alignment.rs
index 4b0e9168e19..d111462ed5a 100644
--- a/src/test/run-pass/intrinsic-alignment.rs
+++ b/src/test/run-pass/intrinsic-alignment.rs
@@ -27,8 +27,8 @@ mod m {
     #[cfg(target_arch = "x86")]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8_usize);
-            assert_eq!(::rusti::min_align_of::<u64>(), 4_usize);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 4);
         }
     }
 
@@ -36,8 +36,8 @@ mod m {
     #[cfg(any(target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64"))]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8_usize);
-            assert_eq!(::rusti::min_align_of::<u64>(), 8_usize);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 8);
         }
     }
 }
@@ -48,8 +48,8 @@ mod m {
     #[cfg(target_arch = "x86_64")]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8u);
-            assert_eq!(::rusti::min_align_of::<u64>(), 8u);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 8);
         }
     }
 }
@@ -60,8 +60,8 @@ mod m {
     #[cfg(target_arch = "x86")]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8_usize);
-            assert_eq!(::rusti::min_align_of::<u64>(), 8_usize);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 8);
         }
     }
 
@@ -69,8 +69,8 @@ mod m {
     #[cfg(target_arch = "x86_64")]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8_usize);
-            assert_eq!(::rusti::min_align_of::<u64>(), 8_usize);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 8);
         }
     }
 }
@@ -81,8 +81,8 @@ mod m {
     #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
     pub fn main() {
         unsafe {
-            assert_eq!(::rusti::pref_align_of::<u64>(), 8_usize);
-            assert_eq!(::rusti::min_align_of::<u64>(), 8_usize);
+            assert_eq!(::rusti::pref_align_of::<u64>(), 8);
+            assert_eq!(::rusti::min_align_of::<u64>(), 8);
         }
     }
 }
diff --git a/src/test/run-pass/intrinsics-integer.rs b/src/test/run-pass/intrinsics-integer.rs
index 2b0f7cc7d7d..e5724c1e0dc 100644
--- a/src/test/run-pass/intrinsics-integer.rs
+++ b/src/test/run-pass/intrinsics-integer.rs
@@ -37,83 +37,83 @@ pub fn main() {
     unsafe {
         use rusti::*;
 
-        assert_eq!(ctpop8(0u8), 0u8);
-        assert_eq!(ctpop16(0u16), 0u16);
-        assert_eq!(ctpop32(0u32), 0u32);
-        assert_eq!(ctpop64(0u64), 0u64);
+        assert_eq!(ctpop8(0), 0);
+        assert_eq!(ctpop16(0), 0);
+        assert_eq!(ctpop32(0), 0);
+        assert_eq!(ctpop64(0), 0);
 
-        assert_eq!(ctpop8(1u8), 1u8);
-        assert_eq!(ctpop16(1u16), 1u16);
-        assert_eq!(ctpop32(1u32), 1u32);
-        assert_eq!(ctpop64(1u64), 1u64);
+        assert_eq!(ctpop8(1), 1);
+        assert_eq!(ctpop16(1), 1);
+        assert_eq!(ctpop32(1), 1);
+        assert_eq!(ctpop64(1), 1);
 
-        assert_eq!(ctpop8(10u8), 2u8);
-        assert_eq!(ctpop16(10u16), 2u16);
-        assert_eq!(ctpop32(10u32), 2u32);
-        assert_eq!(ctpop64(10u64), 2u64);
+        assert_eq!(ctpop8(10), 2);
+        assert_eq!(ctpop16(10), 2);
+        assert_eq!(ctpop32(10), 2);
+        assert_eq!(ctpop64(10), 2);
 
-        assert_eq!(ctpop8(100u8), 3u8);
-        assert_eq!(ctpop16(100u16), 3u16);
-        assert_eq!(ctpop32(100u32), 3u32);
-        assert_eq!(ctpop64(100u64), 3u64);
+        assert_eq!(ctpop8(100), 3);
+        assert_eq!(ctpop16(100), 3);
+        assert_eq!(ctpop32(100), 3);
+        assert_eq!(ctpop64(100), 3);
 
-        assert_eq!(ctpop8(-1u8), 8u8);
-        assert_eq!(ctpop16(-1u16), 16u16);
-        assert_eq!(ctpop32(-1u32), 32u32);
-        assert_eq!(ctpop64(-1u64), 64u64);
+        assert_eq!(ctpop8(-1), 8);
+        assert_eq!(ctpop16(-1), 16);
+        assert_eq!(ctpop32(-1), 32);
+        assert_eq!(ctpop64(-1), 64);
 
-        assert_eq!(ctlz8(0u8), 8u8);
-        assert_eq!(ctlz16(0u16), 16u16);
-        assert_eq!(ctlz32(0u32), 32u32);
-        assert_eq!(ctlz64(0u64), 64u64);
+        assert_eq!(ctlz8(0), 8);
+        assert_eq!(ctlz16(0), 16);
+        assert_eq!(ctlz32(0), 32);
+        assert_eq!(ctlz64(0), 64);
 
-        assert_eq!(ctlz8(1u8), 7u8);
-        assert_eq!(ctlz16(1u16), 15u16);
-        assert_eq!(ctlz32(1u32), 31u32);
-        assert_eq!(ctlz64(1u64), 63u64);
+        assert_eq!(ctlz8(1), 7);
+        assert_eq!(ctlz16(1), 15);
+        assert_eq!(ctlz32(1), 31);
+        assert_eq!(ctlz64(1), 63);
 
-        assert_eq!(ctlz8(10u8), 4u8);
-        assert_eq!(ctlz16(10u16), 12u16);
-        assert_eq!(ctlz32(10u32), 28u32);
-        assert_eq!(ctlz64(10u64), 60u64);
+        assert_eq!(ctlz8(10), 4);
+        assert_eq!(ctlz16(10), 12);
+        assert_eq!(ctlz32(10), 28);
+        assert_eq!(ctlz64(10), 60);
 
-        assert_eq!(ctlz8(100u8), 1u8);
-        assert_eq!(ctlz16(100u16), 9u16);
-        assert_eq!(ctlz32(100u32), 25u32);
-        assert_eq!(ctlz64(100u64), 57u64);
+        assert_eq!(ctlz8(100), 1);
+        assert_eq!(ctlz16(100), 9);
+        assert_eq!(ctlz32(100), 25);
+        assert_eq!(ctlz64(100), 57);
 
-        assert_eq!(cttz8(-1u8), 0u8);
-        assert_eq!(cttz16(-1u16), 0u16);
-        assert_eq!(cttz32(-1u32), 0u32);
-        assert_eq!(cttz64(-1u64), 0u64);
+        assert_eq!(cttz8(-1), 0);
+        assert_eq!(cttz16(-1), 0);
+        assert_eq!(cttz32(-1), 0);
+        assert_eq!(cttz64(-1), 0);
 
-        assert_eq!(cttz8(0u8), 8u8);
-        assert_eq!(cttz16(0u16), 16u16);
-        assert_eq!(cttz32(0u32), 32u32);
-        assert_eq!(cttz64(0u64), 64u64);
+        assert_eq!(cttz8(0), 8);
+        assert_eq!(cttz16(0), 16);
+        assert_eq!(cttz32(0), 32);
+        assert_eq!(cttz64(0), 64);
 
-        assert_eq!(cttz8(1u8), 0u8);
-        assert_eq!(cttz16(1u16), 0u16);
-        assert_eq!(cttz32(1u32), 0u32);
-        assert_eq!(cttz64(1u64), 0u64);
+        assert_eq!(cttz8(1), 0);
+        assert_eq!(cttz16(1), 0);
+        assert_eq!(cttz32(1), 0);
+        assert_eq!(cttz64(1), 0);
 
-        assert_eq!(cttz8(10u8), 1u8);
-        assert_eq!(cttz16(10u16), 1u16);
-        assert_eq!(cttz32(10u32), 1u32);
-        assert_eq!(cttz64(10u64), 1u64);
+        assert_eq!(cttz8(10), 1);
+        assert_eq!(cttz16(10), 1);
+        assert_eq!(cttz32(10), 1);
+        assert_eq!(cttz64(10), 1);
 
-        assert_eq!(cttz8(100u8), 2u8);
-        assert_eq!(cttz16(100u16), 2u16);
-        assert_eq!(cttz32(100u32), 2u32);
-        assert_eq!(cttz64(100u64), 2u64);
+        assert_eq!(cttz8(100), 2);
+        assert_eq!(cttz16(100), 2);
+        assert_eq!(cttz32(100), 2);
+        assert_eq!(cttz64(100), 2);
 
-        assert_eq!(cttz8(-1u8), 0u8);
-        assert_eq!(cttz16(-1u16), 0u16);
-        assert_eq!(cttz32(-1u32), 0u32);
-        assert_eq!(cttz64(-1u64), 0u64);
+        assert_eq!(cttz8(-1), 0);
+        assert_eq!(cttz16(-1), 0);
+        assert_eq!(cttz32(-1), 0);
+        assert_eq!(cttz64(-1), 0);
 
-        assert_eq!(bswap16(0x0A0Bu16), 0x0B0Au16);
-        assert_eq!(bswap32(0x0ABBCC0Du32), 0x0DCCBB0Au32);
-        assert_eq!(bswap64(0x0122334455667708u64), 0x0877665544332201u64);
+        assert_eq!(bswap16(0x0A0B), 0x0B0A);
+        assert_eq!(bswap32(0x0ABBCC0D), 0x0DCCBB0A);
+        assert_eq!(bswap64(0x0122334455667708), 0x0877665544332201);
     }
 }
diff --git a/src/test/run-pass/intrinsics-math.rs b/src/test/run-pass/intrinsics-math.rs
index ed88b3c65e0..ab65f35dd34 100644
--- a/src/test/run-pass/intrinsics-math.rs
+++ b/src/test/run-pass/intrinsics-math.rs
@@ -65,8 +65,8 @@ pub fn main() {
         assert_approx_eq!(sqrtf32(64f32), 8f32);
         assert_approx_eq!(sqrtf64(64f64), 8f64);
 
-        assert_approx_eq!(powif32(25f32, -2i32), 0.0016f32);
-        assert_approx_eq!(powif64(23.2f64, 2i32), 538.24f64);
+        assert_approx_eq!(powif32(25f32, -2), 0.0016f32);
+        assert_approx_eq!(powif64(23.2f64, 2), 538.24f64);
 
         assert_approx_eq!(sinf32(0f32), 0f32);
         assert_approx_eq!(sinf64(f64::consts::PI / 2f64), 1f64);
diff --git a/src/test/run-pass/issue-1112.rs b/src/test/run-pass/issue-1112.rs
index 22c88c874f0..2ade0df7f6b 100644
--- a/src/test/run-pass/issue-1112.rs
+++ b/src/test/run-pass/issue-1112.rs
@@ -24,21 +24,21 @@ struct X<T> {
 pub fn main() {
     let x: X<int> = X {
         a: 12345678,
-        b: 9u8,
+        b: 9,
         c: true,
-        d: 10u8,
-        e: 11u16,
-        f: 12u8,
-        g: 13u8
+        d: 10,
+        e: 11,
+        f: 12,
+        g: 13
     };
     bar(x);
 }
 
 fn bar<T>(x: X<T>) {
-    assert_eq!(x.b, 9u8);
+    assert_eq!(x.b, 9);
     assert_eq!(x.c, true);
-    assert_eq!(x.d, 10u8);
-    assert_eq!(x.e, 11u16);
-    assert_eq!(x.f, 12u8);
-    assert_eq!(x.g, 13u8);
+    assert_eq!(x.d, 10);
+    assert_eq!(x.e, 11);
+    assert_eq!(x.f, 12);
+    assert_eq!(x.g, 13);
 }
diff --git a/src/test/run-pass/issue-11736.rs b/src/test/run-pass/issue-11736.rs
index b901e95ff55..b09d516dd35 100644
--- a/src/test/run-pass/issue-11736.rs
+++ b/src/test/run-pass/issue-11736.rs
@@ -15,7 +15,7 @@ use std::num::Float;
 
 fn main() {
     // Generate sieve of Eratosthenes for n up to 1e6
-    let n = 1000000_usize;
+    let n = 1000000;
     let mut sieve = BitVec::from_elem(n+1, true);
     let limit: uint = (n as f32).sqrt() as uint;
     for i in 2..limit+1 {
diff --git a/src/test/run-pass/issue-11958.rs b/src/test/run-pass/issue-11958.rs
index 00613f35f17..bb34dae77b3 100644
--- a/src/test/run-pass/issue-11958.rs
+++ b/src/test/run-pass/issue-11958.rs
@@ -19,6 +19,6 @@
 use std::thunk::Thunk;
 
 pub fn main() {
-    let mut x = 1i32;
+    let mut x = 1;
     let _thunk = Thunk::new(move|| { x = 2; });
 }
diff --git a/src/test/run-pass/issue-12909.rs b/src/test/run-pass/issue-12909.rs
index b7dc98b92e0..11a2e52cf97 100644
--- a/src/test/run-pass/issue-12909.rs
+++ b/src/test/run-pass/issue-12909.rs
@@ -15,7 +15,7 @@ fn copy<T: Copy>(&x: &T) -> T {
 }
 
 fn main() {
-    let arr = [(1, 1_usize), (2, 2), (3, 3)];
+    let arr = [(1, 1), (2, 2), (3, 3)];
 
     let v1: Vec<&_> = arr.iter().collect();
     let v2: Vec<_> = arr.iter().map(copy).collect();
diff --git a/src/test/run-pass/issue-15571.rs b/src/test/run-pass/issue-15571.rs
index 5b093d16cbf..3dc76f4a089 100644
--- a/src/test/run-pass/issue-15571.rs
+++ b/src/test/run-pass/issue-15571.rs
@@ -47,7 +47,7 @@ fn match_on_binding() {
 }
 
 fn match_on_upvar() {
-    let mut foo: Option<Box<_>> = Some(box 8i32);
+    let mut foo: Option<Box<_>> = Some(box 8);
     let f = move|| {
         match foo {
             None => {},
diff --git a/src/test/run-pass/issue-15673.rs b/src/test/run-pass/issue-15673.rs
index a6b8a04eeb6..227d8f7b8c8 100644
--- a/src/test/run-pass/issue-15673.rs
+++ b/src/test/run-pass/issue-15673.rs
@@ -11,5 +11,5 @@
 use std::iter::AdditiveIterator;
 fn main() {
     let x: [u64; 3] = [1, 2, 3];
-    assert_eq!(6, (0_usize..3).map(|i| x[i]).sum());
+    assert_eq!(6, (0..3).map(|i| x[i]).sum());
 }
diff --git a/src/test/run-pass/issue-15734.rs b/src/test/run-pass/issue-15734.rs
index e66ac8ff53c..18e4190ee45 100644
--- a/src/test/run-pass/issue-15734.rs
+++ b/src/test/run-pass/issue-15734.rs
@@ -53,12 +53,12 @@ impl<T, M: Index<(uint, uint), Output=T>> Index<uint> for Row<M> {
 }
 
 fn main() {
-    let m = Mat::new(vec!(1_usize, 2, 3, 4, 5, 6), 3);
+    let m = Mat::new(vec!(1, 2, 3, 4, 5, 6), 3);
     let r = m.row(1);
 
     assert!(r.index(&2) == &6);
     assert!(r[2] == 6);
-    assert!(r[2_usize] == 6_usize);
+    assert!(r[2] == 6);
     assert!(6 == r[2]);
 
     let e = r[2];
diff --git a/src/test/run-pass/issue-17662.rs b/src/test/run-pass/issue-17662.rs
index 7bd41cc5b52..dbfa91553e6 100644
--- a/src/test/run-pass/issue-17662.rs
+++ b/src/test/run-pass/issue-17662.rs
@@ -17,7 +17,7 @@ use std::marker;
 struct Bar<'a> { m: marker::PhantomData<&'a ()> }
 
 impl<'a> i::Foo<'a, uint> for Bar<'a> {
-    fn foo(&self) -> uint { 5_usize }
+    fn foo(&self) -> uint { 5 }
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/issue-18539.rs b/src/test/run-pass/issue-18539.rs
index ce56f3e8d72..b92cfa1f29b 100644
--- a/src/test/run-pass/issue-18539.rs
+++ b/src/test/run-pass/issue-18539.rs
@@ -19,5 +19,5 @@ fn uint_to_foo(_: uint) -> Foo {
 
 #[allow(unused_must_use)]
 fn main() {
-    (0_usize..10).map(uint_to_foo);
+    (0..10).map(uint_to_foo);
 }
diff --git a/src/test/run-pass/issue-20055-box-trait.rs b/src/test/run-pass/issue-20055-box-trait.rs
index 572a0d82528..7e89cfe24e1 100644
--- a/src/test/run-pass/issue-20055-box-trait.rs
+++ b/src/test/run-pass/issue-20055-box-trait.rs
@@ -41,10 +41,10 @@ pub fn foo(box_1: fn () -> Box<[i8; 1]>,
 }
 
 pub fn main() {
-    fn box_1() -> Box<[i8; 1]> { Box::new( [1i8; 1] ) }
-    fn box_2() -> Box<[i8; 2]> { Box::new( [1i8; 2] ) }
-    fn box_3() -> Box<[i8; 3]> { Box::new( [1i8; 3] ) }
-    fn box_4() -> Box<[i8; 4]> { Box::new( [1i8; 4] ) }
+    fn box_1() -> Box<[i8; 1]> { Box::new( [1; 1] ) }
+    fn box_2() -> Box<[i8; 2]> { Box::new( [1; 2] ) }
+    fn box_3() -> Box<[i8; 3]> { Box::new( [1; 3] ) }
+    fn box_4() -> Box<[i8; 4]> { Box::new( [1; 4] ) }
 
     foo(box_1, box_2, box_3, box_4);
 }
diff --git a/src/test/run-pass/issue-20055-box-unsized-array.rs b/src/test/run-pass/issue-20055-box-unsized-array.rs
index f751be6f13b..5af5186e94f 100644
--- a/src/test/run-pass/issue-20055-box-unsized-array.rs
+++ b/src/test/run-pass/issue-20055-box-unsized-array.rs
@@ -29,10 +29,10 @@ pub fn foo(box_1: fn () -> Box<[i8; 1]>,
 }
 
 pub fn main() {
-    fn box_1() -> Box<[i8; 1]> { Box::new( [1i8] ) }
-    fn box_2() -> Box<[i8; 20]> { Box::new( [1i8; 20] ) }
-    fn box_3() -> Box<[i8; 300]> { Box::new( [1i8; 300] ) }
-    fn box_4() -> Box<[i8; 4000]> { Box::new( [1i8; 4000] ) }
+    fn box_1() -> Box<[i8; 1]> { Box::new( [1] ) }
+    fn box_2() -> Box<[i8; 20]> { Box::new( [1; 20] ) }
+    fn box_3() -> Box<[i8; 300]> { Box::new( [1; 300] ) }
+    fn box_4() -> Box<[i8; 4000]> { Box::new( [1; 4000] ) }
 
     foo(box_1, box_2, box_3, box_4);
 }
diff --git a/src/test/run-pass/issue-20676.rs b/src/test/run-pass/issue-20676.rs
index 01a2322ae93..640774f9d24 100644
--- a/src/test/run-pass/issue-20676.rs
+++ b/src/test/run-pass/issue-20676.rs
@@ -15,6 +15,6 @@
 use std::fmt;
 
 fn main() {
-    let a: &fmt::Debug = &1_i32;
+    let a: &fmt::Debug = &1;
     format!("{:?}", a);
 }
diff --git a/src/test/run-pass/issue-21475.rs b/src/test/run-pass/issue-21475.rs
index 145145af519..29701bd668a 100644
--- a/src/test/run-pass/issue-21475.rs
+++ b/src/test/run-pass/issue-21475.rs
@@ -11,10 +11,10 @@
 use m::{START, END};
 
 fn main() {
-    match 42u32 {
+    match 42 {
         m::START...m::END => {},
-        0u32...m::END => {},
-        m::START...59u32 => {},
+        0...m::END => {},
+        m::START...59 => {},
         _  => {},
     }
 }
diff --git a/src/test/run-pass/issue-2185.rs b/src/test/run-pass/issue-2185.rs
index 20ff8d29b70..3da0a67ea8e 100644
--- a/src/test/run-pass/issue-2185.rs
+++ b/src/test/run-pass/issue-2185.rs
@@ -72,17 +72,17 @@ fn range(lo: uint, hi: uint, it: |uint|) {
     let mut i = lo;
     while i < hi {
         it(i);
-        i += 1_usize;
+        i += 1;
     }
 }
 
 pub fn main() {
-    let range: 'static ||uint|| = |a| range(0_usize, 1000_usize, a);
+    let range: 'static ||uint|| = |a| range(0, 1000, a);
     let filt: 'static ||v: uint|| = |a| filter(
         range,
-        |&&n: uint| n % 3_usize != 0_usize && n % 5_usize != 0_usize,
+        |&&n: uint| n % 3 != 0 && n % 5 != 0,
         a);
-    let sum = foldl(filt, 0_usize, |accum, &&n: uint| accum + n );
+    let sum = foldl(filt, 0, |accum, &&n: uint| accum + n );
 
     println!("{}", sum);
 }
diff --git a/src/test/run-pass/issue-22036.rs b/src/test/run-pass/issue-22036.rs
index c06a29c09f7..7bc6393ef89 100644
--- a/src/test/run-pass/issue-22036.rs
+++ b/src/test/run-pass/issue-22036.rs
@@ -28,6 +28,6 @@ impl<I> DigitCollection for I where I: Iterator<Item=u8> {
 }
 
 fn main() {
-    let xs = vec![1u8, 2, 3, 4, 5];
+    let xs = vec![1, 2, 3, 4, 5];
     assert_eq!(xs.into_iter().digit_sum(), 15);
 }
diff --git a/src/test/run-pass/issue-2550.rs b/src/test/run-pass/issue-2550.rs
index 395b2c4b459..c55de959a94 100644
--- a/src/test/run-pass/issue-2550.rs
+++ b/src/test/run-pass/issue-2550.rs
@@ -22,5 +22,5 @@ fn f<T>(_x: T) {
 }
 
 pub fn main() {
-    f(C(1_usize));
+    f(C(1));
 }
diff --git a/src/test/run-pass/issue-2989.rs b/src/test/run-pass/issue-2989.rs
index 8767d397b64..8b6eb12f102 100644
--- a/src/test/run-pass/issue-2989.rs
+++ b/src/test/run-pass/issue-2989.rs
@@ -21,11 +21,11 @@ impl methods for () {
 // the position of this function is significant! - if it comes before methods
 // then it works, if it comes after it then it doesn't!
 fn to_bools(bitv: Storage) -> Vec<bool> {
-    (0_usize..8).map(|i| {
+    (0..8).map(|i| {
         let w = i / 64;
         let b = i % 64;
-        let x = 1u64 & (bitv.storage[w] >> b);
-        x == 1u64
+        let x = 1 & (bitv.storage[w] >> b);
+        x == 1
     }).collect()
 }
 
@@ -35,7 +35,7 @@ pub fn main() {
     let bools = vec!(false, false, true, false, false, true, true, false);
     let bools2 = to_bools(Storage{storage: vec!(0b01100100)});
 
-    for i in 0_usize..8 {
+    for i in 0..8 {
         println!("{} => {} vs {}", i, bools[i], bools2[i]);
     }
 
diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs
index 28e44536892..b51edcf8bec 100644
--- a/src/test/run-pass/issue-3609.rs
+++ b/src/test/run-pass/issue-3609.rs
@@ -28,7 +28,7 @@ fn foo(name: String, samples_chan: Sender<Msg>) {
 
         // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
         let callback: SamplesFn = Box::new(move |buffer| {
-            for i in 0_usize..buffer.len() {
+            for i in 0..buffer.len() {
                 println!("{}: {}", i, buffer[i])
             }
         });
diff --git a/src/test/run-pass/issue-6130.rs b/src/test/run-pass/issue-6130.rs
index 93429ff10dc..1a1f538a548 100644
--- a/src/test/run-pass/issue-6130.rs
+++ b/src/test/run-pass/issue-6130.rs
@@ -12,9 +12,9 @@
 
 pub fn main() {
     let i: uint = 0;
-    assert!(i <= 0xFFFF_FFFF_usize);
+    assert!(i <= 0xFFFF_FFFF);
 
     let i: int = 0;
-    assert!(i >= -0x8000_0000__isize);
-    assert!(i <= 0x7FFF_FFFF__isize);
+    assert!(i >= -0x8000_0000);
+    assert!(i <= 0x7FFF_FFFF);
 }
diff --git a/src/test/run-pass/issue-6892.rs b/src/test/run-pass/issue-6892.rs
index 557ec82233d..6faca339651 100644
--- a/src/test/run-pass/issue-6892.rs
+++ b/src/test/run-pass/issue-6892.rs
@@ -49,7 +49,7 @@ fn main() {
     assert_eq!(unsafe { NUM_DROPS }, 3);
     { let _x = FooBar::_Foo(Foo); }
     assert_eq!(unsafe { NUM_DROPS }, 5);
-    { let _x = FooBar::_Bar(42_usize); }
+    { let _x = FooBar::_Bar(42); }
     assert_eq!(unsafe { NUM_DROPS }, 6);
 
     { let _ = Foo; }
@@ -60,6 +60,6 @@ fn main() {
     assert_eq!(unsafe { NUM_DROPS }, 9);
     { let _ = FooBar::_Foo(Foo); }
     assert_eq!(unsafe { NUM_DROPS }, 11);
-    { let _ = FooBar::_Bar(42_usize); }
+    { let _ = FooBar::_Bar(42); }
     assert_eq!(unsafe { NUM_DROPS }, 12);
 }
diff --git a/src/test/run-pass/issue-7012.rs b/src/test/run-pass/issue-7012.rs
index 96db28f4a10..3a9864f3a76 100644
--- a/src/test/run-pass/issue-7012.rs
+++ b/src/test/run-pass/issue-7012.rs
@@ -18,11 +18,11 @@ would be printed, however the below prints false.
 struct signature<'a> { pattern : &'a [u32] }
 
 static test1: signature<'static> =  signature {
-  pattern: &[0x243f6a88u32,0x85a308d3u32,0x13198a2eu32,0x03707344u32,0xa4093822u32,0x299f31d0u32]
+  pattern: &[0x243f6a88,0x85a308d3,0x13198a2e,0x03707344,0xa4093822,0x299f31d0]
 };
 
 pub fn main() {
-  let test: &[u32] = &[0x243f6a88u32,0x85a308d3u32,0x13198a2eu32,
-                       0x03707344u32,0xa4093822u32,0x299f31d0u32];
+  let test: &[u32] = &[0x243f6a88,0x85a308d3,0x13198a2e,
+                       0x03707344,0xa4093822,0x299f31d0];
   println!("{}",test==test1.pattern);
 }
diff --git a/src/test/run-pass/issue-8783.rs b/src/test/run-pass/issue-8783.rs
index 815e00e1291..303dd191006 100644
--- a/src/test/run-pass/issue-8783.rs
+++ b/src/test/run-pass/issue-8783.rs
@@ -13,7 +13,7 @@ use std::default::Default;
 struct X { pub x: uint }
 impl Default for X {
     fn default() -> X {
-        X { x: 42_usize }
+        X { x: 42 }
     }
 }
 
diff --git a/src/test/run-pass/issue2170exe.rs b/src/test/run-pass/issue2170exe.rs
index b4a41ef44f8..58424089c5e 100644
--- a/src/test/run-pass/issue2170exe.rs
+++ b/src/test/run-pass/issue2170exe.rs
@@ -12,5 +12,5 @@
 extern crate issue2170lib;
 
 pub fn main() {
-   // let _ = issue2170lib::rsrc(2i32);
+   // let _ = issue2170lib::rsrc(2);
 }
diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs
index dd38a5f8b3b..121338823d2 100644
--- a/src/test/run-pass/ivec-tag.rs
+++ b/src/test/run-pass/ivec-tag.rs
@@ -13,8 +13,8 @@ use std::sync::mpsc::{channel, Sender};
 
 fn producer(tx: &Sender<Vec<u8>>) {
     tx.send(
-         vec!(1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8,
-          13u8)).unwrap();
+         vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+          13)).unwrap();
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs
index 74ddb990c31..45964efad97 100644
--- a/src/test/run-pass/last-use-in-cap-clause.rs
+++ b/src/test/run-pass/last-use-in-cap-clause.rs
@@ -19,8 +19,8 @@ struct A { a: Box<isize> }
 fn foo() -> Box<FnMut() -> isize + 'static> {
     let k: Box<_> = box 22;
     let _u = A {a: k.clone()};
-    // FIXME(#16640) suffix in `22_isize` suffix shouldn't be necessary
-    let result  = || 22_isize;
+    // FIXME(#16640) suffix in `22` suffix shouldn't be necessary
+    let result  = || 22;
     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
     Box::new(result)
 }
diff --git a/src/test/run-pass/macro-interpolation.rs b/src/test/run-pass/macro-interpolation.rs
index 069aeb9220e..1cbd4f6bc70 100644
--- a/src/test/run-pass/macro-interpolation.rs
+++ b/src/test/run-pass/macro-interpolation.rs
@@ -24,6 +24,6 @@ macro_rules! overly_complicated {
 
 pub fn main() {
     assert!(overly_complicated!(f, x, Option<uint>, { return Some(x); },
-                               Some(8_usize), Some(y), y) == 8_usize)
+                               Some(8), Some(y), y) == 8)
 
 }
diff --git a/src/test/run-pass/macro-pat.rs b/src/test/run-pass/macro-pat.rs
index 6f2626a5af5..7a3e55322c8 100644
--- a/src/test/run-pass/macro-pat.rs
+++ b/src/test/run-pass/macro-pat.rs
@@ -47,9 +47,9 @@ fn f(c: Option<char>) -> uint {
 }
 
 pub fn main() {
-    assert_eq!(1_usize, f(Some('x')));
-    assert_eq!(2_usize, f(Some('y')));
-    assert_eq!(3_usize, f(None));
+    assert_eq!(1, f(Some('x')));
+    assert_eq!(2, f(Some('y')));
+    assert_eq!(3, f(None));
 
     assert_eq!(1, match Some('x') {
         Some(char_x!()) => 1,
diff --git a/src/test/run-pass/match-with-ret-arm.rs b/src/test/run-pass/match-with-ret-arm.rs
index d2e27fc822e..79b197f08e2 100644
--- a/src/test/run-pass/match-with-ret-arm.rs
+++ b/src/test/run-pass/match-with-ret-arm.rs
@@ -16,6 +16,6 @@ pub fn main() {
         None => return (),
         Some(num) => num as u32
     };
-    assert_eq!(f, 1234u32);
+    assert_eq!(f, 1234);
     println!("{}", f)
 }
diff --git a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
index 0ad600dd85d..3ffac98418a 100644
--- a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
+++ b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
@@ -38,7 +38,7 @@ impl<'a> MyWriter for &'a mut [u8] {
 }
 
 fn main() {
-    let mut buf = [0_u8; 6];
+    let mut buf = [0; 6];
 
     {
         let mut writer: &mut [_] = &mut buf;
diff --git a/src/test/run-pass/method-self-arg-aux1.rs b/src/test/run-pass/method-self-arg-aux1.rs
index e9a1e19d4bf..81212ee348f 100644
--- a/src/test/run-pass/method-self-arg-aux1.rs
+++ b/src/test/run-pass/method-self-arg-aux1.rs
@@ -26,5 +26,5 @@ fn main() {
 
     x.foo(&x);
 
-    assert!(method_self_arg1::get_count() == 2u64*3*3*3*5*5*5*7*7*7);
+    assert!(method_self_arg1::get_count() == 2*3*3*3*5*5*5*7*7*7);
 }
diff --git a/src/test/run-pass/method-self-arg-aux2.rs b/src/test/run-pass/method-self-arg-aux2.rs
index 7fa810ce154..ca81860dd08 100644
--- a/src/test/run-pass/method-self-arg-aux2.rs
+++ b/src/test/run-pass/method-self-arg-aux2.rs
@@ -30,5 +30,5 @@ fn main() {
 
     x.run_trait();
 
-    assert!(method_self_arg2::get_count() == 2u64*2*3*3*5*5*7*7*11*11*13*13*17);
+    assert!(method_self_arg2::get_count() == 2*2*3*3*5*5*7*7*11*11*13*13*17);
 }
diff --git a/src/test/run-pass/method-self-arg-trait.rs b/src/test/run-pass/method-self-arg-trait.rs
index c79141d9795..17fdd7b45c2 100644
--- a/src/test/run-pass/method-self-arg-trait.rs
+++ b/src/test/run-pass/method-self-arg-trait.rs
@@ -75,5 +75,5 @@ fn main() {
 
     x.baz();
 
-    unsafe { assert!(COUNT == 2u64*2*3*3*5*5*7*7*11*11*13*13*17); }
+    unsafe { assert!(COUNT == 2*2*3*3*5*5*7*7*11*11*13*13*17); }
 }
diff --git a/src/test/run-pass/method-self-arg.rs b/src/test/run-pass/method-self-arg.rs
index de24297c7b5..62b3d52860b 100644
--- a/src/test/run-pass/method-self-arg.rs
+++ b/src/test/run-pass/method-self-arg.rs
@@ -54,5 +54,5 @@ fn main() {
 
     x.foo(&x);
 
-    unsafe { assert!(COUNT == 2_usize*3*3*3*5*5*5*7*7*7); }
+    unsafe { assert!(COUNT == 2*3*3*3*5*5*5*7*7*7); }
 }
diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs
index bb62b1599a4..03027e40d6c 100644
--- a/src/test/run-pass/nullable-pointer-iotareduction.rs
+++ b/src/test/run-pass/nullable-pointer-iotareduction.rs
@@ -55,7 +55,7 @@ macro_rules! check_fancy {
         check_fancy!($e, $T, |ptr| assert!(*ptr == $e));
     }};
     ($e:expr, $T:ty, |$v:ident| $chk:expr) => {{
-        assert!(E::Nothing::<$T>((), ((), ()), [23i8; 0]).is_none());
+        assert!(E::Nothing::<$T>((), ((), ()), [23; 0]).is_none());
         let e = $e;
         let t_ = E::Thing::<$T>(23, e);
         match t_.get_ref() {
diff --git a/src/test/run-pass/object-method-numbering.rs b/src/test/run-pass/object-method-numbering.rs
index 8da753acb96..9c7a925b5bb 100644
--- a/src/test/run-pass/object-method-numbering.rs
+++ b/src/test/run-pass/object-method-numbering.rs
@@ -29,7 +29,7 @@ impl SomeTrait for i32 {
 }
 
 fn main() {
-    let x = 22_i32;
+    let x = 22;
     let x1: &SomeTrait<SomeType=i32> = &x;
     let y = get_int(x1);
     assert_eq!(x, y);
diff --git a/src/test/run-pass/objects-coerce-freeze-borrored.rs b/src/test/run-pass/objects-coerce-freeze-borrored.rs
index 998af27c338..d2523bc4f24 100644
--- a/src/test/run-pass/objects-coerce-freeze-borrored.rs
+++ b/src/test/run-pass/objects-coerce-freeze-borrored.rs
@@ -40,9 +40,9 @@ fn do_it_imm(obj: &Foo, v: uint) {
 }
 
 pub fn main() {
-    let mut x = 22_usize;
+    let mut x = 22;
     let obj = &mut x as &mut Foo;
     do_it_mut(obj);
-    do_it_imm(obj, 23_usize);
+    do_it_imm(obj, 23);
     do_it_mut(obj);
 }
diff --git a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
index 30a8c270bd7..9cee266c4a7 100644
--- a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
+++ b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
@@ -37,7 +37,7 @@ pub fn main() {
         box BarStruct{ x: 2 } as Box<FooTrait>
     );
 
-    for i in 0_usize..foos.len() {
+    for i in 0..foos.len() {
         assert_eq!(i, foos[i].foo());
     }
 }
diff --git a/src/test/run-pass/or-pattern.rs b/src/test/run-pass/or-pattern.rs
index 654d2429a0b..ef399044abc 100644
--- a/src/test/run-pass/or-pattern.rs
+++ b/src/test/run-pass/or-pattern.rs
@@ -16,6 +16,6 @@ fn or_alt(q: blah) -> int {
 
 pub fn main() {
     assert_eq!(or_alt(blah::c), 0);
-    assert_eq!(or_alt(blah::a(10, 100, 0_usize)), 110);
+    assert_eq!(or_alt(blah::a(10, 100, 0)), 110);
     assert_eq!(or_alt(blah::b(20, 200)), 220);
 }
diff --git a/src/test/run-pass/overloaded-calls-param-vtables.rs b/src/test/run-pass/overloaded-calls-param-vtables.rs
index 2ef9e08134c..0ac9c97532b 100644
--- a/src/test/run-pass/overloaded-calls-param-vtables.rs
+++ b/src/test/run-pass/overloaded-calls-param-vtables.rs
@@ -28,5 +28,5 @@ impl<'a, A: Add<i32, Output=i32>> Fn<(A,)> for G<A> {
 
 fn main() {
     // ICE trigger
-    (G(PhantomData))(1_i32);
+    (G(PhantomData))(1);
 }
diff --git a/src/test/run-pass/packed-struct-vec.rs b/src/test/run-pass/packed-struct-vec.rs
index cfe49c38c52..92f57f04b10 100644
--- a/src/test/run-pass/packed-struct-vec.rs
+++ b/src/test/run-pass/packed-struct-vec.rs
@@ -24,7 +24,7 @@ pub fn main() {
 
     assert_eq!(mem::size_of::<[Foo; 10]>(), 90);
 
-    for i in 0_usize..10 {
+    for i in 0..10 {
         assert_eq!(foos[i], Foo { bar: 1, baz: 2});
     }
 
diff --git a/src/test/run-pass/path.rs b/src/test/run-pass/path.rs
index 02d8602d59e..08d00d4dc03 100644
--- a/src/test/run-pass/path.rs
+++ b/src/test/run-pass/path.rs
@@ -14,4 +14,4 @@ mod foo {
     pub fn bar(_offset: uint) { }
 }
 
-pub fn main() { foo::bar(0_usize); }
+pub fn main() { foo::bar(0); }
diff --git a/src/test/run-pass/private-class-field.rs b/src/test/run-pass/private-class-field.rs
index c7380b362fb..b4d04ba18f9 100644
--- a/src/test/run-pass/private-class-field.rs
+++ b/src/test/run-pass/private-class-field.rs
@@ -26,6 +26,6 @@ fn cat(in_x : uint, in_y : int) -> cat {
 }
 
 pub fn main() {
-    let mut nyan : cat = cat(52_usize, 99);
-    assert_eq!(nyan.meow_count(), 52_usize);
+    let mut nyan : cat = cat(52, 99);
+    assert_eq!(nyan.meow_count(), 52);
 }
diff --git a/src/test/run-pass/pure-sum.rs b/src/test/run-pass/pure-sum.rs
index 1fd83041f62..f12cf82f939 100644
--- a/src/test/run-pass/pure-sum.rs
+++ b/src/test/run-pass/pure-sum.rs
@@ -14,31 +14,31 @@
 #![feature(box_syntax)]
 
 fn sums_to(v: Vec<int> , sum: int) -> bool {
-    let mut i = 0_usize;
+    let mut i = 0;
     let mut sum0 = 0;
     while i < v.len() {
         sum0 += v[i];
-        i += 1_usize;
+        i += 1;
     }
     return sum0 == sum;
 }
 
 fn sums_to_using_uniq(v: Vec<int> , sum: int) -> bool {
-    let mut i = 0_usize;
+    let mut i = 0;
     let mut sum0: Box<_> = box 0;
     while i < v.len() {
         *sum0 += v[i];
-        i += 1_usize;
+        i += 1;
     }
     return *sum0 == sum;
 }
 
 fn sums_to_using_rec(v: Vec<int> , sum: int) -> bool {
-    let mut i = 0_usize;
+    let mut i = 0;
     let mut sum0 = F {f: 0};
     while i < v.len() {
         sum0.f += v[i];
-        i += 1_usize;
+        i += 1;
     }
     return sum0.f == sum;
 }
@@ -46,11 +46,11 @@ fn sums_to_using_rec(v: Vec<int> , sum: int) -> bool {
 struct F<T> { f: T }
 
 fn sums_to_using_uniq_rec(v: Vec<int> , sum: int) -> bool {
-    let mut i = 0_usize;
+    let mut i = 0;
     let mut sum0 = F::<Box<_>> {f: box 0};
     while i < v.len() {
         *sum0.f += v[i];
-        i += 1_usize;
+        i += 1;
     }
     return *sum0.f == sum;
 }
diff --git a/src/test/run-pass/ranges-precedence.rs b/src/test/run-pass/ranges-precedence.rs
index db414abb7ff..41ed9a74d13 100644
--- a/src/test/run-pass/ranges-precedence.rs
+++ b/src/test/run-pass/ranges-precedence.rs
@@ -38,7 +38,7 @@ fn main() {
     let x = ..1+3;
     assert!(x == (..4));
 
-    let a = &[0i32, 1, 2, 3, 4, 5, 6];
+    let a = &[0, 1, 2, 3, 4, 5, 6];
     let x = &a[1+1..2+2];
     assert!(x == &a[2..4]);
     let x = &a[..1+2];
diff --git a/src/test/run-pass/realloc-16687.rs b/src/test/run-pass/realloc-16687.rs
index de5b14104c5..e8bcff38131 100644
--- a/src/test/run-pass/realloc-16687.rs
+++ b/src/test/run-pass/realloc-16687.rs
@@ -35,9 +35,9 @@ unsafe fn test_triangle() -> bool {
     // from pairs of rows (where each pair of rows is equally sized),
     // and the elements of the triangle match their row-pair index.
     unsafe fn sanity_check(ascend: &[*mut u8]) {
-        for i in 0_usize..COUNT / 2 {
+        for i in 0..COUNT / 2 {
             let (p0, p1, size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
-            for j in 0_usize..size {
+            for j in 0..size {
                 assert_eq!(*p0.offset(j as int), i as u8);
                 assert_eq!(*p1.offset(j as int), i as u8);
             }
@@ -88,14 +88,14 @@ unsafe fn test_triangle() -> bool {
     // that at least two rows will be allocated near each other, so
     // that we trigger the bug (a buffer overrun) in an observable
     // way.)
-    for i in 0_usize..COUNT / 2 {
+    for i in 0..COUNT / 2 {
         let size = idx_to_size(i);
         ascend[2*i]   = allocate(size, ALIGN);
         ascend[2*i+1] = allocate(size, ALIGN);
     }
 
     // Initialize each pair of rows to distinct value.
-    for i in 0_usize..COUNT / 2 {
+    for i in 0..COUNT / 2 {
         let (p0, p1, size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
         for j in 0..size {
             *p0.offset(j as int) = i as u8;
@@ -109,7 +109,7 @@ unsafe fn test_triangle() -> bool {
     test_3(ascend); // triangle -> square
     test_4(ascend); // square -> triangle
 
-    for i in 0_usize..COUNT / 2 {
+    for i in 0..COUNT / 2 {
         let size = idx_to_size(i);
         deallocate(ascend[2*i], size, ALIGN);
         deallocate(ascend[2*i+1], size, ALIGN);
@@ -123,7 +123,7 @@ unsafe fn test_triangle() -> bool {
     // rows as we go.
     unsafe fn test_1(ascend: &mut [*mut u8]) {
         let new_size = idx_to_size(COUNT-1);
-        for i in 0_usize..COUNT / 2 {
+        for i in 0..COUNT / 2 {
             let (p0, p1, old_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
             assert!(old_size < new_size);
 
@@ -138,7 +138,7 @@ unsafe fn test_triangle() -> bool {
     // Test 2: turn the square back into a triangle, top to bottom.
     unsafe fn test_2(ascend: &mut [*mut u8]) {
         let old_size = idx_to_size(COUNT-1);
-        for i in 0_usize..COUNT / 2 {
+        for i in 0..COUNT / 2 {
             let (p0, p1, new_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
             assert!(new_size < old_size);
 
@@ -153,7 +153,7 @@ unsafe fn test_triangle() -> bool {
     // Test 3: turn triangle into a square, bottom to top.
     unsafe fn test_3(ascend: &mut [*mut u8]) {
         let new_size = idx_to_size(COUNT-1);
-        for i in (0_usize..COUNT / 2).rev() {
+        for i in (0..COUNT / 2).rev() {
             let (p0, p1, old_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
             assert!(old_size < new_size);
 
@@ -168,7 +168,7 @@ unsafe fn test_triangle() -> bool {
     // Test 4: turn the square back into a triangle, bottom to top.
     unsafe fn test_4(ascend: &mut [*mut u8]) {
         let old_size = idx_to_size(COUNT-1);
-        for i in (0_usize..COUNT / 2).rev() {
+        for i in (0..COUNT / 2).rev() {
             let (p0, p1, new_size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
             assert!(new_size < old_size);
 
diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs
index 51b800bc9f0..94fe3f1d9ea 100644
--- a/src/test/run-pass/rec-align-u32.rs
+++ b/src/test/run-pass/rec-align-u32.rs
@@ -38,19 +38,19 @@ struct Outer {
 
 #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "aarch64"))]
 mod m {
-    pub fn align() -> uint { 4_usize }
-    pub fn size() -> uint { 8_usize }
+    pub fn align() -> uint { 4 }
+    pub fn size() -> uint { 8 }
 }
 
 #[cfg(target_arch = "x86_64")]
 mod m {
-    pub fn align() -> uint { 4_usize }
-    pub fn size() -> uint { 8_usize }
+    pub fn align() -> uint { 4 }
+    pub fn size() -> uint { 8 }
 }
 
 pub fn main() {
     unsafe {
-        let x = Outer {c8: 22u8, t: Inner {c64: 44u32}};
+        let x = Outer {c8: 22, t: Inner {c64: 44}};
 
         // Send it through the shape code
         let y = format!("{:?}", x);
diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs
index 835b4c40f5c..8b7434ed063 100644
--- a/src/test/run-pass/rec-align-u64.rs
+++ b/src/test/run-pass/rec-align-u64.rs
@@ -44,14 +44,14 @@ struct Outer {
 mod m {
     #[cfg(target_arch = "x86")]
     pub mod m {
-        pub fn align() -> uint { 4_usize }
-        pub fn size() -> uint { 12_usize }
+        pub fn align() -> uint { 4 }
+        pub fn size() -> uint { 12 }
     }
 
     #[cfg(any(target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64"))]
     pub mod m {
-        pub fn align() -> uint { 8_usize }
-        pub fn size() -> uint { 16_usize }
+        pub fn align() -> uint { 8 }
+        pub fn size() -> uint { 16 }
     }
 }
 
@@ -59,8 +59,8 @@ mod m {
 mod m {
     #[cfg(target_arch = "x86_64")]
     pub mod m {
-        pub fn align() -> uint { 8u }
-        pub fn size() -> uint { 16u }
+        pub fn align() -> uint { 8 }
+        pub fn size() -> uint { 16 }
     }
 }
 
@@ -68,14 +68,14 @@ mod m {
 mod m {
     #[cfg(target_arch = "x86")]
     pub mod m {
-        pub fn align() -> uint { 8_usize }
-        pub fn size() -> uint { 16_usize }
+        pub fn align() -> uint { 8 }
+        pub fn size() -> uint { 16 }
     }
 
     #[cfg(target_arch = "x86_64")]
     pub mod m {
-        pub fn align() -> uint { 8_usize }
-        pub fn size() -> uint { 16_usize }
+        pub fn align() -> uint { 8 }
+        pub fn size() -> uint { 16 }
     }
 }
 
@@ -83,14 +83,14 @@ mod m {
 mod m {
     #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
     pub mod m {
-        pub fn align() -> uint { 8_usize }
-        pub fn size() -> uint { 16_usize }
+        pub fn align() -> uint { 8 }
+        pub fn size() -> uint { 16 }
     }
 }
 
 pub fn main() {
     unsafe {
-        let x = Outer {c8: 22u8, t: Inner {c64: 44u64}};
+        let x = Outer {c8: 22, t: Inner {c64: 44}};
 
         let y = format!("{:?}", x);
 
diff --git a/src/test/run-pass/record-pat.rs b/src/test/run-pass/record-pat.rs
index 282a24a407c..b152470fbb6 100644
--- a/src/test/run-pass/record-pat.rs
+++ b/src/test/run-pass/record-pat.rs
@@ -20,6 +20,6 @@ fn m(input: t3) -> int {
 }
 
 pub fn main() {
-    assert_eq!(m(t3::c(T2 {x: t1::a(10), y: 5}, 4_usize)), 10);
-    assert_eq!(m(t3::c(T2 {x: t1::b(10_usize), y: 5}, 4_usize)), 19);
+    assert_eq!(m(t3::c(T2 {x: t1::a(10), y: 5}, 4)), 10);
+    assert_eq!(m(t3::c(T2 {x: t1::b(10), y: 5}, 4)), 19);
 }
diff --git a/src/test/run-pass/regions-borrow-at.rs b/src/test/run-pass/regions-borrow-at.rs
index 1e91ab7e921..56dd386ead1 100644
--- a/src/test/run-pass/regions-borrow-at.rs
+++ b/src/test/run-pass/regions-borrow-at.rs
@@ -16,8 +16,8 @@ fn foo(x: &uint) -> uint {
 }
 
 pub fn main() {
-    let p: Box<_> = box 22_usize;
+    let p: Box<_> = box 22;
     let r = foo(&*p);
     println!("r={}", r);
-    assert_eq!(r, 22_usize);
+    assert_eq!(r, 22);
 }
diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs
index 7c9b1ae226f..0673179eef0 100644
--- a/src/test/run-pass/regions-borrow-uniq.rs
+++ b/src/test/run-pass/regions-borrow-uniq.rs
@@ -16,7 +16,7 @@ fn foo(x: &uint) -> uint {
 }
 
 pub fn main() {
-    let p: Box<_> = box 3_usize;
+    let p: Box<_> = box 3;
     let r = foo(&*p);
-    assert_eq!(r, 3_usize);
+    assert_eq!(r, 3);
 }
diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs
index 3704fc1d8d1..b39343b1f57 100644
--- a/src/test/run-pass/regions-copy-closure.rs
+++ b/src/test/run-pass/regions-copy-closure.rs
@@ -20,7 +20,7 @@ fn box_it<'a>(x: Box<FnMut() + 'a>) -> closure_box<'a> {
 }
 
 pub fn main() {
-    let mut i = 3i32;
+    let mut i = 3;
     assert_eq!(i, 3);
     {
         let cl = || i += 1;
diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs
index 0ca17e218d2..3708d187d71 100644
--- a/src/test/run-pass/regions-escape-into-other-fn.rs
+++ b/src/test/run-pass/regions-escape-into-other-fn.rs
@@ -15,6 +15,6 @@ fn foo(x: &uint) -> &uint { x }
 fn bar(x: &uint) -> uint { *x }
 
 pub fn main() {
-    let p: Box<_> = box 3_usize;
+    let p: Box<_> = box 3;
     assert_eq!(bar(foo(&*p)), 3);
 }
diff --git a/src/test/run-pass/regions-params.rs b/src/test/run-pass/regions-params.rs
index c71953e20f8..181d962cfae 100644
--- a/src/test/run-pass/regions-params.rs
+++ b/src/test/run-pass/regions-params.rs
@@ -21,6 +21,6 @@ fn parameterized(x: &uint) -> uint {
 }
 
 pub fn main() {
-    let x = 3_usize;
-    assert_eq!(parameterized(&x), 3_usize);
+    let x = 3;
+    assert_eq!(parameterized(&x), 3);
 }
diff --git a/src/test/run-pass/regions-refcell.rs b/src/test/run-pass/regions-refcell.rs
index a224017780e..30d8fc34d00 100644
--- a/src/test/run-pass/regions-refcell.rs
+++ b/src/test/run-pass/regions-refcell.rs
@@ -18,7 +18,7 @@ use std::cell::RefCell;
 // This version does not yet work (associated type issues)...
 #[cfg(cannot_use_this_yet)]
 fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) {
-    let one = [1_usize];
+    let one = [1];
     assert_eq!(map.borrow().get("one"), Some(&one[..]));
 }
 
@@ -26,7 +26,7 @@ fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) {
 // ... and this version does not work (the lifetime of `one` is
 // supposed to match the lifetime `'a`) ...
 fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) {
-    let one = [1_usize];
+    let one = [1];
     assert_eq!(map.borrow().get("one"), Some(&one.as_slice()));
 }
 
@@ -41,9 +41,9 @@ fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) {
 }
 
 fn main() {
-    let zer = [0u8];
-    let one = [1u8];
-    let two = [2u8];
+    let zer = [0];
+    let one = [1];
+    let two = [2];
     let mut map = HashMap::new();
     map.insert("zero", &zer[..]);
     map.insert("one",  &one[..]);
diff --git a/src/test/run-pass/regions-trait-object-1.rs b/src/test/run-pass/regions-trait-object-1.rs
index eb3bec77326..807227d47db 100644
--- a/src/test/run-pass/regions-trait-object-1.rs
+++ b/src/test/run-pass/regions-trait-object-1.rs
@@ -37,7 +37,7 @@ fn extension<'e>(x: &'e E<'e>) -> Box<M+'e> {
 }
 
 fn main() {
-    let w = E { f: &10u8 };
+    let w = E { f: &10 };
     let o = extension(&w);
-    assert_eq!(o.n(), 10u8);
+    assert_eq!(o.n(), 10);
 }
diff --git a/src/test/run-pass/rename-directory.rs b/src/test/run-pass/rename-directory.rs
index abe6ffe7d4c..9209db22433 100644
--- a/src/test/run-pass/rename-directory.rs
+++ b/src/test/run-pass/rename-directory.rs
@@ -34,7 +34,7 @@ fn rename_directory() {
         let fromp = CString::new(test_file.as_vec()).unwrap();
         let modebuf = CString::new(b"w+b").unwrap();
         let ostream = libc::fopen(fromp.as_ptr(), modebuf.as_ptr());
-        assert!((ostream as uint != 0_usize));
+        assert!((ostream as uint != 0));
         let s = "hello".to_string();
         let buf = CString::new(b"hello").unwrap();
         let write_len = libc::fwrite(buf.as_ptr() as *mut _,
diff --git a/src/test/run-pass/ret-bang.rs b/src/test/run-pass/ret-bang.rs
index 74227192cab..14b398b3d9a 100644
--- a/src/test/run-pass/ret-bang.rs
+++ b/src/test/run-pass/ret-bang.rs
@@ -14,11 +14,11 @@
 fn my_err(s: String) -> ! { println!("{}", s); panic!(); }
 
 fn okay(i: uint) -> int {
-    if i == 3_usize {
+    if i == 3 {
         my_err("I don't like three".to_string());
     } else {
         return 42;
     }
 }
 
-pub fn main() { okay(4_usize); }
+pub fn main() { okay(4); }
diff --git a/src/test/run-pass/running-with-no-runtime.rs b/src/test/run-pass/running-with-no-runtime.rs
index ec033b74dd1..abb16c39d11 100644
--- a/src/test/run-pass/running-with-no-runtime.rs
+++ b/src/test/run-pass/running-with-no-runtime.rs
@@ -43,15 +43,15 @@ fn start(argc: int, argv: *const *const u8) -> int {
     };
     let me = &*args[0];
 
-    let x: &[u8] = &[1u8];
+    let x: &[u8] = &[1];
     pass(Command::new(me).arg(x).output().unwrap());
-    let x: &[u8] = &[2u8];
+    let x: &[u8] = &[2];
     pass(Command::new(me).arg(x).output().unwrap());
-    let x: &[u8] = &[3u8];
+    let x: &[u8] = &[3];
     pass(Command::new(me).arg(x).output().unwrap());
-    let x: &[u8] = &[4u8];
+    let x: &[u8] = &[4];
     pass(Command::new(me).arg(x).output().unwrap());
-    let x: &[u8] = &[5u8];
+    let x: &[u8] = &[5];
     pass(Command::new(me).arg(x).output().unwrap());
 
     0
diff --git a/src/test/run-pass/sendfn-is-a-block.rs b/src/test/run-pass/sendfn-is-a-block.rs
index 18519573c26..51c20bcd098 100644
--- a/src/test/run-pass/sendfn-is-a-block.rs
+++ b/src/test/run-pass/sendfn-is-a-block.rs
@@ -10,10 +10,10 @@
 
 
 fn test<F>(f: F) -> uint where F: FnOnce(uint) -> uint {
-    return f(22_usize);
+    return f(22);
 }
 
 pub fn main() {
-    let y = test(|x| 4_usize * x);
-    assert_eq!(y, 88_usize);
+    let y = test(|x| 4 * x);
+    assert_eq!(y, 88);
 }
diff --git a/src/test/run-pass/shift-various-types.rs b/src/test/run-pass/shift-various-types.rs
index 2f56e09b2df..26dc6c5316b 100644
--- a/src/test/run-pass/shift-various-types.rs
+++ b/src/test/run-pass/shift-various-types.rs
@@ -25,17 +25,17 @@ struct Panolpy {
 }
 
 fn foo(p: &Panolpy) {
-    assert_eq!(22_i32 >> p.i8, 11_i32);
-    assert_eq!(22_i32 >> p.i16, 11_i32);
-    assert_eq!(22_i32 >> p.i32, 11_i32);
-    assert_eq!(22_i32 >> p.i64, 11_i32);
-    assert_eq!(22_i32 >> p.isize, 11_i32);
+    assert_eq!(22 >> p.i8, 11);
+    assert_eq!(22 >> p.i16, 11);
+    assert_eq!(22 >> p.i32, 11);
+    assert_eq!(22 >> p.i64, 11);
+    assert_eq!(22 >> p.isize, 11);
 
-    assert_eq!(22_i32 >> p.u8, 11_i32);
-    assert_eq!(22_i32 >> p.u16, 11_i32);
-    assert_eq!(22_i32 >> p.u32, 11_i32);
-    assert_eq!(22_i32 >> p.u64, 11_i32);
-    assert_eq!(22_i32 >> p.usize, 11_i32);
+    assert_eq!(22 >> p.u8, 11);
+    assert_eq!(22 >> p.u16, 11);
+    assert_eq!(22 >> p.u32, 11);
+    assert_eq!(22 >> p.u64, 11);
+    assert_eq!(22 >> p.usize, 11);
 }
 
 fn main() {
diff --git a/src/test/run-pass/small-enums-with-fields.rs b/src/test/run-pass/small-enums-with-fields.rs
index 475af8f2b8e..86eed715f32 100644
--- a/src/test/run-pass/small-enums-with-fields.rs
+++ b/src/test/run-pass/small-enums-with-fields.rs
@@ -29,14 +29,14 @@ macro_rules! check {
 pub fn main() {
     check!(Option<u8>, 2,
            None, "None",
-           Some(129u8), "Some(129)");
+           Some(129), "Some(129)");
     check!(Option<i16>, 4,
            None, "None",
-           Some(-20000i16), "Some(-20000)");
+           Some(-20000), "Some(-20000)");
     check!(Either<u8, i8>, 2,
-           Either::Left(132u8), "Left(132)",
-           Either::Right(-32i8), "Right(-32)");
+           Either::Left(132), "Left(132)",
+           Either::Right(-32), "Right(-32)");
     check!(Either<u8, i16>, 4,
-           Either::Left(132u8), "Left(132)",
-           Either::Right(-20000i16), "Right(-20000)");
+           Either::Left(132), "Left(132)",
+           Either::Right(-20000), "Right(-20000)");
 }
diff --git a/src/test/run-pass/static-methods-in-traits.rs b/src/test/run-pass/static-methods-in-traits.rs
index 5f6dc4f2a53..47f46041c22 100644
--- a/src/test/run-pass/static-methods-in-traits.rs
+++ b/src/test/run-pass/static-methods-in-traits.rs
@@ -21,7 +21,7 @@ mod a {
 
     impl Foo for uint {
         fn foo() -> uint {
-            5_usize
+            5
         }
     }
 }
diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs
index 359c14ea7b0..cef7a93aeed 100644
--- a/src/test/run-pass/string-self-append.rs
+++ b/src/test/run-pass/string-self-append.rs
@@ -12,12 +12,12 @@ pub fn main() {
     // Make sure we properly handle repeated self-appends.
     let mut a: String = "A".to_string();
     let mut i = 20;
-    let mut expected_len = 1_usize;
+    let mut expected_len = 1;
     while i > 0 {
         println!("{}", a.len());
         assert_eq!(a.len(), expected_len);
         a = format!("{}{}", a, a);
         i -= 1;
-        expected_len *= 2_usize;
+        expected_len *= 2;
     }
 }
diff --git a/src/test/run-pass/struct-return.rs b/src/test/run-pass/struct-return.rs
index c8768731e2b..d67c6322c61 100644
--- a/src/test/run-pass/struct-return.rs
+++ b/src/test/run-pass/struct-return.rs
@@ -28,19 +28,19 @@ mod rustrt {
 
 fn test1() {
     unsafe {
-        let q = Quad { a: 0xaaaa_aaaa_aaaa_aaaa_u64,
-                 b: 0xbbbb_bbbb_bbbb_bbbb_u64,
-                 c: 0xcccc_cccc_cccc_cccc_u64,
-                 d: 0xdddd_dddd_dddd_dddd_u64 };
+        let q = Quad { a: 0xaaaa_aaaa_aaaa_aaaa,
+                 b: 0xbbbb_bbbb_bbbb_bbbb,
+                 c: 0xcccc_cccc_cccc_cccc,
+                 d: 0xdddd_dddd_dddd_dddd };
         let qq = rustrt::rust_dbg_abi_1(q);
         println!("a: {:x}", qq.a as uint);
         println!("b: {:x}", qq.b as uint);
         println!("c: {:x}", qq.c as uint);
         println!("d: {:x}", qq.d as uint);
-        assert_eq!(qq.a, q.c + 1u64);
-        assert_eq!(qq.b, q.d - 1u64);
-        assert_eq!(qq.c, q.a + 1u64);
-        assert_eq!(qq.d, q.b - 1u64);
+        assert_eq!(qq.a, q.c + 1);
+        assert_eq!(qq.b, q.d - 1);
+        assert_eq!(qq.c, q.a + 1);
+        assert_eq!(qq.d, q.b - 1);
     }
 }
 
@@ -48,14 +48,14 @@ fn test1() {
 fn test2() {
     unsafe {
         let f = Floats { a: 1.234567890e-15_f64,
-                 b: 0b_1010_1010_u8,
+                 b: 0b_1010_1010,
                  c: 1.0987654321e-15_f64 };
         let ff = rustrt::rust_dbg_abi_2(f);
         println!("a: {}", ff.a as f64);
         println!("b: {}", ff.b as uint);
         println!("c: {}", ff.c as f64);
         assert_eq!(ff.a, f.c + 1.0f64);
-        assert_eq!(ff.b, 0xff_u8);
+        assert_eq!(ff.b, 0xff);
         assert_eq!(ff.c, f.a - 1.0f64);
     }
 }
diff --git a/src/test/run-pass/syntax-extension-source-utils.rs b/src/test/run-pass/syntax-extension-source-utils.rs
index ddd8cd8be3d..684ca7fa2b6 100644
--- a/src/test/run-pass/syntax-extension-source-utils.rs
+++ b/src/test/run-pass/syntax-extension-source-utils.rs
@@ -23,7 +23,7 @@ macro_rules! indirect_line { () => ( line!() ) }
 
 pub fn main() {
     assert_eq!(line!(), 25);
-    assert!((column!() == 4u32));
+    assert!((column!() == 4));
     assert_eq!(indirect_line!(), 27);
     assert!((file!().ends_with("syntax-extension-source-utils.rs")));
     assert_eq!(stringify!((2*3) + 5).to_string(), "( 2 * 3 ) + 5".to_string());
diff --git a/src/test/run-pass/tag-align-dyn-u64.rs b/src/test/run-pass/tag-align-dyn-u64.rs
index b7fe4983b01..a50711fc98d 100644
--- a/src/test/run-pass/tag-align-dyn-u64.rs
+++ b/src/test/run-pass/tag-align-dyn-u64.rs
@@ -23,12 +23,12 @@ struct Rec {
 }
 
 fn mk_rec() -> Rec {
-    return Rec { c8:0u8, t:Tag::Tag2(0u64) };
+    return Rec { c8:0, t:Tag::Tag2(0) };
 }
 
 fn is_8_byte_aligned(u: &Tag<u64>) -> bool {
     let p: uint = unsafe { mem::transmute(u) };
-    return (p & 7_usize) == 0_usize;
+    return (p & 7) == 0;
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/tag-align-dyn-variants.rs b/src/test/run-pass/tag-align-dyn-variants.rs
index cb298e720ed..69af882e1fa 100644
--- a/src/test/run-pass/tag-align-dyn-variants.rs
+++ b/src/test/run-pass/tag-align-dyn-variants.rs
@@ -26,12 +26,12 @@ struct Rec<A,B> {
 }
 
 fn mk_rec<A,B>(a: A, b: B) -> Rec<A,B> {
-    Rec { chA:0u8, tA:Tag::VarA(a), chB:1u8, tB:Tag::VarB(b) }
+    Rec { chA:0, tA:Tag::VarA(a), chB:1, tB:Tag::VarB(b) }
 }
 
 fn is_aligned<A>(amnt: uint, u: &A) -> bool {
     let p: uint = unsafe { mem::transmute(u) };
-    return (p & (amnt-1_usize)) == 0_usize;
+    return (p & (amnt-1)) == 0;
 }
 
 fn variant_data_is_aligned<A,B>(amnt: uint, u: &Tag<A,B>) -> bool {
@@ -42,33 +42,33 @@ fn variant_data_is_aligned<A,B>(amnt: uint, u: &Tag<A,B>) -> bool {
 }
 
 pub fn main() {
-    let x = mk_rec(22u64, 23u64);
-    assert!(is_aligned(8_usize, &x.tA));
-    assert!(variant_data_is_aligned(8_usize, &x.tA));
-    assert!(is_aligned(8_usize, &x.tB));
-    assert!(variant_data_is_aligned(8_usize, &x.tB));
+    let x = mk_rec(22, 23);
+    assert!(is_aligned(8, &x.tA));
+    assert!(variant_data_is_aligned(8, &x.tA));
+    assert!(is_aligned(8, &x.tB));
+    assert!(variant_data_is_aligned(8, &x.tB));
 
-    let x = mk_rec(22u64, 23u32);
-    assert!(is_aligned(8_usize, &x.tA));
-    assert!(variant_data_is_aligned(8_usize, &x.tA));
-    assert!(is_aligned(8_usize, &x.tB));
-    assert!(variant_data_is_aligned(4_usize, &x.tB));
+    let x = mk_rec(22, 23);
+    assert!(is_aligned(8, &x.tA));
+    assert!(variant_data_is_aligned(8, &x.tA));
+    assert!(is_aligned(8, &x.tB));
+    assert!(variant_data_is_aligned(4, &x.tB));
 
-    let x = mk_rec(22u32, 23u64);
-    assert!(is_aligned(8_usize, &x.tA));
-    assert!(variant_data_is_aligned(4_usize, &x.tA));
-    assert!(is_aligned(8_usize, &x.tB));
-    assert!(variant_data_is_aligned(8_usize, &x.tB));
+    let x = mk_rec(22, 23);
+    assert!(is_aligned(8, &x.tA));
+    assert!(variant_data_is_aligned(4, &x.tA));
+    assert!(is_aligned(8, &x.tB));
+    assert!(variant_data_is_aligned(8, &x.tB));
 
-    let x = mk_rec(22u32, 23u32);
-    assert!(is_aligned(4_usize, &x.tA));
-    assert!(variant_data_is_aligned(4_usize, &x.tA));
-    assert!(is_aligned(4_usize, &x.tB));
-    assert!(variant_data_is_aligned(4_usize, &x.tB));
+    let x = mk_rec(22, 23);
+    assert!(is_aligned(4, &x.tA));
+    assert!(variant_data_is_aligned(4, &x.tA));
+    assert!(is_aligned(4, &x.tB));
+    assert!(variant_data_is_aligned(4, &x.tB));
 
     let x = mk_rec(22f64, 23f64);
-    assert!(is_aligned(8_usize, &x.tA));
-    assert!(variant_data_is_aligned(8_usize, &x.tA));
-    assert!(is_aligned(8_usize, &x.tB));
-    assert!(variant_data_is_aligned(8_usize, &x.tB));
+    assert!(is_aligned(8, &x.tA));
+    assert!(variant_data_is_aligned(8, &x.tA));
+    assert!(is_aligned(8, &x.tB));
+    assert!(variant_data_is_aligned(8, &x.tB));
 }
diff --git a/src/test/run-pass/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs
index cc0a75181db..5db886c815b 100644
--- a/src/test/run-pass/tag-align-shape.rs
+++ b/src/test/run-pass/tag-align-shape.rs
@@ -20,7 +20,7 @@ struct t_rec {
 }
 
 pub fn main() {
-    let x = t_rec {c8: 22u8, t: a_tag::a_tag_var(44u64)};
+    let x = t_rec {c8: 22, t: a_tag::a_tag_var(44)};
     let y = format!("{:?}", x);
     println!("y = {:?}", y);
     assert_eq!(y, "t_rec { c8: 22, t: a_tag_var(44) }".to_string());
diff --git a/src/test/run-pass/tag-align-u64.rs b/src/test/run-pass/tag-align-u64.rs
index 713f55cc10c..e5fd11ff9db 100644
--- a/src/test/run-pass/tag-align-u64.rs
+++ b/src/test/run-pass/tag-align-u64.rs
@@ -23,12 +23,12 @@ struct Rec {
 }
 
 fn mk_rec() -> Rec {
-    return Rec { c8:0u8, t:Tag::TagInner(0u64) };
+    return Rec { c8:0, t:Tag::TagInner(0) };
 }
 
 fn is_8_byte_aligned(u: &Tag) -> bool {
     let p: uint = unsafe { mem::transmute(u) };
-    return (p & 7_usize) == 0_usize;
+    return (p & 7) == 0;
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs
index 1d297c04c82..ca009677ee9 100644
--- a/src/test/run-pass/task-comm-16.rs
+++ b/src/test/run-pass/task-comm-16.rs
@@ -16,12 +16,12 @@ fn test_rec() {
     struct R {val0: int, val1: u8, val2: char}
 
     let (tx, rx) = channel();
-    let r0: R = R {val0: 0, val1: 1u8, val2: '2'};
+    let r0: R = R {val0: 0, val1: 1, val2: '2'};
     tx.send(r0).unwrap();
     let mut r1: R;
     r1 = rx.recv().unwrap();
     assert_eq!(r1.val0, 0);
-    assert_eq!(r1.val1, 1u8);
+    assert_eq!(r1.val1, 1);
     assert_eq!(r1.val2, '2');
 }
 
@@ -84,14 +84,14 @@ fn test_tag() {
     let (tx, rx) = channel();
     tx.send(t::tag1).unwrap();
     tx.send(t::tag2(10)).unwrap();
-    tx.send(t::tag3(10, 11u8, 'A')).unwrap();
+    tx.send(t::tag3(10, 11, 'A')).unwrap();
     let mut t1: t;
     t1 = rx.recv().unwrap();
     assert_eq!(t1, t::tag1);
     t1 = rx.recv().unwrap();
     assert_eq!(t1, t::tag2(10));
     t1 = rx.recv().unwrap();
-    assert_eq!(t1, t::tag3(10, 11u8, 'A'));
+    assert_eq!(t1, t::tag3(10, 11, 'A'));
 }
 
 fn test_chan() {
diff --git a/src/test/run-pass/tcp-stress.rs b/src/test/run-pass/tcp-stress.rs
index 82584c83de0..23ea998c026 100644
--- a/src/test/run-pass/tcp-stress.rs
+++ b/src/test/run-pass/tcp-stress.rs
@@ -52,7 +52,7 @@ fn main() {
     let addr = rx.recv().unwrap();
 
     let (tx, rx) = channel();
-    for _ in 0_usize..1000 {
+    for _ in 0..1000 {
         let tx = tx.clone();
         Builder::new().stack_size(64 * 1024).spawn(move|| {
             match TcpStream::connect(addr) {
@@ -71,7 +71,7 @@ fn main() {
     // Wait for all clients to exit, but don't wait for the server to exit. The
     // server just runs infinitely.
     drop(tx);
-    for _ in 0_usize..1000 {
+    for _ in 0..1000 {
         rx.recv().unwrap();
     }
     unsafe { libc::exit(0) }
diff --git a/src/test/run-pass/trait-default-method-bound-subst4.rs b/src/test/run-pass/trait-default-method-bound-subst4.rs
index 383849ca512..acaa74373f0 100644
--- a/src/test/run-pass/trait-default-method-bound-subst4.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst4.rs
@@ -21,6 +21,6 @@ fn f<T, V: A<T>>(i: V, j: uint) -> uint {
 }
 
 pub fn main () {
-    assert_eq!(f::<f64, int>(0, 2_usize), 2_usize);
-    assert_eq!(f::<uint, int>(0, 2_usize), 2_usize);
+    assert_eq!(f::<f64, int>(0, 2), 2);
+    assert_eq!(f::<uint, int>(0, 2), 2);
 }
diff --git a/src/test/run-pass/trait-object-generics.rs b/src/test/run-pass/trait-object-generics.rs
index 6f89490716f..18097b59b08 100644
--- a/src/test/run-pass/trait-object-generics.rs
+++ b/src/test/run-pass/trait-object-generics.rs
@@ -49,5 +49,5 @@ impl<V> Trait<u8,V> for () {
 
 pub fn main() {
     let a = box() () as Box<Trait<u8, u8>>;
-    assert_eq!(a.method(Type::Constant((1u8, 2u8))), 0);
+    assert_eq!(a.method(Type::Constant((1, 2))), 0);
 }
diff --git a/src/test/run-pass/trait-object-with-lifetime-bound.rs b/src/test/run-pass/trait-object-with-lifetime-bound.rs
index 4e481910aa9..99910f15738 100644
--- a/src/test/run-pass/trait-object-with-lifetime-bound.rs
+++ b/src/test/run-pass/trait-object-with-lifetime-bound.rs
@@ -36,7 +36,7 @@ fn extension<'e>(x: &'e E<'e>) -> Box<M+'e> {
 }
 
 fn main() {
-    let w = E { f: &10u8 };
+    let w = E { f: &10 };
     let o = extension(&w);
-    assert_eq!(o.n(), 10u8);
+    assert_eq!(o.n(), 10);
 }
diff --git a/src/test/run-pass/type-params-in-for-each.rs b/src/test/run-pass/type-params-in-for-each.rs
index cf8a09998da..5d80cec2a05 100644
--- a/src/test/run-pass/type-params-in-for-each.rs
+++ b/src/test/run-pass/type-params-in-for-each.rs
@@ -16,11 +16,11 @@ struct S<T> {
 
 fn range_<F>(lo: uint, hi: uint, mut it: F) where F: FnMut(uint) {
     let mut lo_ = lo;
-    while lo_ < hi { it(lo_); lo_ += 1_usize; }
+    while lo_ < hi { it(lo_); lo_ += 1; }
 }
 
 fn create_index<T>(_index: Vec<S<T>> , _hash_fn: extern fn(T) -> uint) {
-    range_(0_usize, 256_usize, |_i| {
+    range_(0, 256, |_i| {
         let _bucket: Vec<T> = Vec::new();
     })
 }
diff --git a/src/test/run-pass/typeck_type_placeholder_1.rs b/src/test/run-pass/typeck_type_placeholder_1.rs
index 48dc9443821..c850c01753b 100644
--- a/src/test/run-pass/typeck_type_placeholder_1.rs
+++ b/src/test/run-pass/typeck_type_placeholder_1.rs
@@ -21,17 +21,17 @@ static CONSTEXPR: TestStruct = TestStruct{x: &413 as *const _};
 
 
 pub fn main() {
-    let x: Vec<_> = (0_usize..5).collect();
+    let x: Vec<_> = (0..5).collect();
     let expected: &[uint] = &[0,1,2,3,4];
     assert_eq!(x, expected);
 
-    let x = (0_usize..5).collect::<Vec<_>>();
+    let x = (0..5).collect::<Vec<_>>();
     assert_eq!(x, expected);
 
     let y: _ = "hello";
     assert_eq!(y.len(), 5);
 
-    let ptr = &5_usize;
+    let ptr = &5;
     let ptr2 = ptr as *const _;
 
     assert_eq!(ptr as *const uint as uint, ptr2 as uint);
diff --git a/src/test/run-pass/u32-decr.rs b/src/test/run-pass/u32-decr.rs
index 6ad320580df..027bd7ca680 100644
--- a/src/test/run-pass/u32-decr.rs
+++ b/src/test/run-pass/u32-decr.rs
@@ -12,7 +12,7 @@
 
 
 pub fn main() {
-    let mut word: u32 = 200000u32;
-    word = word - 1u32;
-    assert_eq!(word, 199999u32);
+    let mut word: u32 = 200000;
+    word = word - 1;
+    assert_eq!(word, 199999);
 }
diff --git a/src/test/run-pass/u8-incr-decr.rs b/src/test/run-pass/u8-incr-decr.rs
index 0a178b250af..ff25d95d1fd 100644
--- a/src/test/run-pass/u8-incr-decr.rs
+++ b/src/test/run-pass/u8-incr-decr.rs
@@ -15,13 +15,13 @@
 // These constants were chosen because they aren't used anywhere
 // in the rest of the generated code so they're easily grep-able.
 pub fn main() {
-    let mut x: u8 = 19u8; // 0x13
+    let mut x: u8 = 19; // 0x13
 
-    let mut y: u8 = 35u8; // 0x23
+    let mut y: u8 = 35; // 0x23
 
-    x = x + 7u8; // 0x7
+    x = x + 7; // 0x7
 
-    y = y - 9u8; // 0x9
+    y = y - 9; // 0x9
 
     assert_eq!(x, y);
 }
diff --git a/src/test/run-pass/u8-incr.rs b/src/test/run-pass/u8-incr.rs
index 90ed3a5eec3..7f69d078134 100644
--- a/src/test/run-pass/u8-incr.rs
+++ b/src/test/run-pass/u8-incr.rs
@@ -12,12 +12,12 @@
 
 
 pub fn main() {
-    let mut x: u8 = 12u8;
-    let y: u8 = 12u8;
-    x = x + 1u8;
-    x = x - 1u8;
+    let mut x: u8 = 12;
+    let y: u8 = 12;
+    x = x + 1;
+    x = x - 1;
     assert_eq!(x, y);
-    // x = 14u8;
-    // x = x + 1u8;
+    // x = 14;
+    // x = x + 1;
 
 }
diff --git a/src/test/run-pass/ufcs-trait-object.rs b/src/test/run-pass/ufcs-trait-object.rs
index 2ae63040d17..34cf44bba2e 100644
--- a/src/test/run-pass/ufcs-trait-object.rs
+++ b/src/test/run-pass/ufcs-trait-object.rs
@@ -20,6 +20,6 @@ impl Foo for i32 {
 }
 
 fn main() {
-    let a: &Foo = &22_i32;
+    let a: &Foo = &22;
     assert_eq!(Foo::test(a), 22);
 }
diff --git a/src/test/run-pass/unboxed-closures-unique-type-id.rs b/src/test/run-pass/unboxed-closures-unique-type-id.rs
index 5c36832d9f6..ce05f077357 100644
--- a/src/test/run-pass/unboxed-closures-unique-type-id.rs
+++ b/src/test/run-pass/unboxed-closures-unique-type-id.rs
@@ -12,8 +12,8 @@
 //
 //    error: internal compiler error: get_unique_type_id_of_type() -
 //    unexpected type: closure,
-//    ty_closure(syntax::ast::DefId{krate: 0u32, node: 66u32},
-//    ReScope(63u32))
+//    ty_closure(syntax::ast::DefId{krate: 0, node: 66},
+//    ReScope(63))
 //
 // This is a regression test for issue #17021.
 //
@@ -28,8 +28,8 @@ pub fn replace_map<'a, T, F>(src: &mut T, prod: F) where F: FnOnce(T) -> T {
 }
 
 pub fn main() {
-    let mut a = 7_usize;
+    let mut a = 7;
     let b = &mut a;
     replace_map(b, |x: uint| x * 2);
-    assert_eq!(*b, 14_usize);
+    assert_eq!(*b, 14);
 }
diff --git a/src/test/run-pass/unique-pat-2.rs b/src/test/run-pass/unique-pat-2.rs
index 5db96bc3564..8141e3bce3c 100644
--- a/src/test/run-pass/unique-pat-2.rs
+++ b/src/test/run-pass/unique-pat-2.rs
@@ -17,7 +17,7 @@ struct Foo {a: int, b: uint}
 enum bar { u(Box<Foo>), w(int), }
 
 pub fn main() {
-    assert!(match bar::u(box Foo{a: 10, b: 40_usize}) {
+    assert!(match bar::u(box Foo{a: 10, b: 40}) {
               bar::u(box Foo{a: a, b: b}) => { a + (b as int) }
               _ => { 66 }
             } == 50);
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index 43824812ec5..654ac9a095c 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -20,9 +20,9 @@ fn child(tx: &Sender<Box<uint>>, i: uint) {
 
 pub fn main() {
     let (tx, rx) = channel();
-    let n = 100_usize;
-    let mut expected = 0_usize;
-    let _t = (0_usize..n).map(|i| {
+    let n = 100;
+    let mut expected = 0;
+    let _t = (0..n).map(|i| {
         expected += i;
         let tx = tx.clone();
         thread::spawn(move|| {
@@ -30,8 +30,8 @@ pub fn main() {
         })
     }).collect::<Vec<_>>();
 
-    let mut actual = 0_usize;
-    for _ in 0_usize..n {
+    let mut actual = 0;
+    for _ in 0..n {
         let j = rx.recv().unwrap();
         actual += *j;
     }
diff --git a/src/test/run-pass/unsized3.rs b/src/test/run-pass/unsized3.rs
index c9a9d6ad147..5bd76d093d4 100644
--- a/src/test/run-pass/unsized3.rs
+++ b/src/test/run-pass/unsized3.rs
@@ -66,12 +66,10 @@ pub fn main() {
             f: [T; 3]
         }
 
-        let data: Box<_> = box Foo_{f: [1i32, 2, 3] };
+        let data: Box<Foo_<i32>> = box Foo_{f: [1, 2, 3] };
         let x: &Foo<i32> = mem::transmute(raw::Slice { len: 3, data: &*data });
         assert!(x.f.len() == 3);
         assert!(x.f[0] == 1);
-        assert!(x.f[1] == 2);
-        assert!(x.f[2] == 3);
 
         struct Baz_ {
             f1: uint,
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index 84f605eef57..88369f2e500 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -18,26 +18,26 @@ pub fn main() {
     let s: String = chs.iter().cloned().collect();
     let schs: Vec<char> = s.chars().collect();
 
-    assert!(s.len() == 10_usize);
-    assert!(s.chars().count() == 4_usize);
-    assert!(schs.len() == 4_usize);
+    assert!(s.len() == 10);
+    assert!(s.chars().count() == 4);
+    assert!(schs.len() == 4);
     assert!(schs.iter().cloned().collect::<String>() == s);
-    assert!(s.char_at(0_usize) == 'e');
-    assert!(s.char_at(1_usize) == 'é');
+    assert!(s.char_at(0) == 'e');
+    assert!(s.char_at(1) == 'é');
 
     assert!((str::from_utf8(s.as_bytes()).is_ok()));
     // invalid prefix
-    assert!((!str::from_utf8(&[0x80_u8]).is_ok()));
+    assert!((!str::from_utf8(&[0x80]).is_ok()));
     // invalid 2 byte prefix
-    assert!((!str::from_utf8(&[0xc0_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xc0_u8, 0x10_u8]).is_ok()));
+    assert!((!str::from_utf8(&[0xc0]).is_ok()));
+    assert!((!str::from_utf8(&[0xc0, 0x10]).is_ok()));
     // invalid 3 byte prefix
-    assert!((!str::from_utf8(&[0xe0_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xe0_u8, 0x10_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xe0_u8, 0xff_u8, 0x10_u8]).is_ok()));
+    assert!((!str::from_utf8(&[0xe0]).is_ok()));
+    assert!((!str::from_utf8(&[0xe0, 0x10]).is_ok()));
+    assert!((!str::from_utf8(&[0xe0, 0xff, 0x10]).is_ok()));
     // invalid 4 byte prefix
-    assert!((!str::from_utf8(&[0xf0_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xf0_u8, 0x10_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xf0_u8, 0xff_u8, 0x10_u8]).is_ok()));
-    assert!((!str::from_utf8(&[0xf0_u8, 0xff_u8, 0xff_u8, 0x10_u8]).is_ok()));
+    assert!((!str::from_utf8(&[0xf0]).is_ok()));
+    assert!((!str::from_utf8(&[0xf0, 0x10]).is_ok()));
+    assert!((!str::from_utf8(&[0xf0, 0xff, 0x10]).is_ok()));
+    assert!((!str::from_utf8(&[0xf0, 0xff, 0xff, 0x10]).is_ok()));
 }
diff --git a/src/test/run-pass/vec-fixed-length.rs b/src/test/run-pass/vec-fixed-length.rs
index 015baea5fb5..a0b3564d84e 100644
--- a/src/test/run-pass/vec-fixed-length.rs
+++ b/src/test/run-pass/vec-fixed-length.rs
@@ -17,11 +17,11 @@ pub fn main() {
     assert_eq!(x[2], 3);
     assert_eq!(x[3], 4);
 
-    assert_eq!(size_of::<[u8; 4]>(), 4_usize);
+    assert_eq!(size_of::<[u8; 4]>(), 4);
 
     // FIXME #10183
     // FIXME #18069
     //if cfg!(target_pointer_width = "64") {
-    //    assert_eq!(size_of::<[u8; (1 << 32)]>(), (1_usize << 32));
+    //    assert_eq!(size_of::<[u8; (1 << 32)]>(), (1 << 32));
     //}
 }
diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs
index baea1b8826a..20e42575b27 100644
--- a/src/test/run-pass/weird-exprs.rs
+++ b/src/test/run-pass/weird-exprs.rs
@@ -65,7 +65,7 @@ fn canttouchthis() -> uint {
     fn p() -> bool { true }
     let _a = (assert!((true)) == (assert!(p())));
     let _c = (assert!((p())) == ());
-    let _b: bool = (println!("{}", 0) == (return 0_usize));
+    let _b: bool = (println!("{}", 0) == (return 0));
 }
 
 fn angrydome() {
diff --git a/src/test/run-pass/where-for-self.rs b/src/test/run-pass/where-for-self.rs
index 1fd223b0dd3..67757d7efa8 100644
--- a/src/test/run-pass/where-for-self.rs
+++ b/src/test/run-pass/where-for-self.rs
@@ -55,7 +55,7 @@ fn foo2<T>(x: &T)
 }
 
 fn main() {
-    let x = 42u32;
+    let x = 42;
     foo1(&x);
     foo2(&x);
     unsafe {
diff --git a/src/test/run-pass/x86stdcall.rs b/src/test/run-pass/x86stdcall.rs
index dea58c8e86f..b884adb7a6e 100644
--- a/src/test/run-pass/x86stdcall.rs
+++ b/src/test/run-pass/x86stdcall.rs
@@ -22,7 +22,7 @@ mod kernel32 {
 #[cfg(windows)]
 pub fn main() {
     unsafe {
-        let expected = 1234_usize;
+        let expected = 1234;
         kernel32::SetLastError(expected);
         let actual = kernel32::GetLastError();
         println!("actual = {}", actual);
diff --git a/src/test/run-pass/x86stdcall2.rs b/src/test/run-pass/x86stdcall2.rs
index 86c1ae0f51f..b5b9d95d87f 100644
--- a/src/test/run-pass/x86stdcall2.rs
+++ b/src/test/run-pass/x86stdcall2.rs
@@ -30,10 +30,10 @@ mod kernel32 {
 #[cfg(windows)]
 pub fn main() {
     let heap = unsafe { kernel32::GetProcessHeap() };
-    let mem = unsafe { kernel32::HeapAlloc(heap, 0u32, 100u32) };
-    assert!(mem != 0_usize);
-    let res = unsafe { kernel32::HeapFree(heap, 0u32, mem) };
-    assert!(res != 0u8);
+    let mem = unsafe { kernel32::HeapAlloc(heap, 0, 100) };
+    assert!(mem != 0);
+    let res = unsafe { kernel32::HeapFree(heap, 0, mem) };
+    assert!(res != 0);
 }
 
 #[cfg(not(windows))]

From 34410ec748b92e15c445ba7371561e2e5c5aaa55 Mon Sep 17 00:00:00 2001
From: Eduard Burtescu <edy.burt@gmail.com>
Date: Wed, 4 Mar 2015 15:48:33 +0200
Subject: [PATCH 27/34] Fix compile-fail error messages after integer suffix
 removal.

---
 src/test/compile-fail/array-not-vector.rs                 | 2 +-
 src/test/compile-fail/bad-const-type.rs                   | 4 ++--
 src/test/compile-fail/binop-logic-int.rs                  | 2 +-
 src/test/compile-fail/coercion-slice.rs                   | 2 +-
 src/test/compile-fail/issue-13058.rs                      | 2 +-
 src/test/compile-fail/issue-13466.rs                      | 4 ++--
 src/test/compile-fail/issue-13482-2.rs                    | 2 +-
 src/test/compile-fail/issue-14845.rs                      | 2 +-
 src/test/compile-fail/issue-17651.rs                      | 2 +-
 src/test/compile-fail/issue-19991.rs                      | 4 ++--
 src/test/compile-fail/issue-7867.rs                       | 4 ++--
 src/test/compile-fail/method-self-arg-1.rs                | 4 ++--
 src/test/compile-fail/mut-pattern-mismatched.rs           | 4 ++--
 .../compile-fail/structure-constructor-type-mismatch.rs   | 8 ++++----
 src/test/compile-fail/tuple-index-out-of-bounds.rs        | 2 +-
 src/test/compile-fail/type-mismatch-multiple.rs           | 4 ++--
 16 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/test/compile-fail/array-not-vector.rs b/src/test/compile-fail/array-not-vector.rs
index 81883108a2b..6c9b8f81b2f 100644
--- a/src/test/compile-fail/array-not-vector.rs
+++ b/src/test/compile-fail/array-not-vector.rs
@@ -12,7 +12,7 @@ fn main() {
     let _x: i32 = [1, 2, 3];
     //~^ ERROR mismatched types
     //~| expected `i32`
-    //~| found `[i32; 3]`
+    //~| found `[_; 3]`
     //~| expected i32
     //~| found array of 3 elements
 
diff --git a/src/test/compile-fail/bad-const-type.rs b/src/test/compile-fail/bad-const-type.rs
index 93ff7c08f79..a9e5c957b89 100644
--- a/src/test/compile-fail/bad-const-type.rs
+++ b/src/test/compile-fail/bad-const-type.rs
@@ -11,7 +11,7 @@
 static i: String = 10;
 //~^ ERROR mismatched types
 //~| expected `collections::string::String`
-//~| found `i32`
+//~| found `_`
 //~| expected struct `collections::string::String`
-//~| found i32
+//~| found integral variable
 fn main() { println!("{}", i); }
diff --git a/src/test/compile-fail/binop-logic-int.rs b/src/test/compile-fail/binop-logic-int.rs
index 1a3db388877..d5dd9e00902 100644
--- a/src/test/compile-fail/binop-logic-int.rs
+++ b/src/test/compile-fail/binop-logic-int.rs
@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern:`&&` cannot be applied to type `i32`
+// error-pattern:`&&` cannot be applied to type `_`
 
 fn main() { let x = 1 && 2; }
diff --git a/src/test/compile-fail/coercion-slice.rs b/src/test/compile-fail/coercion-slice.rs
index 40fbcd556b0..bb4d1693af7 100644
--- a/src/test/compile-fail/coercion-slice.rs
+++ b/src/test/compile-fail/coercion-slice.rs
@@ -14,7 +14,7 @@ fn main() {
     let _: &[i32] = [0];
     //~^ ERROR mismatched types
     //~| expected `&[i32]`
-    //~| found `[i32; 1]`
+    //~| found `[_; 1]`
     //~| expected &-ptr
     //~| found array of 1 elements
 }
diff --git a/src/test/compile-fail/issue-13058.rs b/src/test/compile-fail/issue-13058.rs
index 6f024fc5382..50c4ac94d90 100644
--- a/src/test/compile-fail/issue-13058.rs
+++ b/src/test/compile-fail/issue-13058.rs
@@ -37,7 +37,7 @@ fn main() {
     check((3, 5));
 //~^ ERROR mismatched types
 //~| expected `&_`
-//~| found `(usize, usize)`
+//~| found `(_, _)`
 //~| expected &-ptr
 //~| found tuple
 }
diff --git a/src/test/compile-fail/issue-13466.rs b/src/test/compile-fail/issue-13466.rs
index 3eb42f902f9..a29a83c4306 100644
--- a/src/test/compile-fail/issue-13466.rs
+++ b/src/test/compile-fail/issue-13466.rs
@@ -17,14 +17,14 @@ pub fn main() {
     let _x: usize = match Some(1) {
         Ok(u) => u,
         //~^ ERROR mismatched types
-        //~| expected `core::option::Option<usize>`
+        //~| expected `core::option::Option<_>`
         //~| found `core::result::Result<_, _>`
         //~| expected enum `core::option::Option`
         //~| found enum `core::result::Result`
 
         Err(e) => panic!(e)
         //~^ ERROR mismatched types
-        //~| expected `core::option::Option<usize>`
+        //~| expected `core::option::Option<_>`
         //~| found `core::result::Result<_, _>`
         //~| expected enum `core::option::Option`
         //~| found enum `core::result::Result`
diff --git a/src/test/compile-fail/issue-13482-2.rs b/src/test/compile-fail/issue-13482-2.rs
index 7af10aa13a8..86a79416c77 100644
--- a/src/test/compile-fail/issue-13482-2.rs
+++ b/src/test/compile-fail/issue-13482-2.rs
@@ -15,7 +15,7 @@ fn main() {
     let y = match x {
         [] => None,
 //~^ ERROR mismatched types
-//~| expected `[_#0; 2]`
+//~| expected `[_#0i; 2]`
 //~| found `[_#7t; 0]`
 //~| expected an array with a fixed size of 2 elements
 //~| found one with 0 elements
diff --git a/src/test/compile-fail/issue-14845.rs b/src/test/compile-fail/issue-14845.rs
index 3381b930714..d7bb806999c 100644
--- a/src/test/compile-fail/issue-14845.rs
+++ b/src/test/compile-fail/issue-14845.rs
@@ -26,7 +26,7 @@ fn main() {
     let _v = &local as *mut u8;
     //~^ ERROR mismatched types
     //~| expected `*mut u8`
-    //~| found `&[u8; 1]`
+    //~| found `&[_; 1]`
     //~| expected u8,
     //~| found array of 1 elements
 }
diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs
index 723b4ca03e7..8ebf80a8db0 100644
--- a/src/test/compile-fail/issue-17651.rs
+++ b/src/test/compile-fail/issue-17651.rs
@@ -14,5 +14,5 @@
 fn main() {
     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
     (|| Box::new(*[0].as_slice()))();
-    //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[usize]`
+    //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[_]`
 }
diff --git a/src/test/compile-fail/issue-19991.rs b/src/test/compile-fail/issue-19991.rs
index 7c1e18ba997..6c9b0004f77 100644
--- a/src/test/compile-fail/issue-19991.rs
+++ b/src/test/compile-fail/issue-19991.rs
@@ -14,9 +14,9 @@
 fn main() {
     if let Some(homura) = Some("madoka") { //~  ERROR missing an else clause
                                            //~| expected `()`
-                                           //~| found `i32`
+                                           //~| found `_`
                                            //~| expected ()
-                                           //~| found i32
+                                           //~| found integral variable
         765
     };
 }
diff --git a/src/test/compile-fail/issue-7867.rs b/src/test/compile-fail/issue-7867.rs
index 1eaa85c3b7e..400806c3a5f 100644
--- a/src/test/compile-fail/issue-7867.rs
+++ b/src/test/compile-fail/issue-7867.rs
@@ -26,13 +26,13 @@ fn main() {
     match &Some(42) {
         Some(x) => (),
         //~^ ERROR mismatched types
-        //~| expected `&core::option::Option<i32>`
+        //~| expected `&core::option::Option<_>`
         //~| found `core::option::Option<_>`
         //~| expected &-ptr
         //~| found enum `core::option::Option`
         None => ()
         //~^ ERROR mismatched types
-        //~| expected `&core::option::Option<i32>`
+        //~| expected `&core::option::Option<_>`
         //~| found `core::option::Option<_>`
         //~| expected &-ptr
         //~| found enum `core::option::Option`
diff --git a/src/test/compile-fail/method-self-arg-1.rs b/src/test/compile-fail/method-self-arg-1.rs
index 666812c98bc..57a96bb9a26 100644
--- a/src/test/compile-fail/method-self-arg-1.rs
+++ b/src/test/compile-fail/method-self-arg-1.rs
@@ -25,7 +25,7 @@ fn main() {
                  //~| found struct `Foo`
     Foo::bar(&42); //~  ERROR mismatched types
                       //~| expected `&Foo`
-                      //~| found `&i32`
+                      //~| found `&_`
                       //~| expected struct `Foo`
-                      //~| found i32
+                      //~| found integral variable
 }
diff --git a/src/test/compile-fail/mut-pattern-mismatched.rs b/src/test/compile-fail/mut-pattern-mismatched.rs
index 1b748624491..9eb24c81960 100644
--- a/src/test/compile-fail/mut-pattern-mismatched.rs
+++ b/src/test/compile-fail/mut-pattern-mismatched.rs
@@ -14,7 +14,7 @@ fn main() {
     // (separate lines to ensure the spans are accurate)
 
      let &_ //~  ERROR mismatched types
-            //~| expected `&mut i32`
+            //~| expected `&mut _`
             //~| found `&_`
             //~| values differ in mutability
         = foo;
@@ -23,7 +23,7 @@ fn main() {
     let bar = &1;
     let &_ = bar;
     let &mut _ //~  ERROR mismatched types
-               //~| expected `&i32`
+               //~| expected `&_`
                //~| found `&mut _`
                //~| values differ in mutability
          = bar;
diff --git a/src/test/compile-fail/structure-constructor-type-mismatch.rs b/src/test/compile-fail/structure-constructor-type-mismatch.rs
index 4a0006338e6..ea6d63ca540 100644
--- a/src/test/compile-fail/structure-constructor-type-mismatch.rs
+++ b/src/test/compile-fail/structure-constructor-type-mismatch.rs
@@ -26,7 +26,7 @@ fn main() {
     let pt = PointF {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
-        //~| found i32
+        //~| found integral variable
         x: 1,
         y: 2,
     };
@@ -34,7 +34,7 @@ fn main() {
     let pt2 = Point::<f32> {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
-        //~| found i32
+        //~| found integral variable
         x: 3,
         y: 4,
     };
@@ -42,7 +42,7 @@ fn main() {
     let pair = PairF {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
-        //~| found i32
+        //~| found integral variable
         x: 5,
         y: 6,
     };
@@ -50,7 +50,7 @@ fn main() {
     let pair2 = PairF::<i32> {
         //~^ ERROR structure constructor specifies a structure of type
         //~| expected f32
-        //~| found i32
+        //~| found integral variable
         x: 7,
         y: 8,
     };
diff --git a/src/test/compile-fail/tuple-index-out-of-bounds.rs b/src/test/compile-fail/tuple-index-out-of-bounds.rs
index e2a951cab72..c2c41fbbb2a 100644
--- a/src/test/compile-fail/tuple-index-out-of-bounds.rs
+++ b/src/test/compile-fail/tuple-index-out-of-bounds.rs
@@ -20,5 +20,5 @@ fn main() {
     tuple.0;
     tuple.1;
     tuple.2;
-    //~^ ERROR attempted out-of-bounds tuple index `2` on type `(i32, i32)`
+    //~^ ERROR attempted out-of-bounds tuple index `2` on type `(_, _)`
 }
diff --git a/src/test/compile-fail/type-mismatch-multiple.rs b/src/test/compile-fail/type-mismatch-multiple.rs
index a51a8172543..627300a0377 100644
--- a/src/test/compile-fail/type-mismatch-multiple.rs
+++ b/src/test/compile-fail/type-mismatch-multiple.rs
@@ -13,9 +13,9 @@
 fn main() { let a: bool = 1; let b: i32 = true; }
 //~^ ERROR mismatched types
 //~| expected `bool`
-//~| found `i32`
+//~| found `_`
 //~| expected bool
-//~| found i32
+//~| found integral variable
 //~| ERROR mismatched types
 //~| expected `i32`
 //~| found `bool`

From 5d003c6f7925eba01321a27fac106bfaaaa7973e Mon Sep 17 00:00:00 2001
From: Dave Huseby <dhuseby@mozilla.com>
Date: Tue, 3 Mar 2015 14:04:13 -0800
Subject: [PATCH 28/34] updating llvm submodule to include bitrig support

---
 src/llvm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm b/src/llvm
index b89c3f039b6..bff69076975 160000
--- a/src/llvm
+++ b/src/llvm
@@ -1 +1 @@
-Subproject commit b89c3f039b61edbb077771eda2ee8a718dbec7e0
+Subproject commit bff69076975642c64e76dbeaa53476bfa7212086

From a73fc0fe834db298f199d2b63710db56384b0ed1 Mon Sep 17 00:00:00 2001
From: Dave Huseby <dhuseby@mozilla.com>
Date: Tue, 3 Mar 2015 16:03:21 -0800
Subject: [PATCH 29/34] bumping the jemalloc revision to include the bitrig
 changes

---
 src/jemalloc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/jemalloc b/src/jemalloc
index b001609960c..c30cf42aeca 160000
--- a/src/jemalloc
+++ b/src/jemalloc
@@ -1 +1 @@
-Subproject commit b001609960ca33047e5cbc5a231c1e24b6041d4b
+Subproject commit c30cf42aeca7f4f7996a88763a4fb1c9807afc7a

From 4ca07af526c16d1e170575c6b0fa37d06087dac8 Mon Sep 17 00:00:00 2001
From: Dave Huseby <dhuseby@mozilla.com>
Date: Tue, 3 Mar 2015 16:17:20 -0800
Subject: [PATCH 30/34] bumping again to get the updated configure

---
 src/jemalloc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/jemalloc b/src/jemalloc
index c30cf42aeca..e24a1a025a1 160000
--- a/src/jemalloc
+++ b/src/jemalloc
@@ -1 +1 @@
-Subproject commit c30cf42aeca7f4f7996a88763a4fb1c9807afc7a
+Subproject commit e24a1a025a1f214e40eedafe3b9c7b1d69937922

From 07e51ec7e00dbae524e4746fe13159069024cd90 Mon Sep 17 00:00:00 2001
From: Dave Huseby <dhuseby@mozilla.com>
Date: Tue, 3 Mar 2015 22:51:36 -0800
Subject: [PATCH 31/34] adding bitrig snapshot to snapshots file

---
 src/snapshots.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/snapshots.txt b/src/snapshots.txt
index 318f66b9465..5e85e3dff6a 100644
--- a/src/snapshots.txt
+++ b/src/snapshots.txt
@@ -1,4 +1,5 @@
 S 2015-02-25 880fb89
+  bitrig-x86_64 8cdc4ca0a80103100f46cbf8caa9fe497df048c5
   freebsd-x86_64 f4cbe4227739de986444211f8ee8d74745ab8f7f
   linux-i386 3278ebbce8cb269acc0614dac5ddac07eab6a99c
   linux-x86_64 72287d0d88de3e5a53bae78ac0d958e1a7637d73

From 13720b5571b186fc9667efdff829801b9097b1ab Mon Sep 17 00:00:00 2001
From: Dave Huseby <dhuseby@mozilla.com>
Date: Wed, 4 Mar 2015 07:50:34 -0800
Subject: [PATCH 32/34] updating llvm-auto-clean-trigger too

---
 src/rustllvm/llvm-auto-clean-trigger | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rustllvm/llvm-auto-clean-trigger b/src/rustllvm/llvm-auto-clean-trigger
index 2cd7ed6c155..1ea40fc46a5 100644
--- a/src/rustllvm/llvm-auto-clean-trigger
+++ b/src/rustllvm/llvm-auto-clean-trigger
@@ -1,4 +1,4 @@
 # If this file is modified, then llvm will be forcibly cleaned and then rebuilt.
 # The actual contents of this file do not matter, but to trigger a change on the
 # build bots then the contents should be changed so git updates the mtime.
-2015-02-19
+2015-03-04

From 931c55ab00c6e641faeff2a209ac802f00005500 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 5 Mar 2015 01:32:48 +0530
Subject: [PATCH 33/34] Move span in error (fixup #22764)

---
 src/test/compile-fail/issue-16747.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/test/compile-fail/issue-16747.rs b/src/test/compile-fail/issue-16747.rs
index a213234b89b..64334fe4392 100644
--- a/src/test/compile-fail/issue-16747.rs
+++ b/src/test/compile-fail/issue-16747.rs
@@ -18,11 +18,10 @@ trait Collection { fn len(&self) -> usize; }
 
 struct List<'a, T: ListItem<'a>> {
 //~^ ERROR the parameter type `T` may not live long enough
-//~^^ HELP consider adding an explicit lifetime bound
-//~^^^ NOTE ...so that the reference type `&'a [T]` does not outlive the data it points at
+//~^^ NOTE ...so that the reference type `&'a [T]` does not outlive the data it points at
     slice: &'a [T]
 }
-
+//~^ HELP consider adding an explicit lifetime bound
 impl<'a, T: ListItem<'a>> Collection for List<'a, T> {
     fn len(&self) -> usize {
         0

From 340d1cc7d701bf1c5bae6c2ad5b097462c5d1a7c Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 5 Mar 2015 17:09:12 +0530
Subject: [PATCH 34/34] Fix tag align tests for 32bit linux (fixes #7340)

---
 src/test/run-pass/tag-align-dyn-u64.rs      | 10 +++---
 src/test/run-pass/tag-align-dyn-variants.rs | 40 ++++++++++-----------
 src/test/run-pass/tag-align-u64.rs          | 10 +++---
 3 files changed, 27 insertions(+), 33 deletions(-)

diff --git a/src/test/run-pass/tag-align-dyn-u64.rs b/src/test/run-pass/tag-align-dyn-u64.rs
index a50711fc98d..8d8d4caad24 100644
--- a/src/test/run-pass/tag-align-dyn-u64.rs
+++ b/src/test/run-pass/tag-align-dyn-u64.rs
@@ -8,9 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-linux #7340 fails on 32-bit Linux
-// ignore-macos #7340 fails on 32-bit macos
-
 use std::mem;
 
 enum Tag<A> {
@@ -26,12 +23,13 @@ fn mk_rec() -> Rec {
     return Rec { c8:0, t:Tag::Tag2(0) };
 }
 
-fn is_8_byte_aligned(u: &Tag<u64>) -> bool {
+fn is_u64_aligned(u: &Tag<u64>) -> bool {
     let p: uint = unsafe { mem::transmute(u) };
-    return (p & 7) == 0;
+    let u64_align = std::mem::min_align_of::<u64>();
+    return (p & (u64_align - 1)) == 0;
 }
 
 pub fn main() {
     let x = mk_rec();
-    assert!(is_8_byte_aligned(&x.t));
+    assert!(is_u64_aligned(&x.t));
 }
diff --git a/src/test/run-pass/tag-align-dyn-variants.rs b/src/test/run-pass/tag-align-dyn-variants.rs
index 69af882e1fa..917f2c5b374 100644
--- a/src/test/run-pass/tag-align-dyn-variants.rs
+++ b/src/test/run-pass/tag-align-dyn-variants.rs
@@ -8,9 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-linux #7340 fails on 32-bit Linux
-// ignore-macos #7340 fails on 32-bit macos
-
 use std::mem;
 
 enum Tag<A,B> {
@@ -42,33 +39,34 @@ fn variant_data_is_aligned<A,B>(amnt: uint, u: &Tag<A,B>) -> bool {
 }
 
 pub fn main() {
-    let x = mk_rec(22, 23);
-    assert!(is_aligned(8, &x.tA));
-    assert!(variant_data_is_aligned(8, &x.tA));
-    assert!(is_aligned(8, &x.tB));
-    assert!(variant_data_is_aligned(8, &x.tB));
+    let u64_align = std::mem::min_align_of::<u64>();
+    let x = mk_rec(22u64, 23u64);
+    assert!(is_aligned(u64_align, &x.tA));
+    assert!(variant_data_is_aligned(u64_align, &x.tA));
+    assert!(is_aligned(u64_align, &x.tB));
+    assert!(variant_data_is_aligned(u64_align, &x.tB));
 
-    let x = mk_rec(22, 23);
-    assert!(is_aligned(8, &x.tA));
-    assert!(variant_data_is_aligned(8, &x.tA));
-    assert!(is_aligned(8, &x.tB));
+    let x = mk_rec(22u64, 23u32);
+    assert!(is_aligned(u64_align, &x.tA));
+    assert!(variant_data_is_aligned(u64_align, &x.tA));
+    assert!(is_aligned(u64_align, &x.tB));
     assert!(variant_data_is_aligned(4, &x.tB));
 
-    let x = mk_rec(22, 23);
-    assert!(is_aligned(8, &x.tA));
+    let x = mk_rec(22u32, 23u64);
+    assert!(is_aligned(u64_align, &x.tA));
     assert!(variant_data_is_aligned(4, &x.tA));
-    assert!(is_aligned(8, &x.tB));
-    assert!(variant_data_is_aligned(8, &x.tB));
+    assert!(is_aligned(u64_align, &x.tB));
+    assert!(variant_data_is_aligned(u64_align, &x.tB));
 
-    let x = mk_rec(22, 23);
+    let x = mk_rec(22u32, 23u32);
     assert!(is_aligned(4, &x.tA));
     assert!(variant_data_is_aligned(4, &x.tA));
     assert!(is_aligned(4, &x.tB));
     assert!(variant_data_is_aligned(4, &x.tB));
 
     let x = mk_rec(22f64, 23f64);
-    assert!(is_aligned(8, &x.tA));
-    assert!(variant_data_is_aligned(8, &x.tA));
-    assert!(is_aligned(8, &x.tB));
-    assert!(variant_data_is_aligned(8, &x.tB));
+    assert!(is_aligned(u64_align, &x.tA));
+    assert!(variant_data_is_aligned(u64_align, &x.tA));
+    assert!(is_aligned(u64_align, &x.tB));
+    assert!(variant_data_is_aligned(u64_align, &x.tB));
 }
diff --git a/src/test/run-pass/tag-align-u64.rs b/src/test/run-pass/tag-align-u64.rs
index e5fd11ff9db..df99d77142c 100644
--- a/src/test/run-pass/tag-align-u64.rs
+++ b/src/test/run-pass/tag-align-u64.rs
@@ -8,9 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-linux #7340 fails on 32-bit Linux
-// ignore-macos #7340 fails on 32-bit macos
-
 use std::mem;
 
 enum Tag {
@@ -26,12 +23,13 @@ fn mk_rec() -> Rec {
     return Rec { c8:0, t:Tag::TagInner(0) };
 }
 
-fn is_8_byte_aligned(u: &Tag) -> bool {
+fn is_u64_aligned(u: &Tag) -> bool {
     let p: uint = unsafe { mem::transmute(u) };
-    return (p & 7) == 0;
+    let u64_align = std::mem::min_align_of::<u64>();
+    return (p & (u64_align - 1)) == 0;
 }
 
 pub fn main() {
     let x = mk_rec();
-    assert!(is_8_byte_aligned(&x.t));
+    assert!(is_u64_aligned(&x.t));
 }