---

yaml
---
r: 161142
b: refs/heads/snap-stage3
c: 41fb8f7
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4eb72d268f337a8f117c86a2ac1b98336cab9e9d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: cd7584743710aa2355eb7e09146fea7c338a27e5
+refs/heads/snap-stage3: 41fb8f77ee10221db319096ee45a56a29f013564
 refs/heads/try: 0f0d21c1eb5c7be04d323e0b06faf252ad790af6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/AUTHORS.txt

@@ -121,7 +121,6 @@ Cole Mickens <[email protected]>
 Colin Davidson <[email protected]>
 Colin Sherratt <[email protected]>
 Conrad Kleinespel <[email protected]>
-Corey Farwell <[email protected]>
 Corey Ford <[email protected]>
 Corey Richardson <[email protected]>
 DJUrsus <[email protected]>

branches/snap-stage3/src/libcore/char.rs

@@ -270,6 +270,9 @@ pub trait Char {
     /// Panics if given a radix > 36.
     fn from_digit(num: uint, radix: uint) -> Option<Self>;
 
+    /// Converts from `u32` to a `char`
+    fn from_u32(i: u32) -> Option<char>;
+
     /// Returns the hexadecimal Unicode escape of a character.
     ///
     /// The rules are as follows:
@@ -319,6 +322,9 @@ impl Char for char {
 
     fn from_digit(num: uint, radix: uint) -> Option<char> { from_digit(num, radix) }
 
+    #[inline]
+    fn from_u32(i: u32) -> Option<char> { from_u32(i) }
+
     fn escape_unicode(&self, f: |char|) { escape_unicode(*self, f) }
 
     fn escape_default(&self, f: |char|) { escape_default(*self, f) }

branches/snap-stage3/src/librustc_back/target/mod.rs

@@ -250,7 +250,7 @@ impl Target {
             } );
             ($key_name:ident, list) => ( {
                 let name = (stringify!($key_name)).replace("_", "-");
-                obj.find(name[]).map(|o| o.as_array()
+                obj.find(name[]).map(|o| o.as_list()
                     .map(|v| base.options.$key_name = v.iter()
                         .map(|a| a.as_string().unwrap().to_string()).collect()
                         )

branches/snap-stage3/src/librustdoc/html/render.rs

@@ -101,8 +101,6 @@ pub struct Context {
     /// real location of an item. This is used to allow external links to
     /// publicly reused items to redirect to the right location.
     pub render_redirect_pages: bool,
-    /// All the passes that were run on this crate.
-    pub passes: HashSet<String>,
 }
 
 /// Indicates where an external crate can be found.
@@ -192,7 +190,6 @@ pub struct Cache {
     parent_stack: Vec<ast::DefId>,
     search_index: Vec<IndexItem>,
     privmod: bool,
-    remove_priv: bool,
     public_items: NodeSet,
 
     // In rare case where a structure is defined in one module but implemented
@@ -239,13 +236,9 @@ local_data_key!(pub cache_key: Arc<Cache>)
 local_data_key!(pub current_location_key: Vec<String> )
 
 /// Generates the documentation for `crate` into the directory `dst`
-pub fn run(mut krate: clean::Crate,
-           external_html: &ExternalHtml,
-           dst: Path,
-           passes: HashSet<String>) -> io::IoResult<()> {
+pub fn run(mut krate: clean::Crate, external_html: &ExternalHtml, dst: Path) -> io::IoResult<()> {
     let mut cx = Context {
         dst: dst,
-        passes: passes,
         current: Vec::new(),
         root_path: String::new(),
         sidebar: HashMap::new(),
@@ -327,7 +320,6 @@ pub fn run(mut krate: clean::Crate,
         search_index: Vec::new(),
         extern_locations: HashMap::new(),
         primitive_locations: HashMap::new(),
-        remove_priv: cx.passes.contains("strip-private"),
         privmod: false,
         public_items: public_items,
         orphan_methods: Vec::new(),
@@ -775,7 +767,7 @@ impl DocFolder for Cache {
         let orig_privmod = match item.inner {
             clean::ModuleItem(..) => {
                 let prev = self.privmod;
-                self.privmod = prev || (self.remove_priv && item.visibility != Some(ast::Public));
+                self.privmod = prev || item.visibility != Some(ast::Public);
                 prev
             }
             _ => self.privmod,
@@ -1200,7 +1192,7 @@ impl Context {
         // these modules are recursed into, but not rendered normally (a
         // flag on the context).
         if !self.render_redirect_pages {
-            self.render_redirect_pages = self.ignore_private_item(&item);
+            self.render_redirect_pages = ignore_private_item(&item);
         }
 
         match item.inner {
@@ -1219,7 +1211,7 @@ impl Context {
                         clean::ModuleItem(m) => m,
                         _ => unreachable!()
                     };
-                    this.sidebar = this.build_sidebar(&m);
+                    this.sidebar = build_sidebar(&m);
                     for item in m.items.into_iter() {
                         f(this,item);
                     }
@@ -1238,40 +1230,6 @@ impl Context {
             _ => Ok(())
         }
     }
-
-    fn build_sidebar(&self, m: &clean::Module) -> HashMap<String, Vec<String>> {
-        let mut map = HashMap::new();
-        for item in m.items.iter() {
-            if self.ignore_private_item(item) { continue }
-
-            let short = shortty(item).to_static_str();
-            let myname = match item.name {
-                None => continue,
-                Some(ref s) => s.to_string(),
-            };
-            let v = match map.entry(short.to_string()) {
-                Vacant(entry) => entry.set(Vec::with_capacity(1)),
-                Occupied(entry) => entry.into_mut(),
-            };
-            v.push(myname);
-        }
-
-        for (_, items) in map.iter_mut() {
-            items.as_mut_slice().sort();
-        }
-        return map;
-    }
-
-    fn ignore_private_item(&self, it: &clean::Item) -> bool {
-        match it.inner {
-            clean::ModuleItem(ref m) => {
-                (m.items.len() == 0 && it.doc_value().is_none()) ||
-                (self.passes.contains("strip-private") && it.visibility != Some(ast::Public))
-            }
-            clean::PrimitiveItem(..) => it.visibility != Some(ast::Public),
-            _ => false,
-        }
-    }
 }
 
 impl<'a> Item<'a> {
@@ -1485,7 +1443,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
     try!(document(w, item));
 
     let mut indices = range(0, items.len()).filter(|i| {
-        !cx.ignore_private_item(&items[*i])
+        !ignore_private_item(&items[*i])
     }).collect::<Vec<uint>>();
 
     fn cmp(i1: &clean::Item, i2: &clean::Item, idx1: uint, idx2: uint) -> Ordering {
@@ -2199,6 +2157,29 @@ impl<'a> fmt::Show for Sidebar<'a> {
     }
 }
 
+fn build_sidebar(m: &clean::Module) -> HashMap<String, Vec<String>> {
+    let mut map = HashMap::new();
+    for item in m.items.iter() {
+        if ignore_private_item(item) { continue }
+
+        let short = shortty(item).to_static_str();
+        let myname = match item.name {
+            None => continue,
+            Some(ref s) => s.to_string(),
+        };
+        let v = match map.entry(short.to_string()) {
+            Vacant(entry) => entry.set(Vec::with_capacity(1)),
+            Occupied(entry) => entry.into_mut(),
+        };
+        v.push(myname);
+    }
+
+    for (_, items) in map.iter_mut() {
+        items.as_mut_slice().sort();
+    }
+    return map;
+}
+
 impl<'a> fmt::Show for Source<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let Source(s) = *self;
@@ -2233,6 +2214,17 @@ fn item_primitive(w: &mut fmt::Formatter,
     render_methods(w, it)
 }
 
+fn ignore_private_item(it: &clean::Item) -> bool {
+    match it.inner {
+        clean::ModuleItem(ref m) => {
+            (m.items.len() == 0 && it.doc_value().is_none()) ||
+               it.visibility != Some(ast::Public)
+        }
+        clean::PrimitiveItem(..) => it.visibility != Some(ast::Public),
+        _ => false,
+    }
+}
+
 fn get_basic_keywords() -> &'static str {
     "rust, rustlang, rust-lang"
 }

branches/snap-stage3/src/librustdoc/lib.rs

@@ -86,11 +86,7 @@ static DEFAULT_PASSES: &'static [&'static str] = &[
 
 local_data_key!(pub analysiskey: core::CrateAnalysis)
 
-struct Output {
-    krate: clean::Crate,
-    json_plugins: Vec<plugins::PluginJson>,
-    passes: Vec<String>,
-}
+type Output = (clean::Crate, Vec<plugins::PluginJson> );
 
 pub fn main() {
     std::os::set_exit_status(main_args(std::os::args().as_slice()));
@@ -233,26 +229,24 @@ pub fn main_args(args: &[String]) -> int {
         (false, false) => {}
     }
 
-    let out = match acquire_input(input, externs, &matches) {
-        Ok(out) => out,
+    let (krate, res) = match acquire_input(input, externs, &matches) {
+        Ok(pair) => pair,
         Err(s) => {
             println!("input error: {}", s);
             return 1;
         }
     };
-    let Output { krate, json_plugins, passes, } = out;
+
     info!("going to format");
     match matches.opt_str("w").as_ref().map(|s| s.as_slice()) {
         Some("html") | None => {
-            match html::render::run(krate, &external_html, output.unwrap_or(Path::new("doc")),
-                                    passes.into_iter().collect()) {
+            match html::render::run(krate, &external_html, output.unwrap_or(Path::new("doc"))) {
                 Ok(()) => {}
                 Err(e) => panic!("failed to generate documentation: {}", e),
             }
         }
         Some("json") => {
-            match json_output(krate, json_plugins,
-                              output.unwrap_or(Path::new("doc.json"))) {
+            match json_output(krate, res, output.unwrap_or(Path::new("doc.json"))) {
                 Ok(()) => {}
                 Err(e) => panic!("failed to write json: {}", e),
             }
@@ -403,8 +397,7 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche
 
     // Run everything!
     info!("Executing passes/plugins");
-    let (krate, json) = pm.run_plugins(krate);
-    return Output { krate: krate, json_plugins: json, passes: passes, };
+    return pm.run_plugins(krate);
 }
 
 /// This input format purely deserializes the json output file. No passes are
@@ -442,7 +435,7 @@ fn json_input(input: &str) -> Result<Output, String> {
             // FIXME: this should read from the "plugins" field, but currently
             //      Json doesn't implement decodable...
             let plugin_output = Vec::new();
-            Ok(Output { krate: krate, json_plugins: plugin_output, passes: Vec::new(), })
+            Ok((krate, plugin_output))
         }
         Ok(..) => {
             Err("malformed json input: expected an object at the \