src/bootstrap/metadata.rs

   1 use std::collections::HashMap;
   2 use std::collections::HashSet;
   3 use std::path::PathBuf;
   4 use std::process::Command;
   5
   6 use build_helper::output;
   7 use serde::Deserialize;
   8
   9 use crate::cache::INTERNER;
  10 use crate::{Build, Crate};
  11
  12 #[derive(Deserialize)]
  13 struct Output {
  14     packages: Vec<Package>,
  15     resolve: Resolve,
  16 }
  17
  18 #[derive(Deserialize)]
  19 struct Package {
  20     id: String,
  21     name: String,
  22     source: Option<String>,
  23     manifest_path: String,
  24 }
  25
  26 #[derive(Deserialize)]
  27 struct Resolve {
  28     nodes: Vec<ResolveNode>,
  29 }
  30
  31 #[derive(Deserialize)]
  32 struct ResolveNode {
  33     id: String,
  34     dependencies: Vec<String>,
  35 }
  36
  37 pub fn build(build: &mut Build) {
  38     let mut resolves = Vec::new();
  39     build_krate(&build.std_features(), build, &mut resolves, "src/libstd");
  40     build_krate("", build, &mut resolves, "src/libtest");
  41     build_krate(&build.rustc_features(), build, &mut resolves, "src/rustc");
  42
  43     let mut id2name = HashMap::with_capacity(build.crates.len());
  44     for (name, krate) in build.crates.iter() {
  45         id2name.insert(krate.id.clone(), name.clone());
  46     }
  47
  48     for node in resolves {
  49         let name = match id2name.get(&node.id) {
  50             Some(name) => name,
  51             None => continue,
  52         };
  53
  54         let krate = build.crates.get_mut(name).unwrap();
  55         for dep in node.dependencies.iter() {
  56             let dep = match id2name.get(dep) {
  57                 Some(dep) => dep,
  58                 None => continue,
  59             };
  60             krate.deps.insert(*dep);
  61         }
  62     }
  63 }
  64
  65 fn build_krate(features: &str, build: &mut Build, resolves: &mut Vec<ResolveNode>, krate: &str) {
  66     // Run `cargo metadata` to figure out what crates we're testing.
  67     //
  68     // Down below we're going to call `cargo test`, but to test the right set
  69     // of packages we're going to have to know what `-p` arguments to pass it
  70     // to know what crates to test. Here we run `cargo metadata` to learn about
  71     // the dependency graph and what `-p` arguments there are.
  72     let mut cargo = Command::new(&build.initial_cargo);
  73     cargo
  74         .arg("metadata")
  75         .arg("--format-version")
  76         .arg("1")
  77         .arg("--features")
  78         .arg(features)
  79         .arg("--manifest-path")
  80         .arg(build.src.join(krate).join("Cargo.toml"));
  81     let output = output(&mut cargo);
  82     let output: Output = serde_json::from_str(&output).unwrap();
  83     for package in output.packages {
  84         if package.source.is_none() {
  85             let name = INTERNER.intern_string(package.name);
  86             let mut path = PathBuf::from(package.manifest_path);
  87             path.pop();
  88             build.crates.insert(name, Crate { name, id: package.id, deps: HashSet::new(), path });
  89         }
  90     }
  91     resolves.extend(output.resolve.nodes);
  92 }