2019-01-11 17:32:31 +01:00
|
|
|
//! Library used by tidy and other tools.
|
2017-06-12 15:06:12 +02:00
|
|
|
//!
|
|
|
|
//! This library contains the tidy lints and exposes it
|
|
|
|
//! to be used by tools.
|
|
|
|
|
2018-02-23 02:52:56 +01:00
|
|
|
extern crate serde;
|
|
|
|
extern crate serde_json;
|
|
|
|
#[macro_use]
|
|
|
|
extern crate serde_derive;
|
|
|
|
|
2017-06-12 15:06:12 +02:00
|
|
|
use std::fs;
|
|
|
|
|
|
|
|
use std::path::Path;
|
|
|
|
|
|
|
|
macro_rules! t {
|
|
|
|
($e:expr, $p:expr) => (match $e {
|
|
|
|
Ok(e) => e,
|
|
|
|
Err(e) => panic!("{} failed on {} with {}", stringify!($e), ($p).display(), e),
|
|
|
|
});
|
|
|
|
|
|
|
|
($e:expr) => (match $e {
|
|
|
|
Ok(e) => e,
|
|
|
|
Err(e) => panic!("{} failed with {}", stringify!($e), e),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! tidy_error {
|
|
|
|
($bad:expr, $fmt:expr, $($arg:tt)*) => ({
|
|
|
|
*$bad = true;
|
2017-12-06 09:25:29 +01:00
|
|
|
eprint!("tidy error: ");
|
|
|
|
eprintln!($fmt, $($arg)*);
|
2017-06-12 15:06:12 +02:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
pub mod bins;
|
|
|
|
pub mod style;
|
|
|
|
pub mod errors;
|
|
|
|
pub mod features;
|
|
|
|
pub mod cargo;
|
|
|
|
pub mod pal;
|
|
|
|
pub mod deps;
|
2018-07-15 12:46:02 +02:00
|
|
|
pub mod extdeps;
|
2018-03-09 15:11:06 +01:00
|
|
|
pub mod ui_tests;
|
2017-06-12 15:06:12 +02:00
|
|
|
pub mod unstable_book;
|
2018-05-05 18:54:12 +02:00
|
|
|
pub mod libcoretest;
|
2017-06-12 15:06:12 +02:00
|
|
|
|
|
|
|
fn filter_dirs(path: &Path) -> bool {
|
|
|
|
let skip = [
|
|
|
|
"src/llvm",
|
2019-01-16 18:59:03 +01:00
|
|
|
"src/llvm-project",
|
rustc: Split Emscripten to a separate codegen backend
This commit introduces a separately compiled backend for Emscripten, avoiding
compiling the `JSBackend` target in the main LLVM codegen backend. This builds
on the foundation provided by #47671 to create a new codegen backend dedicated
solely to Emscripten, removing the `JSBackend` of the main codegen backend in
the process.
A new field was added to each target for this commit which specifies the backend
to use for translation, the default being `llvm` which is the main backend that
we use. The Emscripten targets specify an `emscripten` backend instead of the
main `llvm` one.
There's a whole bunch of consequences of this change, but I'll try to enumerate
them here:
* A *second* LLVM submodule was added in this commit. The main LLVM submodule
will soon start to drift from the Emscripten submodule, but currently they're
both at the same revision.
* Logic was added to rustbuild to *not* build the Emscripten backend by default.
This is gated behind a `--enable-emscripten` flag to the configure script. By
default users should neither check out the emscripten submodule nor compile
it.
* The `init_repo.sh` script was updated to fetch the Emscripten submodule from
GitHub the same way we do the main LLVM submodule (a tarball fetch).
* The Emscripten backend, turned off by default, is still turned on for a number
of targets on CI. We'll only be shipping an Emscripten backend with Tier 1
platforms, though. All cross-compiled platforms will not be receiving an
Emscripten backend yet.
This commit means that when you download the `rustc` package in Rustup for Tier
1 platforms you'll be receiving two trans backends, one for Emscripten and one
that's the general LLVM backend. If you never compile for Emscripten you'll
never use the Emscripten backend, so we may update this one day to only download
the Emscripten backend when you add the Emscripten target. For now though it's
just an extra 10MB gzip'd.
Closes #46819
2018-01-24 17:22:34 +01:00
|
|
|
"src/llvm-emscripten",
|
2017-06-12 15:06:12 +02:00
|
|
|
"src/libbacktrace",
|
2017-12-03 13:49:01 +01:00
|
|
|
"src/librustc_data_structures/owning_ref",
|
std: Depend directly on crates.io crates
Ever since we added a Cargo-based build system for the compiler the
standard library has always been a little special, it's never been able
to depend on crates.io crates for runtime dependencies. This has been a
result of various limitations, namely that Cargo doesn't understand that
crates from crates.io depend on libcore, so Cargo tries to build crates
before libcore is finished.
I had an idea this afternoon, however, which lifts the strategy
from #52919 to directly depend on crates.io crates from the standard
library. After all is said and done this removes a whopping three
submodules that we need to manage!
The basic idea here is that for any crate `std` depends on it adds an
*optional* dependency on an empty crate on crates.io, in this case named
`rustc-std-workspace-core`. This crate is overridden via `[patch]` in
this repository to point to a local crate we write, and *that* has a
`path` dependency on libcore.
Note that all `no_std` crates also depend on `compiler_builtins`, but if
we're not using submodules we can publish `compiler_builtins` to
crates.io and all crates can depend on it anyway! The basic strategy
then looks like:
* The standard library (or some transitive dep) decides to depend on a
crate `foo`.
* The standard library adds
```toml
[dependencies]
foo = { version = "0.1", features = ['rustc-dep-of-std'] }
```
* The crate `foo` has an optional dependency on `rustc-std-workspace-core`
* The crate `foo` has an optional dependency on `compiler_builtins`
* The crate `foo` has a feature `rustc-dep-of-std` which activates these
crates and any other necessary infrastructure in the crate.
A sample commit for `dlmalloc` [turns out to be quite simple][commit].
After that all `no_std` crates should largely build "as is" and still be
publishable on crates.io! Notably they should be able to continue to use
stable Rust if necessary, since the `rename-dependency` feature of Cargo
is soon stabilizing.
As a proof of concept, this commit removes the `dlmalloc`,
`libcompiler_builtins`, and `libc` submodules from this repository. Long
thorns in our side these are now gone for good and we can directly
depend on crates.io! It's hoped that in the long term we can bring in
other crates as necessary, but for now this is largely intended to
simply make it easier to manage these crates and remove submodules.
This should be a transparent non-breaking change for all users, but one
possible stickler is that this almost for sure breaks out-of-tree
`std`-building tools like `xargo` and `cargo-xbuild`. I think it should
be relatively easy to get them working, however, as all that's needed is
an entry in the `[patch]` section used to build the standard library.
Hopefully we can work with these tools to solve this problem!
[commit]: https://github.com/alexcrichton/dlmalloc-rs/commit/28ee12db813a3b650a7c25d1c36d2c17dcb88ae3
2018-11-20 06:52:50 +01:00
|
|
|
"src/vendor",
|
2017-06-12 15:06:12 +02:00
|
|
|
"src/tools/cargo",
|
2018-07-03 20:24:24 +02:00
|
|
|
"src/tools/clang",
|
2017-06-12 15:06:12 +02:00
|
|
|
"src/tools/rls",
|
2017-08-15 14:27:20 +02:00
|
|
|
"src/tools/clippy",
|
2017-06-12 15:06:12 +02:00
|
|
|
"src/tools/rust-installer",
|
2017-09-01 08:43:00 +02:00
|
|
|
"src/tools/rustfmt",
|
2017-08-28 16:54:50 +02:00
|
|
|
"src/tools/miri",
|
rust: Import LLD for linking wasm objects
This commit imports the LLD project from LLVM to serve as the default linker for
the `wasm32-unknown-unknown` target. The `binaryen` submoule is consequently
removed along with "binaryen linker" support in rustc.
Moving to LLD brings with it a number of benefits for wasm code:
* LLD is itself an actual linker, so there's no need to compile all wasm code
with LTO any more. As a result builds should be *much* speedier as LTO is no
longer forcibly enabled for all builds of the wasm target.
* LLD is quickly becoming an "official solution" for linking wasm code together.
This, I believe at least, is intended to be the main supported linker for
native code and wasm moving forward. Picking up support early on should help
ensure that we can help LLD identify bugs and otherwise prove that it works
great for all our use cases!
* Improvements to the wasm toolchain are currently primarily focused around LLVM
and LLD (from what I can tell at least), so it's in general much better to be
on this bandwagon for bugfixes and new features.
* Historical "hacks" like `wasm-gc` will soon no longer be necessary, LLD
will [natively implement][gc] `--gc-sections` (better than `wasm-gc`!) which
means a postprocessor is no longer needed to show off Rust's "small wasm
binary size".
LLD is added in a pretty standard way to rustc right now. A new rustbuild target
was defined for building LLD, and this is executed when a compiler's sysroot is
being assembled. LLD is compiled against the LLVM that we've got in tree, which
means we're currently on the `release_60` branch, but this may get upgraded in
the near future!
LLD is placed into rustc's sysroot in a `bin` directory. This is similar to
where `gcc.exe` can be found on Windows. This directory is automatically added
to `PATH` whenever rustc executes the linker, allowing us to define a `WasmLd`
linker which implements the interface that `wasm-ld`, LLD's frontend, expects.
Like Emscripten the LLD target is currently only enabled for Tier 1 platforms,
notably OSX/Windows/Linux, and will need to be installed manually for compiling
to wasm on other platforms. LLD is by default turned off in rustbuild, and
requires a `config.toml` option to be enabled to turn it on.
Finally the unstable `#![wasm_import_memory]` attribute was also removed as LLD
has a native option for controlling this.
[gc]: https://reviews.llvm.org/D42511
2017-08-27 03:30:12 +02:00
|
|
|
"src/tools/lld",
|
2018-07-03 20:24:24 +02:00
|
|
|
"src/tools/lldb",
|
2018-01-18 06:32:32 +01:00
|
|
|
"src/target",
|
2018-02-18 02:23:19 +01:00
|
|
|
"src/stdsimd",
|
2018-08-28 06:33:26 +02:00
|
|
|
"src/rust-sgx",
|
2018-10-19 21:26:43 +02:00
|
|
|
"target",
|
2018-08-22 04:50:46 +02:00
|
|
|
"vendor",
|
2017-06-12 15:06:12 +02:00
|
|
|
];
|
|
|
|
skip.iter().any(|p| path.ends_with(p))
|
|
|
|
}
|
|
|
|
|
2018-07-13 07:25:22 +02:00
|
|
|
fn walk_many(paths: &[&Path], skip: &mut dyn FnMut(&Path) -> bool, f: &mut dyn FnMut(&Path)) {
|
2017-06-12 15:06:12 +02:00
|
|
|
for path in paths {
|
|
|
|
walk(path, skip, f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-13 07:25:22 +02:00
|
|
|
fn walk(path: &Path, skip: &mut dyn FnMut(&Path) -> bool, f: &mut dyn FnMut(&Path)) {
|
2018-08-08 21:37:58 +02:00
|
|
|
if let Ok(dir) = fs::read_dir(path) {
|
|
|
|
for entry in dir {
|
|
|
|
let entry = t!(entry);
|
|
|
|
let kind = t!(entry.file_type());
|
|
|
|
let path = entry.path();
|
|
|
|
if kind.is_dir() {
|
|
|
|
if !skip(&path) {
|
|
|
|
walk(&path, skip, f);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
f(&path);
|
2017-06-12 15:06:12 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|