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

Diff for: src/librustdoc/json/mod.rs

@@ -121,6 +121,54 @@ 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();
+
+        // Build a map of feature stability, ignoring forbidden features which
+        // cannot be specified by #[target_feature]
+        use rustc_target::target_features::Stability;
+        let feature_stability: FxHashMap<_, Option<&str>> = sess
+            .target
+            .rust_target_features()
+            .into_iter()
+            .filter_map(|(name, stability, _)| match stability {
+                Stability::Stable => Some((name, None)),
+                Stability::Unstable(language_feature) => {
+                    Some((name, Some(language_feature.as_str())))
+                }
+                Stability::Forbidden { .. } => None,
+            })
+            .collect();
+
+        types::Target {
+            target_features: sess
+                .target
+                .rust_target_features()
+                .into_iter()
+                .copied()
+                .filter_map(|(name, _, implied)| {
+                    // Look up this feature's stability, skipping if it's forbidden
+                    let unstable = *feature_stability.get(&name)?;
+
+                    Some(types::TargetFeature {
+                        name: name.into(),
+                        unstable: unstable.map(String::from),
+                        implies_features: implied
+                            .into_iter()
+                            .copied()
+                            .filter(|f| feature_stability.contains_key(f))
+                            .map(String::from)
+                            .collect(),
+                        globally_enabled: globally_enabled_features.contains_key(name),
+                    })
+                })
+                .collect(),
+        }
+    }
 }
 
 impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
@@ -288,6 +336,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 {

Diff for: src/rustdoc-json-types/lib.rs

@@ -30,7 +30,7 @@ pub type FxHashMap<K, V> = HashMap<K, V>; // re-export for use in src/librustdoc
 /// This integer is incremented with every breaking change to the API,
 /// and is returned along with the JSON blob as [`Crate::format_version`].
 /// Consuming code should assert that this value matches the format version(s) that it supports.
-pub const FORMAT_VERSION: u32 = 43;
+pub const FORMAT_VERSION: u32 = 44;
 
 /// The root of the emitted JSON blob.
 ///
@@ -52,11 +52,36 @@ 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 target feature
+    pub name: String,
+    /// Other target features which are implied by this target feature
+    pub implies_features: Vec<String>,
+    /// If this target feature is unstable, the name of the associated language feature gate
+    pub unstable: Option<String>,
+    /// 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 like `-C target_feature` or
+    /// `-C target-cpu`
+    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 {

Diff for: src/tools/jsondoclint/src/validator/tests.rs

@@ -42,6 +42,7 @@ fn errors_on_missing_links() {
         )]),
         paths: FxHashMap::default(),
         external_crates: FxHashMap::default(),
+        target: rustdoc_json_types::Target { target_features: vec![] },
         format_version: rustdoc_json_types::FORMAT_VERSION,
     };
 
@@ -112,6 +113,7 @@ fn errors_on_local_in_paths_and_not_index() {
             },
         )]),
         external_crates: FxHashMap::default(),
+        target: rustdoc_json_types::Target { target_features: vec![] },
         format_version: rustdoc_json_types::FORMAT_VERSION,
     };
 
@@ -216,6 +218,7 @@ fn errors_on_missing_path() {
             ItemSummary { crate_id: 0, path: vec!["foo".to_owned()], kind: ItemKind::Module },
         )]),
         external_crates: FxHashMap::default(),
+        target: rustdoc_json_types::Target { target_features: vec![] },
         format_version: rustdoc_json_types::FORMAT_VERSION,
     };
 
@@ -259,6 +262,7 @@ fn checks_local_crate_id_is_correct() {
         )]),
         paths: FxHashMap::default(),
         external_crates: FxHashMap::default(),
+        target: rustdoc_json_types::Target { target_features: vec![] },
         format_version: FORMAT_VERSION,
     };
     check(&krate, &[]);