Merge pull request #491 from jyn514/proc-macro-hack

Document proc-macros despite bugs in rustdoc

Author: QuietMisdreavus

src/docbuilder/rustwide_builder.rs

@@ -26,7 +26,6 @@ static TARGETS: &[&str] = &[
     "x86_64-pc-windows-msvc",
     "x86_64-unknown-linux-gnu",
 ];
-static DEFAULT_TARGET: &str = "x86_64-unknown-linux-gnu";
 
 static ESSENTIAL_FILES_VERSIONED: &[&str] = &[
     "brush.svg",
@@ -267,7 +266,7 @@ impl RustwideBuilder {
             .build(&self.toolchain, &krate, sandbox)
             .run(|build| {
                 let mut files_list = None;
-                let mut has_docs = false;
+                let (mut has_docs, mut in_target) = (false, false);
                 let mut successful_targets = Vec::new();
 
                 // Do an initial build and then copy the sources in the database
@@ -281,54 +280,47 @@ impl RustwideBuilder {
                         build.host_source_dir(),
                     )?);
 
-                    has_docs = res
-                        .cargo_metadata
-                        .root()
-                        .library_name()
-                        .map(|name| {
-                            build
-                                .host_target_dir()
-                                .join(&res.target)
-                                .join("doc")
-                                .join(name)
-                                .is_dir()
-                        })
-                        .unwrap_or(false);
+                    if let Some(name) = res.cargo_metadata.root().library_name() {
+                        let host_target = build.host_target_dir();
+                        if host_target
+                            .join(&res.target)
+                            .join("doc")
+                            .join(&name)
+                            .is_dir()
+                        {
+                            has_docs = true;
+                            in_target = true;
+                        // hack for proc-macro documentation:
+                        // it really should be in target/$target/doc,
+                        // but rustdoc has a bug and puts it in target/doc
+                        } else if host_target.join("doc").join(name).is_dir() {
+                            has_docs = true;
+                        }
+                    }
                 }
 
                 if has_docs {
                     debug!("adding documentation for the default target to the database");
                     self.copy_docs(
                         &build.host_target_dir(),
                         local_storage.path(),
-                        &res.target,
+                        if in_target { &res.target } else { "" },
                         true,
                     )?;
 
-                    // Then build the documentation for all the targets
-                    for target in TARGETS {
-                        debug!("building package {} {} for {}", name, version, target);
-                        let target_res = self.execute_build(Some(target), &build, &limits)?;
-                        if target_res.successful {
-                            // Cargo is not giving any error and not generating documentation of some crates
-                            // when we use a target compile options. Check documentation exists before
-                            // adding target to successfully_targets.
-                            if build.host_target_dir().join(target).join("doc").is_dir() {
-                                debug!(
-                                    "adding documentation for target {} to the database",
-                                    target
-                                );
-                                self.copy_docs(
-                                    &build.host_target_dir(),
-                                    local_storage.path(),
-                                    target,
-                                    false,
-                                )?;
-                                successful_targets.push(target.to_string());
-                            }
+                    if in_target {
+                        // Then build the documentation for all the targets
+                        for target in TARGETS {
+                            debug!("building package {} {} for {}", name, version, target);
+                            self.build_target(
+                                target,
+                                &build,
+                                &limits,
+                                &local_storage.path(),
+                                &mut successful_targets,
+                            )?;
                         }
                     }
-
                     self.upload_docs(&conn, name, version, local_storage.path())?;
                 }
 
@@ -362,6 +354,28 @@ impl RustwideBuilder {
         Ok(res.successful)
     }
 
+    fn build_target(
+        &self,
+        target: &str,
+        build: &Build,
+        limits: &Limits,
+        local_storage: &Path,
+        successful_targets: &mut Vec<String>,
+    ) -> Result<()> {
+        let target_res = self.execute_build(Some(target), build, limits)?;
+        if target_res.successful {
+            // Cargo is not giving any error and not generating documentation of some crates
+            // when we use a target compile options. Check documentation exists before
+            // adding target to successfully_targets.
+            if build.host_target_dir().join(target).join("doc").is_dir() {
+                debug!("adding documentation for target {} to the database", target,);
+                self.copy_docs(&build.host_target_dir(), local_storage, target, false)?;
+                successful_targets.push(target.to_string());
+            }
+        }
+        Ok(())
+    }
+
     fn execute_build(
         &self,
         target: Option<&str>,
@@ -372,14 +386,7 @@ impl RustwideBuilder {
         let cargo_metadata =
             CargoMetadata::load(&self.workspace, &self.toolchain, &build.host_source_dir())?;
 
-        let target = if let Some(target) = target {
-            target
-        } else if let Some(target) = metadata.default_target.as_ref().map(|s| s.as_str()) {
-            target
-        } else {
-            DEFAULT_TARGET
-        }
-        .to_string();
+        let target = target.or_else(|| metadata.default_target.as_ref().map(|s| s.as_str()));
 
         let mut rustdoc_flags: Vec<String> = vec![
             "-Z".to_string(),
@@ -401,13 +408,11 @@ impl RustwideBuilder {
         if let Some(package_rustdoc_args) = &metadata.rustdoc_args {
             rustdoc_flags.append(&mut package_rustdoc_args.iter().map(|s| s.to_owned()).collect());
         }
-        let mut cargo_args = vec![
-            "doc".to_owned(),
-            "--lib".to_owned(),
-            "--no-deps".to_owned(),
-            "--target".to_owned(),
-            target.to_owned(),
-        ];
+        let mut cargo_args = vec!["doc".to_owned(), "--lib".to_owned(), "--no-deps".to_owned()];
+        if let Some(explicit_target) = target {
+            cargo_args.push("--target".to_owned());
+            cargo_args.push(explicit_target.to_owned());
+        };
         if let Some(features) = &metadata.features {
             cargo_args.push("--features".to_owned());
             cargo_args.push(features.join(" "));
@@ -431,8 +436,9 @@ impl RustwideBuilder {
                     "RUSTFLAGS",
                     metadata
                         .rustc_args
+                        .as_ref()
                         .map(|args| args.join(" "))
-                        .unwrap_or("".to_owned()),
+                        .unwrap_or_default(),
                 )
                 .env("RUSTDOCFLAGS", rustdoc_flags.join(" "))
                 .args(&cargo_args)
@@ -446,7 +452,7 @@ impl RustwideBuilder {
             docsrs_version: format!("docsrs {}", ::BUILD_VERSION),
             successful,
             cargo_metadata,
-            target: target.to_string(),
+            target: target.unwrap_or_default().to_string(),
         })
     }