Test fixes and rebase conflicts

alexcrichton · alexcrichton · commit 60541cdc1ec3 · 2014-11-26T16:50:13.000-08:00
diff --git a/src/libcoretest/slice.rs b/src/libcoretest/slice.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::slice::{Found, NotFound};
+use std::slice::BinarySearchResult::{Found, NotFound};
 
 #[test]
 fn binary_search_not_found() {
diff --git a/src/librustc/middle/borrowck/fragments.rs b/src/librustc/middle/borrowck/fragments.rs
@@ -277,8 +277,8 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) {
 
     fn non_member(elem: MovePathIndex, set: &[MovePathIndex]) -> bool {
         match set.binary_search_elem(&elem) {
-            slice::Found(_) => false,
-            slice::NotFound(_) => true,
+            slice::BinarySearchResult::Found(_) => false,
+            slice::BinarySearchResult::NotFound(_) => true,
         }
     }
 }
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
@@ -72,8 +72,8 @@ impl CodeExtent {
     }
 }
 
-The region maps encode information about region relationships.
-
+/// The region maps encode information about region relationships.
+///
 /// - `scope_map` maps from a scope id to the enclosing scope id; this is
 ///   usually corresponding to the lexical nesting, though in the case of
 ///   closures the parent scope is the innermost conditional expression or repeating
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
@@ -741,7 +741,7 @@ fn ast_ty_to_trait_ref<'tcx,AC,RS>(this: &AC,
 
                 _ => {
                     span_note!(this.tcx().sess, ty.span,
-                               "perhaps you forget parentheses? (per RFC 248)");
+                               "perhaps you forgot parentheses? (per RFC 248)");
                 }
             }
             Err(ErrorReported)
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
@@ -35,7 +35,8 @@ use std::io::File;
 use std::io;
 use std::rc::Rc;
 use externalfiles::ExternalHtml;
-use serialize::{json, Decodable, Encodable};
+use serialize::{Decodable, Encodable};
+use serialize::json::{mod, Json};
 
 // reexported from `clean` so it can be easily updated with the mod itself
 pub use clean::SCHEMA_VERSION;
@@ -425,11 +426,11 @@ fn json_input(input: &str) -> Result<Output, String> {
     };
     match json::from_reader(&mut input) {
         Err(s) => Err(s.to_string()),
-        Ok(json::Object(obj)) => {
+        Ok(Json::Object(obj)) => {
             let mut obj = obj;
             // Make sure the schema is what we expect
             match obj.remove(&"schema".to_string()) {
-                Some(json::String(version)) => {
+                Some(Json::String(version)) => {
                     if version.as_slice() != SCHEMA_VERSION {
                         return Err(format!(
                                 "sorry, but I only understand version {}",
@@ -468,7 +469,7 @@ fn json_output(krate: clean::Crate, res: Vec<plugins::PluginJson> ,
     //   "plugins": { output of plugins ... }
     // }
     let mut json = std::collections::TreeMap::new();
-    json.insert("schema".to_string(), json::String(SCHEMA_VERSION.to_string()));
+    json.insert("schema".to_string(), Json::String(SCHEMA_VERSION.to_string()));
     let plugins_json = res.into_iter()
                           .filter_map(|opt| {
                               match opt {
@@ -495,8 +496,8 @@ fn json_output(krate: clean::Crate, res: Vec<plugins::PluginJson> ,
     };
 
     json.insert("crate".to_string(), crate_json);
-    json.insert("plugins".to_string(), json::Object(plugins_json));
+    json.insert("plugins".to_string(), Json::Object(plugins_json));
 
     let mut file = try!(File::create(&dst));
-    json::Object(json).to_writer(&mut file)
+    Json::Object(json).to_writer(&mut file)
 }
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
@@ -113,8 +113,7 @@ for custom mappings.
 
 ```rust
 extern crate serialize;
-use serialize::json::ToJson;
-use serialize::json;
+use serialize::json::{mod, ToJson, Json};
 
 // A custom data structure
 struct ComplexNum {
@@ -125,7 +124,7 @@ struct ComplexNum {
 // JSON value representation
 impl ToJson for ComplexNum {
     fn to_json(&self) -> json::Json {
-        json::String(format!("{}+{}i", self.a, self.b))
+        Json::String(format!("{}+{}i", self.a, self.b))
     }
 }
 
@@ -154,8 +153,7 @@ fn main() {
 ```rust
 extern crate serialize;
 use std::collections::TreeMap;
-use serialize::json::ToJson;
-use serialize::json;
+use serialize::json::{mod, ToJson, Json};
 
 // Only generate `Decodable` trait implementation
 #[deriving(Decodable)]
@@ -173,7 +171,7 @@ impl ToJson for TestStruct {
         d.insert("data_int".to_string(), self.data_int.to_json());
         d.insert("data_str".to_string(), self.data_str.to_json());
         d.insert("data_vector".to_string(), self.data_vector.to_json());
-        json::Object(d)
+        Json::Object(d)
     }
 }
 
@@ -184,7 +182,7 @@ fn main() {
         data_str: "toto".to_string(),
         data_vector: vec![2,3,4,5],
     };
-    let json_obj: json::Json = input_data.to_json();
+    let json_obj: Json = input_data.to_json();
     let json_str: String = json_obj.to_string();
 
     // Deserialize like before
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
@@ -205,11 +205,12 @@ macro_rules! debug_assert_eq(
 ///
 /// ```rust
 /// fn foo(x: Option<int>) {
-///    match x {
-///     Some(n) if n >= 0 => println!("Some(Non-negative)"),
-///     Some(n) if n <  0 => println!("Some(Negative)"),
-///     Some(_)           => unreachable!(), // compile error if commented out
-///     None              => println!("None")
+///     match x {
+///         Some(n) if n >= 0 => println!("Some(Non-negative)"),
+///         Some(n) if n <  0 => println!("Some(Negative)"),
+///         Some(_)           => unreachable!(), // compile error if commented out
+///         None              => println!("None")
+///     }
 /// }
 /// ```
 ///
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
@@ -17,12 +17,12 @@ use parse::token::*;
 use parse::token;
 use ptr::P;
 
-//!  Quasiquoting works via token trees.
-//!
-//!  This is registered as a set of expression syntax extension called quote!
-//!  that lifts its argument token-tree to an AST representing the
-//!  construction of the same token tree, with token::SubstNt interpreted
-//!  as antiquotes (splices).
+///  Quasiquoting works via token trees.
+///
+///  This is registered as a set of expression syntax extension called quote!
+///  that lifts its argument token-tree to an AST representing the
+///  construction of the same token tree, with token::SubstNt interpreted
+///  as antiquotes (splices).
 
 pub mod rt {
     use ast;
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
@@ -1106,9 +1106,9 @@ fn calc_result(desc: &TestDesc, task_succeeded: bool) -> TestResult {
 impl ToJson for Metric {
     fn to_json(&self) -> json::Json {
         let mut map = TreeMap::new();
-        map.insert("value".to_string(), json::F64(self.value));
-        map.insert("noise".to_string(), json::F64(self.noise));
-        json::Object(map)
+        map.insert("value".to_string(), json::Json::F64(self.value));
+        map.insert("noise".to_string(), json::Json::F64(self.noise));
+        json::Json::Object(map)
     }
 }
 
diff --git a/src/libunicode/normalize.rs b/src/libunicode/normalize.rs
@@ -25,11 +25,11 @@ fn bsearch_table<T>(c: char, r: &'static [(char, &'static [T])]) -> Option<&'sta
         else if val < c { Less }
         else { Greater }
     }) {
-        slice::Found(idx) => {
+        slice::BinarySearchResult::Found(idx) => {
             let (_, result) = r[idx];
             Some(result)
         }
-        slice::NotFound(_) => None
+        slice::BinarySearchResult::NotFound(_) => None
     }
 }
 
@@ -88,11 +88,11 @@ pub fn compose(a: char, b: char) -> Option<char> {
                     else if val < b { Less }
                     else { Greater }
                 }) {
-                    slice::Found(idx) => {
+                    slice::BinarySearchResult::Found(idx) => {
                         let (_, result) = candidates[idx];
                         Some(result)
                     }
-                    slice::NotFound(_) => None
+                    slice::BinarySearchResult::NotFound(_) => None
                 }
             }
         }
diff --git a/src/libunicode/tables.rs b/src/libunicode/tables.rs
@@ -6249,11 +6249,11 @@ pub mod normalization {
             else if hi < c { Less }
             else { Greater }
         }) {
-            slice::Found(idx) => {
+            slice::BinarySearchResult::Found(idx) => {
                 let (_, _, result) = r[idx];
                 result
             }
-            slice::NotFound(_) => 0
+            slice::BinarySearchResult::NotFound(_) => 0
         }
     }
 
@@ -6392,8 +6392,8 @@ pub mod conversions {
             else if key < c { Less }
             else { Greater }
         }) {
-            slice::Found(i) => Some(i),
-            slice::NotFound(_) => None,
+            slice::BinarySearchResult::Found(i) => Some(i),
+            slice::BinarySearchResult::NotFound(_) => None,
         }
     }
 
@@ -6945,11 +6945,11 @@ pub mod charwidth {
             else if hi < c { Less }
             else { Greater }
         }) {
-            slice::Found(idx) => {
+            slice::BinarySearchResult::Found(idx) => {
                 let (_, _, r_ncjk, r_cjk) = r[idx];
                 if is_cjk { r_cjk } else { r_ncjk }
             }
-            slice::NotFound(_) => 1
+            slice::BinarySearchResult::NotFound(_) => 1
         }
     }
 
@@ -7160,11 +7160,11 @@ pub mod grapheme {
             else if hi < c { Less }
             else { Greater }
         }) {
-            slice::Found(idx) => {
+            slice::BinarySearchResult::Found(idx) => {
                 let (_, _, cat) = r[idx];
                 cat
             }
-            slice::NotFound(_) => GC_Any
+            slice::BinarySearchResult::NotFound(_) => GC_Any
         }
     }
 
diff --git a/src/test/compile-fail/hrtb-precedence-of-plus-error-message.rs b/src/test/compile-fail/hrtb-precedence-of-plus-error-message.rs
@@ -30,6 +30,7 @@ struct Foo<'a> {
     d: fn() -> Bar+'a,
         //~^ ERROR E0171
         //~^^ NOTE perhaps you forgot parentheses
+        //~^^^ WARN deprecated syntax
 }
 
 fn main() { }
diff --git a/src/test/run-pass/hrtb-precedence-of-plus-where-clause.rs b/src/test/run-pass/hrtb-precedence-of-plus-where-clause.rs
@@ -13,10 +13,15 @@
 // Test that `F : Fn(int) -> int + Send` is interpreted as two
 // distinct bounds on `F`.
 
-fn foo<F>(f: F)
+fn foo1<F>(f: F)
     where F : FnOnce(int) -> int + Send
 {
     bar(f);
+}
+
+fn foo2<F>(f: F)
+    where F : FnOnce(int) -> int + Send
+{
     baz(f);
 }
 
diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs
@@ -13,7 +13,7 @@ extern crate collections;
 extern crate serialize;
 
 use std::collections::HashMap;
-use serialize::json;
+use serialize::json::{mod, Json};
 use std::option;
 
 enum object {
@@ -24,7 +24,7 @@ enum object {
 fn lookup(table: json::Object, key: String, default: String) -> String
 {
     match table.find(&key.to_string()) {
-        option::Some(&json::String(ref s)) => {
+        option::Some(&Json::String(ref s)) => {
             s.to_string()
         }
         option::Some(value) => {
@@ -40,7 +40,7 @@ fn lookup(table: json::Object, key: String, default: String) -> String
 fn add_interface(_store: int, managed_ip: String, data: json::Json) -> (String, object)
 {
     match &data {
-        &json::Object(ref interface) => {
+        &Json::Object(ref interface) => {
             let name = lookup(interface.clone(),
                               "ifDescr".to_string(),
                               "".to_string());
@@ -59,7 +59,7 @@ fn add_interfaces(store: int, managed_ip: String, device: HashMap<String, json::
 -> Vec<(String, object)> {
     match device["interfaces".to_string()]
     {
-        json::Array(ref interfaces) =>
+        Json::Array(ref interfaces) =>
         {
           interfaces.iter().map(|interface| {
                 add_interface(store, managed_ip.clone(), (*interface).clone())

Original file line number	Diff line number	Diff line change
`@@ -277,8 +277,8 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) {`
`277`	`277`
`278`	`278`	`fn non_member(elem: MovePathIndex, set: &[MovePathIndex]) -> bool {`
`279`	`279`	`match set.binary_search_elem(&elem) {`
`280`		`- slice::Found(_) => false,`
`281`		`- slice::NotFound(_) => true,`
	`280`	`+ slice::BinarySearchResult::Found(_) => false,`
	`281`	`+ slice::BinarySearchResult::NotFound(_) => true,`
`282`	`282`	`}`
`283`	`283`	`}`
`284`	`284`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,8 +72,8 @@ impl CodeExtent {`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`		`-The region maps encode information about region relationships.`
`76`		`-`
	`75`	`+/// The region maps encode information about region relationships.`
	`76`	`+///`
`77`	`77`	/// - `scope_map` maps from a scope id to the enclosing scope id; this is
`78`	`78`	`/// usually corresponding to the lexical nesting, though in the case of`
`79`	`79`	`/// closures the parent scope is the innermost conditional expression or repeating`
Original file line number	Diff line number	Diff line change
`@@ -741,7 +741,7 @@ fn ast_ty_to_trait_ref<'tcx,AC,RS>(this: &AC,`
`741`	`741`
`742`	`742`	`_ => {`
`743`	`743`	`span_note!(this.tcx().sess, ty.span,`
`744`		`- "perhaps you forget parentheses? (per RFC 248)");`
	`744`	`+ "perhaps you forgot parentheses? (per RFC 248)");`
`745`	`745`	`}`
`746`	`746`	`}`
`747`	`747`	`Err(ErrorReported)`
Original file line number	Diff line number	Diff line change
`@@ -1106,9 +1106,9 @@ fn calc_result(desc: &TestDesc, task_succeeded: bool) -> TestResult {`
`1106`	`1106`	`impl ToJson for Metric {`
`1107`	`1107`	`fn to_json(&self) -> json::Json {`
`1108`	`1108`	`let mut map = TreeMap::new();`
`1109`		`- map.insert("value".to_string(), json::F64(self.value));`
`1110`		`- map.insert("noise".to_string(), json::F64(self.noise));`
`1111`		`- json::Object(map)`
	`1109`	`+ map.insert("value".to_string(), json::Json::F64(self.value));`
	`1110`	`+ map.insert("noise".to_string(), json::Json::F64(self.noise));`
	`1111`	`+ json::Json::Object(map)`
`1112`	`1112`	`}`
`1113`	`1113`	`}`
`1114`	`1114`
Original file line number	Diff line number	Diff line change
`@@ -25,11 +25,11 @@ fn bsearch_table<T>(c: char, r: &'static [(char, &'static [T])]) -> Option<&'sta`
`25`	`25`	`else if val < c { Less }`
`26`	`26`	`else { Greater }`
`27`	`27`	`}) {`
`28`		`- slice::Found(idx) => {`
	`28`	`+ slice::BinarySearchResult::Found(idx) => {`
`29`	`29`	`let (_, result) = r[idx];`
`30`	`30`	`Some(result)`
`31`	`31`	`}`
`32`		`- slice::NotFound(_) => None`
	`32`	`+ slice::BinarySearchResult::NotFound(_) => None`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`@@ -88,11 +88,11 @@ pub fn compose(a: char, b: char) -> Option<char> {`
`88`	`88`	`else if val < b { Less }`
`89`	`89`	`else { Greater }`
`90`	`90`	`}) {`
`91`		`- slice::Found(idx) => {`
	`91`	`+ slice::BinarySearchResult::Found(idx) => {`
`92`	`92`	`let (_, result) = candidates[idx];`
`93`	`93`	`Some(result)`
`94`	`94`	`}`
`95`		`- slice::NotFound(_) => None`
	`95`	`+ slice::BinarySearchResult::NotFound(_) => None`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6249,11 +6249,11 @@ pub mod normalization {`
`6249`	`6249`	`else if hi < c { Less }`
`6250`	`6250`	`else { Greater }`
`6251`	`6251`	`}) {`
`6252`		`- slice::Found(idx) => {`
	`6252`	`+ slice::BinarySearchResult::Found(idx) => {`
`6253`	`6253`	`let (_, _, result) = r[idx];`
`6254`	`6254`	`result`
`6255`	`6255`	`}`
`6256`		`- slice::NotFound(_) => 0`
	`6256`	`+ slice::BinarySearchResult::NotFound(_) => 0`
`6257`	`6257`	`}`
`6258`	`6258`	`}`
`6259`	`6259`
`@@ -6392,8 +6392,8 @@ pub mod conversions {`
`6392`	`6392`	`else if key < c { Less }`
`6393`	`6393`	`else { Greater }`
`6394`	`6394`	`}) {`
`6395`		`- slice::Found(i) => Some(i),`
`6396`		`- slice::NotFound(_) => None,`
	`6395`	`+ slice::BinarySearchResult::Found(i) => Some(i),`
	`6396`	`+ slice::BinarySearchResult::NotFound(_) => None,`
`6397`	`6397`	`}`
`6398`	`6398`	`}`
`6399`	`6399`
`@@ -6945,11 +6945,11 @@ pub mod charwidth {`
`6945`	`6945`	`else if hi < c { Less }`
`6946`	`6946`	`else { Greater }`
`6947`	`6947`	`}) {`
`6948`		`- slice::Found(idx) => {`
	`6948`	`+ slice::BinarySearchResult::Found(idx) => {`
`6949`	`6949`	`let (_, _, r_ncjk, r_cjk) = r[idx];`
`6950`	`6950`	`if is_cjk { r_cjk } else { r_ncjk }`
`6951`	`6951`	`}`
`6952`		`- slice::NotFound(_) => 1`
	`6952`	`+ slice::BinarySearchResult::NotFound(_) => 1`
`6953`	`6953`	`}`
`6954`	`6954`	`}`
`6955`	`6955`
`@@ -7160,11 +7160,11 @@ pub mod grapheme {`
`7160`	`7160`	`else if hi < c { Less }`
`7161`	`7161`	`else { Greater }`
`7162`	`7162`	`}) {`
`7163`		`- slice::Found(idx) => {`
	`7163`	`+ slice::BinarySearchResult::Found(idx) => {`
`7164`	`7164`	`let (_, _, cat) = r[idx];`
`7165`	`7165`	`cat`
`7166`	`7166`	`}`
`7167`		`- slice::NotFound(_) => GC_Any`
	`7167`	`+ slice::BinarySearchResult::NotFound(_) => GC_Any`
`7168`	`7168`	`}`
`7169`	`7169`	`}`
`7170`	`7170`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@ struct Foo<'a> {`
`30`	`30`	`d: fn() -> Bar+'a,`
`31`	`31`	`//~^ ERROR E0171`
`32`	`32`	`//~^^ NOTE perhaps you forgot parentheses`
	`33`	`+ //~^^^ WARN deprecated syntax`
`33`	`34`	`}`
`34`	`35`
`35`	`36`	`fn main() { }`