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