src/tools/tidy/src/deps.rs

   1 //! Checks the licenses of third-party dependencies.
   2
   3 use cargo_metadata::{Metadata, Package, PackageId, Resolve};
   4 use std::collections::{BTreeSet, HashSet};
   5 use std::path::Path;
   6
   7 /// These are licenses that are allowed for all crates, including the runtime,
   8 /// rustc, tools, etc.
   9 const LICENSES: &[&str] = &[
  10     "MIT/Apache-2.0",
  11     "MIT / Apache-2.0",
  12     "Apache-2.0/MIT",
  13     "Apache-2.0 / MIT",
  14     "MIT OR Apache-2.0",
  15     "Apache-2.0 OR MIT",
  16     "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT", // wasi license
  17     "MIT",
  18     "Unlicense/MIT",
  19     "Unlicense OR MIT",
  20     "0BSD OR MIT OR Apache-2.0", // adler license
  21     "Zlib OR Apache-2.0 OR MIT", // tinyvec
  22 ];
  23
  24 /// These are exceptions to Rust's permissive licensing policy, and
  25 /// should be considered bugs. Exceptions are only allowed in Rust
  26 /// tooling. It is _crucial_ that no exception crates be dependencies
  27 /// of the Rust runtime (std/test).
  28 const EXCEPTIONS: &[(&str, &str)] = &[
  29     ("mdbook", "MPL-2.0"),                                  // mdbook
  30     ("openssl", "Apache-2.0"),                              // cargo, mdbook
  31     ("colored", "MPL-2.0"),                                 // rustfmt
  32     ("ordslice", "Apache-2.0"),                             // rls
  33     ("ryu", "Apache-2.0 OR BSL-1.0"),                       // rls/cargo/... (because of serde)
  34     ("bytesize", "Apache-2.0"),                             // cargo
  35     ("im-rc", "MPL-2.0+"),                                  // cargo
  36     ("sized-chunks", "MPL-2.0+"),                           // cargo via im-rc
  37     ("bitmaps", "MPL-2.0+"),                                // cargo via im-rc
  38     ("crossbeam-queue", "MIT/Apache-2.0 AND BSD-2-Clause"), // rls via rayon
  39     ("instant", "BSD-3-Clause"), // rustc_driver/tracing-subscriber/parking_lot
  40     ("snap", "BSD-3-Clause"),    // rustc
  41     // FIXME: this dependency violates the documentation comment above:
  42     ("fortanix-sgx-abi", "MPL-2.0"), // libstd but only for `sgx` target
  43 ];
  44
  45 const EXCEPTIONS_CRANELIFT: &[(&str, &str)] = &[
  46     ("cranelift-bforest", "Apache-2.0 WITH LLVM-exception"),
  47     ("cranelift-codegen", "Apache-2.0 WITH LLVM-exception"),
  48     ("cranelift-codegen-meta", "Apache-2.0 WITH LLVM-exception"),
  49     ("cranelift-codegen-shared", "Apache-2.0 WITH LLVM-exception"),
  50     ("cranelift-entity", "Apache-2.0 WITH LLVM-exception"),
  51     ("cranelift-frontend", "Apache-2.0 WITH LLVM-exception"),
  52     ("cranelift-jit", "Apache-2.0 WITH LLVM-exception"),
  53     ("cranelift-module", "Apache-2.0 WITH LLVM-exception"),
  54     ("cranelift-native", "Apache-2.0 WITH LLVM-exception"),
  55     ("cranelift-object", "Apache-2.0 WITH LLVM-exception"),
  56     ("libloading", "ISC"),
  57     ("mach", "BSD-2-Clause"),
  58     ("regalloc", "Apache-2.0 WITH LLVM-exception"),
  59     ("target-lexicon", "Apache-2.0 WITH LLVM-exception"),
  60 ];
  61
  62 /// These are the root crates that are part of the runtime. The licenses for
  63 /// these and all their dependencies *must not* be in the exception list.
  64 const RUNTIME_CRATES: &[&str] = &["std", "core", "alloc", "test", "panic_abort", "panic_unwind"];
  65
  66 /// Crates whose dependencies must be explicitly permitted.
  67 const RESTRICTED_DEPENDENCY_CRATES: &[&str] = &["rustc_driver", "rustc_codegen_llvm"];
  68
  69 /// Crates rustc is allowed to depend on. Avoid adding to the list if possible.
  70 ///
  71 /// This list is here to provide a speed-bump to adding a new dependency to
  72 /// rustc. Please check with the compiler team before adding an entry.
  73 const PERMITTED_DEPENDENCIES: &[&str] = &[
  74     "addr2line",
  75     "adler",
  76     "aho-corasick",
  77     "annotate-snippets",
  78     "ansi_term",
  79     "arrayvec",
  80     "atty",
  81     "autocfg",
  82     "bitflags",
  83     "block-buffer",
  84     "block-padding",
  85     "byteorder",
  86     "byte-tools",
  87     "cc",
  88     "cfg-if",
  89     "chalk-derive",
  90     "chalk-engine",
  91     "chalk-ir",
  92     "chalk-solve",
  93     "chrono",
  94     "cmake",
  95     "compiler_builtins",
  96     "cpuid-bool",
  97     "crc32fast",
  98     "crossbeam-deque",
  99     "crossbeam-epoch",
 100     "crossbeam-queue",
 101     "crossbeam-utils",
 102     "cstr",
 103     "datafrog",
 104     "difference",
 105     "digest",
 106     "dlmalloc",
 107     "either",
 108     "ena",
 109     "env_logger",
 110     "expect-test",
 111     "fake-simd",
 112     "filetime",
 113     "fixedbitset",
 114     "flate2",
 115     "fortanix-sgx-abi",
 116     "generic-array",
 117     "getopts",
 118     "getrandom",
 119     "gimli",
 120     "gsgdt",
 121     "hashbrown",
 122     "hermit-abi",
 123     "humantime",
 124     "if_chain",
 125     "indexmap",
 126     "instant",
 127     "itertools",
 128     "itoa",
 129     "jobserver",
 130     "lazy_static",
 131     "libc",
 132     "libz-sys",
 133     "lock_api",
 134     "log",
 135     "matchers",
 136     "maybe-uninit",
 137     "md-5",
 138     "measureme",
 139     "memchr",
 140     "memmap2",
 141     "memoffset",
 142     "miniz_oxide",
 143     "num_cpus",
 144     "num-integer",
 145     "num-traits",
 146     "object",
 147     "odht",
 148     "once_cell",
 149     "opaque-debug",
 150     "parking_lot",
 151     "parking_lot_core",
 152     "pathdiff",
 153     "perf-event-open-sys",
 154     "petgraph",
 155     "pin-project-lite",
 156     "pkg-config",
 157     "polonius-engine",
 158     "ppv-lite86",
 159     "proc-macro2",
 160     "psm",
 161     "punycode",
 162     "quick-error",
 163     "quote",
 164     "rand",
 165     "rand_chacha",
 166     "rand_core",
 167     "rand_hc",
 168     "rand_pcg",
 169     "rand_xorshift",
 170     "rand_xoshiro",
 171     "redox_syscall",
 172     "regex",
 173     "regex-automata",
 174     "regex-syntax",
 175     "remove_dir_all",
 176     "rls-data",
 177     "rls-span",
 178     "rustc-demangle",
 179     "rustc-hash",
 180     "rustc-rayon",
 181     "rustc-rayon-core",
 182     "rustc_version",
 183     "ryu",
 184     "scoped-tls",
 185     "scopeguard",
 186     "semver",
 187     "semver-parser",
 188     "serde",
 189     "serde_derive",
 190     "serde_json",
 191     "sha-1",
 192     "sha2",
 193     "smallvec",
 194     "sharded-slab",
 195     "snap",
 196     "stable_deref_trait",
 197     "stacker",
 198     "syn",
 199     "synstructure",
 200     "tempfile",
 201     "termcolor",
 202     "termize",
 203     "thread_local",
 204     "time",
 205     "tinyvec",
 206     "tracing",
 207     "tracing-attributes",
 208     "tracing-core",
 209     "tracing-log",
 210     "tracing-serde",
 211     "tracing-subscriber",
 212     "tracing-tree",
 213     "typenum",
 214     "unicode-normalization",
 215     "unicode-script",
 216     "unicode-security",
 217     "unicode-width",
 218     "unicode-xid",
 219     "vcpkg",
 220     "version_check",
 221     "wasi",
 222     "winapi",
 223     "winapi-i686-pc-windows-gnu",
 224     "winapi-util",
 225     "winapi-x86_64-pc-windows-gnu",
 226     // this is a false-positive: it's only used by rustfmt, but because it's enabled through a feature, tidy thinks it's used by rustc as well.
 227     "yansi-term",
 228 ];
 229
 230 const PERMITTED_CRANELIFT_DEPENDENCIES: &[&str] = &[
 231     "anyhow",
 232     "ar",
 233     "autocfg",
 234     "bitflags",
 235     "cfg-if",
 236     "cranelift-bforest",
 237     "cranelift-codegen",
 238     "cranelift-codegen-meta",
 239     "cranelift-codegen-shared",
 240     "cranelift-entity",
 241     "cranelift-frontend",
 242     "cranelift-jit",
 243     "cranelift-module",
 244     "cranelift-native",
 245     "cranelift-object",
 246     "crc32fast",
 247     "gimli",
 248     "hashbrown",
 249     "indexmap",
 250     "libc",
 251     "libloading",
 252     "log",
 253     "mach",
 254     "memchr",
 255     "object",
 256     "regalloc",
 257     "region",
 258     "rustc-hash",
 259     "smallvec",
 260     "target-lexicon",
 261     "winapi",
 262     "winapi-i686-pc-windows-gnu",
 263     "winapi-x86_64-pc-windows-gnu",
 264 ];
 265
 266 const FORBIDDEN_TO_HAVE_DUPLICATES: &[&str] = &[
 267     // These two crates take quite a long time to build, so don't allow two versions of them
 268     // to accidentally sneak into our dependency graph, in order to ensure we keep our CI times
 269     // under control.
 270     "cargo",
 271     "rustc-ap-rustc_ast",
 272 ];
 273
 274 /// Dependency checks.
 275 ///
 276 /// `root` is path to the directory with the root `Cargo.toml` (for the workspace). `cargo` is path
 277 /// to the cargo executable.
 278 pub fn check(root: &Path, cargo: &Path, bad: &mut bool) {
 279     let mut cmd = cargo_metadata::MetadataCommand::new();
 280     cmd.cargo_path(cargo)
 281         .manifest_path(root.join("Cargo.toml"))
 282         .features(cargo_metadata::CargoOpt::AllFeatures);
 283     let metadata = t!(cmd.exec());
 284     let runtime_ids = compute_runtime_crates(&metadata);
 285     check_exceptions(&metadata, EXCEPTIONS, runtime_ids, bad);
 286     check_dependencies(&metadata, PERMITTED_DEPENDENCIES, RESTRICTED_DEPENDENCY_CRATES, bad);
 287     check_crate_duplicate(&metadata, FORBIDDEN_TO_HAVE_DUPLICATES, bad);
 288     check_rustfix(&metadata, bad);
 289
 290     // Check rustc_codegen_cranelift independently as it has it's own workspace.
 291     let mut cmd = cargo_metadata::MetadataCommand::new();
 292     cmd.cargo_path(cargo)
 293         .manifest_path(root.join("compiler/rustc_codegen_cranelift/Cargo.toml"))
 294         .features(cargo_metadata::CargoOpt::AllFeatures);
 295     let metadata = t!(cmd.exec());
 296     let runtime_ids = HashSet::new();
 297     check_exceptions(&metadata, EXCEPTIONS_CRANELIFT, runtime_ids, bad);
 298     check_dependencies(
 299         &metadata,
 300         PERMITTED_CRANELIFT_DEPENDENCIES,
 301         &["rustc_codegen_cranelift"],
 302         bad,
 303     );
 304     check_crate_duplicate(&metadata, &[], bad);
 305 }
 306
 307 /// Check that all licenses are in the valid list in `LICENSES`.
 308 ///
 309 /// Packages listed in `EXCEPTIONS` are allowed for tools.
 310 fn check_exceptions(
 311     metadata: &Metadata,
 312     exceptions: &[(&str, &str)],
 313     runtime_ids: HashSet<&PackageId>,
 314     bad: &mut bool,
 315 ) {
 316     // Validate the EXCEPTIONS list hasn't changed.
 317     for (name, license) in exceptions {
 318         // Check that the package actually exists.
 319         if !metadata.packages.iter().any(|p| p.name == *name) {
 320             tidy_error!(
 321                 bad,
 322                 "could not find exception package `{}`\n\
 323                 Remove from EXCEPTIONS list if it is no longer used.",
 324                 name
 325             );
 326         }
 327         // Check that the license hasn't changed.
 328         for pkg in metadata.packages.iter().filter(|p| p.name == *name) {
 329             match &pkg.license {
 330                 None => {
 331                     tidy_error!(
 332                         bad,
 333                         "dependency exception `{}` does not declare a license expression",
 334                         pkg.id
 335                     );
 336                 }
 337                 Some(pkg_license) => {
 338                     if pkg_license.as_str() != *license {
 339                         println!("dependency exception `{}` license has changed", name);
 340                         println!("    previously `{}` now `{}`", license, pkg_license);
 341                         println!("    update EXCEPTIONS for the new license");
 342                         *bad = true;
 343                     }
 344                 }
 345             }
 346         }
 347     }
 348
 349     let exception_names: Vec<_> = exceptions.iter().map(|(name, _license)| *name).collect();
 350
 351     // Check if any package does not have a valid license.
 352     for pkg in &metadata.packages {
 353         if pkg.source.is_none() {
 354             // No need to check local packages.
 355             continue;
 356         }
 357         if !runtime_ids.contains(&pkg.id) && exception_names.contains(&pkg.name.as_str()) {
 358             continue;
 359         }
 360         let license = match &pkg.license {
 361             Some(license) => license,
 362             None => {
 363                 tidy_error!(bad, "dependency `{}` does not define a license expression", pkg.id);
 364                 continue;
 365             }
 366         };
 367         if !LICENSES.contains(&license.as_str()) {
 368             if pkg.name == "fortanix-sgx-abi" {
 369                 // This is a specific exception because SGX is considered
 370                 // "third party". See
 371                 // https://github.com/rust-lang/rust/issues/62620 for more. In
 372                 // general, these should never be added.
 373                 continue;
 374             }
 375             tidy_error!(bad, "invalid license `{}` in `{}`", license, pkg.id);
 376         }
 377     }
 378 }
 379
 380 /// Checks the dependency of `RESTRICTED_DEPENDENCY_CRATES` at the given path. Changes `bad` to
 381 /// `true` if a check failed.
 382 ///
 383 /// Specifically, this checks that the dependencies are on the `PERMITTED_DEPENDENCIES`.
 384 fn check_dependencies(
 385     metadata: &Metadata,
 386     permitted_dependencies: &[&'static str],
 387     restricted_dependency_crates: &[&'static str],
 388     bad: &mut bool,
 389 ) {
 390     // Check that the PERMITTED_DEPENDENCIES does not have unused entries.
 391     for name in permitted_dependencies {
 392         if !metadata.packages.iter().any(|p| p.name == *name) {
 393             tidy_error!(
 394                 bad,
 395                 "could not find allowed package `{}`\n\
 396                 Remove from PERMITTED_DEPENDENCIES list if it is no longer used.",
 397                 name
 398             );
 399         }
 400     }
 401     // Get the list in a convenient form.
 402     let permitted_dependencies: HashSet<_> = permitted_dependencies.iter().cloned().collect();
 403
 404     // Check dependencies.
 405     let mut visited = BTreeSet::new();
 406     let mut unapproved = BTreeSet::new();
 407     for &krate in restricted_dependency_crates.iter() {
 408         let pkg = pkg_from_name(metadata, krate);
 409         let mut bad =
 410             check_crate_dependencies(&permitted_dependencies, metadata, &mut visited, pkg);
 411         unapproved.append(&mut bad);
 412     }
 413
 414     if !unapproved.is_empty() {
 415         tidy_error!(bad, "Dependencies not explicitly permitted:");
 416         for dep in unapproved {
 417             println!("* {}", dep);
 418         }
 419     }
 420 }
 421
 422 /// Checks the dependencies of the given crate from the given cargo metadata to see if they are on
 423 /// the list of permitted dependencies. Returns a list of disallowed dependencies.
 424 fn check_crate_dependencies<'a>(
 425     permitted_dependencies: &'a HashSet<&'static str>,
 426     metadata: &'a Metadata,
 427     visited: &mut BTreeSet<&'a PackageId>,
 428     krate: &'a Package,
 429 ) -> BTreeSet<&'a PackageId> {
 430     // This will contain bad deps.
 431     let mut unapproved = BTreeSet::new();
 432
 433     // Check if we have already visited this crate.
 434     if visited.contains(&krate.id) {
 435         return unapproved;
 436     }
 437
 438     visited.insert(&krate.id);
 439
 440     // If this path is in-tree, we don't require it to be explicitly permitted.
 441     if krate.source.is_some() {
 442         // If this dependency is not on `PERMITTED_DEPENDENCIES`, add to bad set.
 443         if !permitted_dependencies.contains(krate.name.as_str()) {
 444             unapproved.insert(&krate.id);
 445         }
 446     }
 447
 448     // Do a DFS in the crate graph.
 449     let to_check = deps_of(metadata, &krate.id);
 450
 451     for dep in to_check {
 452         let mut bad = check_crate_dependencies(permitted_dependencies, metadata, visited, dep);
 453         unapproved.append(&mut bad);
 454     }
 455
 456     unapproved
 457 }
 458
 459 /// Prevents multiple versions of some expensive crates.
 460 fn check_crate_duplicate(
 461     metadata: &Metadata,
 462     forbidden_to_have_duplicates: &[&str],
 463     bad: &mut bool,
 464 ) {
 465     for &name in forbidden_to_have_duplicates {
 466         let matches: Vec<_> = metadata.packages.iter().filter(|pkg| pkg.name == name).collect();
 467         match matches.len() {
 468             0 => {
 469                 tidy_error!(
 470                     bad,
 471                     "crate `{}` is missing, update `check_crate_duplicate` \
 472                     if it is no longer used",
 473                     name
 474                 );
 475             }
 476             1 => {}
 477             _ => {
 478                 tidy_error!(
 479                     bad,
 480                     "crate `{}` is duplicated in `Cargo.lock`, \
 481                     it is too expensive to build multiple times, \
 482                     so make sure only one version appears across all dependencies",
 483                     name
 484                 );
 485                 for pkg in matches {
 486                     println!("  * {}", pkg.id);
 487                 }
 488             }
 489         }
 490     }
 491 }
 492
 493 /// Returns a list of dependencies for the given package.
 494 fn deps_of<'a>(metadata: &'a Metadata, pkg_id: &'a PackageId) -> Vec<&'a Package> {
 495     let resolve = metadata.resolve.as_ref().unwrap();
 496     let node = resolve
 497         .nodes
 498         .iter()
 499         .find(|n| &n.id == pkg_id)
 500         .unwrap_or_else(|| panic!("could not find `{}` in resolve", pkg_id));
 501     node.deps
 502         .iter()
 503         .map(|dep| {
 504             metadata.packages.iter().find(|pkg| pkg.id == dep.pkg).unwrap_or_else(|| {
 505                 panic!("could not find dep `{}` for pkg `{}` in resolve", dep.pkg, pkg_id)
 506             })
 507         })
 508         .collect()
 509 }
 510
 511 /// Finds a package with the given name.
 512 fn pkg_from_name<'a>(metadata: &'a Metadata, name: &'static str) -> &'a Package {
 513     let mut i = metadata.packages.iter().filter(|p| p.name == name);
 514     let result =
 515         i.next().unwrap_or_else(|| panic!("could not find package `{}` in package list", name));
 516     assert!(i.next().is_none(), "more than one package found for `{}`", name);
 517     result
 518 }
 519
 520 /// Finds all the packages that are in the rust runtime.
 521 fn compute_runtime_crates<'a>(metadata: &'a Metadata) -> HashSet<&'a PackageId> {
 522     let resolve = metadata.resolve.as_ref().unwrap();
 523     let mut result = HashSet::new();
 524     for name in RUNTIME_CRATES {
 525         let id = &pkg_from_name(metadata, name).id;
 526         normal_deps_of_r(resolve, id, &mut result);
 527     }
 528     result
 529 }
 530
 531 /// Recursively find all normal dependencies.
 532 fn normal_deps_of_r<'a>(
 533     resolve: &'a Resolve,
 534     pkg_id: &'a PackageId,
 535     result: &mut HashSet<&'a PackageId>,
 536 ) {
 537     if !result.insert(pkg_id) {
 538         return;
 539     }
 540     let node = resolve
 541         .nodes
 542         .iter()
 543         .find(|n| &n.id == pkg_id)
 544         .unwrap_or_else(|| panic!("could not find `{}` in resolve", pkg_id));
 545     for dep in &node.deps {
 546         normal_deps_of_r(resolve, &dep.pkg, result);
 547     }
 548 }
 549
 550 fn check_rustfix(metadata: &Metadata, bad: &mut bool) {
 551     let cargo = pkg_from_name(metadata, "cargo");
 552     let compiletest = pkg_from_name(metadata, "compiletest");
 553     let cargo_deps = deps_of(metadata, &cargo.id);
 554     let compiletest_deps = deps_of(metadata, &compiletest.id);
 555     let cargo_rustfix = cargo_deps.iter().find(|p| p.name == "rustfix").unwrap();
 556     let compiletest_rustfix = compiletest_deps.iter().find(|p| p.name == "rustfix").unwrap();
 557     if cargo_rustfix.version != compiletest_rustfix.version {
 558         tidy_error!(
 559             bad,
 560             "cargo's rustfix version {} does not match compiletest's rustfix version {}\n\
 561              rustfix should be kept in sync, update the cargo side first, and then update \
 562              compiletest along with cargo.",
 563             cargo_rustfix.version,
 564             compiletest_rustfix.version
 565         );
 566     }
 567 }