rustdoc: Output target feature information

`#[target_feature]` attributes refer to a target-specific list of
features. Enabling certain features can imply enabling other features.
Certain features are always enabled on certain targets, since they are
required by the target's ABI. Features can also be enabled indirectly
based on other compiler flags.

Feature information is ultimately known to `rustc`. Rather than force
external tools to track it -- which may be wildly impractical due to
`-C target-cpu` -- have `rustdoc` output `rustc`'s feature data.

Author: willglynn

src/librustdoc/json/mod.rs

@@ -121,6 +121,28 @@ impl<'tcx> JsonRenderer<'tcx> {
             Ok(())
         })
     }
+
+    pub(crate) fn target(&self) -> types::Target {
+        let sess = self.tcx.sess;
+
+        let globally_enabled_features: FxHashMap<&str, ()> =
+            sess.target_features.iter().map(|sym| (sym.as_str(), ())).collect();
+
+        types::Target {
+            target_features: sess
+                .target
+                .rust_target_features()
+                .into_iter()
+                .copied()
+                .map(|(name, stability, implied)| types::TargetFeature {
+                    name: name.into(),
+                    stable: matches!(stability, rustc_target::target_features::Stability::Stable),
+                    implies_features: implied.into_iter().copied().map(String::from).collect(),
+                    globally_enabled: globally_enabled_features.contains_key(name),
+                })
+                .collect(),
+        }
+    }
 }
 
 impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
@@ -288,6 +310,7 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
                     )
                 })
                 .collect(),
+            target: self.target(),
             format_version: types::FORMAT_VERSION,
         };
         if let Some(ref out_dir) = self.out_dir {

src/rustdoc-json-types/lib.rs

@@ -52,11 +52,35 @@ pub struct Crate {
     pub paths: HashMap<Id, ItemSummary>,
     /// Maps `crate_id` of items to a crate name and html_root_url if it exists.
     pub external_crates: HashMap<u32, ExternalCrate>,
+    /// Information about the target for which this documentation was generated
+    pub target: Target,
     /// A single version number to be used in the future when making backwards incompatible changes
     /// to the JSON output.
     pub format_version: u32,
 }
 
+/// Information about a target
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Target {
+    /// A list of `#[target_feature]` which exist for this target, along with their status in this
+    /// compiler session
+    pub target_features: Vec<TargetFeature>,
+}
+
+/// Information about a `#[target_feature]`
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct TargetFeature {
+    /// The name of this feature
+    pub name: String,
+    /// Other feature(s) which are implied by this feature
+    pub implies_features: Vec<String>,
+    /// Whether this feature is stable
+    pub stable: bool,
+    /// Whether this feature is globally enabled for this target, for example, due to the
+    /// target's ABI requiring this feature, or due to compiler flags which enable it everywhere
+    pub globally_enabled: bool,
+}
+
 /// Metadata of a crate, either the same crate on which `rustdoc` was invoked, or its dependency.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct ExternalCrate {