work from today

Author: EtomicBomb

src/librustdoc/config.rs

@@ -297,7 +297,7 @@ pub(crate) struct RenderOptions {
     /// If `true` (default) write the shared cross-crate information to the doc root
     pub(crate) write_rendered_cci: bool,
     /// Copies these externally documented crates into our doc root.
-    pub(crate) include_rendered_docs: Vec<PathToDocSubdirectory>,
+    pub(crate) include_rendered_docs: Vec<PathToDocRoot>,
     /// Path to crate-info.json for external crates.
     pub(crate) parts_paths: Vec<PathToParts>,
     /// Where to write crate-info.json.
@@ -506,10 +506,14 @@ impl Options {
             Err(err) => dcx.fatal(err),
         };
 
-        let include_rendered_docs = matches.opt_strs("include-rendered-docs").into_iter()
-            .map(|p| PathToDocSubdirectory(PathBuf::from(p)))
+        let include_rendered_docs = matches
+            .opt_strs("include-rendered-docs")
+            .into_iter()
+            .map(|p| PathToDocRoot(PathBuf::from(p)))
             .collect();
-        let parts_paths = matches.opt_strs("include-info-json").into_iter()
+        let parts_paths = matches
+            .opt_strs("include-info-json")
+            .into_iter()
             .map(|path| PathToParts(PathBuf::from(path)))
             .collect();
 
@@ -757,7 +761,8 @@ impl Options {
             Ok(result) => result,
             Err(e) => dcx.fatal(format!("could not parse --merge: {e}")),
         };
-        let parts_out_dir = matches.opt_str("write-info-json").map(|p| PathToParts(PathBuf::from(p)));
+        let parts_out_dir =
+            matches.opt_str("write-info-json").map(|p| PathToParts(PathBuf::from(p)));
 
         if generate_link_to_definition && (show_coverage || output_format != OutputFormat::Html) {
             dcx.fatal(
@@ -926,9 +931,9 @@ fn parse_extern_html_roots(
     Ok(externs)
 }
 
-/// Path to the doc subdirectory for a specific crate, for example `target/doc/serde_json`.
+/// Path to the doc root for a specific crate, for example `target/doc/serde_json`.
 #[derive(Clone, Debug)]
-pub(crate) struct PathToDocSubdirectory(pub PathBuf);
+pub(crate) struct PathToDocRoot(pub PathBuf);
 
 /// Path to crate-info.json
 ///
@@ -952,7 +957,9 @@ fn parse_merge(matches: &getopts::Matches) -> Result<ShouldMerge, &'static str>
         None => Ok(ShouldMerge { read_rendered_cci: true, write_rendered_cci: true }),
         Some("read-write") => Ok(ShouldMerge { read_rendered_cci: true, write_rendered_cci: true }),
         Some("none") => Ok(ShouldMerge { read_rendered_cci: false, write_rendered_cci: false }),
-        Some("write-only") => Ok(ShouldMerge { read_rendered_cci: false, write_rendered_cci: true }),
+        Some("write-only") => {
+            Ok(ShouldMerge { read_rendered_cci: false, write_rendered_cci: true })
+        }
         Some(_) => Err("argument to --merge must be `read-write`, `none`, or `write-only`"),
     }
 }

src/librustdoc/html/render/context.rs

@@ -12,9 +12,9 @@ use rustc_session::Session;
 use rustc_span::edition::Edition;
 use rustc_span::{sym, FileName, Symbol};
 
+use super::copy_dir::copy_dir_all;
 use super::print_item::{full_path, item_path, print_item};
-use super::write_shared::{write_shared};
-use super::copy_dir::{copy_dir_all};
+use super::write_shared::write_shared;
 use super::{
     collect_spans_and_sources, scrape_examples_help,
     sidebar::print_sidebar,

src/librustdoc/html/render/copy_dir.rs

@@ -1,11 +1,13 @@
-use std::io::{Error, Result, ErrorKind};
-use std::path::PathBuf;
 use std::fs;
+use std::io::{Error, ErrorKind, Result};
+use std::path::PathBuf;
 
 /// Recursively copies the contents of the directory `src` to the directory `dst`.
 /// Analogous to `cp -rf src/* dst` and Python's `shutil.copytree`
 ///
 /// Creates all directories needed to perform the copy.
+///
+/// Will overwrite files in the output directory.
 pub(crate) fn copy_dir_all<S: Into<PathBuf>, D: Into<PathBuf>>(src: S, dst: D) -> Result<()> {
     copy_dir_all_mono(src.into(), dst.into())
 }
@@ -15,18 +17,24 @@ fn copy_dir_all_mono(src: PathBuf, dst: PathBuf) -> Result<()> {
     let mut dirs: Vec<(PathBuf, PathBuf)> = Vec::default();
 
     if !src.is_dir() {
-        return Err(Error::new(ErrorKind::Other, format!("src path `{src:?}` should be a directory")));
+        return Err(Error::new(
+            ErrorKind::Other,
+            format!("src path `{src:?}` should be a directory"),
+        ));
     }
     if !dst.is_dir() {
-        return Err(Error::new(ErrorKind::Other, format!("dst path `{dst:?}` should be a directory")));
+        return Err(Error::new(
+            ErrorKind::Other,
+            format!("dst path `{dst:?}` should be a directory"),
+        ));
     }
 
     dirs.push((src, dst));
 
     while let Some((src, dst)) = dirs.pop() {
         match fs::create_dir(&dst) {
-            Ok(()) => {},
-            Err(e) if e.kind() == ErrorKind::AlreadyExists => {},
+            Ok(()) => {}
+            Err(e) if e.kind() == ErrorKind::AlreadyExists => {}
             Err(e) => return Err(e),
         }
 
@@ -50,10 +58,10 @@ fn copy_dir_all_mono(src: PathBuf, dst: PathBuf) -> Result<()> {
 #[cfg(test)]
 mod tests {
     use super::copy_dir_all;
-    use tempfile::TempDir;
+    use std::fs;
     use std::io::Result;
     use std::path::Path;
-    use std::fs;
+    use tempfile::TempDir;
 
     fn create_paths(root: &Path, paths: &[&str]) -> Result<()> {
         for path in paths {

src/librustdoc/html/render/mod.rs

@@ -28,15 +28,15 @@ pub(crate) mod search_index;
 #[cfg(test)]
 mod tests;
 
-mod copy_dir;
 mod context;
+mod copy_dir;
 mod print_item;
 mod sidebar;
+mod sorted_json;
+mod sorted_template;
 mod span_map;
 mod type_layout;
 mod write_shared;
-mod sorted_json;
-mod sorted_template;
 
 pub(crate) use self::context::*;
 pub(crate) use self::span_map::{collect_spans_and_sources, LinkFromSrc};

src/librustdoc/html/render/search_index.rs

@@ -17,8 +17,8 @@ use crate::formats::cache::{Cache, OrphanImplItem};
 use crate::formats::item_type::ItemType;
 use crate::html::format::join_with_double_colon;
 use crate::html::markdown::short_markdown_summary;
-use crate::html::render::{self, IndexItem, IndexItemFunctionType, RenderType, RenderTypeId};
 use crate::html::render::sorted_json::SortedJson;
+use crate::html::render::{self, IndexItem, IndexItemFunctionType, RenderType, RenderTypeId};
 
 use encode::{bitmap_to_string, write_vlqhex_to_string};
 

src/librustdoc/html/render/sorted_json.rs

@@ -1,8 +1,8 @@
+use itertools::Itertools as _;
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use serde::{Serialize, Deserialize};
-use std::fmt;
 use std::borrow::Borrow;
-use itertools::Itertools as _;
+use std::fmt;
 
 /// Prerenedered json.
 ///
@@ -24,14 +24,17 @@ impl SortedJson {
     }
 
     /// Serializes and sorts
-    pub(crate) fn array<T: Borrow<SortedJson>, I: IntoIterator<Item=T>>(items: I) -> Self {
-        let items = items.into_iter()
+    pub(crate) fn array<T: Borrow<SortedJson>, I: IntoIterator<Item = T>>(items: I) -> Self {
+        let items = items
+            .into_iter()
             .sorted_unstable_by(|a, b| a.borrow().cmp(&b.borrow()))
             .format_with(",", |item, f| f(item.borrow()));
         SortedJson(format!("[{}]", items))
     }
 
-    pub(crate) fn array_unsorted<T: Borrow<SortedJson>, I: IntoIterator<Item=T>>(items: I) -> Self {
+    pub(crate) fn array_unsorted<T: Borrow<SortedJson>, I: IntoIterator<Item = T>>(
+        items: I,
+    ) -> Self {
         let items = items.into_iter().format_with(",", |item, f| f(item.borrow()));
         SortedJson(format!("[{items}]"))
     }
@@ -55,6 +58,29 @@ impl From<SortedJson> for Value {
     }
 }
 
+/// For use in JSON.parse('{...}').
+///
+/// JSON.parse supposedly loads faster than raw JS source,
+/// so this is used for large objects.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub(crate) struct EscapedJson(SortedJson);
+
+impl From<SortedJson> for EscapedJson {
+    fn from(json: SortedJson) -> Self {
+        EscapedJson(json)
+    }
+}
+
+impl fmt::Display for EscapedJson {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // All these `replace` calls are because we have to go through JS string
+        // for JSON content.
+        // We need to escape double quotes for the JSON
+        let json = self.0.0.replace('\\', r"\\").replace('\'', r"\'").replace("\\\"", "\\\\\"");
+        write!(f, "{}", json)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -76,6 +102,48 @@ mod tests {
         assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
     }
 
+    #[test]
+    fn escape_json_number() {
+        let json = SortedJson::serialize(3);
+        let json = EscapedJson::from(json);
+        assert_eq!(format!("{json}"), "3");
+    }
+
+    #[test]
+    fn escape_json_single_quote() {
+        let json = SortedJson::serialize("he's");
+        let json = EscapedJson::from(json);
+        assert_eq!(dbg!(format!("{json}")), r#""he\'s""#);
+    }
+
+    #[test]
+    fn escape_json_array() {
+        let json = SortedJson::serialize([1,2,3]);
+        let json = EscapedJson::from(json);
+        assert_eq!(dbg!(format!("{json}")), r#"[1,2,3]"#);
+    }
+
+    #[test]
+    fn escape_json_string() {
+        let json = SortedJson::serialize(r#"he"llo"#);
+        let json = EscapedJson::from(json);
+        assert_eq!(dbg!(format!("{json}")), r#""he\\\"llo""#);
+    }
+
+    #[test]
+    fn escape_json_string_escaped() {
+        let json = SortedJson::serialize(r#"he\"llo"#);
+        let json = EscapedJson::from(json);
+        assert_eq!(format!("{json}"), r#""he\\\\\\\"llo""#);
+    }
+
+    #[test]
+    fn escape_json_string_escaped_escaped() {
+        let json = SortedJson::serialize(r#"he\\"llo"#);
+        let json = EscapedJson::from(json);
+        assert_eq!(format!("{json}"), r#""he\\\\\\\\\\\"llo""#);
+    }
+
     #[test]
     fn number() {
         let json = SortedJson::serialize(3);
@@ -100,7 +168,7 @@ mod tests {
     #[test]
     fn serialize_array() {
         let json = SortedJson::serialize([3, 1, 2]);
-        let serialized =  "[3,1,2]";
+        let serialized = "[3,1,2]";
         check(json, serialized);
     }
 

src/librustdoc/html/render/sorted_template.rs

@@ -1,9 +1,9 @@
+use std::collections::BTreeSet;
 use std::fmt;
 use std::marker::PhantomData;
-use std::collections::BTreeSet;
 use std::str::FromStr;
 
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// Append-only templates for sorted, deduplicated lists of items.
 ///