Bump version, upgrade bootstrap

This commit updates the version number to 1.17.0 as we're not on that version of
the nightly compiler, and at the same time this updates src/stage0.txt to
bootstrap from freshly minted beta compiler and beta Cargo.

src/libserialize/Cargo.toml

@@ -7,6 +7,3 @@ version = "0.0.0"
 name = "serialize"
 path = "lib.rs"
 crate-type = ["dylib", "rlib"]
-
-[dependencies]
-rustc_i128 = { path = "../librustc_i128" }

src/libserialize/json.rs

@@ -211,8 +211,6 @@ use std::string;
 use std::{char, f64, fmt, str};
 use std;
 
-use rustc_i128::{i128, u128};
-
 use Encodable;
 
 /// Represents a json value

src/libserialize/leb128.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use rustc_i128::{i128, u128};
-
 #[inline]
 fn write_to_vec(vec: &mut Vec<u8>, position: usize, byte: u8) {
     if position == vec.len() {

src/libserialize/lib.rs

@@ -30,14 +30,13 @@ Core encoding and decoding interfaces.
 #![feature(box_syntax)]
 #![feature(collections)]
 #![feature(core_intrinsics)]
+#![feature(i128_type)]
 #![feature(specialization)]
 #![feature(staged_api)]
 #![cfg_attr(test, feature(test))]
 
 extern crate collections;
 
-extern crate rustc_i128;
-
 pub use self::serialize::{Decoder, Encoder, Decodable, Encodable};
 
 pub use self::serialize::{SpecializationError, SpecializedEncoder, SpecializedDecoder};

src/libserialize/opaque.rs

@@ -13,8 +13,6 @@ use std::borrow::Cow;
 use std::io::{self, Write};
 use serialize;
 
-use rustc_i128::{i128, u128};
-
 // -----------------------------------------------------------------------------
 // Encoder
 // -----------------------------------------------------------------------------

src/libserialize/serialize.rs

@@ -20,7 +20,6 @@ use std::path;
 use std::rc::Rc;
 use std::cell::{Cell, RefCell};
 use std::sync::Arc;
-use rustc_i128::{i128, u128};
 
 pub trait Encoder {
     type Error;
@@ -333,14 +332,12 @@ impl Decodable for u64 {
     }
 }
 
-#[cfg(not(stage0))]
 impl Encodable for u128 {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         s.emit_u128(*self)
     }
 }
 
-#[cfg(not(stage0))]
 impl Decodable for u128 {
     fn decode<D: Decoder>(d: &mut D) -> Result<u128, D::Error> {
         d.read_u128()
@@ -407,14 +404,12 @@ impl Decodable for i64 {
     }
 }
 
-#[cfg(not(stage0))]
 impl Encodable for i128 {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         s.emit_i128(*self)
     }
 }
 
-#[cfg(not(stage0))]
 impl Decodable for i128 {
     fn decode<D: Decoder>(d: &mut D) -> Result<i128, D::Error> {
         d.read_i128()