Create mdbook-rustc preprocessor

Author: qb42

src/doc/rustc/book.toml

@@ -10,3 +10,9 @@ use-boolean-and = true
 
 [output.html.playground]
 runnable = false
+
+[preprocessor.rustc-gen-target-tables]
+command = "cargo run --release --manifest-path ../../tools/mdbook-rustc/Cargo.toml"
+
+[build]
+extra-watch-dirs = ["../../tools/mdbook-rustc"]

src/tools/mdbook-rustc/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "mdbook-rustc"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+mdbook-preprocessor = "0.5.1"
+rustc_target = {path = "../../../compiler/rustc_target"}

src/tools/mdbook-rustc/src/main.rs

@@ -0,0 +1,158 @@
+use std::io;
+
+use mdbook_preprocessor::{errors::Error, parse_input};
+use rustc_target::spec::{TARGETS, Target, TargetMetadata, TargetTuple};
+
+
+const TIER_1_HOST_MARKER: &str   = "{{TIER_1_HOST_TABLE}}";
+const TIER_1_NOHOST_MARKER: &str = "{{TIER_1_NOHOST_TABLE}}";
+const TIER_2_HOST_MARKER: &str   = "{{TIER_2_HOST_TABLE}}";
+const TIER_2_NOHOST_MARKER: &str = "{{TIER_2_NOHOST_TABLE}}";
+const TIER_3_MARKER: &str        = "{{TIER_3_TABLE}}";
+
+const EMPTY_TIER_1_NOHOST_MSG: &str = "At this time, all Tier 1 targets are [Tier 1 with Host Tools](#tier-1-with-host-tools).\n";
+const EMPTY_TIER_2_NOHOST_MSG: &str = "At this time, all Tier 2 targets are [Tier 2 with Host Tools](#tier-2-with-host-tools).\n";
+
+struct AllTargetsInfo {
+    tier1_host:   Vec<TargetInfo>,
+    tier1_nohost: Vec<TargetInfo>,
+    tier2_host:   Vec<TargetInfo>,
+    tier2_nohost: Vec<TargetInfo>,
+    tier3:        Vec<TargetInfo>,
+}
+
+struct TargetInfo {
+    tuple: &'static str,
+    meta:  TargetMetadata,
+}
+
+fn main() -> Result<(), Error> {
+    let mut args = std::env::args().skip(1);
+    match args.next().as_deref() {
+        Some("supports") => {
+            // Supports all renderers.
+            return;
+        }
+        Some(arg) => {
+            return Err(Error::msg("unknown argument: {arg}"));
+        }
+        None => {}
+    }
+
+    let (ctx, book) = mdbook_preprocessor::parse_input(io::stdin().lock())?;
+    let targets = AllTargetsInfo::load();
+
+    book.for_each_chapter_mut(|chapter| {
+        if chapter.source_path.as_deref() != Some("platform-support.md") {
+            return;
+        }
+
+        let mut new_content = String::new();
+
+        for line in chapter.content.lines() {
+            match line.trim() {
+                TIER_1_HOST_MARKER   => write_host_table(&mut new_content, &targets.tier1_host),
+                TIER_1_NOHOST_MARKER => write_nohost_table(&mut new_content, &targets.tier1_nohost, EMPTY_TIER_1_NOHOST_MSG),
+                TIER_2_HOST_MARKER   => write_host_table(&mut new_content, &targets.tier2_host),
+                TIER_2_NOHOST_MARKER => write_nohost_table(&mut new_content, &targets.tier2_nohost, EMPTY_TIER_2_NOHOST_MSG),
+                TIER_3_MARKER        => write_tier3_table(&mut new_content, &targets.tier3),
+                _ => {
+                    new_content.push(line);
+                    new_content.push("\n");
+                },
+            }
+        }
+
+        chapter.content = new_content;
+    })
+
+    serde_json::to_writer(io::stdout().lock(), &book)?;
+    Ok(())
+}
+
+fn write_host_table(out: &mut String, targets: &[TargetInfo]) {
+    out.push("target | notes\n-------|-------\n");
+    for target in targets {
+        _ = writeln!(out, "`{}` | {}",
+            target.tuple,
+            target.meta.description.unwrap_or("")
+        );
+    }
+}
+
+fn write_nohost_table(out: &mut String, targets: &[TargetInfo], empty_msg: &str) {
+    if targets.is_empty() {
+        out.push(empty_msg);
+        return;
+    }
+
+    out.push("target | std | notes\n-------|:---:|-------\n");
+    for target in targets {
+        _ = writeln!(out, "`{}` | {} | {}",
+            target.tuple,
+            support_symbol(target.meta.std),
+            target.meta.description.unwrap_or("")
+        );
+    }
+}
+
+fn write_tier3_table(out: &mut String, targets: &[TargetInfo]) {
+    out.push("target | std | host | notes\n-------|:---:|:----:|-------\n");
+    for (target, meta) in targets {
+        _ = writeln!(out, "`{}` | {} | {} | {}",
+            target.tuple,
+            support_symbol(target.meta.std),
+            support_symbol(target.meta.host_tools),
+            target.meta.description.unwrap_or("")
+        );
+    }
+}
+
+fn support_symbol(support: Option<bool>) -> &'static str {
+    match support {
+        Some(true)  => "✓",
+        Some(false) => "*",
+        None        => "?",
+    }
+}
+
+impl AllTargetsInfo {
+    fn load() -> Self {
+        let mut tier1_host   = Vec::new();
+        let mut tier1_nohost = Vec::new();
+        let mut tier2_host   = Vec::new();
+        let mut tier2_nohost = Vec::new();
+        let mut tier3        = Vec::new();
+
+        for tuple in TARGETS {
+            let target = TargetInfo {
+                tuple,
+                meta: Target::expect_builtin(TargetTuple::from_tuple(target)).metadata,
+            }
+            let host_tools = target.meta.host_tools.unwrap_or(false);
+
+            match target.meta.tier {
+                Some(1) if host_tools => tier1_host.push(target),
+                Some(1)               => tier1_nohost.push(target),
+                Some(2) if host_tools => tier2_host.push(target),
+                Some(2)               => tier2_nohost.push(target),
+                Some(3)               => tier3.push(target),
+                tier => panic!("unknown target tier: {tier}"),
+            }
+        }
+
+        tier1_host.sort_by_key(|t| t.tuple);
+        tier1_nohost.sort_by_key(|t| t.tuple);
+        tier2_host.sort_by_key(|t| t.tuple);
+        tier2_nohost.sort_by_key(|t| t.tuple);
+        tier3.sort_by_key(|t| t.tuple);
+
+        Self {
+            tier1_host,
+            tier1_nohost,
+            tier2_host,
+            tier2_nohost,
+            tier3,
+        }
+    }
+}