+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
[[package]]
name = "adler32"
version = "1.0.3"
version = "0.0.0"
dependencies = [
"arena 0.0.0",
- "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
"byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"either 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"graphviz 0.0.0",
/// Run this rule for all hosts without cross compiling.
const ONLY_HOSTS: bool = false;
- /// Primary function to execute this rule. Can call `builder.ensure(...)`
+ /// Primary function to execute this rule. Can call `builder.ensure()`
/// with other steps to run those.
fn run(self, builder: &Builder) -> Self::Output;
/// When bootstrap is passed a set of paths, this controls whether this rule
/// will execute. However, it does not get called in a "default" context
- /// when we are not passed any paths; in that case, make_run is called
+ /// when we are not passed any paths; in that case, `make_run` is called
/// directly.
fn should_run(run: ShouldRun) -> ShouldRun;
- /// Build up a "root" rule, either as a default rule or from a path passed
+ /// Builds up a "root" rule, either as a default rule or from a path passed
/// to us.
///
/// When path is `None`, we are executing in a context where no paths were
test::TheBook,
test::UnstableBook,
test::RustcBook,
+ test::EmbeddedBook,
test::Rustfmt,
test::Miri,
test::Clippy,
add_lib_path(vec![self.rustc_libdir(compiler)], cmd);
}
- /// Get a path to the compiler specified.
+ /// Gets a path to the compiler specified.
pub fn rustc(&self, compiler: Compiler) -> PathBuf {
if compiler.is_snapshot(self) {
self.initial_rustc.clone()
}
}
- /// Get the paths to all of the compiler's codegen backends.
+ /// Gets the paths to all of the compiler's codegen backends.
fn codegen_backends(&self, compiler: Compiler) -> impl Iterator<Item = PathBuf> {
fs::read_dir(self.sysroot_codegen_backends(compiler))
.into_iter()
let compiler = self.compiler(self.top_stage, host);
cmd.env("RUSTC_STAGE", compiler.stage.to_string())
.env("RUSTC_SYSROOT", self.sysroot(compiler))
- .env(
- "RUSTDOC_LIBDIR",
- self.sysroot_libdir(compiler, self.config.build),
- )
+ // Note that this is *not* the sysroot_libdir because rustdoc must be linked
+ // equivalently to rustc.
+ .env("RUSTDOC_LIBDIR", self.rustc_libdir(compiler))
.env("CFG_RELEASE_CHANNEL", &self.config.channel)
.env("RUSTDOC_REAL", self.rustdoc(host))
.env("RUSTDOC_CRATE_VERSION", self.rust_version())
} else {
&maybe_sysroot
};
- let libdir = sysroot.join(libdir(&compiler.host));
+ let libdir = self.rustc_libdir(compiler);
// Customize the compiler we're running. Specify the compiler to cargo
// as our shim and then pass it some various options used to configure
cargo.env("RUSTC_ERROR_FORMAT", error_format);
}
if cmd != "build" && cmd != "check" && cmd != "rustc" && want_rustdoc {
- cargo.env("RUSTDOC_LIBDIR", self.sysroot_libdir(compiler, self.config.build));
+ cargo.env("RUSTDOC_LIBDIR", self.rustc_libdir(compiler));
}
if mode.is_tool() {
cargo.env("RUSTC_VERBOSE", self.verbosity.to_string());
- // in std, we want to avoid denying warnings for stage 0 as that makes cfg's painful.
- if self.config.deny_warnings && !(mode == Mode::Std && stage == 0) {
+ if self.config.deny_warnings {
cargo.env("RUSTC_DENY_WARNINGS", "1");
}
pub static ref INTERNER: Interner = Interner::default();
}
-/// This is essentially a HashMap which allows storing any type in its input and
+/// This is essentially a `HashMap` which allows storing any type in its input and
/// any type in its output. It is a write-once cache; values are never evicted,
/// which means that references to the value can safely be returned from the
-/// get() method.
+/// `get()` method.
#[derive(Debug)]
pub struct Cache(
RefCell<HashMap<
});
}
- /// Build the compiler.
+ /// Builds the compiler.
///
/// This will build the compiler for a particular stage of the build using
/// the `compiler` targeting the `target` architecture. The artifacts
//! Responsible for cleaning out a build directory of all old and stale
//! artifacts to prepare for a fresh build. Currently doesn't remove the
//! `build/cache` directory (download cache) or the `build/$target/llvm`
-//! directory unless the --all flag is present.
+//! directory unless the `--all` flag is present.
use std::fs;
use std::io::{self, ErrorKind};
});
}
- /// Build the standard library.
+ /// Builds the standard library.
///
/// This will build the standard library for a particular stage of the build
/// using the `compiler` targeting the `target` architecture. The artifacts
});
}
- /// Build and prepare startup objects like rsbegin.o and rsend.o
+ /// Builds and prepare startup objects like rsbegin.o and rsend.o
///
/// These are primarily used on Windows right now for linking executables/dlls.
/// They don't require any library support as they're just plain old object
});
}
- /// Build libtest.
+ /// Builds libtest.
///
/// This will build libtest and supporting libraries for a particular stage of
/// the build using the `compiler` targeting the `target` architecture. The
});
}
- /// Build the compiler.
+ /// Builds the compiler.
///
/// This will build the compiler for a particular stage of the build using
/// the `compiler` targeting the `target` architecture. The artifacts
run.builder.ensure(Mingw { host: run.target });
}
- /// Build the `rust-mingw` installer component.
+ /// Builds the `rust-mingw` installer component.
///
/// This contains all the bits and pieces to run the MinGW Windows targets
/// without any extra installed software (e.g., we bundle gcc, libraries, etc).
});
}
- /// Build the book and associated stuff.
+ /// Builds the book and associated stuff.
///
/// We need to build:
///
});
}
- /// Generate whitelisted compiler crate documentation.
+ /// Generates whitelisted compiler crate documentation.
///
/// This will generate all documentation for crates that are whitelisted
/// to be included in the standard documentation. This documentation is
});
}
- /// Generate compiler documentation.
+ /// Generates compiler documentation.
///
/// This will generate all documentation for compiler and dependencies.
/// Compiler documentation is distributed separately, so we make sure
});
}
- /// Generate compiler documentation.
+ /// Generates compiler documentation.
///
/// This will generate all documentation for compiler and dependencies.
/// Compiler documentation is distributed separately, so we make sure
//! ## Copying stage0 {std,test,rustc}
//!
//! This copies the build output from Cargo into
-//! `build/$HOST/stage0-sysroot/lib/rustlib/$ARCH/lib`. FIXME: This step's
+//! `build/$HOST/stage0-sysroot/lib/rustlib/$ARCH/lib`. FIXME: this step's
//! documentation should be expanded -- the information already here may be
//! incorrect.
//!
cleared
}
- /// Get the space-separated set of activated features for the standard
+ /// Gets the space-separated set of activated features for the standard
/// library.
fn std_features(&self) -> String {
let mut features = "panic-unwind".to_string();
features
}
- /// Get the space-separated set of activated features for the compiler.
+ /// Gets the space-separated set of activated features for the compiler.
fn rustc_features(&self) -> String {
let mut features = String::new();
if self.config.jemalloc {
self.out.join(&*target).join("crate-docs")
}
- /// Returns true if no custom `llvm-config` is set for the specified target.
+ /// Returns `true` if no custom `llvm-config` is set for the specified target.
///
/// If no custom `llvm-config` was specified then Rust's llvm will be used.
fn is_rust_llvm(&self, target: Interned<String>) -> bool {
.map(|p| &**p)
}
- /// Returns true if this is a no-std `target`, if defined
+ /// Returns `true` if this is a no-std `target`, if defined
fn no_std(&self, target: Interned<String>) -> Option<bool> {
self.config.target_config.get(&target)
.map(|t| t.no_std)
}
- /// Returns whether the target will be tested using the `remote-test-client`
+ /// Returns `true` if the target will be tested using the `remote-test-client`
/// and `remote-test-server` binaries.
fn remote_tested(&self, target: Interned<String>) -> bool {
self.qemu_rootfs(target).is_some() || target.contains("android") ||
self.rust_info.version(self, channel::CFG_RELEASE_NUM)
}
- /// Return the full commit hash
+ /// Returns the full commit hash.
fn rust_sha(&self) -> Option<&str> {
self.rust_info.sha()
}
panic!("failed to find version in {}'s Cargo.toml", package)
}
- /// Returns whether unstable features should be enabled for the compiler
+ /// Returns `true` if unstable features should be enabled for the compiler
/// we're building.
fn unstable_features(&self) -> bool {
match &self.config.channel[..] {
self
}
- /// Returns whether this is a snapshot compiler for `build`'s configuration
+ /// Returns `true` if this is a snapshot compiler for `build`'s configuration
pub fn is_snapshot(&self, build: &Build) -> bool {
self.stage == 0 && self.host == build.build
}
/// The two modes of the test runner; tests or benchmarks.
#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone, PartialOrd, Ord)]
pub enum TestKind {
- /// Run `cargo test`
+ /// Run `cargo test`.
Test,
- /// Run `cargo bench`
+ /// Run `cargo bench`.
Bench,
}
run.never()
}
- /// Run `rustdoc --test` for all documentation in `src/doc`.
+ /// Runs `rustdoc --test` for all documentation in `src/doc`.
///
/// This will run all tests in our markdown documentation (e.g., the book)
/// located in `src/doc`. The `rustdoc` that's run is the one that sits next to
RustdocBook, "src/doc/rustdoc", "rustdoc", default=true;
RustcBook, "src/doc/rustc", "rustc", default=true;
RustByExample, "src/doc/rust-by-example", "rust-by-example", default=false;
+ EmbeddedBook, "src/doc/embedded-book", "embedded-book", default=false;
TheBook, "src/doc/book", "book", default=false;
UnstableBook, "src/doc/unstable-book", "unstable-book", default=true;
);
});
}
- /// Run the error index generator tool to execute the tests located in the error
+ /// Runs the error index generator tool to execute the tests located in the error
/// index.
///
/// The `error_index_generator` tool lives in `src/tools` and is used to
}
}
- /// Run all unit tests plus documentation tests for a given crate defined
+ /// Runs all unit tests plus documentation tests for a given crate defined
/// by a `Cargo.toml` (single manifest)
///
/// This is what runs tests for crates like the standard library, compiler, etc.
/// the standard library and such to the emulator ahead of time. This step
/// represents this and is a dependency of all test suites.
///
-/// Most of the time this is a noop. For some steps such as shipping data to
+/// Most of the time this is a no-op. For some steps such as shipping data to
/// QEMU we have to build our own tools so we've got conditional dependencies
/// on those programs as well. Note that the remote test client is built for
/// the build target (us) and the server is built for the target.
run.builder.ensure(Distcheck);
}
- /// Run "distcheck", a 'make check' from a tarball
+ /// Runs "distcheck", a 'make check' from a tarball
fn run(self, builder: &Builder) {
builder.info("Distcheck");
let dir = builder.out.join("tmp").join("distcheck");
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
- /// Test the build system itself
+ /// Tests the build system itself.
fn run(self, builder: &Builder) {
let mut cmd = Command::new(&builder.initial_cargo);
cmd.arg("test")
run.never()
}
- /// Build a tool in `src/tools`
+ /// Builds a tool in `src/tools`
///
/// This will build the specified tool with the specified `host` compiler in
/// `stage` into the normal cargo output directory.
fn run(self, builder: &Builder) -> PathBuf {
let target_compiler = builder.compiler(builder.top_stage, self.host);
+ if target_compiler.stage == 0 {
+ if !target_compiler.is_snapshot(builder) {
+ panic!("rustdoc in stage 0 must be snapshot rustdoc");
+ }
+ return builder.initial_rustc.with_file_name(exe("rustdoc", &target_compiler.host));
+ }
let target = target_compiler.host;
- let build_compiler = if target_compiler.stage == 0 {
- builder.compiler(0, builder.config.build)
- } else if target_compiler.stage >= 2 {
- // Past stage 2, we consider the compiler to be ABI-compatible and hence capable of
- // building rustdoc itself.
- builder.compiler(target_compiler.stage, builder.config.build)
- } else {
- // Similar to `compile::Assemble`, build with the previous stage's compiler. Otherwise
- // we'd have stageN/bin/rustc and stageN/bin/rustdoc be effectively different stage
- // compilers, which isn't what we want.
- builder.compiler(target_compiler.stage - 1, builder.config.build)
- };
-
- builder.ensure(compile::Rustc { compiler: build_compiler, target });
- builder.ensure(compile::Rustc {
- compiler: build_compiler,
- target: builder.config.build,
- });
+ // Similar to `compile::Assemble`, build with the previous stage's compiler. Otherwise
+ // we'd have stageN/bin/rustc and stageN/bin/rustdoc be effectively different stage
+ // compilers, which isn't what we want. Rustdoc should be linked in the same way as the
+ // rustc compiler it's paired with, so it must be built with the previous stage compiler.
+ let build_compiler = builder.compiler(target_compiler.stage - 1, builder.config.build);
+
+ // The presence of `target_compiler` ensures that the necessary libraries (codegen backends,
+ // compiler libraries, ...) are built. Rustdoc does not require the presence of any
+ // libraries within sysroot_libdir (i.e., rustlib), though doctests may want it (since
+ // they'll be linked to those libraries). As such, don't explicitly `ensure` any additional
+ // libraries here. The intuition here is that If we've built a compiler, we should be able
+ // to build rustdoc.
let mut cargo = prepare_tool_cargo(
builder,
);
impl<'a> Builder<'a> {
- /// Get a `Command` which is ready to run `tool` in `stage` built for
+ /// Gets a `Command` which is ready to run `tool` in `stage` built for
/// `host`.
pub fn tool_cmd(&self, tool: Tool) -> Command {
let mut cmd = Command::new(self.tool_exe(tool));
}
}
-/// Returns whether the file name given looks like a dynamic library.
+/// Returns `true` if the file name given looks like a dynamic library.
pub fn is_dylib(name: &str) -> bool {
name.ends_with(".dylib") || name.ends_with(".so") || name.ends_with(".dll")
}
name = "build_helper"
version = "0.1.0"
authors = ["The Rust Project Developers"]
+edition = "2018"
[lib]
name = "build_helper"
+#![deny(rust_2018_idioms)]
+
use std::fs::File;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
.unwrap_or(UNIX_EPOCH)
}
-/// Returns whether `dst` is up to date given that the file or files in `src`
+/// Returns `true` if `dst` is up to date given that the file or files in `src`
/// are used to generate it.
///
/// Uses last-modified time checks to verify this.
}
impl NativeLibBoilerplate {
- /// On OSX we don't want to ship the exact filename that compiler-rt builds.
+ /// On macOS we don't want to ship the exact filename that compiler-rt builds.
/// This conflicts with the system and ours is likely a wildly different
/// version, so they can't be substituted.
///
/// As a result, we rename it here but we need to also use
- /// `install_name_tool` on OSX to rename the commands listed inside of it to
+ /// `install_name_tool` on macOS to rename the commands listed inside of it to
/// ensure it's linked against correctly.
pub fn fixup_sanitizer_lib_name(&self, sanitizer_name: &str) {
if env::var("TARGET").unwrap() != "x86_64-apple-darwin" {
ln -s ../../${target} /usr/lib/llvm-5.0/${target}
# Install the C++ runtime libraries from CloudABI Ports.
-echo deb https://nuxi.nl/distfiles/cloudabi-ports/debian/ cloudabi cloudabi > \
- /etc/apt/sources.list.d/cloudabi.list
-curl 'https://pgp.mit.edu/pks/lookup?op=get&search=0x0DA51B8531344B15' | \
- apt-key add -
+apt-key adv --batch --yes --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 0DA51B8531344B15
+add-apt-repository -y 'deb https://nuxi.nl/distfiles/cloudabi-ports/debian/ cloudabi cloudabi'
+
apt-get update
-apt-get install -y $(echo ${target} | sed -e s/_/-/g)-cxx-runtime
+apt-get install -y "${target//_/-}-cxx-runtime"
-Subproject commit d663113d1d9fbd35f1145c29f6080a6350b7f419
+Subproject commit bd2778f304989ee52be8201504d6ec621dd60ca9
% Error Handling in Rust
This content has moved into
-[the Rust Programming Language book](book/error-handling.html).
+[the Rust Programming Language book](book/ch09-00-error-handling.html).
% The (old) Rust Ownership Guide
This content has moved into
-[the Rust Programming Language book](book/ownership.html).
+[the Rust Programming Language book](book/ch04-00-understanding-ownership.html).
This content has been removed, with no direct replacement. Rust only
has two built-in pointer types now,
-[references](book/references-and-borrowing.html) and [raw
+[references](book/ch04-02-references-and-borrowing.html) and [raw
pointers](book/raw-pointers.html). Older Rusts had many more pointer
types, they’re gone now.
% The (old) Rust Testing Guide
This content has moved into
-[the Rust Programming Language book](book/testing.html).
+[the Rust Programming Language book](book/ch11-00-testing.html).
- [Targets](targets/index.md)
- [Built-in Targets](targets/built-in.md)
- [Custom Targets](targets/custom.md)
-- [Contributing to `rustc`](contributing.md)
\ No newline at end of file
+- [Linker-plugin based LTO](linker-plugin-lto.md)
+- [Contributing to `rustc`](contributing.md)
--- /dev/null
+# Linker-plugin-LTO
+
+The `-C linker-plugin-lto` flag allows for deferring the LTO optimization
+to the actual linking step, which in turn allows for performing
+interprocedural optimizations across programming language boundaries if
+all the object files being linked were created by LLVM based toolchains.
+The prime example here would be linking Rust code together with
+Clang-compiled C/C++ code.
+
+## Usage
+
+There are two main cases how linker plugin based LTO can be used:
+
+ - compiling a Rust `staticlib` that is used as a C ABI dependency
+ - compiling a Rust binary where `rustc` invokes the linker
+
+In both cases the Rust code has to be compiled with `-C linker-plugin-lto` and
+the C/C++ code with `-flto` or `-flto=thin` so that object files are emitted
+as LLVM bitcode.
+
+### Rust `staticlib` as dependency in C/C++ program
+
+In this case the Rust compiler just has to make sure that the object files in
+the `staticlib` are in the right format. For linking, a linker with the
+LLVM plugin must be used (e.g. LLD).
+
+Using `rustc` directly:
+
+```bash
+# Compile the Rust staticlib
+rustc --crate-type=staticlib -Clinker-plugin-lto -Copt-level=2 ./lib.rs
+# Compile the C code with `-flto=thin`
+clang -c -O2 -flto=thin -o main.o ./main.c
+# Link everything, making sure that we use an appropriate linker
+clang -flto=thin -fuse-ld=lld -L . -l"name-of-your-rust-lib" -o main -O2 ./cmain.o
+```
+
+Using `cargo`:
+
+```bash
+# Compile the Rust staticlib
+RUSTFLAGS="-Clinker-plugin-lto" cargo build --release
+# Compile the C code with `-flto=thin`
+clang -c -O2 -flto=thin -o main.o ./main.c
+# Link everything, making sure that we use an appropriate linker
+clang -flto=thin -fuse-ld=lld -L . -l"name-of-your-rust-lib" -o main -O2 ./cmain.o
+```
+
+### C/C++ code as a dependency in Rust
+
+In this case the linker will be invoked by `rustc`. We again have to make sure
+that an appropriate linker is used.
+
+Using `rustc` directly:
+
+```bash
+# Compile C code with `-flto`
+clang ./clib.c -flto=thin -c -o ./clib.o -O2
+# Create a static library from the C code
+ar crus ./libxyz.a ./clib.o
+
+# Invoke `rustc` with the additional arguments
+rustc -Clinker-plugin-lto -L. -Copt-level=2 -Clinker=clang -Clink-arg=-fuse-ld=lld ./main.rs
+```
+
+Using `cargo` directly:
+
+```bash
+# Compile C code with `-flto`
+clang ./clib.c -flto=thin -c -o ./clib.o -O2
+# Create a static library from the C code
+ar crus ./libxyz.a ./clib.o
+
+# Set the linking arguments via RUSTFLAGS
+RUSTFLAGS="-Clinker-plugin-lto -Clinker=clang -Clink-arg=-fuse-ld=lld" cargo build --release
+```
+
+### Explicitly specifying the linker plugin to be used by `rustc`
+
+If one wants to use a linker other than LLD, the LLVM linker plugin has to be
+specified explicitly. Otherwise the linker cannot read the object files. The
+path to the plugin is passed as an argument to the `-Clinker-plugin-lto`
+option:
+
+```bash
+rustc -Clinker-plugin-lto="/path/to/LLVMgold.so" -L. -Copt-level=2 ./main.rs
+```
+
+
+## Toolchain Compatibility
+
+In order for this kind of LTO to work, the LLVM linker plugin must be able to
+handle the LLVM bitcode produced by both `rustc` and `clang`.
+
+Best results are achieved by using a `rustc` and `clang` that are based on the
+exact same version of LLVM. One can use `rustc -vV` in order to view the LLVM
+used by a given `rustc` version. Note that the version number given
+here is only an approximation as Rust sometimes uses unstable revisions of
+LLVM. However, the approximation is usually reliable.
+
+The following table shows known good combinations of toolchain versions.
+
+| | Clang 7 | Clang 8 |
+|-----------|-----------|-----------|
+| Rust 1.34 | ✗ | ✓ |
+| Rust 1.35 | ✗ | ✓(?) |
+
+Note that the compatibility policy for this feature might change in the future.
# Unstable features
Rustdoc is under active development, and like the Rust compiler, some features are only available
-on the nightly releases. Some of these are new and need some more testing before they're able to get
-released to the world at large, and some of them are tied to features in the Rust compiler that are
-themselves unstable. Several features here require a matching `#![feature(...)]` attribute to
+on nightly releases. Some of these features are new and need some more testing before they're able to be
+released to the world at large, and some of them are tied to features in the Rust compiler that are unstable. Several features here require a matching `#![feature(...)]` attribute to
enable, and thus are more fully documented in the [Unstable Book]. Those sections will link over
there as necessary.
This flag allows you to keep doctest executables around after they're compiled or run.
Usually, rustdoc will immediately discard a compiled doctest after it's been tested, but
-with this option, you can keep those binaries around for farther testing.
\ No newline at end of file
+with this option, you can keep those binaries around for farther testing.
sample usage: src/etc/generate-deriving-span-tests.py
"""
-import os, datetime, stat, re
+import os, stat
TEST_DIR = os.path.abspath(
os.path.join(os.path.dirname(__file__), '../test/ui/derives/'))
-YEAR = datetime.datetime.now().year
-
-TEMPLATE = """
+TEMPLATE = """\
// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
{error_deriving}
errors = '\n'.join('//~%s ERROR' % ('^' * n) for n in range(error_count))
code = string.format(traits = all_traits, errors = errors)
- return TEMPLATE.format(year = YEAR, error_deriving=error_deriving, code = code)
+ return TEMPLATE.format(error_deriving=error_deriving, code = code)
def write_file(name, string):
test_file = os.path.join(TEST_DIR, 'derives-span-%s.rs' % name)
- with open(test_file) as f:
- old_str = f.read()
- old_str_ignoring_date = re.sub(r'^// Copyright \d+',
- '// Copyright {year}'.format(year = YEAR), old_str)
- if old_str_ignoring_date == string:
- # if all we're doing is updating the copyright year, ignore it
- return 0
-
# set write permission if file exists, so it can be changed
if os.path.exists(test_file):
os.chmod(test_file, stat.S_IWUSR)
# mark file read-only
os.chmod(test_file, stat.S_IRUSR|stat.S_IRGRP|stat.S_IROTH)
- return 1
-
ENUM = 1
STRUCT = 2
('Hash', [], 1)]:
traits[trait] = (ALL, supers, errs)
-files = 0
-
for (trait, (types, super_traits, error_count)) in traits.items():
mk = lambda ty: create_test_case(ty, trait, super_traits, error_count)
if types & ENUM:
- files += write_file(trait + '-enum', mk(ENUM_TUPLE))
- files += write_file(trait + '-enum-struct-variant', mk(ENUM_STRUCT))
+ write_file(trait + '-enum', mk(ENUM_TUPLE))
+ write_file(trait + '-enum-struct-variant', mk(ENUM_STRUCT))
if types & STRUCT:
- files += write_file(trait + '-struct', mk(STRUCT_FIELDS))
- files += write_file(trait + '-tuple-struct', mk(STRUCT_TUPLE))
-
-print('Generated {files} deriving span test{}.'.format('s' if files != 1 else '', files = files))
+ write_file(trait + '-struct', mk(STRUCT_FIELDS))
+ write_file(trait + '-tuple-struct', mk(STRUCT_TUPLE))
#![feature(repr_simd)]
-#![feature(slice_sort_by_cached_key)]
#![feature(test)]
extern crate rand;
/// ```
/// use std::borrow::{Cow, ToOwned};
///
-/// struct Items<'a, X: 'a> where [X]: ToOwned<Owned=Vec<X>> {
+/// struct Items<'a, X: 'a> where [X]: ToOwned<Owned = Vec<X>> {
/// values: Cow<'a, [X]>,
/// }
///
-/// impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned<Owned=Vec<X>> {
+/// impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned<Owned = Vec<X>> {
/// fn new(v: Cow<'a, [X]>) -> Self {
/// Items { values: v }
/// }
CoerceUnsized, DispatchFromDyn, Deref, DerefMut, Receiver, Generator, GeneratorState
};
use core::ptr::{self, NonNull, Unique};
-use core::task::{LocalWaker, Poll};
+use core::task::{Waker, Poll};
use crate::vec::Vec;
use crate::raw_vec::RawVec;
impl<F: ?Sized + Future + Unpin> Future for Box<F> {
type Output = F::Output;
- fn poll(mut self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output> {
- F::poll(Pin::new(&mut *self), lw)
+ fn poll(mut self: Pin<&mut Self>, waker: &Waker) -> Poll<Self::Output> {
+ F::poll(Pin::new(&mut *self), waker)
}
}
}
impl<'a, T> Hole<'a, T> {
- /// Create a new Hole at index `pos`.
+ /// Create a new `Hole` at index `pos`.
///
/// Unsafe because pos must be within the data slice.
#[inline]
/// Gets a mutable reference to the value in the entry.
///
- /// If you need a reference to the `OccupiedEntry` which may outlive the
+ /// If you need a reference to the `OccupiedEntry` that may outlive the
/// destruction of the `Entry` value, see [`into_mut`].
///
/// [`into_mut`]: #method.into_mut
///
/// We have a separate type for the header and rely on it matching the prefix of `LeafNode`, in
/// order to statically allocate a single dummy node to avoid allocations. This struct is
-/// `repr(C)` to prevent them from being reordered. `LeafNode` does not just contain a
+/// `repr(C)` to prevent them from being reordered. `LeafNode` does not just contain a
/// `NodeHeader` because we do not want unnecessary padding between `len` and the keys.
-/// Crucially, `NodeHeader` can be safely transmuted to different K and V. (This is exploited
+/// Crucially, `NodeHeader` can be safely transmuted to different K and V. (This is exploited
/// by `as_header`.)
-/// See `into_key_slice` for an explanation of K2. K2 cannot be safely transmuted around
+/// See `into_key_slice` for an explanation of K2. K2 cannot be safely transmuted around
/// because the size of `NodeHeader` depends on its alignment!
#[repr(C)]
struct NodeHeader<K, V, K2 = ()> {
}
}
- /// Returns whether it is valid to call `.merge()`, i.e., whether there is enough room in
+ /// Returns `true` if it is valid to call `.merge()`, i.e., whether there is enough room in
/// a node to hold the combination of the nodes to the left and right of this handle along
/// with the key/value pair at this handle.
pub fn can_merge(&self) -> bool {
impl<BorrowType, K, V, HandleType>
Handle<NodeRef<BorrowType, K, V, marker::LeafOrInternal>, HandleType> {
- /// Check whether the underlying node is an `Internal` node or a `Leaf` node.
+ /// Checks whether the underlying node is an `Internal` node or a `Leaf` node.
pub fn force(self) -> ForceResult<
Handle<NodeRef<BorrowType, K, V, marker::Leaf>, HandleType>,
Handle<NodeRef<BorrowType, K, V, marker::Internal>, HandleType>
Recover::replace(&mut self.map, value)
}
- /// Removes a value from the set. Returns `true` if the value was
+ /// Removes a value from the set. Returns whether the value was
/// present in the set.
///
/// The value may be any borrowed form of the set's value type,
#[stable(feature = "fused", since = "1.26.0")]
impl<T> FusedIterator for Range<'_, T> {}
-/// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
+/// Compares `x` and `y`, but return `short` if x is None and `long` if y is None
fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>, short: Ordering, long: Ordering) -> Ordering {
match (x, y) {
(None, _) => short,
ptr::write(self.ptr().add(off), value);
}
- /// Returns `true` if and only if the buffer is at full capacity.
+ /// Returns `true` if the buffer is at full capacity.
#[inline]
fn is_full(&self) -> bool {
self.cap() - self.len() == 1
/// Does nothing if the capacity is already sufficient.
///
/// Note that the allocator may give the collection more space than it
- /// requests. Therefore capacity can not be relied upon to be precisely
+ /// requests. Therefore, capacity can not be relied upon to be precisely
/// minimal. Prefer `reserve` if future insertions are expected.
///
/// # Errors
self.tail == self.head
}
- /// Create a draining iterator that removes the specified range in the
+ /// Creates a draining iterator that removes the specified range in the
/// `VecDeque` and yields the removed items.
///
/// Note 1: The element range is removed even if the iterator is not
///
/// Note 2: It is unspecified how many elements are removed from the deque,
/// if the `Drain` value is not dropped, but the borrow it holds expires
- /// (eg. due to mem::forget).
+ /// (e.g., due to `mem::forget`).
///
/// # Panics
///
///
/// # Panics
///
- /// If `mid` is greater than `len()`. Note that `mid == len()`
+ /// If `mid` is greater than `len()`. Note that `mid == len()`
/// does _not_ panic and is a no-op rotation.
///
/// # Complexity
///
/// # Panics
///
- /// If `k` is greater than `len()`. Note that `k == len()`
+ /// If `k` is greater than `len()`. Note that `k == len()`
/// does _not_ panic and is a no-op rotation.
///
/// # Complexity
//! will then parse the format string and determine if the list of arguments
//! provided is suitable to pass to this format string.
//!
-//! To convert a single value to a string, use the [`to_string`] method. This
+//! To convert a single value to a string, use the [`to_string`] method. This
//! will use the [`Display`] formatting trait.
//!
//! ## Positional parameters
//! When requesting that an argument be formatted with a particular type, you
//! are actually requesting that an argument ascribes to a particular trait.
//! This allows multiple actual types to be formatted via `{:x}` (like [`i8`] as
-//! well as [`isize`]). The current mapping of types to traits is:
+//! well as [`isize`]). The current mapping of types to traits is:
//!
//! * *nothing* ⇒ [`Display`]
//! * `?` ⇒ [`Debug`]
//! 3. An asterisk `.*`:
//!
//! `.*` means that this `{...}` is associated with *two* format inputs rather than one: the
-//! first input holds the `usize` precision, and the second holds the value to print. Note that
+//! first input holds the `usize` precision, and the second holds the value to print. Note that
//! in this case, if one uses the format string `{<arg>:<spec>.*}`, then the `<arg>` part refers
//! to the *value* to print, and the `precision` must come in the input preceding `<arg>`.
//!
#![warn(intra_doc_link_resolution_failure)]
#![warn(missing_debug_implementations)]
-#![cfg_attr(not(test), feature(fn_traits))]
#![cfg_attr(not(test), feature(generator_trait))]
#![cfg_attr(test, feature(test))]
#![feature(dropck_eyepatch)]
#![feature(exact_size_is_empty)]
#![feature(fmt_internals)]
+#![feature(fn_traits)]
#![feature(fundamental)]
#![feature(futures_api)]
#![feature(lang_items)]
#![feature(receiver_trait)]
#![feature(specialization)]
#![feature(staged_api)]
+#![feature(std_internals)]
#![feature(str_internals)]
#![feature(trusted_len)]
#![feature(try_reserve)]
pub mod alloc;
-#[unstable(feature = "futures_api",
- reason = "futures in libcore are unstable",
- issue = "50547")]
-pub mod task;
// Primitive types using the heaps above
// Need to conditionally define the mod from `boxed.rs` to avoid
#[cfg(not(test))]
#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow_internal_unstable]
+#[cfg_attr(not(stage0), allow_internal_unstable(box_syntax))]
+#[cfg_attr(stage0, allow_internal_unstable)]
macro_rules! vec {
($elem:expr; $n:expr) => (
$crate::vec::from_elem($elem, $n)
/// Creates a `String` using interpolation of runtime expressions.
///
-/// The first argument `format!` receives is a format string. This must be a string
-/// literal. The power of the formatting string is in the `{}`s contained.
+/// The first argument `format!` receives is a format string. This must be a string
+/// literal. The power of the formatting string is in the `{}`s contained.
///
/// Additional parameters passed to `format!` replace the `{}`s within the
/// formatting string in the order given unless named or positional parameters
-/// are used, see [`std::fmt`][fmt] for more information.
+/// are used; see [`std::fmt`][fmt] for more information.
///
/// A common use for `format!` is concatenation and interpolation of strings.
/// The same convention is used with [`print!`] and [`write!`] macros,
/// depending on the intended destination of the string.
///
-/// To convert a single value to a string, use the [`to_string`] method. This
+/// To convert a single value to a string, use the [`to_string`] method. This
/// will use the [`Display`] formatting trait.
///
/// [fmt]: ../std/fmt/index.html
/// enough to want to do that it's easiest to just have a dedicated method. Slightly
/// more efficient logic can be provided for this than the general case.
///
- /// Returns true if the reallocation attempt has succeeded, or false otherwise.
+ /// Returns `true` if the reallocation attempt has succeeded.
///
/// # Panics
///
/// the requested space. This is not really unsafe, but the unsafe
/// code *you* write that relies on the behavior of this function may break.
///
- /// Returns true if the reallocation attempt has succeeded, or false otherwise.
+ /// Returns `true` if the reallocation attempt has succeeded.
///
/// # Panics
///
this.strong()
}
- /// Returns true if there are no other `Rc` or [`Weak`][weak] pointers to
+ /// Returns `true` if there are no other `Rc` or [`Weak`][weak] pointers to
/// this inner value.
///
/// [weak]: struct.Weak.html
#[inline]
#[stable(feature = "ptr_eq", since = "1.17.0")]
- /// Returns true if the two `Rc`s point to the same value (not
+ /// Returns `true` if the two `Rc`s point to the same value (not
/// just values that compare as equal).
///
/// # Examples
})
}
- /// Return `None` when the pointer is dangling and there is no allocated `RcBox`,
- /// i.e., this `Weak` was created by `Weak::new`
+ /// Returns `None` when the pointer is dangling and there is no allocated `RcBox`
+ /// (i.e., when this `Weak` was created by `Weak::new`).
#[inline]
fn inner(&self) -> Option<&RcBox<T>> {
if is_dangling(self.ptr) {
}
}
- /// Returns true if the two `Weak`s point to the same value (not just values
+ /// Returns `true` if the two `Weak`s point to the same value (not just values
/// that compare as equal).
///
/// # Notes
///
/// The comparator function must define a total ordering for the elements in the slice. If
/// the ordering is not total, the order of the elements is unspecified. An order is a
- /// total order if it is (for all a, b and c):
+ /// total order if it is (for all `a`, `b` and `c`):
///
- /// * total and antisymmetric: exactly one of a < b, a == b or a > b is true; and
- /// * transitive, a < b and b < c implies a < c. The same must hold for both == and >.
+ /// * total and antisymmetric: exactly one of `a < b`, `a == b` or `a > b` is true, and
+ /// * transitive, `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.
///
/// For example, while [`f64`] doesn't implement [`Ord`] because `NaN != NaN`, we can use
/// `partial_cmp` as our sort function when we know the slice doesn't contain a `NaN`.
/// This sort is stable (i.e., does not reorder equal elements) and `O(m n log(m n))`
/// worst-case, where the key function is `O(m)`.
///
+ /// For expensive key functions (e.g. functions that are not simple property accesses or
+ /// basic operations), [`sort_by_cached_key`](#method.sort_by_cached_key) is likely to be
+ /// significantly faster, as it does not recompute element keys.
+ ///
/// When applicable, unstable sorting is preferred because it is generally faster than stable
/// sorting and it doesn't allocate auxiliary memory.
/// See [`sort_unstable_by_key`](#method.sort_unstable_by_key).
/// # Examples
///
/// ```
- /// #![feature(slice_sort_by_cached_key)]
/// let mut v = [-5i32, 4, 32, -3, 2];
///
/// v.sort_by_cached_key(|k| k.to_string());
/// ```
///
/// [pdqsort]: https://github.com/orlp/pdqsort
- #[unstable(feature = "slice_sort_by_cached_key", issue = "34447")]
+ #[stable(feature = "slice_sort_by_cached_key", since = "1.34.0")]
#[inline]
pub fn sort_by_cached_key<K, F>(&mut self, f: F)
where F: FnMut(&T) -> K, K: Ord
#![allow(unused_imports)]
use core::borrow::Borrow;
-use core::fmt;
-use core::str as core_str;
use core::str::pattern::{Pattern, Searcher, ReverseSearcher, DoubleEndedSearcher};
use core::mem;
use core::ptr;
return s;
}
- /// Escapes each char in `s` with [`char::escape_debug`].
- ///
- /// Note: only extended grapheme codepoints that begin the string will be
- /// escaped.
- ///
- /// [`char::escape_debug`]: primitive.char.html#method.escape_debug
- #[unstable(feature = "str_escape",
- reason = "return type may change to be an iterator",
- issue = "27791")]
- pub fn escape_debug(&self) -> String {
- let mut string = String::with_capacity(self.len());
- let mut chars = self.chars();
- if let Some(first) = chars.next() {
- string.extend(first.escape_debug_ext(true))
- }
- string.extend(chars.flat_map(|c| c.escape_debug_ext(false)));
- string
- }
-
- /// Escapes each char in `s` with [`char::escape_default`].
- ///
- /// [`char::escape_default`]: primitive.char.html#method.escape_default
- #[unstable(feature = "str_escape",
- reason = "return type may change to be an iterator",
- issue = "27791")]
- pub fn escape_default(&self) -> String {
- self.chars().flat_map(|c| c.escape_default()).collect()
- }
-
- /// Escapes each char in `s` with [`char::escape_unicode`].
- ///
- /// [`char::escape_unicode`]: primitive.char.html#method.escape_unicode
- #[unstable(feature = "str_escape",
- reason = "return type may change to be an iterator",
- issue = "27791")]
- pub fn escape_unicode(&self) -> String {
- self.chars().flat_map(|c| c.escape_unicode()).collect()
- }
-
/// Converts a [`Box<str>`] into a [`String`] without copying or allocating.
///
/// [`String`]: string/struct.String.html
pub unsafe fn from_boxed_utf8_unchecked(v: Box<[u8]>) -> Box<str> {
Box::from_raw(Box::into_raw(v) as *mut str)
}
+
/// Does nothing if the capacity is already sufficient.
///
/// Note that the allocator may give the collection more space than it
- /// requests. Therefore capacity can not be relied upon to be precisely
+ /// requests. Therefore, capacity can not be relied upon to be precisely
/// minimal. Prefer `reserve` if future insertions are expected.
///
/// # Errors
self.vec.len()
}
- /// Returns `true` if this `String` has a length of zero.
- ///
- /// Returns `false` otherwise.
+ /// Returns `true` if this `String` has a length of zero, and `false` otherwise.
///
/// # Examples
///
#[inline]
#[stable(feature = "ptr_eq", since = "1.17.0")]
- /// Returns true if the two `Arc`s point to the same value (not
+ /// Returns `true` if the two `Arc`s point to the same value (not
/// just values that compare as equal).
///
/// # Examples
})
}
- /// Return `None` when the pointer is dangling and there is no allocated `ArcInner`,
- /// i.e., this `Weak` was created by `Weak::new`
+ /// Returns `None` when the pointer is dangling and there is no allocated `ArcInner`,
+ /// (i.e., when this `Weak` was created by `Weak::new`).
#[inline]
fn inner(&self) -> Option<&ArcInner<T>> {
if is_dangling(self.ptr) {
}
}
- /// Returns true if the two `Weak`s point to the same value (not just values
+ /// Returns `true` if the two `Weak`s point to the same value (not just values
/// that compare as equal).
///
/// # Notes
+++ /dev/null
-//! Types and Traits for working with asynchronous tasks.
-
-pub use core::task::*;
-
-#[cfg(all(target_has_atomic = "ptr", target_has_atomic = "cas"))]
-pub use if_arc::*;
-
-#[cfg(all(target_has_atomic = "ptr", target_has_atomic = "cas"))]
-mod if_arc {
- use super::*;
- use core::marker::PhantomData;
- use core::mem;
- use core::ptr::{self, NonNull};
- use crate::sync::Arc;
-
- /// A way of waking up a specific task.
- ///
- /// Any task executor must provide a way of signaling that a task it owns
- /// is ready to be `poll`ed again. Executors do so by implementing this trait.
- pub trait Wake: Send + Sync {
- /// Indicates that the associated task is ready to make progress and should
- /// be `poll`ed.
- ///
- /// Executors generally maintain a queue of "ready" tasks; `wake` should place
- /// the associated task onto this queue.
- fn wake(arc_self: &Arc<Self>);
-
- /// Indicates that the associated task is ready to make progress and should
- /// be `poll`ed. This function is like `wake`, but can only be called from the
- /// thread on which this `Wake` was created.
- ///
- /// Executors generally maintain a queue of "ready" tasks; `wake_local` should place
- /// the associated task onto this queue.
- #[inline]
- unsafe fn wake_local(arc_self: &Arc<Self>) {
- Self::wake(arc_self);
- }
- }
-
- #[cfg(all(target_has_atomic = "ptr", target_has_atomic = "cas"))]
- struct ArcWrapped<T>(PhantomData<T>);
-
- unsafe impl<T: Wake + 'static> UnsafeWake for ArcWrapped<T> {
- #[inline]
- unsafe fn clone_raw(&self) -> Waker {
- let me: *const ArcWrapped<T> = self;
- let arc = (*(&me as *const *const ArcWrapped<T> as *const Arc<T>)).clone();
- Waker::from(arc)
- }
-
- #[inline]
- unsafe fn drop_raw(&self) {
- let mut me: *const ArcWrapped<T> = self;
- let me = &mut me as *mut *const ArcWrapped<T> as *mut Arc<T>;
- ptr::drop_in_place(me);
- }
-
- #[inline]
- unsafe fn wake(&self) {
- let me: *const ArcWrapped<T> = self;
- T::wake(&*(&me as *const *const ArcWrapped<T> as *const Arc<T>))
- }
-
- #[inline]
- unsafe fn wake_local(&self) {
- let me: *const ArcWrapped<T> = self;
- T::wake_local(&*(&me as *const *const ArcWrapped<T> as *const Arc<T>))
- }
- }
-
- impl<T> From<Arc<T>> for Waker
- where T: Wake + 'static,
- {
- fn from(rc: Arc<T>) -> Self {
- unsafe {
- let ptr = mem::transmute::<Arc<T>, NonNull<ArcWrapped<T>>>(rc);
- Waker::new(ptr)
- }
- }
- }
-
- /// Creates a `LocalWaker` from a local `wake`.
- ///
- /// This function requires that `wake` is "local" (created on the current thread).
- /// The resulting `LocalWaker` will call `wake.wake_local()` when awoken, and
- /// will call `wake.wake()` if awoken after being converted to a `Waker`.
- #[inline]
- pub unsafe fn local_waker<W: Wake + 'static>(wake: Arc<W>) -> LocalWaker {
- let ptr = mem::transmute::<Arc<W>, NonNull<ArcWrapped<W>>>(wake);
- LocalWaker::new(ptr)
- }
-
- struct NonLocalAsLocal<T>(ArcWrapped<T>);
-
- unsafe impl<T: Wake + 'static> UnsafeWake for NonLocalAsLocal<T> {
- #[inline]
- unsafe fn clone_raw(&self) -> Waker {
- self.0.clone_raw()
- }
-
- #[inline]
- unsafe fn drop_raw(&self) {
- self.0.drop_raw()
- }
-
- #[inline]
- unsafe fn wake(&self) {
- self.0.wake()
- }
-
- #[inline]
- unsafe fn wake_local(&self) {
- // Since we're nonlocal, we can't call wake_local
- self.0.wake()
- }
- }
-
- /// Creates a `LocalWaker` from a non-local `wake`.
- ///
- /// This function is similar to `local_waker`, but does not require that `wake`
- /// is local to the current thread. The resulting `LocalWaker` will call
- /// `wake.wake()` when awoken.
- #[inline]
- pub fn local_waker_from_nonlocal<W: Wake + 'static>(wake: Arc<W>) -> LocalWaker {
- unsafe {
- let ptr = mem::transmute::<Arc<W>, NonNull<NonLocalAsLocal<W>>>(wake);
- LocalWaker::new(ptr)
- }
- }
-}
+#![cfg(not(miri))]
+
use std::any::Any;
use std::sync::{Arc, Weak};
use std::cell::RefCell;
//
// Destructors must be called exactly once per element.
#[test]
+#[cfg(not(miri))]
fn panic_safe() {
static DROP_COUNTER: AtomicUsize = AtomicUsize::new(0);
+#![cfg(not(miri))]
+
mod map;
mod set;
+#![cfg(not(miri))]
+
use std::alloc::{Global, Alloc, Layout, System};
-/// https://github.com/rust-lang/rust/issues/45955
+/// Issue #45955.
#[test]
fn alloc_system_overaligned_request() {
check_overalign_requests(System)
#![feature(exact_size_is_empty)]
#![feature(pattern)]
#![feature(repeat_generic_slice)]
-#![feature(slice_sort_by_cached_key)]
-#![feature(str_escape)]
#![feature(try_reserve)]
#![feature(unboxed_closures)]
#![feature(vecdeque_rotate)]
+#![cfg(not(miri))]
+
use std::any::Any;
use std::rc::{Rc, Weak};
use std::cell::RefCell;
+#![cfg(not(miri))]
+
use std::cell::Cell;
use std::cmp::Ordering::{self, Equal, Greater, Less};
use std::mem;
}
#[test]
+#[cfg(not(miri))]
fn test_collect() {
let empty = "";
let s: String = empty.chars().collect();
#[test]
fn test_concat_for_different_lengths() {
let empty: &[&str] = &[];
+ #[cfg(not(miri))]
test_concat!("", empty);
test_concat!("a", ["a"]);
test_concat!("ab", ["a", "b"]);
#[test]
fn test_join_for_different_lengths() {
let empty: &[&str] = &[];
+ #[cfg(not(miri))]
test_join!("", empty, "-");
test_join!("a", ["a"], "-");
test_join!("a-b", ["a", "b"], "-");
assert_eq!("～～～～～".len(), 15);
let empty: &[&str] = &[];
+ #[cfg(not(miri))]
test_join!("", empty, "～～～～～");
test_join!("a", ["a"], "～～～～～");
test_join!("a～～～～～b", ["a", "b"], "～～～～～");
}
#[test]
+#[cfg(not(miri))]
fn test_unsafe_slice() {
assert_eq!("ab", unsafe {"abc".get_unchecked(0..2)});
assert_eq!("bc", unsafe {"abc".get_unchecked(1..3)});
#[test]
fn test_replace() {
let a = "a";
+ #[cfg(not(miri))]
assert_eq!("".replace(a, "b"), "");
assert_eq!("a".replace(a, "b"), "b");
assert_eq!("ab".replace(a, "b"), "bb");
// The current implementation of SliceIndex fails to handle methods
// orthogonally from range types; therefore, it is worth testing
// all of the indexing operations on each input.
+#[cfg(not(miri))]
mod slice_index {
// Test a slicing operation **that should succeed,**
// testing it on all of the indexing methods.
#[test]
#[should_panic]
+#[cfg(not(miri))]
fn test_str_slice_rangetoinclusive_notok() {
let s = "abcαβγ";
&s[..=3];
#[test]
#[should_panic]
+#[cfg(not(miri))]
fn test_str_slicemut_rangetoinclusive_notok() {
let mut s = "abcαβγ".to_owned();
let s: &mut str = &mut s;
#[test]
#[should_panic]
+#[cfg(not(miri))]
fn test_as_bytes_fail() {
// Don't double free. (I'm not sure if this exercises the
// original problem code path anymore.)
#[test]
#[should_panic]
+#[cfg(not(miri))]
fn test_split_at_boundscheck() {
let s = "ศไทย中华Việt Nam";
s.split_at(1);
#[test]
fn test_escape_unicode() {
- assert_eq!("abc".escape_unicode(), "\\u{61}\\u{62}\\u{63}");
- assert_eq!("a c".escape_unicode(), "\\u{61}\\u{20}\\u{63}");
- assert_eq!("\r\n\t".escape_unicode(), "\\u{d}\\u{a}\\u{9}");
- assert_eq!("'\"\\".escape_unicode(), "\\u{27}\\u{22}\\u{5c}");
- assert_eq!("\x00\x01\u{fe}\u{ff}".escape_unicode(), "\\u{0}\\u{1}\\u{fe}\\u{ff}");
- assert_eq!("\u{100}\u{ffff}".escape_unicode(), "\\u{100}\\u{ffff}");
- assert_eq!("\u{10000}\u{10ffff}".escape_unicode(), "\\u{10000}\\u{10ffff}");
- assert_eq!("ab\u{fb00}".escape_unicode(), "\\u{61}\\u{62}\\u{fb00}");
- assert_eq!("\u{1d4ea}\r".escape_unicode(), "\\u{1d4ea}\\u{d}");
+ assert_eq!("abc".escape_unicode().to_string(), "\\u{61}\\u{62}\\u{63}");
+ assert_eq!("a c".escape_unicode().to_string(), "\\u{61}\\u{20}\\u{63}");
+ assert_eq!("\r\n\t".escape_unicode().to_string(), "\\u{d}\\u{a}\\u{9}");
+ assert_eq!("'\"\\".escape_unicode().to_string(), "\\u{27}\\u{22}\\u{5c}");
+ assert_eq!("\x00\x01\u{fe}\u{ff}".escape_unicode().to_string(), "\\u{0}\\u{1}\\u{fe}\\u{ff}");
+ assert_eq!("\u{100}\u{ffff}".escape_unicode().to_string(), "\\u{100}\\u{ffff}");
+ assert_eq!("\u{10000}\u{10ffff}".escape_unicode().to_string(), "\\u{10000}\\u{10ffff}");
+ assert_eq!("ab\u{fb00}".escape_unicode().to_string(), "\\u{61}\\u{62}\\u{fb00}");
+ assert_eq!("\u{1d4ea}\r".escape_unicode().to_string(), "\\u{1d4ea}\\u{d}");
}
#[test]
// they are escaped. However, when the character is unescaped (e.g., for
// printable characters), only a single backslash appears (as the character
// itself appears in the debug string).
- assert_eq!("abc".escape_debug(), "abc");
- assert_eq!("a c".escape_debug(), "a c");
- assert_eq!("éèê".escape_debug(), "éèê");
- assert_eq!("\r\n\t".escape_debug(), "\\r\\n\\t");
- assert_eq!("'\"\\".escape_debug(), "\\'\\\"\\\\");
- assert_eq!("\u{7f}\u{ff}".escape_debug(), "\\u{7f}\u{ff}");
- assert_eq!("\u{100}\u{ffff}".escape_debug(), "\u{100}\\u{ffff}");
- assert_eq!("\u{10000}\u{10ffff}".escape_debug(), "\u{10000}\\u{10ffff}");
- assert_eq!("ab\u{200b}".escape_debug(), "ab\\u{200b}");
- assert_eq!("\u{10d4ea}\r".escape_debug(), "\\u{10d4ea}\\r");
- assert_eq!("\u{301}a\u{301}bé\u{e000}".escape_debug(), "\\u{301}a\u{301}bé\\u{e000}");
+ assert_eq!("abc".escape_debug().to_string(), "abc");
+ assert_eq!("a c".escape_debug().to_string(), "a c");
+ assert_eq!("éèê".escape_debug().to_string(), "éèê");
+ assert_eq!("\r\n\t".escape_debug().to_string(), "\\r\\n\\t");
+ assert_eq!("'\"\\".escape_debug().to_string(), "\\'\\\"\\\\");
+ assert_eq!("\u{7f}\u{ff}".escape_debug().to_string(), "\\u{7f}\u{ff}");
+ assert_eq!("\u{100}\u{ffff}".escape_debug().to_string(), "\u{100}\\u{ffff}");
+ assert_eq!("\u{10000}\u{10ffff}".escape_debug().to_string(), "\u{10000}\\u{10ffff}");
+ assert_eq!("ab\u{200b}".escape_debug().to_string(), "ab\\u{200b}");
+ assert_eq!("\u{10d4ea}\r".escape_debug().to_string(), "\\u{10d4ea}\\r");
+ assert_eq!("\u{301}a\u{301}bé\u{e000}".escape_debug().to_string(),
+ "\\u{301}a\u{301}bé\\u{e000}");
}
#[test]
fn test_escape_default() {
- assert_eq!("abc".escape_default(), "abc");
- assert_eq!("a c".escape_default(), "a c");
- assert_eq!("éèê".escape_default(), "\\u{e9}\\u{e8}\\u{ea}");
- assert_eq!("\r\n\t".escape_default(), "\\r\\n\\t");
- assert_eq!("'\"\\".escape_default(), "\\'\\\"\\\\");
- assert_eq!("\u{7f}\u{ff}".escape_default(), "\\u{7f}\\u{ff}");
- assert_eq!("\u{100}\u{ffff}".escape_default(), "\\u{100}\\u{ffff}");
- assert_eq!("\u{10000}\u{10ffff}".escape_default(), "\\u{10000}\\u{10ffff}");
- assert_eq!("ab\u{200b}".escape_default(), "ab\\u{200b}");
- assert_eq!("\u{10d4ea}\r".escape_default(), "\\u{10d4ea}\\r");
+ assert_eq!("abc".escape_default().to_string(), "abc");
+ assert_eq!("a c".escape_default().to_string(), "a c");
+ assert_eq!("éèê".escape_default().to_string(), "\\u{e9}\\u{e8}\\u{ea}");
+ assert_eq!("\r\n\t".escape_default().to_string(), "\\r\\n\\t");
+ assert_eq!("'\"\\".escape_default().to_string(), "\\'\\\"\\\\");
+ assert_eq!("\u{7f}\u{ff}".escape_default().to_string(), "\\u{7f}\\u{ff}");
+ assert_eq!("\u{100}\u{ffff}".escape_default().to_string(), "\\u{100}\\u{ffff}");
+ assert_eq!("\u{10000}\u{10ffff}".escape_default().to_string(), "\\u{10000}\\u{10ffff}");
+ assert_eq!("ab\u{200b}".escape_default().to_string(), "ab\\u{200b}");
+ assert_eq!("\u{10d4ea}\r".escape_default().to_string(), "\\u{10d4ea}\\r");
}
#[test]
}
#[test]
+#[cfg(not(miri))]
fn test_chars_decoding() {
let mut bytes = [0; 4];
for c in (0..0x110000).filter_map(std::char::from_u32) {
}
#[test]
+#[cfg(not(miri))]
fn test_chars_rev_decoding() {
let mut bytes = [0; 4];
for c in (0..0x110000).filter_map(std::char::from_u32) {
}
#[test]
+#[cfg(not(miri))]
fn test_str_default() {
use std::default::Default;
assert_eq!("not even a boolean".parse::<bool>().ok(), None);
}
+#[cfg(not(miri))]
fn check_contains_all_substrings(s: &str) {
assert!(s.contains(""));
for i in 0..s.len() {
}
#[test]
+#[cfg(not(miri))]
fn strslice_issue_16589() {
assert!("bananas".contains("nana"));
}
#[test]
+#[cfg(not(miri))]
fn strslice_issue_16878() {
assert!(!"1234567ah012345678901ah".contains("hah"));
assert!(!"00abc01234567890123456789abc".contains("bcabc"));
#[test]
+#[cfg(not(miri))]
fn test_strslice_contains() {
let x = "There are moments, Jeeves, when one asks oneself, 'Do trousers matter?'";
check_contains_all_substrings(x);
#[test]
fn to_lowercase() {
+ #[cfg(not(miri))]
assert_eq!("".to_lowercase(), "");
assert_eq!("AÉDžaé ".to_lowercase(), "aédžaé ");
#[test]
fn to_uppercase() {
+ #[cfg(not(miri))]
assert_eq!("".to_uppercase(), "");
assert_eq!("aéDžßfiᾀ".to_uppercase(), "AÉDŽSSFIἈΙ");
}
}
#[test]
+#[cfg(not(miri))]
fn test_repeat() {
assert_eq!("".repeat(3), "");
assert_eq!("abc".repeat(0), "");
+#![cfg(not(miri))]
+
use std::borrow::Cow;
use std::collections::CollectionAllocErr::*;
use std::mem::size_of;
+#![cfg(not(miri))]
+
use std::borrow::Cow;
use std::mem::size_of;
use std::{usize, isize};
#[test]
#[should_panic]
+#[cfg(not(miri))]
fn test_index_out_of_bounds() {
let mut deq = VecDeque::new();
for i in 1..4 {
// normal append
a.append(&mut b);
assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
+ #[cfg(not(miri))]
assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
// append nothing to something
a.append(&mut b);
assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
+ #[cfg(not(miri))]
assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
// append something to nothing
b.append(&mut a);
assert_eq!(b.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
+ #[cfg(not(miri))]
assert_eq!(a.iter().cloned().collect::<Vec<_>>(), []);
}
#[test]
+#[cfg(not(miri))]
fn test_append_permutations() {
fn construct_vec_deque(
push_back: usize,
}
#[test]
+#[cfg(not(miri))]
fn test_try_reserve() {
// These are the interesting cases:
}
#[test]
+#[cfg(not(miri))]
fn test_try_reserve_exact() {
// This is exactly the same as test_try_reserve with the method changed.
/// Does nothing if the capacity is already sufficient.
///
/// Note that the allocator may give the collection more space than it
- /// requests. Therefore capacity can not be relied upon to be precisely
+ /// requests. Therefore, capacity can not be relied upon to be precisely
/// minimal. Prefer `reserve` if future insertions are expected.
///
/// # Panics
/// Does nothing if the capacity is already sufficient.
///
/// Note that the allocator may give the collection more space than it
- /// requests. Therefore capacity can not be relied upon to be precisely
+ /// requests. Therefore, capacity can not be relied upon to be precisely
/// minimal. Prefer `reserve` if future insertions are expected.
///
/// # Errors
/// Forces the length of the vector to `new_len`.
///
/// This is a low-level operation that maintains none of the normal
- /// invariants of the type. Normally changing the length of a vector
+ /// invariants of the type. Normally changing the length of a vector
/// is done using one of the safe operations instead, such as
/// [`truncate`], [`resize`], [`extend`], or [`clear`].
///
/// The range from `self.vec.len` to `self.tail_start` contains elements
/// that have been moved out.
/// Fill that range as much as possible with new elements from the `replace_with` iterator.
- /// Return whether we filled the entire range. (`replace_with.next()` didn’t return `None`.)
+ /// Returns `true` if we filled the entire range. (`replace_with.next()` didn’t return `None`.)
unsafe fn fill<I: Iterator<Item=T>>(&mut self, replace_with: &mut I) -> bool {
let vec = self.vec.as_mut();
let range_start = vec.len;
true
}
- /// Make room for inserting more elements before the tail.
+ /// Makes room for inserting more elements before the tail.
unsafe fn move_tail(&mut self, extra_capacity: usize) {
let vec = self.vec.as_mut();
let used_capacity = self.tail_start + self.tail_len;
authors = ["The Rust Project Developers"]
name = "arena"
version = "0.0.0"
+edition = "2018"
[lib]
name = "arena"
crate-type = ["dylib"]
[dependencies]
-rustc_data_structures = { path = "../librustc_data_structures" }
\ No newline at end of file
+rustc_data_structures = { path = "../librustc_data_structures" }
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/",
test(no_crate_inject, attr(deny(warnings))))]
+#![deny(rust_2018_idioms)]
+
#![feature(alloc)]
#![feature(core_intrinsics)]
#![feature(dropck_eyepatch)]
-#![feature(nll)]
#![feature(raw_vec_internals)]
#![cfg_attr(test, feature(test))]
#![allow(deprecated)]
extern crate alloc;
-extern crate rustc_data_structures;
use rustc_data_structures::sync::MTLock;
#[cfg(test)]
mod tests {
extern crate test;
- use self::test::Bencher;
+ use test::Bencher;
use super::TypedArena;
use std::cell::Cell;
impl<'a> Wrap<'a> {
fn alloc_inner<F: Fn() -> Inner>(&self, f: F) -> &Inner {
- let r: &EI = self.0.alloc(EI::I(f()));
+ let r: &EI<'_> = self.0.alloc(EI::I(f()));
if let &EI::I(ref i) = r {
i
} else {
panic!("mismatch");
}
}
- fn alloc_outer<F: Fn() -> Outer<'a>>(&self, f: F) -> &Outer {
- let r: &EI = self.0.alloc(EI::O(f()));
+ fn alloc_outer<F: Fn() -> Outer<'a>>(&self, f: F) -> &Outer<'_> {
+ let r: &EI<'_> = self.0.alloc(EI::O(f()));
if let &EI::O(ref o) = r {
o
} else {
count: &'a Cell<u32>,
}
- impl<'a> Drop for DropCounter<'a> {
+ impl Drop for DropCounter<'_> {
fn drop(&mut self) {
self.count.set(self.count.get() + 1);
}
fn test_typed_arena_drop_count() {
let counter = Cell::new(0);
{
- let arena: TypedArena<DropCounter> = TypedArena::default();
+ let arena: TypedArena<DropCounter<'_>> = TypedArena::default();
for _ in 0..100 {
// Allocate something with drop glue to make sure it doesn't leak.
arena.alloc(DropCounter { count: &counter });
#[test]
fn test_typed_arena_drop_on_clear() {
let counter = Cell::new(0);
- let mut arena: TypedArena<DropCounter> = TypedArena::default();
+ let mut arena: TypedArena<DropCounter<'_>> = TypedArena::default();
for i in 0..10 {
for _ in 0..100 {
// Allocate something with drop glue to make sure it doesn't leak.
/// The `GlobalAlloc` trait is an `unsafe` trait for a number of reasons, and
/// implementors must ensure that they adhere to these contracts:
///
-/// * It's undefined behavior if global allocators unwind. This restriction may
+/// * It's undefined behavior if global allocators unwind. This restriction may
/// be lifted in the future, but currently a panic from any of these
/// functions may lead to memory unsafety.
///
//!
//! Consider a situation where we want to log out a value passed to a function.
//! We know the value we're working on implements Debug, but we don't know its
-//! concrete type. We want to give special treatment to certain types: in this
+//! concrete type. We want to give special treatment to certain types: in this
//! case printing out the length of String values prior to their value.
//! We don't know the concrete type of our value at compile time, so we need to
//! use runtime reflection instead.
//! fn log<T: Any + Debug>(value: &T) {
//! let value_any = value as &dyn Any;
//!
-//! // try to convert our value to a String. If successful, we want to
-//! // output the String's length as well as its value. If not, it's a
+//! // Try to convert our value to a `String`. If successful, we want to
+//! // output the String`'s length as well as its value. If not, it's a
//! // different type: just print it out unadorned.
//! match value_any.downcast_ref::<String>() {
//! Some(as_string) => {
//!
//! This is simply a special - but common - case of the previous: hiding mutability for operations
//! that appear to be immutable. The `clone` method is expected to not change the source value, and
-//! is declared to take `&self`, not `&mut self`. Therefore any mutation that happens in the
+//! is declared to take `&self`, not `&mut self`. Therefore, any mutation that happens in the
//! `clone` method must use cell types. For example, `Rc<T>` maintains its reference counts within a
//! `Cell<T>`.
//!
/// The `RefCell` is already immutably borrowed, so this cannot fail.
///
/// This is an associated function that needs to be used as
- /// `Ref::clone(...)`. A `Clone` implementation or a method would interfere
+ /// `Ref::clone(...)`. A `Clone` implementation or a method would interfere
/// with the widespread use of `r.borrow().clone()` to clone the contents of
/// a `RefCell`.
#[stable(feature = "cell_extras", since = "1.15.0")]
}
}
- /// Make a new `Ref` for a component of the borrowed data.
+ /// Makes a new `Ref` for a component of the borrowed data.
///
/// The `RefCell` is already immutably borrowed, so this cannot fail.
///
}
}
- /// Split a `Ref` into multiple `Ref`s for different components of the
+ /// Splits a `Ref` into multiple `Ref`s for different components of the
/// borrowed data.
///
/// The `RefCell` is already immutably borrowed, so this cannot fail.
}
impl<'b, T: ?Sized> RefMut<'b, T> {
- /// Make a new `RefMut` for a component of the borrowed data, e.g., an enum
+ /// Makes a new `RefMut` for a component of the borrowed data, e.g., an enum
/// variant.
///
/// The `RefCell` is already mutably borrowed, so this cannot fail.
///
/// This is an associated function that needs to be used as
- /// `RefMut::map(...)`. A method would interfere with methods of the same
+ /// `RefMut::map(...)`. A method would interfere with methods of the same
/// name on the contents of a `RefCell` used through `Deref`.
///
/// # Examples
}
}
- /// Split a `RefMut` into multiple `RefMut`s for different components of the
+ /// Splits a `RefMut` into multiple `RefMut`s for different components of the
/// borrowed data.
///
/// The underlying `RefCell` will remain mutably borrowed until both
/// co-exist with it. A `&mut T` must always be unique.
///
/// Note that while mutating or mutably aliasing the contents of an `&UnsafeCell<T>` is
-/// okay (provided you enforce the invariants some other way), it is still undefined behavior
+/// ok (provided you enforce the invariants some other way), it is still undefined behavior
/// to have multiple `&mut UnsafeCell<T>` aliases.
///
/// # Examples
code: u16,
}
-/// Create an iterator over the UTF-16 encoded code points in `iter`,
+/// Creates an iterator over the UTF-16 encoded code points in `iter`,
/// returning unpaired surrogates as `Err`s.
///
/// # Examples
/// An extended version of `escape_debug` that optionally permits escaping
/// Extended Grapheme codepoints. This allows us to format characters like
/// nonspacing marks better when they're at the start of a string.
- #[doc(hidden)]
- #[unstable(feature = "str_internals", issue = "0")]
#[inline]
- pub fn escape_debug_ext(self, escape_grapheme_extended: bool) -> EscapeDebug {
+ pub(crate) fn escape_debug_ext(self, escape_grapheme_extended: bool) -> EscapeDebug {
let init_state = match self {
'\t' => EscapeDefaultState::Backslash('t'),
'\r' => EscapeDefaultState::Backslash('r'),
}
}
- /// Returns true if this `char` is an alphabetic code point, and false if not.
+ /// Returns `true` if this `char` is an alphabetic code point, and false if not.
///
/// # Examples
///
}
}
- /// Returns true if this `char` satisfies the 'XID_Start' Unicode property, and false
+ /// Returns `true` if this `char` satisfies the 'XID_Start' Unicode property, and false
/// otherwise.
///
/// 'XID_Start' is a Unicode Derived Property specified in
derived_property::XID_Start(self)
}
- /// Returns true if this `char` satisfies the 'XID_Continue' Unicode property, and false
+ /// Returns `true` if this `char` satisfies the 'XID_Continue' Unicode property, and false
/// otherwise.
///
/// 'XID_Continue' is a Unicode Derived Property specified in
derived_property::XID_Continue(self)
}
- /// Returns true if this `char` is lowercase, and false otherwise.
+ /// Returns `true` if this `char` is lowercase.
///
/// 'Lowercase' is defined according to the terms of the Unicode Derived Core
/// Property `Lowercase`.
}
}
- /// Returns true if this `char` is uppercase, and false otherwise.
+ /// Returns `true` if this `char` is uppercase.
///
/// 'Uppercase' is defined according to the terms of the Unicode Derived Core
/// Property `Uppercase`.
}
}
- /// Returns true if this `char` is whitespace, and false otherwise.
+ /// Returns `true` if this `char` is whitespace.
///
/// 'Whitespace' is defined according to the terms of the Unicode Derived Core
/// Property `White_Space`.
}
}
- /// Returns true if this `char` is alphanumeric, and false otherwise.
+ /// Returns `true` if this `char` is alphanumeric.
///
/// 'Alphanumeric'-ness is defined in terms of the Unicode General Categories
/// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
self.is_alphabetic() || self.is_numeric()
}
- /// Returns true if this `char` is a control code point, and false otherwise.
+ /// Returns `true` if this `char` is a control code point.
///
/// 'Control code point' is defined in terms of the Unicode General
/// Category `Cc`.
general_category::Cc(self)
}
- /// Returns true if this `char` is an extended grapheme character, and false otherwise.
+ /// Returns `true` if this `char` is an extended grapheme character.
///
/// 'Extended grapheme character' is defined in terms of the Unicode Shaping and Rendering
/// Category `Grapheme_Extend`.
derived_property::Grapheme_Extend(self)
}
- /// Returns true if this `char` is numeric, and false otherwise.
+ /// Returns `true` if this `char` is numeric.
///
/// 'Numeric'-ness is defined in terms of the Unicode General Categories
/// 'Nd', 'Nl', 'No'.
/// relations](http://en.wikipedia.org/wiki/Partial_equivalence_relation).
///
/// This trait allows for partial equality, for types that do not have a full
-/// equivalence relation. For example, in floating point numbers `NaN != NaN`,
+/// equivalence relation. For example, in floating point numbers `NaN != NaN`,
/// so floating point types implement `PartialEq` but not `Eq`.
///
/// Formally, the equality must be (for all `a`, `b` and `c`):
//! [`TryFrom<T>`][`TryFrom`] rather than [`Into<U>`][`Into`] or [`TryInto<U>`][`TryInto`],
//! as [`From`] and [`TryFrom`] provide greater flexibility and offer
//! equivalent [`Into`] or [`TryInto`] implementations for free, thanks to a
-//! blanket implementation in the standard library.
+//! blanket implementation in the standard library. However, there are some cases
+//! where this is not possible, such as creating conversions into a type defined
+//! outside your library, so implementing [`Into`] instead of [`From`] is
+//! sometimes necessary.
//!
//! # Generic Implementations
//!
/// - Use `Borrow` when the goal is related to writing code that is agnostic to
/// the type of borrow and whether it is a reference or value
///
-/// See [the book][book] for a more detailed comparison.
-///
-/// [book]: ../../book/first-edition/borrow-and-asref.html
/// [`Borrow`]: ../../std/borrow/trait.Borrow.html
///
/// **Note: this trait must not fail**. If the conversion can fail, use a
///
/// There is one exception to implementing `Into`, and it's kind of esoteric.
/// If the destination type is not part of the current crate, and it uses a
-/// generic variable, then you can't implement `From` directly. For example,
+/// generic variable, then you can't implement `From` directly. For example,
/// take this crate:
///
/// ```compile_fail
/// [`String`]: ../../std/string/struct.String.html
/// [`Into<U>`]: trait.Into.html
/// [`from`]: trait.From.html#tymethod.from
-/// [book]: ../../book/first-edition/error-handling.html
+/// [book]: ../../book/ch09-00-error-handling.html
#[stable(feature = "rust1", since = "1.0.0")]
pub trait From<T>: Sized {
/// Performs the conversion.
///
/// ## How can I implement `Default`?
///
-/// Provide an implementation for the `default()` method that returns the value of
+/// Provides an implementation for the `default()` method that returns the value of
/// your type that should be the default:
///
/// ```
va_arg(self)
}
- /// Copy the `va_list` at the current location.
+ /// Copies the `va_list` at the current location.
#[unstable(feature = "c_variadic",
reason = "the `c_variadic` feature has not been properly tested on \
all supported platforms",
/// `va_copy`.
fn va_end(ap: &mut VaList);
- /// Copy the current location of arglist `src` to the arglist `dst`.
+ /// Copies the current location of arglist `src` to the arglist `dst`.
#[cfg(any(all(not(target_arch = "aarch64"), not(target_arch = "powerpc"),
not(target_arch = "x86_64")),
windows))]
/// implementations, such as [`debug_struct`][debug_struct].
///
/// `Debug` implementations using either `derive` or the debug builder API
-/// on [`Formatter`] support pretty printing using the alternate flag: `{:#?}`.
+/// on [`Formatter`] support pretty-printing using the alternate flag: `{:#?}`.
///
/// [debug_struct]: ../../std/fmt/struct.Formatter.html#method.debug_struct
/// [`Formatter`]: ../../std/fmt/struct.Formatter.html
///
-/// Pretty printing with `#?`:
+/// Pretty-printing with `#?`:
///
/// ```
/// #[derive(Debug)]
Ok(())
}
+/// Padding after the end of something. Returned by `Formatter::padding`.
+#[must_use = "don't forget to write the post padding"]
+struct PostPadding {
+ fill: char,
+ padding: usize,
+}
+
+impl PostPadding {
+ fn new(fill: char, padding: usize) -> PostPadding {
+ PostPadding { fill, padding }
+ }
+
+ /// Write this post padding.
+ fn write(self, buf: &mut dyn Write) -> Result {
+ for _ in 0..self.padding {
+ buf.write_char(self.fill)?;
+ }
+ Ok(())
+ }
+}
+
impl<'a> Formatter<'a> {
fn wrap_buf<'b, 'c, F>(&'b mut self, wrap: F) -> Formatter<'c>
where 'b: 'c, F: FnOnce(&'b mut (dyn Write+'b)) -> &'c mut (dyn Write+'c)
sign = Some('+'); width += 1;
}
- let prefixed = self.alternate();
- if prefixed {
+ let prefix = if self.alternate() {
width += prefix.chars().count();
- }
+ Some(prefix)
+ } else {
+ None
+ };
// Writes the sign if it exists, and then the prefix if it was requested
- let write_prefix = |f: &mut Formatter| {
+ #[inline(never)]
+ fn write_prefix(f: &mut Formatter, sign: Option<char>, prefix: Option<&str>) -> Result {
if let Some(c) = sign {
f.buf.write_char(c)?;
}
- if prefixed { f.buf.write_str(prefix) }
- else { Ok(()) }
- };
+ if let Some(prefix) = prefix {
+ f.buf.write_str(prefix)
+ } else {
+ Ok(())
+ }
+ }
// The `width` field is more of a `min-width` parameter at this point.
match self.width {
// If there's no minimum length requirements then we can just
// write the bytes.
None => {
- write_prefix(self)?; self.buf.write_str(buf)
+ write_prefix(self, sign, prefix)?;
+ self.buf.write_str(buf)
}
// Check if we're over the minimum width, if so then we can also
// just write the bytes.
Some(min) if width >= min => {
- write_prefix(self)?; self.buf.write_str(buf)
+ write_prefix(self, sign, prefix)?;
+ self.buf.write_str(buf)
}
// The sign and prefix goes before the padding if the fill character
// is zero
Some(min) if self.sign_aware_zero_pad() => {
self.fill = '0';
self.align = rt::v1::Alignment::Right;
- write_prefix(self)?;
- self.with_padding(min - width, rt::v1::Alignment::Right, |f| {
- f.buf.write_str(buf)
- })
+ write_prefix(self, sign, prefix)?;
+ let post_padding = self.padding(min - width, rt::v1::Alignment::Right)?;
+ self.buf.write_str(buf)?;
+ post_padding.write(self.buf)
}
// Otherwise, the sign and prefix goes after the padding
Some(min) => {
- self.with_padding(min - width, rt::v1::Alignment::Right, |f| {
- write_prefix(f)?; f.buf.write_str(buf)
- })
+ let post_padding = self.padding(min - width, rt::v1::Alignment::Right)?;
+ write_prefix(self, sign, prefix)?;
+ self.buf.write_str(buf)?;
+ post_padding.write(self.buf)
}
}
}
// up the minimum width with the specified string + some alignment.
Some(width) => {
let align = rt::v1::Alignment::Left;
- self.with_padding(width - s.chars().count(), align, |me| {
- me.buf.write_str(s)
- })
+ let post_padding = self.padding(width - s.chars().count(), align)?;
+ self.buf.write_str(s)?;
+ post_padding.write(self.buf)
}
}
}
- /// Runs a callback, emitting the correct padding either before or
- /// afterwards depending on whether right or left alignment is requested.
- fn with_padding<F>(&mut self, padding: usize, default: rt::v1::Alignment,
- f: F) -> Result
- where F: FnOnce(&mut Formatter) -> Result,
- {
+ /// Write the pre-padding and return the unwritten post-padding. Callers are
+ /// responsible for ensuring post-padding is written after the thing that is
+ /// being padded.
+ fn padding(
+ &mut self,
+ padding: usize,
+ default: rt::v1::Alignment
+ ) -> result::Result<PostPadding, Error> {
let align = match self.align {
rt::v1::Alignment::Unknown => default,
_ => self.align
rt::v1::Alignment::Center => (padding / 2, (padding + 1) / 2),
};
- let mut fill = [0; 4];
- let fill = self.fill.encode_utf8(&mut fill);
-
for _ in 0..pre_pad {
- self.buf.write_str(fill)?;
- }
-
- f(self)?;
-
- for _ in 0..post_pad {
- self.buf.write_str(fill)?;
+ self.buf.write_char(self.fill)?;
}
- Ok(())
+ Ok(PostPadding::new(self.fill, post_pad))
}
/// Takes the formatted parts and applies the padding.
let ret = if width <= len { // no padding
self.write_formatted_parts(&formatted)
} else {
- self.with_padding(width - len, align, |f| {
- f.write_formatted_parts(&formatted)
- })
+ let post_padding = self.padding(width - len, align)?;
+ self.write_formatted_parts(&formatted)?;
+ post_padding.write(self.buf)
};
self.fill = old_fill;
self.align = old_align;
integer! { i64, u64 }
integer! { i128, u128 }
-const DEC_DIGITS_LUT: &'static[u8] =
+
+static DEC_DIGITS_LUT: &[u8; 200] =
b"0001020304050607080910111213141516171819\
2021222324252627282930313233343536373839\
4041424344454647484950515253545556575859\
8081828384858687888990919293949596979899";
macro_rules! impl_Display {
- ($($t:ident),*: $conv_fn:ident) => ($(
- #[stable(feature = "rust1", since = "1.0.0")]
- impl fmt::Display for $t {
- #[allow(unused_comparisons)]
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let is_nonnegative = *self >= 0;
- let mut n = if is_nonnegative {
- self.$conv_fn()
- } else {
- // convert the negative num to positive by summing 1 to it's 2 complement
- (!self.$conv_fn()).wrapping_add(1)
- };
+ ($($t:ident),* as $u:ident via $conv_fn:ident named $name:ident) => {
+ fn $name(mut n: $u, is_nonnegative: bool, f: &mut fmt::Formatter) -> fmt::Result {
let mut buf = uninitialized_array![u8; 39];
let mut curr = buf.len() as isize;
let buf_ptr = MaybeUninit::first_ptr_mut(&mut buf);
unsafe {
// need at least 16 bits for the 4-characters-at-a-time to work.
- if ::mem::size_of::<$t>() >= 2 {
- // eagerly decode 4 characters at a time
- while n >= 10000 {
- let rem = (n % 10000) as isize;
- n /= 10000;
-
- let d1 = (rem / 100) << 1;
- let d2 = (rem % 100) << 1;
- curr -= 4;
- ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
- ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2);
- }
+ assert!(::mem::size_of::<$u>() >= 2);
+
+ // eagerly decode 4 characters at a time
+ while n >= 10000 {
+ let rem = (n % 10000) as isize;
+ n /= 10000;
+
+ let d1 = (rem / 100) << 1;
+ let d2 = (rem % 100) << 1;
+ curr -= 4;
+ ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+ ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2);
}
// if we reach here numbers are <= 9999, so at most 4 chars long
};
f.pad_integral(is_nonnegative, "", buf_slice)
}
- })*);
+
+ $(
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl fmt::Display for $t {
+ #[allow(unused_comparisons)]
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let is_nonnegative = *self >= 0;
+ let n = if is_nonnegative {
+ self.$conv_fn()
+ } else {
+ // convert the negative num to positive by summing 1 to it's 2 complement
+ (!self.$conv_fn()).wrapping_add(1)
+ };
+ $name(n, is_nonnegative, f)
+ }
+ })*
+ };
+}
+
+// Include wasm32 in here since it doesn't reflect the native pointer size, and
+// often cares strongly about getting a smaller code size.
+#[cfg(any(target_pointer_width = "64", target_arch = "wasm32"))]
+mod imp {
+ use super::*;
+ impl_Display!(
+ i8, u8, i16, u16, i32, u32, i64, u64, usize, isize
+ as u64 via to_u64 named fmt_u64
+ );
+}
+
+#[cfg(not(any(target_pointer_width = "64", target_arch = "wasm32")))]
+mod imp {
+ use super::*;
+ impl_Display!(i8, u8, i16, u16, i32, u32, isize, usize as u32 via to_u32 named fmt_u32);
+ impl_Display!(i64, u64 as u64 via to_u64 named fmt_u64);
}
-impl_Display!(i8, u8, i16, u16, i32, u32: to_u32);
-impl_Display!(i64, u64: to_u64);
-impl_Display!(i128, u128: to_u128);
-#[cfg(target_pointer_width = "16")]
-impl_Display!(isize, usize: to_u16);
-#[cfg(target_pointer_width = "32")]
-impl_Display!(isize, usize: to_u32);
-#[cfg(target_pointer_width = "64")]
-impl_Display!(isize, usize: to_u64);
+impl_Display!(i128, u128 as u128 via to_u128 named fmt_u128);
use marker::Unpin;
use ops;
use pin::Pin;
-use task::{Poll, LocalWaker};
+use task::{Poll, Waker};
/// A future represents an asynchronous computation.
///
/// final value. This method does not block if the value is not ready. Instead,
/// the current task is scheduled to be woken up when it's possible to make
/// further progress by `poll`ing again. The wake up is performed using
-/// `cx.waker()`, a handle for waking up the current task.
+/// the `waker` argument of the `poll()` method, which is a handle for waking
+/// up the current task.
///
/// When using a future, you generally won't call `poll` directly, but instead
/// `await!` the value.
#[must_use = "futures do nothing unless polled"]
pub trait Future {
- /// The result of the `Future`.
+ /// The type of value produced on completion.
type Output;
/// Attempt to resolve the future to a final value, registering
/// Once a future has finished, clients should not `poll` it again.
///
/// When a future is not ready yet, `poll` returns `Poll::Pending` and
- /// stores a clone of the [`LocalWaker`] to be woken once the future can
+ /// stores a clone of the [`Waker`] to be woken once the future can
/// make progress. For example, a future waiting for a socket to become
- /// readable would call `.clone()` on the [`LocalWaker`] and store it.
+ /// readable would call `.clone()` on the [`Waker`] and store it.
/// When a signal arrives elsewhere indicating that the socket is readable,
- /// `[LocalWaker::wake]` is called and the socket future's task is awoken.
+ /// `[Waker::wake]` is called and the socket future's task is awoken.
/// Once a task has been woken up, it should attempt to `poll` the future
/// again, which may or may not produce a final value.
///
/// Note that on multiple calls to `poll`, only the most recent
- /// [`LocalWaker`] passed to `poll` should be scheduled to receive a
+ /// [`Waker`] passed to `poll` should be scheduled to receive a
/// wakeup.
///
/// # Runtime characteristics
/// progress, meaning that each time the current task is woken up, it should
/// actively re-`poll` pending futures that it still has an interest in.
///
- /// The `poll` function is not called repeatedly in a tight loop-- instead,
+ /// The `poll` function is not called repeatedly in a tight loop -- instead,
/// it should only be called when the future indicates that it is ready to
/// make progress (by calling `wake()`). If you're familiar with the
/// `poll(2)` or `select(2)` syscalls on Unix it's worth noting that futures
/// typically do *not* suffer the same problems of "all wakeups must poll
/// all events"; they are more like `epoll(4)`.
///
- /// An implementation of `poll` should strive to return quickly, and must
- /// *never* block. Returning quickly prevents unnecessarily clogging up
+ /// An implementation of `poll` should strive to return quickly, and should
+ /// not block. Returning quickly prevents unnecessarily clogging up
/// threads or event loops. If it is known ahead of time that a call to
/// `poll` may end up taking awhile, the work should be offloaded to a
/// thread pool (or something similar) to ensure that `poll` can return
/// quickly.
///
- /// # [`LocalWaker`], [`Waker`] and thread-safety
- ///
- /// The `poll` function takes a [`LocalWaker`], an object which knows how to
- /// awaken the current task. [`LocalWaker`] is not `Send` nor `Sync`, so in
- /// order to make thread-safe futures the [`LocalWaker::into_waker`] method
- /// should be used to convert the [`LocalWaker`] into a thread-safe version.
- /// [`LocalWaker::wake`] implementations have the ability to be more
- /// efficient, however, so when thread safety is not necessary,
- /// [`LocalWaker`] should be preferred.
+ /// An implementation of `poll` may also never cause memory unsafety.
///
/// # Panics
///
/// Once a future has completed (returned `Ready` from `poll`),
/// then any future calls to `poll` may panic, block forever, or otherwise
- /// cause bad behavior. The `Future` trait itself provides no guarantees
- /// about the behavior of `poll` after a future has completed.
+ /// cause any kind of bad behavior expect causing memory unsafety.
+ /// The `Future` trait itself provides no guarantees about the behavior
+ /// of `poll` after a future has completed.
///
/// [`Poll::Pending`]: ../task/enum.Poll.html#variant.Pending
/// [`Poll::Ready(val)`]: ../task/enum.Poll.html#variant.Ready
- /// [`LocalWaker`]: ../task/struct.LocalWaker.html
- /// [`LocalWaker::into_waker`]: ../task/struct.LocalWaker.html#method.into_waker
- /// [`LocalWaker::wake`]: ../task/struct.LocalWaker.html#method.wake
/// [`Waker`]: ../task/struct.Waker.html
- fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output>;
+ /// [`Waker::wake`]: ../task/struct.Waker.html#method.wake
+ fn poll(self: Pin<&mut Self>, waker: &Waker) -> Poll<Self::Output>;
}
impl<'a, F: ?Sized + Future + Unpin> Future for &'a mut F {
type Output = F::Output;
- fn poll(mut self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output> {
- F::poll(Pin::new(&mut **self), lw)
+ fn poll(mut self: Pin<&mut Self>, waker: &Waker) -> Poll<Self::Output> {
+ F::poll(Pin::new(&mut **self), waker)
}
}
{
type Output = <<P as ops::Deref>::Target as Future>::Output;
- fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output> {
- Pin::get_mut(self).as_mut().poll(lw)
+ fn poll(self: Pin<&mut Self>, waker: &Waker) -> Poll<Self::Output> {
+ Pin::get_mut(self).as_mut().poll(waker)
}
}
/// An implementation of SipHash 1-3.
///
/// This is currently the default hashing function used by standard library
-/// (eg. `collections::HashMap` uses it by default).
+/// (e.g., `collections::HashMap` uses it by default).
///
/// See: <https://131002.net/siphash>
#[unstable(feature = "hashmap_internals", issue = "0")]
});
}
-/// Load an integer of the desired type from a byte stream, in LE order. Uses
+/// Loads an integer of the desired type from a byte stream, in LE order. Uses
/// `copy_nonoverlapping` to let the compiler generate the most efficient way
/// to load it from a possibly unaligned address.
///
});
}
-/// Load an u64 using up to 7 bytes of a byte slice.
+/// Loads an u64 using up to 7 bytes of a byte slice.
///
/// Unsafe because: unchecked indexing at start..start+len
#[inline]
/// use std::hint::unreachable_unchecked;
///
/// // `b.saturating_add(1)` is always positive (not zero),
-/// // hence `checked_div` will never return None.
+/// // hence `checked_div` will never return `None`.
/// // Therefore, the else branch is unreachable.
/// a.checked_div(b.saturating_add(1))
/// .unwrap_or_else(|| unsafe { unreachable_unchecked() })
}
}
}
+
+/// Create a zero-size type similar to a closure type, but named.
+#[unstable(feature = "std_internals", issue = "0")]
+macro_rules! impl_fn_for_zst {
+ ($(
+ $( #[$attr: meta] )*
+ // FIXME: when libcore is in the 2018 edition, use `?` repetition in
+ // $( <$( $li : lifetime ),+> )?
+ struct $Name: ident impl$( <$( $lifetime : lifetime ),+> )* Fn =
+ |$( $arg: ident: $ArgTy: ty ),*| -> $ReturnTy: ty
+ $body: block;
+ )+) => {
+ $(
+ $( #[$attr] )*
+ struct $Name;
+
+ impl $( <$( $lifetime ),+> )* Fn<($( $ArgTy, )*)> for $Name {
+ #[inline]
+ extern "rust-call" fn call(&self, ($( $arg, )*): ($( $ArgTy, )*)) -> $ReturnTy {
+ $body
+ }
+ }
+
+ impl $( <$( $lifetime ),+> )* FnMut<($( $ArgTy, )*)> for $Name {
+ #[inline]
+ extern "rust-call" fn call_mut(
+ &mut self,
+ ($( $arg, )*): ($( $ArgTy, )*)
+ ) -> $ReturnTy {
+ Fn::call(&*self, ($( $arg, )*))
+ }
+ }
+
+ impl $( <$( $lifetime ),+> )* FnOnce<($( $ArgTy, )*)> for $Name {
+ type Output = $ReturnTy;
+
+ #[inline]
+ extern "rust-call" fn call_once(self, ($( $arg, )*): ($( $ArgTy, )*)) -> $ReturnTy {
+ Fn::call(&self, ($( $arg, )*))
+ }
+ }
+ )+
+ }
+}
-//! rustc compiler intrinsics.
+//! Compiler intrinsics.
//!
-//! The corresponding definitions are in librustc_codegen_llvm/intrinsic.rs.
+//! The corresponding definitions are in `librustc_codegen_llvm/intrinsic.rs`.
//!
//! # Volatiles
//!
/// [`AtomicBool::swap`](../../std/sync/atomic/struct.AtomicBool.html#method.swap).
pub fn atomic_xchg_relaxed<T>(dst: *mut T, src: T) -> T;
- /// Add to the current value, returning the previous value.
+ /// Adds to the current value, returning the previous value.
/// The stabilized version of this intrinsic is available on the
/// `std::sync::atomic` types via the `fetch_add` method by passing
/// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
/// as the `order`. For example,
/// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
pub fn atomic_xadd<T>(dst: *mut T, src: T) -> T;
- /// Add to the current value, returning the previous value.
+ /// Adds to the current value, returning the previous value.
/// The stabilized version of this intrinsic is available on the
/// `std::sync::atomic` types via the `fetch_add` method by passing
/// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
/// as the `order`. For example,
/// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
pub fn atomic_xadd_acq<T>(dst: *mut T, src: T) -> T;
- /// Add to the current value, returning the previous value.
+ /// Adds to the current value, returning the previous value.
/// The stabilized version of this intrinsic is available on the
/// `std::sync::atomic` types via the `fetch_add` method by passing
/// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
/// as the `order`. For example,
/// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
pub fn atomic_xadd_rel<T>(dst: *mut T, src: T) -> T;
- /// Add to the current value, returning the previous value.
+ /// Adds to the current value, returning the previous value.
/// The stabilized version of this intrinsic is available on the
/// `std::sync::atomic` types via the `fetch_add` method by passing
/// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
/// as the `order`. For example,
/// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
pub fn atomic_xadd_acqrel<T>(dst: *mut T, src: T) -> T;
- /// Add to the current value, returning the previous value.
+ /// Adds to the current value, returning the previous value.
/// The stabilized version of this intrinsic is available on the
/// `std::sync::atomic` types via the `fetch_add` method by passing
/// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
pub fn atomic_umax_relaxed<T>(dst: *mut T, src: T) -> T;
/// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
- /// if supported; otherwise, it is a noop.
+ /// if supported; otherwise, it is a no-op.
/// Prefetches have no effect on the behavior of the program but can change its performance
/// characteristics.
///
/// ranging from (0) - no locality, to (3) - extremely local keep in cache
pub fn prefetch_read_data<T>(data: *const T, locality: i32);
/// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
- /// if supported; otherwise, it is a noop.
+ /// if supported; otherwise, it is a no-op.
/// Prefetches have no effect on the behavior of the program but can change its performance
/// characteristics.
///
/// ranging from (0) - no locality, to (3) - extremely local keep in cache
pub fn prefetch_write_data<T>(data: *const T, locality: i32);
/// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
- /// if supported; otherwise, it is a noop.
+ /// if supported; otherwise, it is a no-op.
/// Prefetches have no effect on the behavior of the program but can change its performance
/// characteristics.
///
/// ranging from (0) - no locality, to (3) - extremely local keep in cache
pub fn prefetch_read_instruction<T>(data: *const T, locality: i32);
/// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
- /// if supported; otherwise, it is a noop.
+ /// if supported; otherwise, it is a no-op.
/// Prefetches have no effect on the behavior of the program but can change its performance
/// characteristics.
///
/// Creates a value initialized to zero.
///
/// `init` is unsafe because it returns a zeroed-out datum,
- /// which is unsafe unless T is `Copy`. Also, even if T is
+ /// which is unsafe unless `T` is `Copy`. Also, even if T is
/// `Copy`, an all-zero value may not correspond to any legitimate
/// state for the type in question.
pub fn init<T>() -> T;
///
/// // The no-copy, unsafe way, still using transmute, but not UB.
/// // This is equivalent to the original, but safer, and reuses the
- /// // same Vec internals. Therefore the new inner type must have the
+ /// // same `Vec` internals. Therefore, the new inner type must have the
/// // exact same size, and the same alignment, as the old type.
/// // The same caveats exist for this method as transmute, for
/// // the original inner type (`&i32`) to the converted inner type
/// ```
/// use std::{slice, mem};
///
- /// // There are multiple ways to do this; and there are multiple problems
- /// // with the following, transmute, way.
+ /// // There are multiple ways to do this, and there are multiple problems
+ /// // with the following (transmute) way.
/// fn split_at_mut_transmute<T>(slice: &mut [T], mid: usize)
/// -> (&mut [T], &mut [T]) {
/// let len = slice.len();
/// beginning at `dst` with the same size.
///
/// Like [`read`], `copy_nonoverlapping` creates a bitwise copy of `T`, regardless of
- /// whether `T` is [`Copy`]. If `T` is not [`Copy`], using *both* the values
+ /// whether `T` is [`Copy`]. If `T` is not [`Copy`], using *both* the values
/// in the region beginning at `*src` and the region beginning at `*dst` can
/// [violate memory safety][read-ownership].
///
/// [`copy_nonoverlapping`] can be used instead.
///
/// `copy` is semantically equivalent to C's [`memmove`], but with the argument
- /// order swapped. Copying takes place as if the bytes were copied from `src`
+ /// order swapped. Copying takes place as if the bytes were copied from `src`
/// to a temporary array and then copied from the array to `dst`.
///
/// [`copy_nonoverlapping`]: ./fn.copy_nonoverlapping.html
/// * Both `src` and `dst` must be properly aligned.
///
/// Like [`read`], `copy` creates a bitwise copy of `T`, regardless of
- /// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the values
+ /// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the values
/// in the region beginning at `*src` and the region beginning at `*dst` can
/// [violate memory safety][read-ownership].
///
/// unless size is equal to zero.
pub fn volatile_set_memory<T>(dst: *mut T, val: u8, count: usize);
- /// Perform a volatile load from the `src` pointer.
+ /// Performs a volatile load from the `src` pointer.
/// The stabilized version of this intrinsic is
/// [`std::ptr::read_volatile`](../../std/ptr/fn.read_volatile.html).
pub fn volatile_load<T>(src: *const T) -> T;
- /// Perform a volatile store to the `dst` pointer.
+ /// Performs a volatile store to the `dst` pointer.
/// The stabilized version of this intrinsic is
/// [`std::ptr::write_volatile`](../../std/ptr/fn.write_volatile.html).
pub fn volatile_store<T>(dst: *mut T, val: T);
- /// Perform a volatile load from the `src` pointer
+ /// Performs a volatile load from the `src` pointer
/// The pointer is not required to be aligned.
pub fn unaligned_volatile_load<T>(src: *const T) -> T;
- /// Perform a volatile store to the `dst` pointer.
+ /// Performs a volatile store to the `dst` pointer.
/// The pointer is not required to be aligned.
pub fn unaligned_volatile_store<T>(dst: *mut T, val: T);
/// without overflow.
fn steps_between(start: &Self, end: &Self) -> Option<usize>;
- /// Replaces this step with `1`, returning itself
+ /// Replaces this step with `1`, returning itself.
fn replace_one(&mut self) -> Self;
- /// Replaces this step with `0`, returning itself
+ /// Replaces this step with `0`, returning itself.
fn replace_zero(&mut self) -> Self;
- /// Adds one to this step, returning the result
+ /// Adds one to this step, returning the result.
fn add_one(&self) -> Self;
- /// Subtracts one to this step, returning the result
+ /// Subtracts one to this step, returning the result.
fn sub_one(&self) -> Self;
- /// Add an usize, returning None on overflow
+ /// Adds a `usize`, returning `None` on overflow.
fn add_usize(&self, n: usize) -> Option<Self>;
}
lower
}
- /// Returns whether the iterator is empty.
+ /// Returns `true` if the iterator is empty.
///
/// This method has a default implementation using `self.len()`, so you
/// don't need to implement it yourself.
/// // ... and then None once it's over.
/// assert_eq!(None, iter.next());
///
- /// // More calls may or may not return None. Here, they always will.
+ /// // More calls may or may not return `None`. Here, they always will.
/// assert_eq!(None, iter.next());
/// assert_eq!(None, iter.next());
/// ```
/// Calls a closure on each element of an iterator.
///
/// This is equivalent to using a [`for`] loop on the iterator, although
- /// `break` and `continue` are not possible from a closure. It's generally
+ /// `break` and `continue` are not possible from a closure. It's generally
/// more idiomatic to use a `for` loop, but `for_each` may be more legible
- /// when processing items at the end of longer iterator chains. In some
+ /// when processing items at the end of longer iterator chains. In some
/// cases `for_each` may also be faster than a loop, because it will use
/// internal iteration on adaptors like `Chain`.
///
/// assert_eq!(iter.next(), Some(4));
/// assert_eq!(iter.next(), None);
///
- /// // it will always return None after the first time.
+ /// // it will always return `None` after the first time.
/// assert_eq!(iter.next(), None);
/// assert_eq!(iter.next(), None);
/// assert_eq!(iter.next(), None);
/// is propagated back to the caller immediately (short-circuiting).
///
/// The initial value is the value the accumulator will have on the first
- /// call. If applying the closure succeeded against every element of the
+ /// call. If applying the closure succeeded against every element of the
/// iterator, `try_fold()` returns the final accumulator as success.
///
/// Folding is useful whenever you have a collection of something, and want
/// do something better than the default `for` loop implementation.
///
/// In particular, try to have this call `try_fold()` on the internal parts
- /// from which this iterator is composed. If multiple calls are needed,
+ /// from which this iterator is composed. If multiple calls are needed,
/// the `?` operator may be convenient for chaining the accumulator value
/// along, but beware any invariants that need to be upheld before those
- /// early returns. This is a `&mut self` method, so iteration needs to be
+ /// early returns. This is a `&mut self` method, so iteration needs to be
/// resumable after hitting an error here.
///
/// # Examples
//! often generated by LLVM. Additionally, this library can make explicit
//! calls to these functions. Their signatures are the same as found in C.
//! These functions are often provided by the system libc, but can also be
-//! provided by the [rlibc crate](https://crates.io/crates/rlibc).
+//! provided by the [compiler-builtins crate](https://crates.io/crates/compiler_builtins).
//!
//! * `rust_begin_panic` - This function takes four arguments, a
//! `fmt::Arguments`, a `&'static str`, and two `u32`'s. These four arguments
#![feature(simd_ffi)]
#![feature(specialization)]
#![feature(staged_api)]
+#![feature(std_internals)]
#![feature(stmt_expr_attributes)]
#![feature(unboxed_closures)]
#![feature(unsized_locals)]
// `core_arch` depends on libcore, but the contents of this module are
// set up in such a way that directly pulling it here works such that the
// crate uses the this crate as its libcore.
-#[allow(unused_macros)]
-macro_rules! test_v16 { ($item:item) => {}; }
-#[allow(unused_macros)]
-macro_rules! test_v32 { ($item:item) => {}; }
-#[allow(unused_macros)]
-macro_rules! test_v64 { ($item:item) => {}; }
-#[allow(unused_macros)]
-macro_rules! test_v128 { ($item:item) => {}; }
-#[allow(unused_macros)]
-macro_rules! test_v256 { ($item:item) => {}; }
-#[allow(unused_macros)]
-macro_rules! test_v512 { ($item:item) => {}; }
-#[allow(unused_macros)]
-macro_rules! vector_impl { ($([$f:ident, $($args:tt)*]),*) => { $($f!($($args)*);)* } }
#[path = "../stdsimd/crates/core_arch/src/mod.rs"]
#[allow(missing_docs, missing_debug_implementations, dead_code, unused_imports)]
#[unstable(feature = "stdsimd", issue = "48556")]
-/// Entry point of thread panic, for details, see std::macros
+/// Entry point of thread panic. For details, see `std::macros`.
#[macro_export]
-#[allow_internal_unstable]
+#[cfg_attr(not(stage0), allow_internal_unstable(core_panic, __rust_unstable_column))]
+#[cfg_attr(stage0, allow_internal_unstable)]
#[stable(feature = "core", since = "1.6.0")]
macro_rules! panic {
() => (
match (&$left, &$right) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
+ // The reborrows below are intentional. Without them, the stack slot for the
+ // borrow is initialized even before the values are compared, leading to a
+ // noticeable slow down.
panic!(r#"assertion failed: `(left == right)`
left: `{:?}`,
- right: `{:?}`"#, left_val, right_val)
+ right: `{:?}`"#, &*left_val, &*right_val)
}
}
}
match (&($left), &($right)) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
+ // The reborrows below are intentional. Without them, the stack slot for the
+ // borrow is initialized even before the values are compared, leading to a
+ // noticeable slow down.
panic!(r#"assertion failed: `(left == right)`
left: `{:?}`,
- right: `{:?}`: {}"#, left_val, right_val,
+ right: `{:?}`: {}"#, &*left_val, &*right_val,
format_args!($($arg)+))
}
}
match (&$left, &$right) {
(left_val, right_val) => {
if *left_val == *right_val {
+ // The reborrows below are intentional. Without them, the stack slot for the
+ // borrow is initialized even before the values are compared, leading to a
+ // noticeable slow down.
panic!(r#"assertion failed: `(left != right)`
left: `{:?}`,
- right: `{:?}`"#, left_val, right_val)
+ right: `{:?}`"#, &*left_val, &*right_val)
}
}
}
match (&($left), &($right)) {
(left_val, right_val) => {
if *left_val == *right_val {
+ // The reborrows below are intentional. Without them, the stack slot for the
+ // borrow is initialized even before the values are compared, leading to a
+ // noticeable slow down.
panic!(r#"assertion failed: `(left != right)`
left: `{:?}`,
- right: `{:?}`: {}"#, left_val, right_val,
+ right: `{:?}`: {}"#, &*left_val, &*right_val,
format_args!($($arg)+))
}
}
/// ```
#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow_internal_unstable]
+#[cfg_attr(stage0, allow_internal_unstable)]
+#[cfg_attr(not(stage0), allow_internal_unstable(format_args_nl))]
macro_rules! writeln {
($dst:expr) => (
write!($dst, "\n")
/// * Iterators that dynamically terminate.
///
/// If the determination that the code is unreachable proves incorrect, the
-/// program immediately terminates with a [`panic!`]. The function [`unreachable_unchecked`],
+/// program immediately terminates with a [`panic!`]. The function [`unreachable_unchecked`],
/// which belongs to the [`std::hint`] module, informs the compiler to
/// optimize the code out of the release version entirely.
///
/// A standardized placeholder for marking unfinished code.
///
/// This can be useful if you are prototyping and are just looking to have your
-/// code typecheck, or if you're implementing a trait that requires multiple
+/// code type-check, or if you're implementing a trait that requires multiple
/// methods, and you're only planning on using one of them.
///
/// # Panics
#[macro_export]
#[unstable(feature = "maybe_uninit", issue = "53491")]
macro_rules! uninitialized_array {
- // This `into_inner` is safe because an array of `MaybeUninit` does not
+ // This `into_initialized` is safe because an array of `MaybeUninit` does not
// require initialization.
// FIXME(#49147): Could be replaced by an array initializer, once those can
// be any const expression.
($t:ty; $size:expr) => (unsafe {
- MaybeUninit::<[MaybeUninit<$t>; $size]>::uninitialized().into_inner()
+ MaybeUninit::<[MaybeUninit<$t>; $size]>::uninitialized().into_initialized()
});
}
/// // be made into an object
/// ```
///
-/// [trait object]: ../../book/first-edition/trait-objects.html
+/// [trait object]: ../../book/ch17-02-trait-objects.html
#[stable(feature = "rust1", since = "1.0.0")]
#[lang = "sized"]
#[rustc_on_unimplemented(
/// types. We track the Rust type using a phantom type parameter on
/// the struct `ExternalResource` which wraps a handle.
///
-/// [FFI]: ../../book/first-edition/ffi.html
+/// [FFI]: ../../book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code
///
/// ```
/// # #![allow(dead_code)]
/// Returns the size of the pointed-to value in bytes.
///
/// This is usually the same as `size_of::<T>()`. However, when `T` *has* no
-/// statically known size, e.g., a slice [`[T]`][slice] or a [trait object],
+/// statically-known size, e.g., a slice [`[T]`][slice] or a [trait object],
/// then `size_of_val` can be used to get the dynamically-known size.
///
/// [slice]: ../../std/primitive.slice.html
-/// [trait object]: ../../book/first-edition/trait-objects.html
+/// [trait object]: ../../book/ch17-02-trait-objects.html
///
/// # Examples
///
unsafe { intrinsics::min_align_of_val(val) }
}
-/// Returns whether dropping values of type `T` matters.
+/// Returns `true` if dropping values of type `T` matters.
///
/// This is purely an optimization hint, and may be implemented conservatively:
/// it may return `true` for types that don't actually need to be dropped.
ManuallyDrop { value }
}
- /// Extract the value from the `ManuallyDrop` container.
+ /// Extracts the value from the `ManuallyDrop` container.
///
/// This allows the value to be dropped again.
///
}
}
-/// A newtype to construct uninitialized instances of `T`
+/// A newtype to construct uninitialized instances of `T`.
+///
+/// The compiler, in general, assumes that variables are properly initialized
+/// at their respective type. For example, a variable of reference type must
+/// be aligned and non-NULL. This is an invariant that must *always* be upheld,
+/// even in unsafe code. As a consequence, zero-initializing a variable of reference
+/// type causes instantaneous undefined behavior, no matter whether that reference
+/// ever gets used to access memory:
+///
+/// ```rust,no_run
+/// use std::mem;
+///
+/// let x: &i32 = unsafe { mem::zeroed() }; // undefined behavior!
+/// ```
+///
+/// This is exploited by the compiler for various optimizations, such as eliding
+/// run-time checks and optimizing `enum` layout.
+///
+/// Not initializing memory at all (instead of zero--initializing it) causes the same
+/// issue: after all, the initial value of the variable might just happen to be
+/// one that violates the invariant.
+///
+/// `MaybeUninit` serves to enable unsafe code to deal with uninitialized data:
+/// it is a signal to the compiler indicating that the data here might *not*
+/// be initialized:
+///
+/// ```rust
+/// #![feature(maybe_uninit)]
+/// use std::mem::MaybeUninit;
+///
+/// // Create an explicitly uninitialized reference.
+/// let mut x = MaybeUninit::<&i32>::uninitialized();
+/// // Set it to a valid value.
+/// x.set(&0);
+/// // Extract the initialized data -- this is only allowed *after* properly
+/// // initializing `x`!
+/// let x = unsafe { x.into_initialized() };
+/// ```
+///
+/// The compiler then knows to not optimize this code.
#[allow(missing_debug_implementations)]
#[unstable(feature = "maybe_uninit", issue = "53491")]
// NOTE after stabilizing `MaybeUninit` proceed to deprecate `mem::{uninitialized,zeroed}`
MaybeUninit { value: ManuallyDrop::new(val) }
}
- /// Create a new `MaybeUninit` in an uninitialized state.
+ /// Creates a new `MaybeUninit` in an uninitialized state.
///
/// Note that dropping a `MaybeUninit` will never call `T`'s drop code.
/// It is your responsibility to make sure `T` gets dropped if it got initialized.
MaybeUninit { uninit: () }
}
- /// Create a new `MaybeUninit` in an uninitialized state, with the memory being
- /// filled with `0` bytes. It depends on `T` whether that already makes for
+ /// Creates a new `MaybeUninit` in an uninitialized state, with the memory being
+ /// filled with `0` bytes. It depends on `T` whether that already makes for
/// proper initialization. For example, `MaybeUninit<usize>::zeroed()` is initialized,
/// but `MaybeUninit<&'static i32>::zeroed()` is not because references must not
/// be null.
u
}
- /// Set the value of the `MaybeUninit`. This overwrites any previous value without dropping it.
+ /// Sets the value of the `MaybeUninit`. This overwrites any previous value without dropping it.
+ /// For your convenience, this also returns a mutable reference to the (now safely initialized)
+ /// contents of `self`.
#[unstable(feature = "maybe_uninit", issue = "53491")]
#[inline(always)]
- pub fn set(&mut self, val: T) {
+ pub fn set(&mut self, val: T) -> &mut T {
unsafe {
self.value = ManuallyDrop::new(val);
+ self.get_mut()
}
}
- /// Extract the value from the `MaybeUninit` container. This is a great way
+ /// Extracts the value from the `MaybeUninit` container. This is a great way
/// to ensure that the data will get dropped, because the resulting `T` is
/// subject to the usual drop handling.
///
/// state, otherwise this will immediately cause undefined behavior.
#[unstable(feature = "maybe_uninit", issue = "53491")]
#[inline(always)]
- pub unsafe fn into_inner(self) -> T {
+ pub unsafe fn into_initialized(self) -> T {
intrinsics::panic_if_uninhabited::<T>();
ManuallyDrop::into_inner(self.value)
}
- /// Get a reference to the contained value.
+ /// Deprecated alternative to `into_initialized`. Will never get stabilized.
+ /// Exists only to transition stdsimd to `into_initialized`.
+ #[inline(always)]
+ #[allow(unused)]
+ pub(crate) unsafe fn into_inner(self) -> T {
+ self.into_initialized()
+ }
+
+ /// Gets a reference to the contained value.
///
/// # Unsafety
///
&*self.value
}
- /// Get a mutable reference to the contained value.
+ /// Gets a mutable reference to the contained value.
///
/// # Unsafety
///
&mut *self.value
}
- /// Get a pointer to the contained value. Reading from this pointer will be undefined
- /// behavior unless the `MaybeUninit` is initialized.
+ /// Gets a pointer to the contained value. Reading from this pointer or turning it
+ /// into a reference will be undefined behavior unless the `MaybeUninit` is initialized.
#[unstable(feature = "maybe_uninit", issue = "53491")]
#[inline(always)]
pub fn as_ptr(&self) -> *const T {
unsafe { &*self.value as *const T }
}
- /// Get a mutable pointer to the contained value. Reading from this pointer will be undefined
- /// behavior unless the `MaybeUninit` is initialized.
+ /// Get sa mutable pointer to the contained value. Reading from this pointer or turning it
+ /// into a reference will be undefined behavior unless the `MaybeUninit` is initialized.
#[unstable(feature = "maybe_uninit", issue = "53491")]
#[inline(always)]
pub fn as_mut_ptr(&mut self) -> *mut T {
unsafe { &mut *self.value as *mut T }
}
- /// Get a pointer to the first element of the array.
+ /// Gets a pointer to the first element of the array.
#[unstable(feature = "maybe_uninit", issue = "53491")]
#[inline(always)]
pub fn first_ptr(this: &[MaybeUninit<T>]) -> *const T {
this as *const [MaybeUninit<T>] as *const T
}
- /// Get a mutable pointer to the first element of the array.
+ /// Gets a mutable pointer to the first element of the array.
#[unstable(feature = "maybe_uninit", issue = "53491")]
#[inline(always)]
pub fn first_ptr_mut(this: &mut [MaybeUninit<T>]) -> *mut T {
unsafe { asm!("fldcw $0" :: "m" (cw) :: "volatile") }
}
- /// Set the precision field of the FPU to `T` and return a `FPUControlWord`
+ /// Sets the precision field of the FPU to `T` and returns a `FPUControlWord`.
pub fn set_precision<T>() -> FPUControlWord {
let cw = 0u16;
//!
//! In addition, there are numerous helper functions that are used in the paper but not available
//! in Rust (or at least in core). Our version is additionally complicated by the need to handle
-//! overflow and underflow and the desire to handle subnormal numbers. Bellerophon and
+//! overflow and underflow and the desire to handle subnormal numbers. Bellerophon and
//! Algorithm R have trouble with overflow, subnormals, and underflow. We conservatively switch to
//! Algorithm M (with the modifications described in section 8 of the paper) well before the
//! inputs get into the critical region.
//! operations as well, if you want 0.5 ULP accuracy you need to do *everything* in full precision
//! and round *exactly once, at the end*, by considering all truncated bits at once.
//!
-//! FIXME Although some code duplication is necessary, perhaps parts of the code could be shuffled
+//! FIXME: Although some code duplication is necessary, perhaps parts of the code could be shuffled
//! around such that less code is duplicated. Large parts of the algorithms are independent of the
//! float type to output, or only needs access to a few constants, which could be passed in as
//! parameters.
/// # Return value
///
/// `Err(ParseFloatError)` if the string did not represent a valid
- /// number. Otherwise, `Ok(n)` where `n` is the floating-point
+ /// number. Otherwise, `Ok(n)` where `n` is the floating-point
/// number represented by `src`.
#[inline]
fn from_str(src: &str) -> Result<Self, ParseFloatError> {
ParseFloatError { kind: FloatErrorKind::Invalid }
}
-/// Split decimal string into sign and the rest, without inspecting or validating the rest.
+/// Splits a decimal string into sign and the rest, without inspecting or validating the rest.
fn extract_sign(s: &str) -> (Sign, &str) {
match s.as_bytes()[0] {
b'+' => (Sign::Positive, &s[1..]),
}
}
-/// Convert a decimal string into a floating point number.
+/// Converts a decimal string into a floating point number.
fn dec2flt<T: RawFloat>(s: &str) -> Result<T, ParseFloatError> {
if s.is_empty() {
return Err(pfe_empty())
Equal
}
-/// Convert an ASCII string containing only decimal digits to a `u64`.
+/// Converts an ASCII string containing only decimal digits to a `u64`.
///
/// Does not perform checks for overflow or invalid characters, so if the caller is not careful,
/// the result is bogus and can panic (though it won't be `unsafe`). Additionally, empty strings
result
}
-/// Convert a string of ASCII digits into a bignum.
+/// Converts a string of ASCII digits into a bignum.
///
/// Like `from_str_unchecked`, this function relies on the parser to weed out non-digits.
pub fn digits_to_big(integral: &[u8], fractional: &[u8]) -> Big {
}
-/// Extract a range of bits.
+/// Extracts a range of bits.
/// Index 0 is the least significant bit and the range is half-open as usual.
/// Panics if asked to extract more bits than fit into the return type.
Invalid,
}
-/// Check if the input string is a valid floating point number and if so, locate the integral
+/// Checks if the input string is a valid floating point number and if so, locate the integral
/// part, the fractional part, and the exponent in it. Does not handle signs.
pub fn parse_decimal(s: &str) -> ParseResult {
if s.is_empty() {
/// Type used by `to_bits` and `from_bits`.
type Bits: Add<Output = Self::Bits> + From<u8> + TryFrom<u64>;
- /// Raw transmutation to integer.
+ /// Performs a raw transmutation to an integer.
fn to_bits(self) -> Self::Bits;
- /// Raw transmutation from integer.
+ /// Performs a raw transmutation from an integer.
fn from_bits(v: Self::Bits) -> Self;
/// Returns the category that this number falls into.
/// Returns the mantissa, exponent and sign as integers.
fn integer_decode(self) -> (u64, i16, i8);
- /// Decode the float.
+ /// Decodes the float.
fn unpack(self) -> Unpacked;
- /// Cast from a small integer that can be represented exactly. Panic if the integer can't be
+ /// Casts from a small integer that can be represented exactly. Panic if the integer can't be
/// represented, the other code in this module makes sure to never let that happen.
fn from_int(x: u64) -> Self;
- /// Get the value 10<sup>e</sup> from a pre-computed table.
+ /// Gets the value 10<sup>e</sup> from a pre-computed table.
/// Panics for `e >= CEIL_LOG5_OF_MAX_SIG`.
fn short_fast_pow10(e: usize) -> Self;
fn from_bits(v: Self::Bits) -> Self { Self::from_bits(v) }
}
-/// Convert an Fp to the closest machine float type.
+/// Converts an `Fp` to the closest machine float type.
/// Does not handle subnormal results.
pub fn fp_to_float<T: RawFloat>(x: Fp) -> T {
let x = x.normalize();
}
}
-/// Find the largest floating point number strictly smaller than the argument.
+/// Finds the largest floating point number strictly smaller than the argument.
/// Does not handle subnormals, zero, or exponent underflow.
pub fn prev_float<T: RawFloat>(x: T) -> T {
match x.classify() {
#[lang = "f32"]
#[cfg(not(test))]
impl f32 {
- /// Returns `true` if this value is `NaN` and false otherwise.
+ /// Returns `true` if this value is `NaN`.
///
/// ```
/// use std::f32;
f32::from_bits(self.to_bits() & 0x7fff_ffff)
}
- /// Returns `true` if this value is positive infinity or negative infinity and
- /// false otherwise.
+ /// Returns `true` if this value is positive infinity or negative infinity, and
+ /// `false` otherwise.
///
/// ```
/// use std::f32;
}
}
- /// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaN`s with
+ /// Returns `true` if `self` has a positive sign, including `+0.0`, `NaN`s with
/// positive sign bit and positive infinity.
///
/// ```
!self.is_sign_negative()
}
- /// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaN`s with
+ /// Returns `true` if `self` has a negative sign, including `-0.0`, `NaN`s with
/// negative sign bit and negative infinity.
///
/// ```
#[lang = "f64"]
#[cfg(not(test))]
impl f64 {
- /// Returns `true` if this value is `NaN` and false otherwise.
+ /// Returns `true` if this value is `NaN`.
///
/// ```
/// use std::f64;
f64::from_bits(self.to_bits() & 0x7fff_ffff_ffff_ffff)
}
- /// Returns `true` if this value is positive infinity or negative infinity and
- /// false otherwise.
+ /// Returns `true` if this value is positive infinity or negative infinity, and
+ /// `false` otherwise.
///
/// ```
/// use std::f64;
}
}
- /// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaN`s with
+ /// Returns `true` if `self` has a positive sign, including `+0.0`, `NaN`s with
/// positive sign bit and positive infinity.
///
/// ```
self.is_sign_positive()
}
- /// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaN`s with
+ /// Returns `true` if `self` has a negative sign, including `-0.0`, `NaN`s with
/// negative sign bit and negative infinity.
///
/// ```
}
impl $Ty {
- /// Create a non-zero without checking the value.
+ /// Creates a non-zero without checking the value.
///
/// # Safety
///
$Ty(n)
}
- /// Create a non-zero if the given value is not zero.
+ /// Creates a non-zero if the given value is not zero.
#[$stability]
#[inline]
pub fn new(n: $Int) -> Option<Self> {
```"),
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
+ #[cfg(stage0)]
pub fn saturating_add(self, rhs: Self) -> Self {
- #[cfg(stage0)]
match self.checked_add(rhs) {
Some(x) => x,
None if rhs >= 0 => Self::max_value(),
None => Self::min_value(),
}
- #[cfg(not(stage0))]
- {
- intrinsics::saturating_add(self, rhs)
- }
+ }
+
+ }
+
+ doc_comment! {
+ concat!("Saturating integer addition. Computes `self + rhs`, saturating at the numeric
+bounds instead of overflowing.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
+assert_eq!(", stringify!($SelfT), "::max_value().saturating_add(100), ", stringify!($SelfT),
+"::max_value());",
+$EndFeature, "
+```"),
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[rustc_const_unstable(feature = "const_saturating_int_methods")]
+ #[inline]
+ #[cfg(not(stage0))]
+ pub const fn saturating_add(self, rhs: Self) -> Self {
+ intrinsics::saturating_add(self, rhs)
}
}
```"),
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
+ #[cfg(stage0)]
pub fn saturating_sub(self, rhs: Self) -> Self {
- #[cfg(stage0)]
match self.checked_sub(rhs) {
Some(x) => x,
None if rhs >= 0 => Self::min_value(),
None => Self::max_value(),
}
- #[cfg(not(stage0))]
- {
- intrinsics::saturating_sub(self, rhs)
- }
+ }
+ }
+
+ doc_comment! {
+ concat!("Saturating integer subtraction. Computes `self - rhs`, saturating at the
+numeric bounds instead of overflowing.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_sub(127), -27);
+assert_eq!(", stringify!($SelfT), "::min_value().saturating_sub(100), ", stringify!($SelfT),
+"::min_value());",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[rustc_const_unstable(feature = "const_saturating_int_methods")]
+ #[inline]
+ #[cfg(not(stage0))]
+ pub const fn saturating_sub(self, rhs: Self) -> Self {
+ intrinsics::saturating_sub(self, rhs)
}
}
```"),
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
+ #[cfg(stage0)]
pub fn saturating_add(self, rhs: Self) -> Self {
- #[cfg(stage0)]
match self.checked_add(rhs) {
Some(x) => x,
None => Self::max_value(),
}
- #[cfg(not(stage0))]
- {
- intrinsics::saturating_add(self, rhs)
- }
+ }
+ }
+
+ doc_comment! {
+ concat!("Saturating integer addition. Computes `self + rhs`, saturating at
+the numeric bounds instead of overflowing.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
+assert_eq!(200u8.saturating_add(127), 255);", $EndFeature, "
+```"),
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[rustc_const_unstable(feature = "const_saturating_int_methods")]
+ #[inline]
+ #[cfg(not(stage0))]
+ pub const fn saturating_add(self, rhs: Self) -> Self {
+ intrinsics::saturating_add(self, rhs)
}
}
```"),
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
+ #[cfg(stage0)]
pub fn saturating_sub(self, rhs: Self) -> Self {
- #[cfg(stage0)]
match self.checked_sub(rhs) {
Some(x) => x,
None => Self::min_value(),
}
- #[cfg(not(stage0))]
- {
- intrinsics::saturating_sub(self, rhs)
- }
+ }
+ }
+
+ doc_comment! {
+ concat!("Saturating integer subtraction. Computes `self - rhs`, saturating
+at the numeric bounds instead of overflowing.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_sub(27), 73);
+assert_eq!(13", stringify!($SelfT), ".saturating_sub(127), 0);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[rustc_const_unstable(feature = "const_saturating_int_methods")]
+ #[inline]
+ #[cfg(not(stage0))]
+ pub const fn saturating_sub(self, rhs: Self) -> Self {
+ intrinsics::saturating_sub(self, rhs)
}
}
/// }
///
/// // Notice that the implementation uses the associated type `Output`.
-/// impl<T: Add<Output=T>> Add for Point<T> {
+/// impl<T: Add<Output = T>> Add for Point<T> {
/// type Output = Point<T>;
///
/// fn add(self, other: Point<T>) -> Point<T> {
/// }
///
/// // Notice that the implementation uses the associated type `Output`.
-/// impl<T: Sub<Output=T>> Sub for Point<T> {
+/// impl<T: Sub<Output = T>> Sub for Point<T> {
/// type Output = Point<T>;
///
/// fn sub(self, other: Point<T>) -> Point<T> {
macro_rules! rem_impl_integer {
($($t:ty)*) => ($(
- /// This operation satisfies `n % d == n - (n / d) * d`. The
+ /// This operation satisfies `n % d == n - (n / d) * d`. The
/// result has the same sign as the left operand.
#[stable(feature = "rust1", since = "1.0.0")]
impl Rem for $t {
label="expected an `Fn<{Args}>` closure, found `{Self}`",
)]
#[fundamental] // so that regex can rely that `&str: !FnMut`
-#[must_use]
+#[must_use = "closures are lazy and do nothing unless called"]
pub trait Fn<Args> : FnMut<Args> {
/// Performs the call operation.
#[unstable(feature = "fn_traits", issue = "29625")]
label="expected an `FnMut<{Args}>` closure, found `{Self}`",
)]
#[fundamental] // so that regex can rely that `&str: !FnMut`
-#[must_use]
+#[must_use = "closures are lazy and do nothing unless called"]
pub trait FnMut<Args> : FnOnce<Args> {
/// Performs the call operation.
#[unstable(feature = "fn_traits", issue = "29625")]
label="expected an `FnOnce<{Args}>` closure, found `{Self}`",
)]
#[fundamental] // so that regex can rely that `&str: !FnMut`
-#[must_use]
+#[must_use = "closures are lazy and do nothing unless called"]
pub trait FnOnce<Args> {
/// The returned type after the call operator is used.
#[stable(feature = "fn_once_output", since = "1.12.0")]
/// (`start..end`).
///
/// The `Range` `start..end` contains all values with `x >= start` and
-/// `x < end`. It is empty unless `start < end`.
+/// `x < end`. It is empty unless `start < end`.
///
/// # Examples
///
/// A range bounded inclusively below and above (`start..=end`).
///
/// The `RangeInclusive` `start..=end` contains all values with `x >= start`
-/// and `x <= end`. It is empty unless `start <= end`.
+/// and `x <= end`. It is empty unless `start <= end`.
///
/// This iterator is [fused], but the specific values of `start` and `end` after
/// iteration has finished are **unspecified** other than that [`.is_empty()`]
/// A trait for customizing the behavior of the `?` operator.
///
/// A type implementing `Try` is one that has a canonical way to view it
-/// in terms of a success/failure dichotomy. This trait allows both
+/// in terms of a success/failure dichotomy. This trait allows both
/// extracting those success or failure values from an existing instance and
/// creating a new instance from a success or failure value.
#[unstable(feature = "try_trait", issue = "42327")]
///
/// # Examples
///
- /// Convert an `Option<`[`String`]`>` into an `Option<`[`usize`]`>`, preserving the original.
+ /// Converts an `Option<`[`String`]`>` into an `Option<`[`usize`]`>`, preserving the original.
/// The [`map`] method takes the `self` argument by value, consuming the original,
/// so this technique uses `as_ref` to first take an `Option` to a reference
/// to the value inside the original.
///
/// # Examples
///
- /// Convert an `Option<`[`String`]`>` into an `Option<`[`usize`]`>`, consuming the original:
+ /// Converts an `Option<`[`String`]`>` into an `Option<`[`usize`]`>`, consuming the original:
///
/// [`String`]: ../../std/string/struct.String.html
/// [`usize`]: ../../std/primitive.usize.html
///
/// # Examples
///
- /// Convert a string to an integer, turning poorly-formed strings
+ /// Converts a string to an integer, turning poorly-formed strings
/// into 0 (the default value for integers). [`parse`] converts
/// a string to any other type that implements [`FromStr`], returning
/// [`None`] on error.
Pin { pointer }
}
- /// Get a pinned shared reference from this pinned pointer.
+ /// Gets a pinned shared reference from this pinned pointer.
#[stable(feature = "pin", since = "1.33.0")]
#[inline(always)]
pub fn as_ref(self: &Pin<P>) -> Pin<&P::Target> {
}
impl<P: DerefMut> Pin<P> {
- /// Get a pinned mutable reference from this pinned pointer.
+ /// Gets a pinned mutable reference from this pinned pointer.
#[stable(feature = "pin", since = "1.33.0")]
#[inline(always)]
pub fn as_mut(self: &mut Pin<P>) -> Pin<&mut P::Target> {
Pin::new_unchecked(new_pointer)
}
- /// Get a shared reference out of a pin.
+ /// Gets a shared reference out of a pin.
///
/// Note: `Pin` also implements `Deref` to the target, which can be used
/// to access the inner value. However, `Deref` only provides a reference
}
impl<'a, T: ?Sized> Pin<&'a mut T> {
- /// Convert this `Pin<&mut T>` into a `Pin<&T>` with the same lifetime.
+ /// Converts this `Pin<&mut T>` into a `Pin<&T>` with the same lifetime.
#[stable(feature = "pin", since = "1.33.0")]
#[inline(always)]
pub fn into_ref(self: Pin<&'a mut T>) -> Pin<&'a T> {
Pin { pointer: self.pointer }
}
- /// Get a mutable reference to the data inside of this `Pin`.
+ /// Gets a mutable reference to the data inside of this `Pin`.
///
/// This requires that the data inside this `Pin` is `Unpin`.
///
self.pointer
}
- /// Get a mutable reference to the data inside of this `Pin`.
+ /// Gets a mutable reference to the data inside of this `Pin`.
///
/// # Safety
///
//! to access only a single value, in which case the documentation omits the size
//! and implicitly assumes it to be `size_of::<T>()` bytes.
//!
-//! The precise rules for validity are not determined yet. The guarantees that are
+//! The precise rules for validity are not determined yet. The guarantees that are
//! provided at this point are very minimal:
//!
//! * A [null] pointer is *never* valid, not even for accesses of [size zero][zst].
///
/// * `to_drop` must be [valid] for reads.
///
-/// * `to_drop` must be properly aligned. See the example below for how to drop
+/// * `to_drop` must be properly aligned. See the example below for how to drop
/// an unaligned pointer.
///
/// Additionally, if `T` is not [`Copy`], using the pointed-to value after
/// unsafe {
/// // Get a raw pointer to the last element in `v`.
/// let ptr = &mut v[1] as *mut _;
-/// // Shorten `v` to prevent the last item from being dropped. We do that first,
+/// // Shorten `v` to prevent the last item from being dropped. We do that first,
/// // to prevent issues if the `drop_in_place` below panics.
/// v.set_len(1);
/// // Without a call `drop_in_place`, the last item would never be dropped,
///
/// `read` creates a bitwise copy of `T`, regardless of whether `T` is [`Copy`].
/// If `T` is not [`Copy`], using both the returned value and the value at
-/// `*src` can violate memory safety. Note that assigning to `*src` counts as a
+/// `*src` can violate memory safety. Note that assigning to `*src` counts as a
/// use because it will attempt to drop the value at `*src`.
///
/// [`write`] can be used to overwrite data without causing it to be dropped.
pub unsafe fn read<T>(src: *const T) -> T {
let mut tmp = MaybeUninit::<T>::uninitialized();
copy_nonoverlapping(src, tmp.as_mut_ptr(), 1);
- tmp.into_inner()
+ tmp.into_initialized()
}
/// Reads the value from `src` without moving it. This leaves the
/// * `src` must be [valid] for reads.
///
/// Like [`read`], `read_unaligned` creates a bitwise copy of `T`, regardless of
-/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned
+/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned
/// value and the value at `*src` can [violate memory safety][read-ownership].
///
/// Note that even if `T` has size `0`, the pointer must be non-NULL.
copy_nonoverlapping(src as *const u8,
tmp.as_mut_ptr() as *mut u8,
mem::size_of::<T>());
- tmp.into_inner()
+ tmp.into_initialized()
}
/// Overwrites a memory location with the given value without reading or
///
/// The compiler shouldn't change the relative order or number of volatile
/// memory operations. However, volatile memory operations on zero-sized types
-/// (e.g., if a zero-sized type is passed to `read_volatile`) are no-ops
+/// (e.g., if a zero-sized type is passed to `read_volatile`) are noops
/// and may be ignored.
///
/// [c11]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
/// * `src` must be properly aligned.
///
/// Like [`read`], `read_unaligned` creates a bitwise copy of `T`, regardless of
-/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned
+/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned
/// value and the value at `*src` can [violate memory safety][read-ownership].
/// However, storing non-[`Copy`] types in volatile memory is almost certainly
/// incorrect.
///
/// The compiler shouldn't change the relative order or number of volatile
/// memory operations. However, volatile memory operations on zero-sized types
-/// (e.g., if a zero-sized type is passed to `write_volatile`) are no-ops
+/// (e.g., if a zero-sized type is passed to `write_volatile`) are noops
/// and may be ignored.
///
/// [c11]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
/// unless `x` and `y` point into the same allocated object.
///
/// Always use `.offset(count)` instead when possible, because `offset`
- /// allows the compiler to optimize better. If you need to cross object
+ /// allows the compiler to optimize better. If you need to cross object
/// boundaries, cast the pointer to an integer and do the arithmetic there.
///
/// # Examples
/// unless `x` and `y` point into the same allocated object.
///
/// Always use `.offset(count)` instead when possible, because `offset`
- /// allows the compiler to optimize better. If you need to cross object
+ /// allows the compiler to optimize better. If you need to cross object
/// boundaries, cast the pointer to an integer and do the arithmetic there.
///
/// # Examples
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> Eq for *mut T {}
-/// Compare raw pointers for equality.
+/// Compares raw pointers for equality.
///
/// This is the same as using the `==` operator, but less generic:
/// the arguments have to be `*const T` raw pointers,
///
/// # Examples
///
- /// Convert a string to an integer, turning poorly-formed strings
+ /// Converts a string to an integer, turning poorly-formed strings
/// into 0 (the default value for integers). [`parse`] converts
/// a string to any other type that implements [`FromStr`], returning an
/// [`Err`] on error.
const LO_USIZE: usize = LO_U64 as usize;
const HI_USIZE: usize = HI_U64 as usize;
-/// Returns whether `x` contains any zero byte.
+/// Returns `true` if `x` contains any zero byte.
///
/// From *Matters Computational*, J. Arndt:
///
/// Returns an iterator over subslices separated by elements that match
/// `pred` limited to returning at most `n` items. This starts at the end of
- /// the slice and works backwards. The matched element is not contained in
+ /// the slice and works backwards. The matched element is not contained in
/// the subslices.
///
/// The last element returned, if any, will contain the remainder of the
/// randomization to avoid degenerate cases, but with a fixed seed to always provide
/// deterministic behavior.
///
+ /// Due to its key calling strategy, [`sort_unstable_by_key`](#method.sort_unstable_by_key)
+ /// is likely to be slower than [`sort_by_cached_key`](#method.sort_by_cached_key) in
+ /// cases where the key function is expensive.
+ ///
/// # Examples
///
/// ```
unsafe impl<T: Sync> Send for Iter<'_, T> {}
impl<'a, T> Iter<'a, T> {
- /// View the underlying data as a subslice of the original data.
+ /// Views the underlying data as a subslice of the original data.
///
/// This has the same lifetime as the original slice, and so the
/// iterator can continue to be used while this exists.
unsafe impl<T: Send> Send for IterMut<'_, T> {}
impl<'a, T> IterMut<'a, T> {
- /// View the underlying data as a subslice of the original data.
+ /// Views the underlying data as a subslice of the original data.
///
/// To avoid creating `&mut` references that alias, this is forced
/// to consume the iterator.
}
impl<'a, T> ChunksExact<'a, T> {
- /// Return the remainder of the original slice that is not going to be
+ /// Returns the remainder of the original slice that is not going to be
/// returned by the iterator. The returned slice has at most `chunk_size-1`
/// elements.
#[stable(feature = "chunks_exact", since = "1.31.0")]
}
impl<'a, T> ChunksExactMut<'a, T> {
- /// Return the remainder of the original slice that is not going to be
+ /// Returns the remainder of the original slice that is not going to be
/// returned by the iterator. The returned slice has at most `chunk_size-1`
/// elements.
#[stable(feature = "chunks_exact", since = "1.31.0")]
}
impl<'a, T> RChunksExact<'a, T> {
- /// Return the remainder of the original slice that is not going to be
+ /// Returns the remainder of the original slice that is not going to be
/// returned by the iterator. The returned slice has at most `chunk_size-1`
/// elements.
#[stable(feature = "rchunks", since = "1.31.0")]
}
impl<'a, T> RChunksExactMut<'a, T> {
- /// Return the remainder of the original slice that is not going to be
+ /// Returns the remainder of the original slice that is not going to be
/// returned by the iterator. The returned slice has at most `chunk_size-1`
/// elements.
#[stable(feature = "rchunks", since = "1.31.0")]
}
/// Rotates the range `[mid-left, mid+right)` such that the element at `mid`
-/// becomes the first element. Equivalently, rotates the range `left`
+/// becomes the first element. Equivalently, rotates the range `left`
/// elements to the left or `right` elements to the right.
///
/// # Safety
/// # Algorithm
///
/// For longer rotations, swap the left-most `delta = min(left, right)`
-/// elements with the right-most `delta` elements. LLVM vectorizes this,
+/// elements with the right-most `delta` elements. LLVM vectorizes this,
/// which is profitable as we only reach this step for a "large enough"
-/// rotation. Doing this puts `delta` elements on the larger side into the
-/// correct position, leaving a smaller rotate problem. Demonstration:
+/// rotation. Doing this puts `delta` elements on the larger side into the
+/// correct position, leaving a smaller rotate problem. Demonstration:
///
/// ```text
/// [ 6 7 8 9 10 11 12 13 . 1 2 3 4 5 ]
-//! String manipulation
+//! String manipulation.
//!
-//! For more details, see std::str
+//! For more details, see the `std::str` module.
#![stable(feature = "rust1", since = "1.0.0")]
use self::pattern::{Searcher, ReverseSearcher, DoubleEndedSearcher};
use char;
-use fmt;
+use fmt::{self, Write};
use iter::{Map, Cloned, FusedIterator, TrustedLen, TrustedRandomAccess, Filter};
+use iter::{Flatten, FlatMap, Chain};
use slice::{self, SliceIndex, Split as SliceSplit};
use mem;
+use ops::Try;
+use option;
pub mod pattern;
#[stable(feature = "utf8_error", since = "1.5.0")]
pub fn valid_up_to(&self) -> usize { self.valid_up_to }
- /// Provide more information about the failure:
+ /// Provides more information about the failure:
///
/// * `None`: the end of the input was reached unexpectedly.
/// `self.valid_up_to()` is 1 to 3 bytes from the end of the input.
impl FusedIterator for Chars<'_> {}
impl<'a> Chars<'a> {
- /// View the underlying data as a subslice of the original data.
+ /// Views the underlying data as a subslice of the original data.
///
/// This has the same lifetime as the original slice, and so the
/// iterator can continue to be used while this exists.
impl FusedIterator for CharIndices<'_> {}
impl<'a> CharIndices<'a> {
- /// View the underlying data as a subslice of the original data.
+ /// Views the underlying data as a subslice of the original data.
///
/// This has the same lifetime as the original slice, and so the
/// iterator can continue to be used while this exists.
#[allow(deprecated)]
pub struct LinesAny<'a>(Lines<'a>);
-/// A nameable, cloneable fn type
-#[derive(Clone)]
-struct LinesAnyMap;
-
-impl<'a> Fn<(&'a str,)> for LinesAnyMap {
- #[inline]
- extern "rust-call" fn call(&self, (line,): (&'a str,)) -> &'a str {
+impl_fn_for_zst! {
+ /// A nameable, cloneable fn type
+ #[derive(Clone)]
+ struct LinesAnyMap impl<'a> Fn = |line: &'a str| -> &'a str {
let l = line.len();
if l > 0 && line.as_bytes()[l - 1] == b'\r' { &line[0 .. l - 1] }
else { line }
- }
-}
-
-impl<'a> FnMut<(&'a str,)> for LinesAnyMap {
- #[inline]
- extern "rust-call" fn call_mut(&mut self, (line,): (&'a str,)) -> &'a str {
- Fn::call(&*self, (line,))
- }
-}
-
-impl<'a> FnOnce<(&'a str,)> for LinesAnyMap {
- type Output = &'a str;
-
- #[inline]
- extern "rust-call" fn call_once(self, (line,): (&'a str,)) -> &'a str {
- Fn::call(&self, (line,))
- }
+ };
}
#[stable(feature = "rust1", since = "1.0.0")]
/// Implements ordering of strings.
///
- /// Strings are ordered lexicographically by their byte values. This orders Unicode code
- /// points based on their positions in the code charts. This is not necessarily the same as
- /// "alphabetical" order, which varies by language and locale. Sorting strings according to
+ /// Strings are ordered lexicographically by their byte values. This orders Unicode code
+ /// points based on their positions in the code charts. This is not necessarily the same as
+ /// "alphabetical" order, which varies by language and locale. Sorting strings according to
/// culturally-accepted standards requires locale-specific data that is outside the scope of
/// the `str` type.
#[stable(feature = "rust1", since = "1.0.0")]
/// Implements comparison operations on strings.
///
- /// Strings are compared lexicographically by their byte values. This compares Unicode code
- /// points based on their positions in the code charts. This is not necessarily the same as
- /// "alphabetical" order, which varies by language and locale. Comparing strings according to
+ /// Strings are compared lexicographically by their byte values. This compares Unicode code
+ /// points based on their positions in the code charts. This is not necessarily the same as
+ /// "alphabetical" order, which varies by language and locale. Comparing strings according to
/// culturally-accepted standards requires locale-specific data that is outside the scope of
/// the `str` type.
#[stable(feature = "rust1", since = "1.0.0")]
}
#[inline]
unsafe fn get_unchecked_mut(self, slice: &mut str) -> &mut Self::Output {
- let ptr = slice.as_ptr().add(self.start);
+ let ptr = slice.as_mut_ptr().add(self.start);
let len = self.end - self.start;
- super::from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr as *mut u8, len))
+ super::from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr, len))
}
#[inline]
fn index(self, slice: &str) -> &Self::Output {
}
#[inline]
unsafe fn get_unchecked_mut(self, slice: &mut str) -> &mut Self::Output {
- let ptr = slice.as_ptr();
- super::from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr as *mut u8, self.end))
+ let ptr = slice.as_mut_ptr();
+ super::from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr, self.end))
}
#[inline]
fn index(self, slice: &str) -> &Self::Output {
}
#[inline]
unsafe fn get_unchecked_mut(self, slice: &mut str) -> &mut Self::Output {
- let ptr = slice.as_ptr().add(self.start);
+ let ptr = slice.as_mut_ptr().add(self.start);
let len = slice.len() - self.start;
- super::from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr as *mut u8, len))
+ super::from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr, len))
}
#[inline]
fn index(self, slice: &str) -> &Self::Output {
self as *const str as *const u8
}
+ /// Converts a mutable string slice to a raw pointer.
+ ///
+ /// As string slices are a slice of bytes, the raw pointer points to a
+ /// [`u8`]. This pointer will be pointing to the first byte of the string
+ /// slice.
+ ///
+ /// It is your responsibility to make sure that the string slice only gets
+ /// modified in a way that it remains valid UTF-8.
+ ///
+ /// [`u8`]: primitive.u8.html
+ #[unstable(feature = "str_as_mut_ptr", issue = "58215")]
+ #[inline]
+ pub fn as_mut_ptr(&mut self) -> *mut u8 {
+ self as *mut str as *mut u8
+ }
+
/// Returns a subslice of `str`.
///
/// This is the non-panicking alternative to indexing the `str`. Returns
// is_char_boundary checks that the index is in [0, .len()]
if self.is_char_boundary(mid) {
let len = self.len();
- let ptr = self.as_ptr() as *mut u8;
+ let ptr = self.as_mut_ptr();
unsafe {
(from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr, mid)),
from_utf8_unchecked_mut(slice::from_raw_parts_mut(
Bytes(self.as_bytes().iter().cloned())
}
- /// Split a string slice by whitespace.
+ /// Splits a string slice by whitespace.
///
/// The iterator returned will return string slices that are sub-slices of
/// the original string slice, separated by any amount of whitespace.
SplitWhitespace { inner: self.split(IsWhitespace).filter(IsNotEmpty) }
}
- /// Split a string slice by ASCII whitespace.
+ /// Splits a string slice by ASCII whitespace.
///
/// The iterator returned will return string slices that are sub-slices of
/// the original string slice, separated by any amount of ASCII whitespace.
let inner = self
.as_bytes()
.split(IsAsciiWhitespace)
- .filter(IsNotEmpty)
+ .filter(BytesIsNotEmpty)
.map(UnsafeBytesToStr);
SplitAsciiWhitespace { inner }
}
///
/// A string is a sequence of bytes. `start` in this context means the first
/// position of that byte string; for a left-to-right language like English or
- /// Russian, this will be left side; and for right-to-left languages like
+ /// Russian, this will be left side, and for right-to-left languages like
/// like Arabic or Hebrew, this will be the right side.
///
/// # Examples
///
/// A string is a sequence of bytes. `end` in this context means the last
/// position of that byte string; for a left-to-right language like English or
- /// Russian, this will be right side; and for right-to-left languages like
+ /// Russian, this will be right side, and for right-to-left languages like
/// like Arabic or Hebrew, this will be the left side.
///
/// # Examples
///
/// A string is a sequence of bytes. `start` in this context means the first
/// position of that byte string; for a left-to-right language like English or
- /// Russian, this will be left side; and for right-to-left languages like
+ /// Russian, this will be left side, and for right-to-left languages like
/// like Arabic or Hebrew, this will be the right side.
///
/// # Examples
///
/// A string is a sequence of bytes. `end` in this context means the last
/// position of that byte string; for a left-to-right language like English or
- /// Russian, this will be right side; and for right-to-left languages like
+ /// Russian, this will be right side, and for right-to-left languages like
/// like Arabic or Hebrew, this will be the left side.
///
/// # Examples
let me = unsafe { self.as_bytes_mut() };
me.make_ascii_lowercase()
}
+
+ /// Return an iterator that escapes each char in `s` with [`char::escape_debug`].
+ ///
+ /// Note: only extended grapheme codepoints that begin the string will be
+ /// escaped.
+ ///
+ /// [`char::escape_debug`]: ../std/primitive.char.html#method.escape_debug
+ ///
+ /// # Examples
+ ///
+ /// As an iterator:
+ ///
+ /// ```
+ /// for c in "❤\n!".escape_debug() {
+ /// print!("{}", c);
+ /// }
+ /// println!();
+ /// ```
+ ///
+ /// Using `println!` directly:
+ ///
+ /// ```
+ /// println!("{}", "❤\n!".escape_debug());
+ /// ```
+ ///
+ ///
+ /// Both are equivalent to:
+ ///
+ /// ```
+ /// println!("❤\\n!");
+ /// ```
+ ///
+ /// Using `to_string`:
+ ///
+ /// ```
+ /// assert_eq!("❤\n!".escape_debug().to_string(), "❤\\n!");
+ /// ```
+ #[stable(feature = "str_escape", since = "1.34.0")]
+ pub fn escape_debug(&self) -> EscapeDebug {
+ let mut chars = self.chars();
+ EscapeDebug {
+ inner: chars.next()
+ .map(|first| first.escape_debug_ext(true))
+ .into_iter()
+ .flatten()
+ .chain(chars.flat_map(CharEscapeDebugContinue))
+ }
+ }
+
+ /// Return an iterator that escapes each char in `s` with [`char::escape_default`].
+ ///
+ /// [`char::escape_default`]: ../std/primitive.char.html#method.escape_default
+ ///
+ /// # Examples
+ ///
+ /// As an iterator:
+ ///
+ /// ```
+ /// for c in "❤\n!".escape_default() {
+ /// print!("{}", c);
+ /// }
+ /// println!();
+ /// ```
+ ///
+ /// Using `println!` directly:
+ ///
+ /// ```
+ /// println!("{}", "❤\n!".escape_default());
+ /// ```
+ ///
+ ///
+ /// Both are equivalent to:
+ ///
+ /// ```
+ /// println!("\\u{{2764}}\n!");
+ /// ```
+ ///
+ /// Using `to_string`:
+ ///
+ /// ```
+ /// assert_eq!("❤\n!".escape_default().to_string(), "\\u{2764}\\n!");
+ /// ```
+ #[stable(feature = "str_escape", since = "1.34.0")]
+ pub fn escape_default(&self) -> EscapeDefault {
+ EscapeDefault { inner: self.chars().flat_map(CharEscapeDefault) }
+ }
+
+ /// Return an iterator that escapes each char in `s` with [`char::escape_unicode`].
+ ///
+ /// [`char::escape_unicode`]: ../std/primitive.char.html#method.escape_unicode
+ ///
+ /// # Examples
+ ///
+ /// As an iterator:
+ ///
+ /// ```
+ /// for c in "❤\n!".escape_unicode() {
+ /// print!("{}", c);
+ /// }
+ /// println!();
+ /// ```
+ ///
+ /// Using `println!` directly:
+ ///
+ /// ```
+ /// println!("{}", "❤\n!".escape_unicode());
+ /// ```
+ ///
+ ///
+ /// Both are equivalent to:
+ ///
+ /// ```
+ /// println!("\\u{{2764}}\\u{{a}}\\u{{21}}");
+ /// ```
+ ///
+ /// Using `to_string`:
+ ///
+ /// ```
+ /// assert_eq!("❤\n!".escape_unicode().to_string(), "\\u{2764}\\u{a}\\u{21}");
+ /// ```
+ #[stable(feature = "str_escape", since = "1.34.0")]
+ pub fn escape_unicode(&self) -> EscapeUnicode {
+ EscapeUnicode { inner: self.chars().flat_map(CharEscapeUnicode) }
+ }
+}
+
+impl_fn_for_zst! {
+ #[derive(Clone)]
+ struct CharEscapeDebugContinue impl Fn = |c: char| -> char::EscapeDebug {
+ c.escape_debug_ext(false)
+ };
+
+ #[derive(Clone)]
+ struct CharEscapeUnicode impl Fn = |c: char| -> char::EscapeUnicode {
+ c.escape_unicode()
+ };
+ #[derive(Clone)]
+ struct CharEscapeDefault impl Fn = |c: char| -> char::EscapeDefault {
+ c.escape_default()
+ };
}
#[stable(feature = "rust1", since = "1.0.0")]
#[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
#[derive(Clone, Debug)]
pub struct SplitAsciiWhitespace<'a> {
- inner: Map<Filter<SliceSplit<'a, u8, IsAsciiWhitespace>, IsNotEmpty>, UnsafeBytesToStr>,
-}
-
-#[derive(Clone)]
-struct IsWhitespace;
-
-impl FnOnce<(char, )> for IsWhitespace {
- type Output = bool;
-
- #[inline]
- extern "rust-call" fn call_once(mut self, arg: (char, )) -> bool {
- self.call_mut(arg)
- }
-}
-
-impl FnMut<(char, )> for IsWhitespace {
- #[inline]
- extern "rust-call" fn call_mut(&mut self, arg: (char, )) -> bool {
- arg.0.is_whitespace()
- }
-}
-
-#[derive(Clone)]
-struct IsAsciiWhitespace;
-
-impl<'a> FnOnce<(&'a u8, )> for IsAsciiWhitespace {
- type Output = bool;
-
- #[inline]
- extern "rust-call" fn call_once(mut self, arg: (&u8, )) -> bool {
- self.call_mut(arg)
- }
-}
-
-impl<'a> FnMut<(&'a u8, )> for IsAsciiWhitespace {
- #[inline]
- extern "rust-call" fn call_mut(&mut self, arg: (&u8, )) -> bool {
- arg.0.is_ascii_whitespace()
- }
-}
-
-#[derive(Clone)]
-struct IsNotEmpty;
-
-impl<'a, 'b> FnOnce<(&'a &'b str, )> for IsNotEmpty {
- type Output = bool;
-
- #[inline]
- extern "rust-call" fn call_once(mut self, arg: (&'a &'b str, )) -> bool {
- self.call_mut(arg)
- }
-}
-
-impl<'a, 'b> FnMut<(&'a &'b str, )> for IsNotEmpty {
- #[inline]
- extern "rust-call" fn call_mut(&mut self, arg: (&'a &'b str, )) -> bool {
- !arg.0.is_empty()
- }
-}
-
-impl<'a, 'b> FnOnce<(&'a &'b [u8], )> for IsNotEmpty {
- type Output = bool;
-
- #[inline]
- extern "rust-call" fn call_once(mut self, arg: (&'a &'b [u8], )) -> bool {
- self.call_mut(arg)
- }
+ inner: Map<Filter<SliceSplit<'a, u8, IsAsciiWhitespace>, BytesIsNotEmpty>, UnsafeBytesToStr>,
}
-impl<'a, 'b> FnMut<(&'a &'b [u8], )> for IsNotEmpty {
- #[inline]
- extern "rust-call" fn call_mut(&mut self, arg: (&'a &'b [u8], )) -> bool {
- !arg.0.is_empty()
- }
-}
+impl_fn_for_zst! {
+ #[derive(Clone)]
+ struct IsWhitespace impl Fn = |c: char| -> bool {
+ c.is_whitespace()
+ };
-#[derive(Clone)]
-struct UnsafeBytesToStr;
+ #[derive(Clone)]
+ struct IsAsciiWhitespace impl Fn = |byte: &u8| -> bool {
+ byte.is_ascii_whitespace()
+ };
-impl<'a> FnOnce<(&'a [u8], )> for UnsafeBytesToStr {
- type Output = &'a str;
+ #[derive(Clone)]
+ struct IsNotEmpty impl<'a, 'b> Fn = |s: &'a &'b str| -> bool {
+ !s.is_empty()
+ };
- #[inline]
- extern "rust-call" fn call_once(mut self, arg: (&'a [u8], )) -> &'a str {
- self.call_mut(arg)
- }
-}
+ #[derive(Clone)]
+ struct BytesIsNotEmpty impl<'a, 'b> Fn = |s: &'a &'b [u8]| -> bool {
+ !s.is_empty()
+ };
-impl<'a> FnMut<(&'a [u8], )> for UnsafeBytesToStr {
- #[inline]
- extern "rust-call" fn call_mut(&mut self, arg: (&'a [u8], )) -> &'a str {
- unsafe { from_utf8_unchecked(arg.0) }
- }
+ #[derive(Clone)]
+ struct UnsafeBytesToStr impl<'a> Fn = |bytes: &'a [u8]| -> &'a str {
+ unsafe { from_utf8_unchecked(bytes) }
+ };
}
-
#[stable(feature = "split_whitespace", since = "1.1.0")]
impl<'a> Iterator for SplitWhitespace<'a> {
type Item = &'a str;
#[stable(feature = "fused", since = "1.26.0")]
impl FusedIterator for EncodeUtf16<'_> {}
+
+/// The return type of [`str::escape_debug`].
+///
+/// [`str::escape_debug`]: ../../std/primitive.str.html#method.escape_debug
+#[stable(feature = "str_escape", since = "1.34.0")]
+#[derive(Clone, Debug)]
+pub struct EscapeDebug<'a> {
+ inner: Chain<
+ Flatten<option::IntoIter<char::EscapeDebug>>,
+ FlatMap<Chars<'a>, char::EscapeDebug, CharEscapeDebugContinue>
+ >,
+}
+
+/// The return type of [`str::escape_default`].
+///
+/// [`str::escape_default`]: ../../std/primitive.str.html#method.escape_default
+#[stable(feature = "str_escape", since = "1.34.0")]
+#[derive(Clone, Debug)]
+pub struct EscapeDefault<'a> {
+ inner: FlatMap<Chars<'a>, char::EscapeDefault, CharEscapeDefault>,
+}
+
+/// The return type of [`str::escape_unicode`].
+///
+/// [`str::escape_unicode`]: ../../std/primitive.str.html#method.escape_unicode
+#[stable(feature = "str_escape", since = "1.34.0")]
+#[derive(Clone, Debug)]
+pub struct EscapeUnicode<'a> {
+ inner: FlatMap<Chars<'a>, char::EscapeUnicode, CharEscapeUnicode>,
+}
+
+macro_rules! escape_types_impls {
+ ($( $Name: ident ),+) => {$(
+ #[stable(feature = "str_escape", since = "1.34.0")]
+ impl<'a> fmt::Display for $Name<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.clone().try_for_each(|c| f.write_char(c))
+ }
+ }
+
+ #[stable(feature = "str_escape", since = "1.34.0")]
+ impl<'a> Iterator for $Name<'a> {
+ type Item = char;
+
+ #[inline]
+ fn next(&mut self) -> Option<char> { self.inner.next() }
+
+ #[inline]
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+
+ #[inline]
+ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
+ Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
+ {
+ self.inner.try_fold(init, fold)
+ }
+
+ #[inline]
+ fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
+ where Fold: FnMut(Acc, Self::Item) -> Acc,
+ {
+ self.inner.fold(init, fold)
+ }
+ }
+
+ #[stable(feature = "str_escape", since = "1.34.0")]
+ impl<'a> FusedIterator for $Name<'a> {}
+ )+}
+}
+
+escape_types_impls!(EscapeDebug, EscapeDefault, EscapeUnicode);
//! The string Pattern API.
//!
-//! For more details, see the traits `Pattern`, `Searcher`,
-//! `ReverseSearcher` and `DoubleEndedSearcher`.
+//! For more details, see the traits [`Pattern`], [`Searcher`],
+//! [`ReverseSearcher`], and [`DoubleEndedSearcher`].
#![unstable(feature = "pattern",
reason = "API not fully fleshed out and ready to be stabilized",
/// `[Reject(0, 1), Reject(1, 2), Match(2, 5), Reject(5, 8)]`
fn next(&mut self) -> SearchStep;
- /// Find the next `Match` result. See `next()`
+ /// Finds the next `Match` result. See `next()`
///
/// Unlike next(), there is no guarantee that the returned ranges
/// of this and next_reject will overlap. This will return (start_match, end_match),
}
}
- /// Find the next `Reject` result. See `next()` and `next_match()`
+ /// Finds the next `Reject` result. See `next()` and `next_match()`
///
/// Unlike next(), there is no guarantee that the returned ranges
/// of this and next_match will overlap.
/// `[Reject(7, 8), Match(4, 7), Reject(1, 4), Reject(0, 1)]`
fn next_back(&mut self) -> SearchStep;
- /// Find the next `Match` result. See `next_back()`
+ /// Finds the next `Match` result. See `next_back()`
#[inline]
fn next_match_back(&mut self) -> Option<(usize, usize)>{
loop {
}
}
- /// Find the next `Reject` result. See `next_back()`
+ /// Finds the next `Reject` result. See `next_back()`
#[inline]
fn next_reject_back(&mut self) -> Option<(usize, usize)>{
loop {
pub use self::poll::Poll;
mod wake;
-pub use self::wake::{Waker, LocalWaker, UnsafeWake};
+pub use self::wake::{Waker, RawWaker, RawWakerVTable};
}
impl<T> Poll<T> {
- /// Change the ready value of this `Poll` with the closure provided
+ /// Changes the ready value of this `Poll` with the closure provided.
pub fn map<U, F>(self, f: F) -> Poll<U>
where F: FnOnce(T) -> U
{
}
}
- /// Returns whether this is `Poll::Ready`
+ /// Returns `true` if this is `Poll::Ready`
#[inline]
pub fn is_ready(&self) -> bool {
match *self {
}
}
- /// Returns whether this is `Poll::Pending`
+ /// Returns `true` if this is `Poll::Pending`
#[inline]
pub fn is_pending(&self) -> bool {
!self.is_ready()
}
impl<T, E> Poll<Result<T, E>> {
- /// Change the success value of this `Poll` with the closure provided
+ /// Changes the success value of this `Poll` with the closure provided.
pub fn map_ok<U, F>(self, f: F) -> Poll<Result<U, E>>
where F: FnOnce(T) -> U
{
}
}
- /// Change the error value of this `Poll` with the closure provided
+ /// Changes the error value of this `Poll` with the closure provided.
pub fn map_err<U, F>(self, f: F) -> Poll<Result<T, U>>
where F: FnOnce(E) -> U
{
use fmt;
use marker::Unpin;
-use ptr::NonNull;
+
+/// A `RawWaker` allows the implementor of a task executor to create a [`Waker`]
+/// which provides customized wakeup behavior.
+///
+/// [vtable]: https://en.wikipedia.org/wiki/Virtual_method_table
+///
+/// It consists of a data pointer and a [virtual function pointer table (vtable)][vtable] that
+/// customizes the behavior of the `RawWaker`.
+#[derive(PartialEq, Debug)]
+pub struct RawWaker {
+ /// A data pointer, which can be used to store arbitrary data as required
+ /// by the executor. This could be e.g. a type-erased pointer to an `Arc`
+ /// that is associated with the task.
+ /// The value of this field gets passed to all functions that are part of
+ /// the vtable as the first parameter.
+ data: *const (),
+ /// Virtual function pointer table that customizes the behavior of this waker.
+ vtable: &'static RawWakerVTable,
+}
+
+impl RawWaker {
+ /// Creates a new `RawWaker` from the provided `data` pointer and `vtable`.
+ ///
+ /// The `data` pointer can be used to store arbitrary data as required
+ /// by the executor. This could be e.g. a type-erased pointer to an `Arc`
+ /// that is associated with the task.
+ /// The value of this poiner will get passed to all functions that are part
+ /// of the `vtable` as the first parameter.
+ ///
+ /// The `vtable` customizes the behavior of a `Waker` which gets created
+ /// from a `RawWaker`. For each operation on the `Waker`, the associated
+ /// function in the `vtable` of the underlying `RawWaker` will be called.
+ pub const fn new(data: *const (), vtable: &'static RawWakerVTable) -> RawWaker {
+ RawWaker {
+ data,
+ vtable,
+ }
+ }
+}
+
+/// A virtual function pointer table (vtable) that specifies the behavior
+/// of a [`RawWaker`].
+///
+/// The pointer passed to all functions inside the vtable is the `data` pointer
+/// from the enclosing [`RawWaker`] object.
+///
+/// The functions inside this struct are only intended be called on the `data`
+/// pointer of a properly constructed [`RawWaker`] object from inside the
+/// [`RawWaker`] implementation. Calling one of the contained functions using
+/// any other `data` pointer will cause undefined behavior.
+#[derive(PartialEq, Copy, Clone, Debug)]
+pub struct RawWakerVTable {
+ /// This function will be called when the [`RawWaker`] gets cloned, e.g. when
+ /// the [`Waker`] in which the [`RawWaker`] is stored gets cloned.
+ ///
+ /// The implementation of this function must retain all resources that are
+ /// required for this additional instance of a [`RawWaker`] and associated
+ /// task. Calling `wake` on the resulting [`RawWaker`] should result in a wakeup
+ /// of the same task that would have been awoken by the original [`RawWaker`].
+ pub clone: unsafe fn(*const ()) -> RawWaker,
+
+ /// This function will be called when `wake` is called on the [`Waker`].
+ /// It must wake up the task associated with this [`RawWaker`].
+ ///
+ /// The implemention of this function must not consume the provided data
+ /// pointer.
+ pub wake: unsafe fn(*const ()),
+
+ /// This function gets called when a [`RawWaker`] gets dropped.
+ ///
+ /// The implementation of this function must make sure to release any
+ /// resources that are associated with this instance of a [`RawWaker`] and
+ /// associated task.
+ pub drop: unsafe fn(*const ()),
+}
/// A `Waker` is a handle for waking up a task by notifying its executor that it
/// is ready to be run.
///
-/// This handle contains a trait object pointing to an instance of the `UnsafeWake`
-/// trait, allowing notifications to get routed through it.
+/// This handle encapsulates a [`RawWaker`] instance, which defines the
+/// executor-specific wakeup behavior.
+///
+/// Implements [`Clone`], [`Send`], and [`Sync`].
#[repr(transparent)]
pub struct Waker {
- inner: NonNull<dyn UnsafeWake>,
+ waker: RawWaker,
}
impl Unpin for Waker {}
unsafe impl Sync for Waker {}
impl Waker {
- /// Constructs a new `Waker` directly.
- ///
- /// Note that most code will not need to call this. Implementers of the
- /// `UnsafeWake` trait will typically provide a wrapper that calls this
- /// but you otherwise shouldn't call it directly.
- ///
- /// If you're working with the standard library then it's recommended to
- /// use the `Waker::from` function instead which works with the safe
- /// `Arc` type and the safe `Wake` trait.
- #[inline]
- pub unsafe fn new(inner: NonNull<dyn UnsafeWake>) -> Self {
- Waker { inner }
- }
-
/// Wake up the task associated with this `Waker`.
- #[inline]
pub fn wake(&self) {
- unsafe { self.inner.as_ref().wake() }
+ // The actual wakeup call is delegated through a virtual function call
+ // to the implementation which is defined by the executor.
+
+ // SAFETY: This is safe because `Waker::new_unchecked` is the only way
+ // to initialize `wake` and `data` requiring the user to acknowledge
+ // that the contract of `RawWaker` is upheld.
+ unsafe { (self.waker.vtable.wake)(self.waker.data) }
}
- /// Returns whether or not this `Waker` and `other` awaken the same task.
+ /// Returns whether or not this `Waker` and other `Waker` have awaken the same task.
///
/// This function works on a best-effort basis, and may return false even
/// when the `Waker`s would awaken the same task. However, if this function
- /// returns true, it is guaranteed that the `Waker`s will awaken the same
- /// task.
+ /// returns `true`, it is guaranteed that the `Waker`s will awaken the same task.
///
/// This function is primarily used for optimization purposes.
- #[inline]
pub fn will_wake(&self, other: &Waker) -> bool {
- self.inner == other.inner
+ self.waker == other.waker
}
- /// Returns whether or not this `Waker` and `other` `LocalWaker` awaken
- /// the same task.
+ /// Creates a new `Waker` from [`RawWaker`].
///
- /// This function works on a best-effort basis, and may return false even
- /// when the `Waker`s would awaken the same task. However, if this function
- /// returns true, it is guaranteed that the `Waker`s will awaken the same
- /// task.
- ///
- /// This function is primarily used for optimization purposes.
- #[inline]
- pub fn will_wake_local(&self, other: &LocalWaker) -> bool {
- self.will_wake(&other.0)
+ /// The behavior of the returned `Waker` is undefined if the contract defined
+ /// in [`RawWaker`]'s and [`RawWakerVTable`]'s documentation is not upheld.
+ /// Therefore this method is unsafe.
+ pub unsafe fn new_unchecked(waker: RawWaker) -> Waker {
+ Waker {
+ waker,
+ }
}
}
impl Clone for Waker {
- #[inline]
fn clone(&self) -> Self {
- unsafe {
- self.inner.as_ref().clone_raw()
+ Waker {
+ // SAFETY: This is safe because `Waker::new_unchecked` is the only way
+ // to initialize `clone` and `data` requiring the user to acknowledge
+ // that the contract of [`RawWaker`] is upheld.
+ waker: unsafe { (self.waker.vtable.clone)(self.waker.data) },
}
}
}
-impl fmt::Debug for Waker {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- f.debug_struct("Waker")
- .finish()
- }
-}
-
impl Drop for Waker {
- #[inline]
fn drop(&mut self) {
- unsafe {
- self.inner.as_ref().drop_raw()
- }
- }
-}
-
-/// A `LocalWaker` is a handle for waking up a task by notifying its executor that it
-/// is ready to be run.
-///
-/// This is similar to the `Waker` type, but cannot be sent across threads.
-/// Task executors can use this type to implement more optimized single-threaded wakeup
-/// behavior.
-#[repr(transparent)]
-#[derive(Clone)]
-pub struct LocalWaker(Waker);
-
-impl Unpin for LocalWaker {}
-impl !Send for LocalWaker {}
-impl !Sync for LocalWaker {}
-
-impl LocalWaker {
- /// Constructs a new `LocalWaker` directly.
- ///
- /// Note that most code will not need to call this. Implementers of the
- /// `UnsafeWake` trait will typically provide a wrapper that calls this
- /// but you otherwise shouldn't call it directly.
- ///
- /// If you're working with the standard library then it's recommended to
- /// use the `local_waker_from_nonlocal` or `local_waker` to convert a `Waker`
- /// into a `LocalWaker`.
- ///
- /// For this function to be used safely, it must be sound to call `inner.wake_local()`
- /// on the current thread.
- #[inline]
- pub unsafe fn new(inner: NonNull<dyn UnsafeWake>) -> Self {
- LocalWaker(Waker::new(inner))
- }
-
- /// Borrows this `LocalWaker` as a `Waker`.
- ///
- /// `Waker` is nearly identical to `LocalWaker`, but is threadsafe
- /// (implements `Send` and `Sync`).
- #[inline]
- pub fn as_waker(&self) -> &Waker {
- &self.0
- }
-
- /// Converts this `LocalWaker` into a `Waker`.
- ///
- /// `Waker` is nearly identical to `LocalWaker`, but is threadsafe
- /// (implements `Send` and `Sync`).
- #[inline]
- pub fn into_waker(self) -> Waker {
- self.0
- }
-
- /// Wake up the task associated with this `LocalWaker`.
- #[inline]
- pub fn wake(&self) {
- unsafe { self.0.inner.as_ref().wake_local() }
- }
-
- /// Returns whether or not this `LocalWaker` and `other` `LocalWaker` awaken the same task.
- ///
- /// This function works on a best-effort basis, and may return false even
- /// when the `LocalWaker`s would awaken the same task. However, if this function
- /// returns true, it is guaranteed that the `LocalWaker`s will awaken the same
- /// task.
- ///
- /// This function is primarily used for optimization purposes.
- #[inline]
- pub fn will_wake(&self, other: &LocalWaker) -> bool {
- self.0.will_wake(&other.0)
- }
-
- /// Returns whether or not this `LocalWaker` and `other` `Waker` awaken the same task.
- ///
- /// This function works on a best-effort basis, and may return false even
- /// when the `Waker`s would awaken the same task. However, if this function
- /// returns true, it is guaranteed that the `LocalWaker`s will awaken the same
- /// task.
- ///
- /// This function is primarily used for optimization purposes.
- #[inline]
- pub fn will_wake_nonlocal(&self, other: &Waker) -> bool {
- self.0.will_wake(other)
- }
-}
-
-impl From<LocalWaker> for Waker {
- /// Converts a `LocalWaker` into a `Waker`.
- ///
- /// This conversion turns a `!Sync` `LocalWaker` into a `Sync` `Waker`, allowing a wakeup
- /// object to be sent to another thread, but giving up its ability to do specialized
- /// thread-local wakeup behavior.
- #[inline]
- fn from(local_waker: LocalWaker) -> Self {
- local_waker.0
+ // SAFETY: This is safe because `Waker::new_unchecked` is the only way
+ // to initialize `drop` and `data` requiring the user to acknowledge
+ // that the contract of `RawWaker` is upheld.
+ unsafe { (self.waker.vtable.drop)(self.waker.data) }
}
}
-impl fmt::Debug for LocalWaker {
+impl fmt::Debug for Waker {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- f.debug_struct("LocalWaker")
+ let vtable_ptr = self.waker.vtable as *const RawWakerVTable;
+ f.debug_struct("Waker")
+ .field("data", &self.waker.data)
+ .field("vtable", &vtable_ptr)
.finish()
}
}
-
-/// An unsafe trait for implementing custom memory management for a `Waker` or `LocalWaker`.
-///
-/// A `Waker` conceptually is a cloneable trait object for `Wake`, and is
-/// most often essentially just `Arc<dyn Wake>`. However, in some contexts
-/// (particularly `no_std`), it's desirable to avoid `Arc` in favor of some
-/// custom memory management strategy. This trait is designed to allow for such
-/// customization.
-///
-/// When using `std`, a default implementation of the `UnsafeWake` trait is provided for
-/// `Arc<T>` where `T: Wake`.
-pub unsafe trait UnsafeWake: Send + Sync {
- /// Creates a clone of this `UnsafeWake` and stores it behind a `Waker`.
- ///
- /// This function will create a new uniquely owned handle that under the
- /// hood references the same notification instance. In other words calls
- /// to `wake` on the returned handle should be equivalent to calls to
- /// `wake` on this handle.
- ///
- /// # Unsafety
- ///
- /// This function is unsafe to call because it's asserting the `UnsafeWake`
- /// value is in a consistent state, i.e., hasn't been dropped.
- unsafe fn clone_raw(&self) -> Waker;
-
- /// Drops this instance of `UnsafeWake`, deallocating resources
- /// associated with it.
- ///
- /// FIXME(cramertj)
- /// This method is intended to have a signature such as:
- ///
- /// ```ignore (not-a-doctest)
- /// fn drop_raw(self: *mut Self);
- /// ```
- ///
- /// Unfortunately in Rust today that signature is not object safe.
- /// Nevertheless it's recommended to implement this function *as if* that
- /// were its signature. As such it is not safe to call on an invalid
- /// pointer, nor is the validity of the pointer guaranteed after this
- /// function returns.
- ///
- /// # Unsafety
- ///
- /// This function is unsafe to call because it's asserting the `UnsafeWake`
- /// value is in a consistent state, i.e., hasn't been dropped.
- unsafe fn drop_raw(&self);
-
- /// Indicates that the associated task is ready to make progress and should
- /// be `poll`ed.
- ///
- /// Executors generally maintain a queue of "ready" tasks; `wake` should place
- /// the associated task onto this queue.
- ///
- /// # Panics
- ///
- /// Implementations should avoid panicking, but clients should also be prepared
- /// for panics.
- ///
- /// # Unsafety
- ///
- /// This function is unsafe to call because it's asserting the `UnsafeWake`
- /// value is in a consistent state, i.e., hasn't been dropped.
- unsafe fn wake(&self);
-
- /// Indicates that the associated task is ready to make progress and should
- /// be `poll`ed. This function is the same as `wake`, but can only be called
- /// from the thread that this `UnsafeWake` is "local" to. This allows for
- /// implementors to provide specialized wakeup behavior specific to the current
- /// thread. This function is called by `LocalWaker::wake`.
- ///
- /// Executors generally maintain a queue of "ready" tasks; `wake_local` should place
- /// the associated task onto this queue.
- ///
- /// # Panics
- ///
- /// Implementations should avoid panicking, but clients should also be prepared
- /// for panics.
- ///
- /// # Unsafety
- ///
- /// This function is unsafe to call because it's asserting the `UnsafeWake`
- /// value is in a consistent state, i.e., hasn't been dropped, and that the
- /// `UnsafeWake` hasn't moved from the thread on which it was created.
- unsafe fn wake_local(&self) {
- self.wake()
- }
-}
+#![cfg(not(miri))]
+
use core::cell::*;
use core::default::Default;
use std::mem::drop;
+#![cfg(not(miri))]
+
mod builders;
mod float;
mod num;
+#![cfg(not(miri))]
+
mod sip;
use std::hash::{Hash, Hasher};
}
#[test]
+#[cfg(not(miri))]
fn test_iterator_step_by_nth() {
let mut it = (0..16).step_by(5);
assert_eq!(it.nth(0), Some(0));
}
#[test]
+#[cfg(not(miri))]
fn test_iterator_step_by_nth_overflow() {
#[cfg(target_pointer_width = "8")]
type Bigger = u16;
#[test]
#[should_panic]
+#[cfg(not(miri))]
fn test_iterator_step_by_zero() {
let mut it = (0..).step_by(0);
it.next();
}
#[test]
+#[cfg(not(miri))]
fn test_iterator_step_by_size_hint() {
struct StubSizeHint(usize, Option<usize>);
impl Iterator for StubSizeHint {
assert_eq!(i, ys.len());
}
-/// Test `FlatMap::fold` with items already picked off the front and back,
+/// Tests `FlatMap::fold` with items already picked off the front and back,
/// to make sure all parts of the `FlatMap` are folded correctly.
#[test]
fn test_iterator_flat_map_fold() {
assert_eq!(i, ys.len());
}
-/// Test `Flatten::fold` with items already picked off the front and back,
+/// Tests `Flatten::fold` with items already picked off the front and back,
/// to make sure all parts of the `Flatten` are folded correctly.
#[test]
fn test_iterator_flatten_fold() {
#[test]
#[should_panic]
+#[cfg(not(miri))]
fn test_rposition_panic() {
let v: [(Box<_>, Box<_>); 4] =
[(box 0, box 0), (box 0, box 0),
}
#[test]
+#[cfg(not(miri))]
fn test_range_step() {
#![allow(deprecated)]
}
#[test]
+#[cfg(not(miri))]
fn test_step_by_skip() {
assert_eq!((0..640).step_by(128).skip(1).collect::<Vec<_>>(), [128, 256, 384, 512]);
assert_eq!((0..=50).step_by(10).nth(3), Some(30));
}
#[test]
+#[cfg(not(miri))]
fn test_range_inclusive_step() {
assert_eq!((0..=50).step_by(10).collect::<Vec<_>>(), [0, 10, 20, 30, 40, 50]);
assert_eq!((0..=5).step_by(1).collect::<Vec<_>>(), [0, 1, 2, 3, 4, 5]);
+#![cfg(not(miri))]
+
use core::convert::{TryFrom, TryInto};
use core::cmp::PartialEq;
use core::fmt::Debug;
}
#[test] #[should_panic]
+#[cfg(not(miri))]
fn test_option_too_much_dance() {
struct A;
let mut y = Some(A);
#[test]
#[should_panic]
+#[cfg(not(miri))]
fn test_unwrap_panic1() {
let x: Option<isize> = None;
x.unwrap();
#[test]
#[should_panic]
+#[cfg(not(miri))]
fn test_unwrap_panic2() {
let x: Option<String> = None;
x.unwrap();
+#![cfg(not(miri))]
+
use core::ptr::*;
use core::cell::RefCell;
#[test]
#[should_panic]
+#[cfg(not(miri))]
pub fn test_unwrap_or_else_panic() {
fn handler(msg: &'static str) -> isize {
if msg == "I got this." {
}
#[test]
#[should_panic(expected="Got expected error: \"All good\"")]
+#[cfg(not(miri))]
pub fn test_expect_err() {
let err: Result<isize, &'static str> = Err("All good");
err.expect("Got expected error");
}
#[test]
#[should_panic(expected="Got expected ok: \"All good\"")]
+#[cfg(not(miri))]
pub fn test_expect_err_ok() {
let err: Result<&'static str, isize> = Ok("All good");
err.expect_err("Got expected ok");
// to be used in `should_panic`)
#[test]
#[should_panic(expected = "out of range")]
+ #[cfg(not(miri))]
fn assert_range_eq_can_fail_by_panic() {
assert_range_eq!([0, 1, 2], 0..5, [0, 1, 2]);
}
// to be used in `should_panic`)
#[test]
#[should_panic(expected = "==")]
+ #[cfg(not(miri))]
fn assert_range_eq_can_fail_by_inequality() {
assert_range_eq!([0, 1, 2], 0..2, [0, 1, 2]);
}
#[test]
#[should_panic(expected = $expect_msg)]
+ #[cfg(not(miri))]
fn index_fail() {
let v = $data;
let v: &[_] = &v;
#[test]
#[should_panic(expected = $expect_msg)]
+ #[cfg(not(miri))]
fn index_mut_fail() {
let mut v = $data;
let v: &mut [_] = &mut v;
#[test]
#[cfg(not(target_arch = "wasm32"))]
+#[cfg(not(miri))]
fn sort_unstable() {
use core::cmp::Ordering::{Equal, Greater, Less};
use core::slice::heapsort;
}
#[test]
+#[cfg(not(miri))]
fn test_align_to_simple() {
let bytes = [1u8, 2, 3, 4, 5, 6, 7];
let (prefix, aligned, suffix) = unsafe { bytes.align_to::<u16>() };
}
#[test]
+#[cfg(not(miri))]
fn test_align_to_zst() {
let bytes = [1, 2, 3, 4, 5, 6, 7];
let (prefix, aligned, suffix) = unsafe { bytes.align_to::<()>() };
}
#[test]
+#[cfg(not(miri))]
fn test_align_to_non_trivial() {
#[repr(align(8))] struct U64(u64, u64);
#[repr(align(8))] struct U64U64U32(u64, u64, u32);
}
#[test]
+#[cfg(not(miri))]
fn test_align_to_empty_mid() {
use core::mem;
#[test]
#[should_panic(expected = "src is out of bounds")]
+#[cfg(not(miri))]
fn test_copy_within_panics_src_too_long() {
let mut bytes = *b"Hello, World!";
// The length is only 13, so 14 is out of bounds.
#[test]
#[should_panic(expected = "dest is out of bounds")]
+#[cfg(not(miri))]
fn test_copy_within_panics_dest_too_long() {
let mut bytes = *b"Hello, World!";
// The length is only 13, so a slice of length 4 starting at index 10 is out of bounds.
}
#[test]
#[should_panic(expected = "src end is before src start")]
+#[cfg(not(miri))]
fn test_copy_within_panics_src_inverted() {
let mut bytes = *b"Hello, World!";
// 2 is greater than 1, so this range is invalid.
+#![cfg(not(miri))]
+
use core::time::Duration;
#[test]
/// timeouts.
///
/// Each `Duration` is composed of a whole number of seconds and a fractional part
-/// represented in nanoseconds. If the underlying system does not support
+/// represented in nanoseconds. If the underlying system does not support
/// nanosecond-level precision, APIs binding a system timeout will typically round up
/// the number of nanoseconds.
///
}
}
- /// Multiply `Duration` by `f64`.
+ /// Multiplies `Duration` by `f64`.
///
/// # Panics
/// This method will panic if result is not finite, negative or overflows `Duration`.
#![deny(rust_2018_idioms)]
+#![feature(nll)]
#![feature(rustc_private)]
pub use Piece::*;
#![deny(rust_2018_idioms)]
-#![feature(str_escape)]
+#![feature(nll)]
use LabelText::*;
/// digit (i.e., the regular expression `[a-zA-Z_][a-zA-Z_0-9]*`).
///
/// (Note: this format is a strict subset of the `ID` format
- /// defined by the DOT language. This function may change in the
+ /// defined by the DOT language. This function may change in the
/// future to accept a broader subset, or the entirety, of DOT's
/// `ID` format.)
///
}
/// Decomposes content into string suitable for making EscStr that
- /// yields same content as self. The result obeys the law
+ /// yields same content as self. The result obeys the law
/// render(`lt`) == render(`EscStr(lt.pre_escaped_content())`) for
/// all `lt: LabelText`.
fn pre_escaped_content(self) -> Cow<'a, str> {
EscStr(s) => s,
LabelStr(s) => {
if s.contains('\\') {
- (&*s).escape_default().into()
+ (&*s).escape_default().to_string().into()
} else {
s
}
#![feature(core_intrinsics)]
#![feature(libc)]
+#![feature(nll)]
#![feature(panic_runtime)]
#![feature(staged_api)]
#![feature(rustc_attrs)]
authors = ["The Rust Project Developers"]
name = "panic_unwind"
version = "0.0.0"
+edition = "2018"
[lib]
path = "lib.rs"
-//! Unwinding for wasm32
+//! Unwinding for *wasm32* target.
//!
-//! Right now we don't support this, so this is just stubs
+//! Right now we don't support this, so this is just stubs.
use alloc::boxed::Box;
use core::any::Any;
//! http://www.airs.com/blog/archives/464
//!
//! A reference implementation may be found in the GCC source tree
-//! (<root>/libgcc/unwind-c.c as of this writing)
+//! (`<root>/libgcc/unwind-c.c` as of this writing).
#![allow(non_upper_case_globals)]
#![allow(unused)]
-use dwarf::DwarfReader;
+use crate::dwarf::DwarfReader;
use core::mem;
pub const DW_EH_PE_omit: u8 = 0xFF;
pub const USING_SJLJ_EXCEPTIONS: bool = cfg!(all(target_os = "ios", target_arch = "arm"));
-pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext)
+pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext<'_>)
-> Result<EHAction, ()>
{
if lsda.is_null() {
}
unsafe fn read_encoded_pointer(reader: &mut DwarfReader,
- context: &EHContext,
+ context: &EHContext<'_>,
encoding: u8)
-> Result<usize, ()> {
if encoding == DW_EH_PE_omit {
//! Utilities for parsing DWARF-encoded data streams.
-//! See http://www.dwarfstd.org,
+//! See <http://www.dwarfstd.org>,
//! DWARF-4 standard, Section 7 - "Data Representation"
// This module is used only by x86_64-pc-windows-gnu for now, but we
-//! Unwinding for emscripten
+//! Unwinding for *emscripten* target.
//!
//! Whereas Rust's usual unwinding implementation for Unix platforms
-//! calls into the libunwind APIs directly, on emscripten we instead
+//! calls into the libunwind APIs directly, on Emscripten we instead
//! call into the C++ unwinding APIs. This is just an expedience since
-//! emscripten's runtime always implements those APIs and does not
+//! Emscripten's runtime always implements those APIs and does not
//! implement libunwind.
#![allow(private_no_mangle_fns)]
use core::any::Any;
use core::ptr;
+use core::mem;
use alloc::boxed::Box;
use libc::{self, c_int};
use unwind as uw;
-use core::mem;
pub fn payload() -> *mut u8 {
ptr::null_mut()
-//! Implementation of panics backed by libgcc/libunwind (in some form)
+//! Implementation of panics backed by libgcc/libunwind (in some form).
//!
//! For background on exception handling and stack unwinding please see
//! "Exception Handling in LLVM" (llvm.org/docs/ExceptionHandling.html) and
//!
//! In the search phase, the job of a personality routine is to examine
//! exception object being thrown, and to decide whether it should be caught at
-//! that stack frame. Once the handler frame has been identified, cleanup phase
+//! that stack frame. Once the handler frame has been identified, cleanup phase
//! begins.
//!
//! In the cleanup phase, the unwinder invokes each personality routine again.
//! This time it decides which (if any) cleanup code needs to be run for
-//! the current stack frame. If so, the control is transferred to a special
+//! the current stack frame. If so, the control is transferred to a special
//! branch in the function body, the "landing pad", which invokes destructors,
-//! frees memory, etc. At the end of the landing pad, control is transferred
+//! frees memory, etc. At the end of the landing pad, control is transferred
//! back to the unwinder and unwinding resumes.
//!
//! Once stack has been unwound down to the handler frame level, unwinding stops
//! ## `eh_personality` and `eh_unwind_resume`
//!
//! These language items are used by the compiler when generating unwind info.
-//! The first one is the personality routine described above. The second one
+//! The first one is the personality routine described above. The second one
//! allows compilation target to customize the process of resuming unwind at the
//! end of the landing pads. `eh_unwind_resume` is used only if
//! `custom_unwind_resume` flag in the target options is set.
use unwind as uw;
use libc::{c_int, uintptr_t};
-use dwarf::eh::{self, EHContext, EHAction};
+use crate::dwarf::eh::{self, EHContext, EHAction};
#[repr(C)]
struct Exception {
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/",
issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/")]
+#![deny(rust_2018_idioms)]
+
#![feature(allocator_api)]
#![feature(alloc)]
#![feature(core_intrinsics)]
#![panic_runtime]
#![feature(panic_runtime)]
-extern crate alloc;
-extern crate libc;
-#[cfg(not(any(target_env = "msvc", all(windows, target_arch = "x86_64", target_env = "gnu"))))]
-extern crate unwind;
-
use alloc::boxed::Box;
use core::intrinsics;
use core::mem;
vtable_ptr: *mut usize)
-> u32 {
let mut payload = imp::payload();
- if intrinsics::try(f, data, &mut payload as *mut _ as *mut _) == 0 {
+ if intrinsics::r#try(f, data, &mut payload as *mut _ as *mut _) == 0 {
0
} else {
let obj = mem::transmute::<_, raw::TraitObject>(imp::cleanup(payload));
use core::mem;
use core::raw;
-use windows as c;
+use crate::windows as c;
use libc::{c_int, c_uint};
// First up, a whole bunch of type definitions. There's a few platform-specific
#[lang = "eh_personality"]
#[cfg(not(test))]
fn rust_eh_personality() {
- unsafe { ::core::intrinsics::abort() }
+ unsafe { core::intrinsics::abort() }
}
use core::any::Any;
use core::intrinsics;
use core::ptr;
-use dwarf::eh::{EHContext, EHAction, find_eh_action};
-use windows as c;
+use crate::dwarf::eh::{EHContext, EHAction, find_eh_action};
+use crate::windows as c;
// Define our exception codes:
// according to http://msdn.microsoft.com/en-us/library/het71c37(v=VS.80).aspx,
ScopedCell(Cell::new(value))
}
- /// Set the value in `self` to `replacement` while
+ /// Sets the value in `self` to `replacement` while
/// running `f`, which gets the old value, mutably.
/// The old value will be restored after `f` exits, even
/// by panic, including modifications made to it by `f`.
f(RefMutL(put_back_on_drop.value.as_mut().unwrap()))
}
- /// Set the value in `self` to `value` while running `f`.
+ /// Sets the value in `self` to `value` while running `f`.
pub fn set<'a, R>(&self, value: <T as ApplyL<'a>>::Out, f: impl FnOnce() -> R) -> R {
self.replace(value, |_| f())
}
macro_rules! diagnostic_child_methods {
($spanned:ident, $regular:ident, $level:expr) => (
- /// Add a new child diagnostic message to `self` with the level
+ /// Adds a new child diagnostic message to `self` with the level
/// identified by this method's name with the given `spans` and
/// `message`.
#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
self
}
- /// Add a new child diagnostic message to `self` with the level
+ /// Adds a new child diagnostic message to `self` with the level
/// identified by this method's name with the given `message`.
#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
pub fn $regular<T: Into<String>>(mut self, message: T) -> Diagnostic {
#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
impl Diagnostic {
- /// Create a new diagnostic with the given `level` and `message`.
+ /// Creates a new diagnostic with the given `level` and `message`.
#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
pub fn new<T: Into<String>>(level: Level, message: T) -> Diagnostic {
Diagnostic {
}
}
- /// Create a new diagnostic with the given `level` and `message` pointing to
+ /// Creates a new diagnostic with the given `level` and `message` pointing to
/// the given set of `spans`.
#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
pub fn spanned<S, T>(spans: S, level: Level, message: T) -> Diagnostic
//! function-like macros `#[proc_macro]`, macro attributes `#[proc_macro_attribute]` and
//! custom derive attributes`#[proc_macro_derive]`.
//!
-//! See [the book](../book/first-edition/procedural-macros.html) for more.
+//! See [the book] for more.
+//!
+//! [the book]: ../book/ch19-06-macros.html#procedural-macros-for-generating-code-from-attributes
#![stable(feature = "proc_macro_lib", since = "1.15.0")]
#![deny(missing_docs)]
#![deny(rust_2018_idioms)]
+#![feature(nll)]
#![feature(staged_api)]
#![feature(const_fn)]
#![feature(extern_types)]
/// or characters not existing in the language.
/// All tokens in the parsed stream get `Span::call_site()` spans.
///
-/// NOTE: Some errors may cause panics instead of returning `LexError`. We reserve the right to
+/// NOTE: some errors may cause panics instead of returning `LexError`. We reserve the right to
/// change these errors into `LexError`s later.
#[stable(feature = "proc_macro_lib", since = "1.15.0")]
impl FromStr for TokenStream {
macro_rules! diagnostic_method {
($name:ident, $level:expr) => (
- /// Create a new `Diagnostic` with the given `message` at the span
+ /// Creates a new `Diagnostic` with the given `message` at the span
/// `self`.
#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
pub fn $name<T: Into<String>>(self, message: T) -> Diagnostic {
Span(self.0.source())
}
- /// Get the starting line/column in the source file for this span.
+ /// Gets the starting line/column in the source file for this span.
#[unstable(feature = "proc_macro_span", issue = "54725")]
pub fn start(&self) -> LineColumn {
self.0.start()
}
- /// Get the ending line/column in the source file for this span.
+ /// Gets the ending line/column in the source file for this span.
#[unstable(feature = "proc_macro_span", issue = "54725")]
pub fn end(&self) -> LineColumn {
self.0.end()
}
- /// Create a new span encompassing `self` and `other`.
+ /// Creates a new span encompassing `self` and `other`.
///
/// Returns `None` if `self` and `other` are from different files.
#[unstable(feature = "proc_macro_span", issue = "54725")]
pub struct SourceFile(bridge::client::SourceFile);
impl SourceFile {
- /// Get the path to this source file.
+ /// Gets the path to this source file.
///
/// ### Note
/// If the code span associated with this `SourceFile` was generated by an external macro, this
reason = "internal implementation detail of rustc right now",
issue = "0")]
#![allow(unused_features)]
+#![feature(nll)]
#![feature(staged_api)]
#![deny(rust_2018_idioms)]
rustc_apfloat = { path = "../librustc_apfloat" }
rustc_target = { path = "../librustc_target" }
rustc_data_structures = { path = "../librustc_data_structures" }
-rustc_errors = { path = "../librustc_errors" }
+errors = { path = "../librustc_errors", package = "rustc_errors" }
serialize = { path = "../libserialize" }
syntax = { path = "../libsyntax" }
syntax_pos = { path = "../libsyntax_pos" }
}
}
- /// True if all nodes always pass the filter.
+ /// Returns `true` if all nodes always pass the filter.
pub fn accepts_all(&self) -> bool {
self.text.is_empty()
}
}
}
- /// Create a new, parameterless DepNode. This method will assert
+ /// Creates a new, parameterless DepNode. This method will assert
/// that the DepNode corresponding to the given DepKind actually
/// does not require any parameters.
#[inline(always)]
}
}
- /// Extract the DefId corresponding to this DepNode. This will work
+ /// Extracts the DefId corresponding to this DepNode. This will work
/// if two conditions are met:
///
/// 1. The Fingerprint of the DepNode actually is a DefPathHash, and
}
/// A "work product" corresponds to a `.o` (or other) file that we
-/// save in between runs. These ids do not have a DefId but rather
+/// save in between runs. These IDs do not have a `DefId` but rather
/// some independent path or string that persists between runs without
/// the need to be mapped or unmapped. (This ensures we can serialize
/// them even in the absence of a tcx.)
///
/// Here, `[op]` represents whatever nodes `op` reads in the
/// course of execution; `Map(key)` represents the node for this
- /// map; and `CurrentTask` represents the current task when
+ /// map, and `CurrentTask` represents the current task when
/// `memoize` is invoked.
///
/// **Important:** when `op` is invoked, the current task will be
-use crate::errors::{Diagnostic, DiagnosticBuilder};
+use errors::{Diagnostic, DiagnosticBuilder};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
colors: DepNodeColorMap,
- /// A set of loaded diagnostics which has been emitted.
+ /// A set of loaded diagnostics that have been emitted.
emitted_diagnostics: Mutex<FxHashSet<DepNodeIndex>>,
/// Used to wait for diagnostics to be emitted.
emitted_diagnostics_cond_var: Condvar,
- /// When we load, there may be `.o` files, cached mir, or other such
+ /// When we load, there may be `.o` files, cached MIR, or other such
/// things available to us. If we find that they are not dirty, we
/// load the path to the file storing those work-products here into
/// this map. We can later look for and extract that data.
loaded_from_cache: Lock<FxHashMap<DepNodeIndex, bool>>,
}
+pub fn hash_result<R>(hcx: &mut StableHashingContext<'_>, result: &R) -> Option<Fingerprint>
+where
+ R: for<'a> HashStable<StableHashingContext<'a>>,
+{
+ let mut stable_hasher = StableHasher::new();
+ result.hash_stable(hcx, &mut stable_hasher);
+
+ Some(stable_hasher.finish())
+}
+
impl DepGraph {
pub fn new(prev_graph: PreviousDepGraph,
}
}
- /// True if we are actually building the full dep-graph.
+ /// Returns `true` if we are actually building the full dep-graph, and `false` otherwise.
#[inline]
pub fn is_fully_enabled(&self) -> bool {
self.data.is_some()
/// `arg` parameter.
///
/// [rustc guide]: https://rust-lang.github.io/rustc-guide/incremental-compilation.html
- pub fn with_task<'gcx, C, A, R>(&self,
- key: DepNode,
- cx: C,
- arg: A,
- task: fn(C, A) -> R)
- -> (R, DepNodeIndex)
- where C: DepGraphSafe + StableHashingContextProvider<'gcx>,
- R: HashStable<StableHashingContext<'gcx>>,
+ pub fn with_task<'a, C, A, R>(
+ &self,
+ key: DepNode,
+ cx: C,
+ arg: A,
+ task: fn(C, A) -> R,
+ hash_result: impl FnOnce(&mut StableHashingContext<'_>, &R) -> Option<Fingerprint>,
+ ) -> (R, DepNodeIndex)
+ where
+ C: DepGraphSafe + StableHashingContextProvider<'a>,
{
self.with_task_impl(key, cx, arg, false, task,
|_key| Some(TaskDeps {
}),
|data, key, fingerprint, task| {
data.borrow_mut().complete_task(key, task.unwrap(), fingerprint)
- })
+ },
+ hash_result)
}
/// Creates a new dep-graph input with value `input`
- pub fn input_task<'gcx, C, R>(&self,
+ pub fn input_task<'a, C, R>(&self,
key: DepNode,
cx: C,
input: R)
-> (R, DepNodeIndex)
- where C: DepGraphSafe + StableHashingContextProvider<'gcx>,
- R: HashStable<StableHashingContext<'gcx>>,
+ where C: DepGraphSafe + StableHashingContextProvider<'a>,
+ R: for<'b> HashStable<StableHashingContext<'b>>,
{
fn identity_fn<C, A>(_: C, arg: A) -> A {
arg
|_| None,
|data, key, fingerprint, _| {
data.borrow_mut().alloc_node(key, SmallVec::new(), fingerprint)
- })
+ },
+ hash_result::<R>)
}
- fn with_task_impl<'gcx, C, A, R>(
+ fn with_task_impl<'a, C, A, R>(
&self,
key: DepNode,
cx: C,
finish_task_and_alloc_depnode: fn(&Lock<CurrentDepGraph>,
DepNode,
Fingerprint,
- Option<TaskDeps>) -> DepNodeIndex
+ Option<TaskDeps>) -> DepNodeIndex,
+ hash_result: impl FnOnce(&mut StableHashingContext<'_>, &R) -> Option<Fingerprint>,
) -> (R, DepNodeIndex)
where
- C: DepGraphSafe + StableHashingContextProvider<'gcx>,
- R: HashStable<StableHashingContext<'gcx>>,
+ C: DepGraphSafe + StableHashingContextProvider<'a>,
{
if let Some(ref data) = self.data {
let task_deps = create_task(key).map(|deps| Lock::new(deps));
profq_msg(hcx.sess(), ProfileQueriesMsg::TaskEnd)
};
- let mut stable_hasher = StableHasher::new();
- result.hash_stable(&mut hcx, &mut stable_hasher);
-
- let current_fingerprint = stable_hasher.finish();
+ let current_fingerprint = hash_result(&mut hcx, &result);
let dep_node_index = finish_task_and_alloc_depnode(
&data.current,
key,
- current_fingerprint,
+ current_fingerprint.unwrap_or(Fingerprint::ZERO),
task_deps.map(|lock| lock.into_inner()),
);
+ let print_status = cfg!(debug_assertions) && hcx.sess().opts.debugging_opts.dep_tasks;
+
// Determine the color of the new DepNode.
if let Some(prev_index) = data.previous.node_to_index_opt(&key) {
let prev_fingerprint = data.previous.fingerprint_by_index(prev_index);
- let color = if current_fingerprint == prev_fingerprint {
- DepNodeColor::Green(dep_node_index)
+ let color = if let Some(current_fingerprint) = current_fingerprint {
+ if current_fingerprint == prev_fingerprint {
+ if print_status {
+ eprintln!("[task::green] {:?}", key);
+ }
+ DepNodeColor::Green(dep_node_index)
+ } else {
+ if print_status {
+ eprintln!("[task::red] {:?}", key);
+ }
+ DepNodeColor::Red
+ }
} else {
+ if print_status {
+ eprintln!("[task::unknown] {:?}", key);
+ }
+ // Mark the node as Red if we can't hash the result
DepNodeColor::Red
};
debug_assert!(data.colors.get(prev_index).is_none(),
- "DepGraph::with_task() - Duplicate DepNodeColor \
- insertion for {:?}", key);
+ "DepGraph::with_task() - Duplicate DepNodeColor \
+ insertion for {:?}", key);
data.colors.insert(prev_index, color);
+ } else {
+ if print_status {
+ eprintln!("[task::new] {:?}", key);
+ }
}
(result, dep_node_index)
}
}
- /// Execute something within an "anonymous" task, that is, a task the
- /// DepNode of which is determined by the list of inputs it read from.
+ /// Executes something within an "anonymous" task, that is, a task the
+ /// `DepNode` of which is determined by the list of inputs it read from.
pub fn with_anon_task<OP,R>(&self, dep_kind: DepKind, op: OP) -> (R, DepNodeIndex)
where OP: FnOnce() -> R
{
}
}
- /// Execute something within an "eval-always" task which is a task
- // that runs whenever anything changes.
- pub fn with_eval_always_task<'gcx, C, A, R>(&self,
- key: DepNode,
- cx: C,
- arg: A,
- task: fn(C, A) -> R)
- -> (R, DepNodeIndex)
- where C: DepGraphSafe + StableHashingContextProvider<'gcx>,
- R: HashStable<StableHashingContext<'gcx>>,
+ /// Executes something within an "eval-always" task which is a task
+ /// that runs whenever anything changes.
+ pub fn with_eval_always_task<'a, C, A, R>(
+ &self,
+ key: DepNode,
+ cx: C,
+ arg: A,
+ task: fn(C, A) -> R,
+ hash_result: impl FnOnce(&mut StableHashingContext<'_>, &R) -> Option<Fingerprint>,
+ ) -> (R, DepNodeIndex)
+ where
+ C: DepGraphSafe + StableHashingContextProvider<'a>,
{
self.with_task_impl(key, cx, arg, false, task,
|_| None,
&DepNode::new_no_params(DepKind::Krate)
];
current.alloc_node(key, smallvec![krate_idx], fingerprint)
- })
+ },
+ hash_result)
}
#[inline]
self.data.as_ref().unwrap().previous.node_to_index(dep_node)
}
- /// Check whether a previous work product exists for `v` and, if
+ /// Checks whether a previous work product exists for `v` and, if
/// so, return the path that leads to it. Used to skip doing work.
pub fn previous_work_product(&self, v: &WorkProductId) -> Option<WorkProduct> {
self.data
}
}
- /// Try to mark a dep-node which existed in the previous compilation session as green
+ /// Try to mark a dep-node which existed in the previous compilation session as green.
fn try_mark_previous_green<'tcx>(
&self,
tcx: TyCtxt<'_, 'tcx, 'tcx>,
Some(dep_node_index)
}
- /// Atomically emits some loaded diagnotics assuming that this only gets called with
- /// did_allocation set to true on one thread
+ /// Atomically emits some loaded diagnotics, assuming that this only gets called with
+ /// `did_allocation` set to `true` on a single thread.
#[cold]
#[inline(never)]
fn emit_diagnostics<'tcx>(
#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
pub struct WorkProduct {
pub cgu_name: String,
- /// Saved files associated with this CGU
+ /// Saved files associated with this CGU.
pub saved_files: Vec<(WorkProductFileKind, String)>,
}
#[allow(dead_code)]
forbidden_edge: Option<EdgeFilter>,
- // Anonymous DepNodes are nodes the ID of which we compute from the list of
- // their edges. This has the beneficial side-effect that multiple anonymous
- // nodes can be coalesced into one without changing the semantics of the
- // dependency graph. However, the merging of nodes can lead to a subtle
- // problem during red-green marking: The color of an anonymous node from
- // the current session might "shadow" the color of the node with the same
- // ID from the previous session. In order to side-step this problem, we make
- // sure that anon-node IDs allocated in different sessions don't overlap.
- // This is implemented by mixing a session-key into the ID fingerprint of
- // each anon node. The session-key is just a random number generated when
- // the DepGraph is created.
+ /// Anonymous `DepNode`s are nodes whose IDs we compute from the list of
+ /// their edges. This has the beneficial side-effect that multiple anonymous
+ /// nodes can be coalesced into one without changing the semantics of the
+ /// dependency graph. However, the merging of nodes can lead to a subtle
+ /// problem during red-green marking: The color of an anonymous node from
+ /// the current session might "shadow" the color of the node with the same
+ /// ID from the previous session. In order to side-step this problem, we make
+ /// sure that anonymous `NodeId`s allocated in different sessions don't overlap.
+ /// This is implemented by mixing a session-key into the ID fingerprint of
+ /// each anon node. The session-key is just a random number generated when
+ /// the `DepGraph` is created.
anon_id_seed: Fingerprint,
total_read_count: u64,
pub use self::dep_tracking_map::{DepTrackingMap, DepTrackingMapConfig};
pub use self::dep_node::{DepNode, DepKind, DepConstructor, WorkProductId, label_strs};
-pub use self::graph::{DepGraph, WorkProduct, DepNodeIndex, DepNodeColor, TaskDeps};
+pub use self::graph::{DepGraph, WorkProduct, DepNodeIndex, DepNodeColor, TaskDeps, hash_result};
pub use self::graph::WorkProductFileKind;
pub use self::prev::PreviousDepGraph;
pub use self::query::DepGraphQuery;
+// ignore-tidy-linelength
#![allow(non_snake_case)]
// Error messages for EXXXX errors.
Lifetime elision in implementation headers was part of the lifetime elision
RFC. It is, however, [currently unimplemented][iss15872].
-[book-le]: https://doc.rust-lang.org/nightly/book/first-edition/lifetimes.html#lifetime-elision
+[book-le]: https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-elision
[iss15872]: https://github.com/rust-lang/rust/issues/15872
"##,
#![no_std]
```
-See also https://doc.rust-lang.org/book/first-edition/no-stdlib.html
+See also the [unstable book][1].
+
+[1]: https://doc.rust-lang.org/unstable-book/language-features/lang-items.html#writing-an-executable-without-stdlib
"##,
E0214: r##"
```
To understand better how closures work in Rust, read:
-https://doc.rust-lang.org/book/first-edition/closures.html
+https://doc.rust-lang.org/book/ch13-01-closures.html
"##,
E0580: r##"
}
impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
- /// Check any attribute.
+ /// Checks any attribute.
fn check_attributes(&self, item: &hir::Item, target: Target) {
if target == Target::Fn || target == Target::Const {
self.tcx.codegen_fn_attrs(self.tcx.hir().local_def_id(item.id));
self.check_used(item, target);
}
- /// Check if an `#[inline]` is applied to a function or a closure.
+ /// Checks if an `#[inline]` is applied to a function or a closure.
fn check_inline(&self, attr: &hir::Attribute, span: &Span, target: Target) {
if target != Target::Fn && target != Target::Closure {
struct_span_err!(self.tcx.sess,
}
}
- /// Check if the `#[non_exhaustive]` attribute on an `item` is valid.
+ /// Checks if the `#[non_exhaustive]` attribute on an `item` is valid.
fn check_non_exhaustive(&self, attr: &hir::Attribute, item: &hir::Item, target: Target) {
match target {
Target::Struct | Target::Enum => { /* Valid */ },
}
}
- /// Check if the `#[marker]` attribute on an `item` is valid.
+ /// Checks if the `#[marker]` attribute on an `item` is valid.
fn check_marker(&self, attr: &hir::Attribute, item: &hir::Item, target: Target) {
match target {
Target::Trait => { /* Valid */ },
}
}
- /// Check if the `#[repr]` attributes on `item` are valid.
+ /// Checks if the `#[repr]` attributes on `item` are valid.
fn check_repr(&self, item: &hir::Item, target: Target) {
// Extract the names of all repr hints, e.g., [foo, bar, align] for:
// ```
}
impl<T> PerNS<Option<T>> {
- /// Returns whether all the items in this collection are `None`.
+ /// Returns `true` if all the items in this collection are `None`.
pub fn is_empty(&self) -> bool {
self.type_ns.is_none() && self.value_ns.is_none() && self.macro_ns.is_none()
}
}
impl DefId {
- /// Make a local `DefId` with the given index.
+ /// Makes a local `DefId` from the given `DefIndex`.
#[inline]
pub fn local(index: DefIndex) -> DefId {
DefId { krate: LOCAL_CRATE, index: index }
//! `super::itemlikevisit::ItemLikeVisitor` trait.**
//!
//! If you have decided to use this visitor, here are some general
-//! notes on how to do it:
+//! notes on how to do so:
//!
//! Each overridden visit method has full control over what
//! happens with its node, it can do its own traversal of the node's children,
/// using this setting.
OnlyBodies(&'this Map<'tcx>),
- /// Visit all nested things, including item-likes.
+ /// Visits all nested things, including item-likes.
///
/// **This is an unusual choice.** It is used when you want to
/// process everything within their lexical context. Typically you
impl<'this, 'tcx> NestedVisitorMap<'this, 'tcx> {
/// Returns the map to use for an "intra item-like" thing (if any).
- /// e.g., function body.
+ /// E.g., function body.
pub fn intra(self) -> Option<&'this Map<'tcx>> {
match self {
NestedVisitorMap::None => None,
}
/// Returns the map to use for an "item-like" thing (if any).
- /// e.g., item, impl-item.
+ /// E.g., item, impl-item.
pub fn inter(self) -> Option<&'this Map<'tcx>> {
match self {
NestedVisitorMap::None => None,
}
/// Each method of the Visitor trait is a hook to be potentially
-/// overridden. Each method's default implementation recursively visits
+/// overridden. Each method's default implementation recursively visits
/// the substructure of the input via the corresponding `walk` method;
/// e.g., the `visit_mod` method by default calls `intravisit::walk_mod`.
///
/// on `visit_nested_item` for details on how to visit nested items.
///
/// If you want to ensure that your code handles every variant
-/// explicitly, you need to override each method. (And you also need
+/// explicitly, you need to override each method. (And you also need
/// to monitor future changes to `Visitor` in case a new method with a
/// new default implementation gets introduced.)
pub trait Visitor<'v> : Sized {
}
}
- /// Visit the top-level item and (optionally) nested items / impl items. See
+ /// Visits the top-level item and (optionally) nested items / impl items. See
/// `visit_nested_item` for details.
fn visit_item(&mut self, i: &'v Item) {
walk_item(self, i)
}
/// When invoking `visit_all_item_likes()`, you need to supply an
- /// item-like visitor. This method converts a "intra-visit"
+ /// item-like visitor. This method converts a "intra-visit"
/// visitor into an item-like visitor that walks the entire tree.
/// If you use this, you probably don't want to process the
/// contents of nested item-like things, since the outer loop will
//! Since the AST and HIR are fairly similar, this is mostly a simple procedure,
//! much like a fold. Where lowering involves a bit more work things get more
//! interesting and there are some invariants you should know about. These mostly
-//! concern spans and ids.
+//! concern spans and IDs.
//!
//! Spans are assigned to AST nodes during parsing and then are modified during
//! expansion to indicate the origin of a node and the process it went through
-//! being expanded. Ids are assigned to AST nodes just before lowering.
+//! being expanded. IDs are assigned to AST nodes just before lowering.
//!
-//! For the simpler lowering steps, ids and spans should be preserved. Unlike
+//! For the simpler lowering steps, IDs and spans should be preserved. Unlike
//! expansion we do not preserve the process of lowering in the spans, so spans
//! should not be modified here. When creating a new node (as opposed to
-//! 'folding' an existing one), then you create a new id using `next_id()`.
+//! 'folding' an existing one), then you create a new ID using `next_id()`.
//!
-//! You must ensure that ids are unique. That means that you should only use the
-//! id from an AST node in a single HIR node (you can assume that AST node ids
-//! are unique). Every new node must have a unique id. Avoid cloning HIR nodes.
-//! If you do, you must then set the new node's id to a fresh one.
+//! You must ensure that IDs are unique. That means that you should only use the
+//! ID from an AST node in a single HIR node (you can assume that AST node IDs
+//! are unique). Every new node must have a unique ID. Avoid cloning HIR nodes.
+//! If you do, you must then set the new node's ID to a fresh one.
//!
//! Spans are used for error messages and for tools to map semantics back to
-//! source code. It is therefore not as important with spans as ids to be strict
+//! source code. It is therefore not as important with spans as IDs to be strict
//! about use (you can't break the compiler by screwing up a span). Obviously, a
//! HIR node can only have a single span. But multiple nodes can have the same
//! span and spans don't need to be kept in order, etc. Where code is preserved
//! in the HIR, especially for multiple identifiers.
use crate::dep_graph::DepGraph;
-use crate::errors::Applicability;
use crate::hir::{self, ParamName};
use crate::hir::HirVec;
use crate::hir::map::{DefKey, DefPathData, Definitions};
use crate::lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
ELIDED_LIFETIMES_IN_PATHS};
use crate::middle::cstore::CrateStore;
-use rustc_data_structures::fx::FxHashSet;
-use rustc_data_structures::indexed_vec::IndexVec;
-use rustc_data_structures::thin_vec::ThinVec;
use crate::session::Session;
use crate::session::config::nightly_options;
use crate::util::common::FN_OUTPUT_NAME;
use crate::util::nodemap::{DefIdMap, NodeMap};
+use errors::Applicability;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::indexed_vec::IndexVec;
+use rustc_data_structures::thin_vec::ThinVec;
+use rustc_data_structures::sync::Lrc;
use std::collections::{BTreeSet, BTreeMap};
use std::fmt::Debug;
is_value: bool,
) -> hir::Path;
- /// Obtain the resolution for a node-id.
+ /// Obtain the resolution for a `NodeId`.
fn get_resolution(&mut self, id: NodeId) -> Option<PathResolution>;
/// Obtain the possible resolutions for the given `use` statement.
}
/// What to do when we encounter an **anonymous** lifetime
-/// reference. Anonymous lifetime references come in two flavors. You
+/// reference. Anonymous lifetime references come in two flavors. You
/// have implicit, or fully elided, references to lifetimes, like the
/// one in `&T` or `Ref<T>`, and you have `'_` lifetimes, like `&'_ T`
-/// or `Ref<'_, T>`. These often behave the same, but not always:
+/// or `Ref<'_, T>`. These often behave the same, but not always:
///
/// - certain usages of implicit references are deprecated, like
/// `Ref<T>`, and we sometimes just give hard errors in those cases
Ident::with_empty_ctxt(Symbol::gensym(s))
}
- fn allow_internal_unstable(&self, reason: CompilerDesugaringKind, span: Span) -> Span {
+ /// Reuses the span but adds information like the kind of the desugaring and features that are
+ /// allowed inside this span.
+ fn mark_span_with_reason(
+ &self,
+ reason: CompilerDesugaringKind,
+ span: Span,
+ allow_internal_unstable: Option<Lrc<[Symbol]>>,
+ ) -> Span {
let mark = Mark::fresh(Mark::root());
mark.set_expn_info(source_map::ExpnInfo {
call_site: span,
def_site: Some(span),
format: source_map::CompilerDesugaring(reason),
- allow_internal_unstable: true,
+ allow_internal_unstable,
allow_internal_unsafe: false,
local_inner_macros: false,
edition: source_map::hygiene::default_edition(),
attrs: ThinVec::new(),
};
- let unstable_span = self.allow_internal_unstable(CompilerDesugaringKind::Async, span);
+ let unstable_span = self.mark_span_with_reason(
+ CompilerDesugaringKind::Async,
+ span,
+ Some(vec![
+ Symbol::intern("gen_future"),
+ ].into()),
+ );
let gen_future = self.expr_std_path(
unstable_span, &["future", "from_generator"], None, ThinVec::new());
hir::ExprKind::Call(P(gen_future), hir_vec![generator])
// desugaring that explicitly states that we don't want to track that.
// Not tracking it makes lints in rustc and clippy very fragile as
// frequently opened issues show.
- let exist_ty_span = self.allow_internal_unstable(
+ let exist_ty_span = self.mark_span_with_reason(
CompilerDesugaringKind::ExistentialReturnType,
span,
+ None,
);
let exist_ty_def_index = self
/// Paths like the visibility path in `pub(super) use foo::{bar, baz}` are repeated
/// many times in the HIR tree; for each occurrence, we need to assign distinct
- /// node-ids. (See e.g., #56128.)
+ /// `NodeId`s. (See, e.g., #56128.)
fn renumber_segment_ids(&mut self, path: &P<hir::Path>) -> P<hir::Path> {
debug!("renumber_segment_ids(path = {:?})", path);
let mut path = path.clone();
hir::ExprKind::Call(f, args.iter().map(|x| self.lower_expr(x)).collect())
}
ExprKind::MethodCall(ref seg, ref args) => {
- let hir_seg = self.lower_path_segment(
+ let hir_seg = P(self.lower_path_segment(
e.span,
seg,
ParamMode::Optional,
ParenthesizedGenericArgs::Err,
ImplTraitContext::disallowed(),
None,
- );
+ ));
let args = args.iter().map(|x| self.lower_expr(x)).collect();
hir::ExprKind::MethodCall(hir_seg, seg.ident.span, args)
}
}),
ExprKind::TryBlock(ref body) => {
self.with_catch_scope(body.id, |this| {
- let unstable_span =
- this.allow_internal_unstable(CompilerDesugaringKind::TryBlock, body.span);
+ let unstable_span = this.mark_span_with_reason(
+ CompilerDesugaringKind::TryBlock,
+ body.span,
+ Some(vec![
+ Symbol::intern("try_trait"),
+ ].into()),
+ );
let mut block = this.lower_block(body, true).into_inner();
let tail = block.expr.take().map_or_else(
|| {
node: if is_unit {
hir::ExprKind::Path(struct_path)
} else {
- hir::ExprKind::Struct(struct_path, fields, None)
+ hir::ExprKind::Struct(P(struct_path), fields, None)
},
span: e.span,
attrs: e.attrs.clone(),
hir::ExprKind::InlineAsm(P(hir_asm), outputs, inputs)
}
ExprKind::Struct(ref path, ref fields, ref maybe_expr) => hir::ExprKind::Struct(
- self.lower_qpath(
+ P(self.lower_qpath(
e.id,
&None,
path,
ParamMode::Optional,
ImplTraitContext::disallowed(),
- ),
+ )),
fields.iter().map(|x| self.lower_field(x)).collect(),
maybe_expr.as_ref().map(|x| P(self.lower_expr(x))),
),
// expand <head>
let head = self.lower_expr(head);
let head_sp = head.span;
- let desugared_span = self.allow_internal_unstable(
+ let desugared_span = self.mark_span_with_reason(
CompilerDesugaringKind::ForLoop,
head_sp,
+ None,
);
let iter = self.str_to_ident("iter");
// return Try::from_error(From::from(err)),
// }
- let unstable_span =
- self.allow_internal_unstable(CompilerDesugaringKind::QuestionMark, e.span);
+ let unstable_span = self.mark_span_with_reason(
+ CompilerDesugaringKind::QuestionMark,
+ e.span,
+ Some(vec![
+ Symbol::intern("try_trait")
+ ].into()),
+ );
// `Try::into_result(<expr>)`
let discr = {
//! This module provides a simplified abstraction for working with
-//! code blocks identified by their integer node-id. In particular,
+//! code blocks identified by their integer `NodeId`. In particular,
//! it captures a common set of attributes that all "function-like
-//! things" (represented by `FnLike` instances) share. For example,
+//! things" (represented by `FnLike` instances) share. For example,
//! all `FnLike` instances have a type signature (be it explicit or
-//! inferred). And all `FnLike` instances have a body, i.e., the code
+//! inferred). And all `FnLike` instances have a body, i.e., the code
//! that is run when the function-like thing it represents is invoked.
//!
//! With the above abstraction in place, one can treat the program
hir_body_nodes: Vec<(DefPathHash, Fingerprint)>,
}
-fn input_dep_node_and_hash<'a, I>(
+fn input_dep_node_and_hash<I>(
dep_graph: &DepGraph,
- hcx: &mut StableHashingContext<'a>,
+ hcx: &mut StableHashingContext<'_>,
dep_node: DepNode,
input: I,
) -> (DepNodeIndex, Fingerprint)
where
- I: HashStable<StableHashingContext<'a>>,
+ I: for<'a> HashStable<StableHashingContext<'a>>,
{
let dep_node_index = dep_graph.input_task(dep_node, &mut *hcx, &input).1;
(dep_node_index, hash)
}
-fn alloc_hir_dep_nodes<'a, I>(
+fn alloc_hir_dep_nodes<I>(
dep_graph: &DepGraph,
- hcx: &mut StableHashingContext<'a>,
+ hcx: &mut StableHashingContext<'_>,
def_path_hash: DefPathHash,
item_like: I,
hir_body_nodes: &mut Vec<(DefPathHash, Fingerprint)>,
) -> (DepNodeIndex, DepNodeIndex)
where
- I: HashStable<StableHashingContext<'a>>,
+ I: for<'a> HashStable<StableHashingContext<'a>>,
{
let sig = dep_graph.input_task(
def_path_hash.to_dep_node(DepKind::Hir),
self.parent_node = parent_node;
}
- fn with_dep_node_owner<T: HashStable<StableHashingContext<'a>>,
+ fn with_dep_node_owner<T: for<'b> HashStable<StableHashingContext<'b>>,
F: FnOnce(&mut Self)>(&mut self,
dep_node_owner: DefIndex,
item_like: &T,
use crate::hir::map::{ITEM_LIKE_SPACE, REGULAR_SPACE};
-/// Creates def ids for nodes in the AST.
+/// Creates `DefId`s for nodes in the AST.
pub struct DefCollector<'a> {
definitions: &'a mut Definitions,
parent_def: Option<DefIndex>,
-//! For each definition, we track the following data. A definition
-//! here is defined somewhat circularly as "something with a def-id",
+//! For each definition, we track the following data. A definition
+//! here is defined somewhat circularly as "something with a `DefId`",
//! but it generally corresponds to things like structs, enums, etc.
//! There are also some rather random cases (like const initializer
//! expressions) that are mostly just leftovers.
/// any) with a `DisambiguatedDefPathData`.
#[derive(Clone, PartialEq, Debug, Hash, RustcEncodable, RustcDecodable)]
pub struct DefKey {
- /// Parent path.
+ /// The parent path.
pub parent: Option<DefIndex>,
- /// Identifier of this node.
+ /// The identifier of this node.
pub disambiguated_data: DisambiguatedDefPathData,
}
}
}
-/// Pair of `DefPathData` and an integer disambiguator. The integer is
+/// A pair of `DefPathData` and an integer disambiguator. The integer is
/// normally 0, but in the event that there are multiple defs with the
/// same `parent` and `data`, we use this field to disambiguate
/// between them. This introduces some artificial ordering dependency
/// but means that if you have (e.g.) two impls for the same type in
-/// the same module, they do get distinct def-ids.
+/// the same module, they do get distinct `DefId`s.
#[derive(Clone, PartialEq, Debug, Hash, RustcEncodable, RustcDecodable)]
pub struct DisambiguatedDefPathData {
pub data: DefPathData,
#[derive(Clone, Debug, Hash, RustcEncodable, RustcDecodable)]
pub struct DefPath {
- /// the path leading from the crate root to the item
+ /// The path leading from the crate root to the item.
pub data: Vec<DisambiguatedDefPathData>,
- /// what krate root is this path relative to?
+ /// The crate root this path is relative to.
pub krate: CrateNum,
}
DefPath { data: data, krate: krate }
}
- /// Returns a string representation of the DefPath without
+ /// Returns a string representation of the `DefPath` without
/// the crate-prefix. This method is useful if you don't have
- /// a TyCtxt available.
+ /// a `TyCtxt` available.
pub fn to_string_no_crate(&self) -> String {
let mut s = String::with_capacity(self.data.len() * 16);
s
}
- /// Return filename friendly string of the DefPah with the
+ /// Returns a filename-friendly string for the `DefPath`, with the
/// crate-prefix.
pub fn to_string_friendly<F>(&self, crate_imported_name: F) -> String
where F: FnOnce(CrateNum) -> Symbol
s
}
- /// Return filename friendly string of the DefPah without
+ /// Returns a filename-friendly string of the `DefPath`, without
/// the crate-prefix. This method is useful if you don't have
- /// a TyCtxt available.
+ /// a `TyCtxt` available.
pub fn to_filename_friendly_no_crate(&self) -> String {
let mut s = String::with_capacity(self.data.len() * 16);
}
impl Definitions {
- /// Create new empty definition map.
+ /// Creates new empty definition map.
///
- /// The DefIndex returned from a new Definitions are as follows:
- /// 1. At DefIndexAddressSpace::Low,
+ /// The `DefIndex` returned from a new `Definitions` are as follows:
+ /// 1. At `DefIndexAddressSpace::Low`,
/// CRATE_ROOT has index 0:0, and then new indexes are allocated in
/// ascending order.
- /// 2. At DefIndexAddressSpace::High,
- /// the first FIRST_FREE_HIGH_DEF_INDEX indexes are reserved for
- /// internal use, then 1:FIRST_FREE_HIGH_DEF_INDEX are allocated in
+ /// 2. At `DefIndexAddressSpace::High`,
+ /// the first `FIRST_FREE_HIGH_DEF_INDEX` indexes are reserved for
+ /// internal use, then `1:FIRST_FREE_HIGH_DEF_INDEX` are allocated in
/// ascending order.
- ///
- /// FIXME: there is probably a better place to put this comment.
+ //
+ // FIXME: there is probably a better place to put this comment.
pub fn new() -> Self {
Self::default()
}
&self.table
}
- /// Get the number of definitions.
+ /// Gets the number of definitions.
pub fn def_index_counts_lo_hi(&self) -> (usize, usize) {
(self.table.index_to_key[DefIndexAddressSpace::Low.index()].len(),
self.table.index_to_key[DefIndexAddressSpace::High.index()].len())
self.node_to_hir_id[node_id]
}
- /// Retrieve the span of the given `DefId` if `DefId` is in the local crate, the span exists and
- /// it's not DUMMY_SP
+ /// Retrieves the span of the given `DefId` if `DefId` is in the local crate, the span exists
+ /// and it's not `DUMMY_SP`.
#[inline]
pub fn opt_span(&self, def_id: DefId) -> Option<Span> {
if def_id.krate == LOCAL_CRATE {
}
}
- /// Add a definition with a parent definition.
+ /// Adds a root definition (no parent).
pub fn create_root_def(&mut self,
crate_name: &str,
crate_disambiguator: CrateDisambiguator)
index
}
- /// Initialize the ast::NodeId to HirId mapping once it has been generated during
+ /// Initialize the `ast::NodeId` to `HirId` mapping once it has been generated during
/// AST to HIR lowering.
pub fn init_node_id_to_hir_id_mapping(&mut self,
mapping: IndexVec<ast::NodeId, hir::HirId>) {
pub const ITEM_LIKE_SPACE: DefIndexAddressSpace = DefIndexAddressSpace::Low;
pub const REGULAR_SPACE: DefIndexAddressSpace = DefIndexAddressSpace::High;
-/// Represents an entry and its parent NodeId.
+/// Represents an entry and its parent `NodeId`.
#[derive(Copy, Clone, Debug)]
pub struct Entry<'hir> {
parent: NodeId,
}
}
- fn is_body_owner(self, node_id: NodeId) -> bool {
+ fn is_body_owner(self, hir_id: HirId) -> bool {
match self.associated_body() {
- Some(b) => b.node_id == node_id,
+ Some(b) => b.hir_id == hir_id,
None => false,
}
}
}
}
-/// Represents a mapping from Node IDs to AST elements and their parent
-/// Node IDs
+/// Represents a mapping from `NodeId`s to AST elements and their parent `NodeId`s.
#[derive(Clone)]
pub struct Map<'hir> {
/// The backing storage for all the AST nodes.
let def_id = self.local_def_id(variant.node.data.id());
Some(Def::Variant(def_id))
}
- Node::Field(_) |
+ Node::StructCtor(variant) => {
+ let def_id = self.local_def_id(variant.id());
+ Some(Def::StructCtor(def_id, def::CtorKind::from_hir(variant)))
+ }
Node::AnonConst(_) |
+ Node::Field(_) |
Node::Expr(_) |
Node::Stmt(_) |
Node::PathSegment(_) |
Node::TraitRef(_) |
Node::Pat(_) |
Node::Binding(_) |
- Node::StructCtor(_) |
Node::Lifetime(_) |
Node::Visibility(_) |
Node::Block(_) |
}
pub fn body(&self, id: BodyId) -> &'hir Body {
- self.read(id.node_id);
+ self.read_by_hir_id(id.hir_id);
// N.B., intentionally bypass `self.forest.krate()` so that we
// do not trigger a read of the whole krate here
/// Returns the `NodeId` that corresponds to the definition of
/// which this is the body of, i.e., a `fn`, `const` or `static`
/// item (possibly associated), a closure, or a `hir::AnonConst`.
- pub fn body_owner(&self, BodyId { node_id }: BodyId) -> NodeId {
+ pub fn body_owner(&self, BodyId { hir_id }: BodyId) -> NodeId {
+ let node_id = self.hir_to_node_id(hir_id);
let parent = self.get_parent_node(node_id);
- assert!(self.map[parent.as_usize()].map_or(false, |e| e.is_body_owner(node_id)));
+ assert!(self.map[parent.as_usize()].map_or(false, |e| e.is_body_owner(hir_id)));
parent
}
self.local_def_id(self.body_owner(id))
}
- /// Given a node id, returns the `BodyId` associated with it,
+ /// Given a `NodeId`, returns the `BodyId` associated with it,
/// if the node is a body owner, otherwise returns `None`.
pub fn maybe_body_owned_by(&self, id: NodeId) -> Option<BodyId> {
if let Some(entry) = self.find_entry(id) {
}
}
+ // FIXME(@ljedrz): replace the NodeId variant
+ pub fn maybe_body_owned_by_by_hir_id(&self, id: HirId) -> Option<BodyId> {
+ let node_id = self.hir_to_node_id(id);
+ self.maybe_body_owned_by(node_id)
+ }
+
/// Given a body owner's id, returns the `BodyId` associated with it.
pub fn body_owned_by(&self, id: NodeId) -> BodyId {
self.maybe_body_owned_by(id).unwrap_or_else(|| {
}
}
+ // FIXME(@ljedrz): replace the NodeId variant
+ pub fn body_owner_kind_by_hir_id(&self, id: HirId) -> BodyOwnerKind {
+ let node_id = self.hir_to_node_id(id);
+ self.body_owner_kind(node_id)
+ }
+
pub fn ty_param_owner(&self, id: NodeId) -> NodeId {
match self.get(id) {
Node::Item(&Item { node: ItemKind::Trait(..), .. }) => id,
self.trait_auto_impl(trait_did).is_some()
}
- /// Get the attributes on the krate. This is preferable to
+ /// Gets the attributes on the crate. This is preferable to
/// invoking `krate.attrs` because it registers a tighter
/// dep-graph access.
pub fn krate_attrs(&self) -> &'hir [ast::Attribute] {
self.get_generics(id).map(|generics| generics.span).filter(|sp| *sp != DUMMY_SP)
}
- /// Retrieve the Node corresponding to `id`, returning None if
- /// cannot be found.
+ /// Retrieves the `Node` corresponding to `id`, returning `None` if cannot be found.
pub fn find(&self, id: NodeId) -> Option<Node<'hir>> {
let result = self.find_entry(id).and_then(|entry| {
if let Node::Crate = entry.node {
/// returns the enclosing item. Note that this might not be the actual parent
/// node in the AST - some kinds of nodes are not in the map and these will
/// never appear as the parent_node. So you can always walk the `parent_nodes`
- /// from a node to the root of the ast (unless you get the same id back here
- /// that can happen if the id is not in the map itself or is just weird).
+ /// from a node to the root of the ast (unless you get the same ID back here
+ /// that can happen if the ID is not in the map itself or is just weird).
pub fn get_parent_node(&self, id: NodeId) -> NodeId {
if self.dep_graph.is_fully_enabled() {
let hir_id_owner = self.node_to_hir_id(id).owner;
/// If there is some error when walking the parents (e.g., a node does not
/// have a parent in the map or a node can't be found), then we return the
- /// last good node id we found. Note that reaching the crate root (`id == 0`),
+ /// last good `NodeId` we found. Note that reaching the crate root (`id == 0`),
/// is not an error, since items in the crate module have the crate root as
/// parent.
fn walk_parent_nodes<F, F2>(&self,
}
}
- /// Retrieve the `NodeId` for `id`'s enclosing method, unless there's a
+ /// Retrieves the `NodeId` for `id`'s enclosing method, unless there's a
/// `while` or `loop` before reaching it, as block tail returns are not
/// available in them.
///
self.walk_parent_nodes(id, match_fn, match_non_returning_block).ok()
}
- /// Retrieve the `NodeId` for `id`'s parent item, or `id` itself if no
+ /// Retrieves the `NodeId` for `id`'s parent item, or `id` itself if no
/// parent item is in this map. The "parent item" is the closest parent node
/// in the HIR which is recorded by the map and is an item, either an item
/// in a module, trait, or impl.
self.local_def_id(self.get_module_parent_node(id))
}
+ // FIXME(@ljedrz): replace the NodeId variant
+ pub fn get_module_parent_by_hir_id(&self, id: HirId) -> DefId {
+ let node_id = self.hir_to_node_id(id);
+ self.get_module_parent(node_id)
+ }
+
/// Returns the `NodeId` of `id`'s nearest module parent, or `id` itself if no
/// module parent is in this map.
pub fn get_module_parent_node(&self, id: NodeId) -> NodeId {
}
}
- pub fn expect_variant_data(&self, id: NodeId) -> &'hir VariantData {
+ pub fn expect_variant_data(&self, id: HirId) -> &'hir VariantData {
+ let id = self.hir_to_node_id(id); // FIXME(@ljedrz): remove when possible
+
match self.find(id) {
Some(Node::Item(i)) => {
match i.node {
}
}
- pub fn expect_variant(&self, id: NodeId) -> &'hir Variant {
+ pub fn expect_variant(&self, id: HirId) -> &'hir Variant {
+ let id = self.hir_to_node_id(id); // FIXME(@ljedrz): remove when possible
+
match self.find(id) {
Some(Node::Variant(variant)) => variant,
_ => bug!("expected variant, found {}", self.node_to_string(id)),
}
impl<'a, 'hir> NodesMatchingSuffix<'a, 'hir> {
- /// Returns true only if some suffix of the module path for parent
+ /// Returns `true` only if some suffix of the module path for parent
/// matches `self.in_which`.
///
/// In other words: let `[x_0,x_1,...,x_k]` be `self.in_which`;
pub use self::UnOp::*;
pub use self::UnsafeSource::*;
-use crate::errors::FatalError;
use crate::hir::def::Def;
use crate::hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX};
use crate::util::nodemap::{NodeMap, FxHashSet};
use crate::mir::mono::Linkage;
+use errors::FatalError;
use syntax_pos::{Span, DUMMY_SP, symbol::InternedString};
use syntax::source_map::Spanned;
use rustc_target::spec::abi::Abi;
pub mod pat_util;
pub mod print;
-/// A HirId uniquely identifies a node in the HIR of the current crate. It is
-/// composed of the `owner`, which is the DefIndex of the directly enclosing
-/// hir::Item, hir::TraitItem, or hir::ImplItem (i.e., the closest "item-like"),
+/// Uniquely identifies a node in the HIR of the current crate. It is
+/// composed of the `owner`, which is the `DefIndex` of the directly enclosing
+/// `hir::Item`, `hir::TraitItem`, or `hir::ImplItem` (i.e., the closest "item-like"),
/// and the `local_id` which is unique within the given owner.
///
/// This two-level structure makes for more stable values: One can move an item
/// around within the source code, or add or remove stuff before it, without
-/// the local_id part of the HirId changing, which is a very useful property in
+/// the `local_id` part of the `HirId` changing, which is a very useful property in
/// incremental compilation where we have to persist things through changes to
/// the code base.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
pub struct HirId {
pub owner: DefIndex,
pub local_id: ItemLocalId,
pub use self::item_local_id_inner::ItemLocalId;
-/// The `HirId` corresponding to CRATE_NODE_ID and CRATE_DEF_INDEX
+/// The `HirId` corresponding to `CRATE_NODE_ID` and `CRATE_DEF_INDEX`.
pub const CRATE_HIR_ID: HirId = HirId {
owner: CRATE_DEF_INDEX,
local_id: ItemLocalId::from_u32_const(0)
pub hir_id: HirId,
pub span: Span,
- /// Either "'a", referring to a named lifetime definition,
- /// or "" (aka keywords::Invalid), for elision placeholders.
+ /// Either "`'a`", referring to a named lifetime definition,
+ /// or "``" (i.e., `keywords::Invalid`), for elision placeholders.
///
/// HIR lowering inserts these placeholders in type paths that
/// refer to type definitions needing lifetime parameters,
/// Some user-given name like `T` or `'x`.
Plain(Ident),
- /// Synthetic name generated when user elided a lifetime in an impl header,
- /// e.g., the lifetimes in cases like these:
+ /// Synthetic name generated when user elided a lifetime in an impl header.
+ ///
+ /// E.g., the lifetimes in cases like these:
///
/// impl Foo for &u32
/// impl Foo<'_> for u32
/// Indicates an illegal name was given and an error has been
/// repored (so we should squelch other derived errors). Occurs
- /// when e.g., `'_` is used in the wrong place.
+ /// when, e.g., `'_` is used in the wrong place.
Error,
}
/// User-given names or fresh (synthetic) names.
Param(ParamName),
- /// User typed nothing. e.g., the lifetime in `&u32`.
+ /// User wrote nothing (e.g., the lifetime in `&u32`).
Implicit,
/// Indicates an error during lowering (usually `'_` in wrong place)
/// that was already reported.
Error,
- /// User typed `'_`.
+ /// User wrote specifies `'_`.
Underscore,
- /// User wrote `'static`
+ /// User wrote `'static`.
Static,
}
}
}
-/// A "Path" is essentially Rust's notion of a name; for instance:
+/// A `Path` is essentially Rust's notion of a name; for instance,
/// `std::cmp::PartialEq`. It's represented as a sequence of identifiers,
/// along with a bunch of supporting information.
#[derive(Clone, RustcEncodable, RustcDecodable)]
}
impl PathSegment {
- /// Convert an identifier to the corresponding segment.
+ /// Converts an identifier to the corresponding segment.
pub fn from_ident(ident: Ident) -> PathSegment {
PathSegment {
ident,
}
}
-/// Synthetic Type Parameters are converted to an other form during lowering, this allows
-/// to track the original form they had. Useful for error messages.
+/// Synthetic type parameters are converted to another form during lowering; this allows
+/// us to track the original form they had, and is useful for error messages.
#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum SyntheticTyParamKind {
ImplTrait
}
-/// A `where` clause in a definition
+/// A where-clause in a definition.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct WhereClause {
pub id: NodeId,
}
}
-/// A single predicate in a `where` clause
+/// A single predicate in a where-clause.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub enum WherePredicate {
/// A type binding (e.g., `for<'c> Foo: Send + Clone + 'c`).
}
}
-/// A type bound, eg `for<'c> Foo: Send+Clone+'c`
+/// A type bound (e.g., `for<'c> Foo: Send + Clone + 'c`).
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct WhereBoundPredicate {
pub span: Span,
- /// Any generics from a `for` binding
+ /// Any generics from a `for` binding.
pub bound_generic_params: HirVec<GenericParam>,
- /// The type being bounded
+ /// The type being bounded.
pub bounded_ty: P<Ty>,
- /// Trait and lifetime bounds (`Clone+Send+'static`)
+ /// Trait and lifetime bounds (e.g., `Clone + Send + 'static`).
pub bounds: GenericBounds,
}
-/// A lifetime predicate, e.g., `'a: 'b+'c`
+/// A lifetime predicate (e.g., `'a: 'b + 'c`).
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct WhereRegionPredicate {
pub span: Span,
pub bounds: GenericBounds,
}
-/// An equality predicate (unsupported), e.g., `T=int`
+/// An equality predicate (e.g., `T = int`); currently unsupported.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct WhereEqPredicate {
pub id: NodeId,
}
}
- /// A parallel version of visit_all_item_likes
+ /// A parallel version of `visit_all_item_likes`.
pub fn par_visit_all_item_likes<'hir, V>(&'hir self, visitor: &V)
where V: itemlikevisit::ParItemLikeVisitor<'hir> + Sync + Send
{
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct Block {
- /// Statements in a block
+ /// Statements in a block.
pub stmts: HirVec<Stmt>,
/// An expression at the end of the block
- /// without a semicolon, if any
+ /// without a semicolon, if any.
pub expr: Option<P<Expr>>,
pub id: NodeId,
pub hir_id: HirId,
- /// Distinguishes between `unsafe { ... }` and `{ ... }`
+ /// Distinguishes between `unsafe { ... }` and `{ ... }`.
pub rules: BlockCheckMode,
pub span: Span,
/// If true, then there may exist `break 'a` values that aim to
}
}
-/// A single field in a struct pattern
+/// A single field in a struct pattern.
///
/// Patterns like the fields of Foo `{ x, ref y, ref mut z }`
/// are treated the same as` x: x, y: ref y, z: ref mut z`,
-/// except is_shorthand is true
+/// except `is_shorthand` is true.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct FieldPat {
pub id: NodeId,
pub hir_id: HirId,
- /// The identifier for the field
+ /// The identifier for the field.
pub ident: Ident,
- /// The pattern the field is destructured to
+ /// The pattern the field is destructured to.
pub pat: P<Pat>,
pub is_shorthand: bool,
}
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub enum PatKind {
- /// Represents a wildcard pattern (`_`)
+ /// Represents a wildcard pattern (i.e., `_`).
Wild,
/// A fresh binding `ref mut binding @ OPT_SUBPATTERN`.
/// The `NodeId` is the canonical ID for the variable being bound,
- /// e.g., in `Ok(x) | Err(x)`, both `x` use the same canonical ID,
+ /// (e.g., in `Ok(x) | Err(x)`, both `x` use the same canonical ID),
/// which is the pattern ID of the first `x`.
Binding(BindingAnnotation, NodeId, HirId, Ident, Option<P<Pat>>),
- /// A struct or struct variant pattern, e.g., `Variant {x, y, ..}`.
+ /// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`).
/// The `bool` is `true` in the presence of a `..`.
Struct(QPath, HirVec<Spanned<FieldPat>>, bool),
/// A tuple struct/variant pattern `Variant(x, y, .., z)`.
/// If the `..` pattern fragment is present, then `Option<usize>` denotes its position.
- /// 0 <= position <= subpats.len()
+ /// `0 <= position <= subpats.len()`
TupleStruct(QPath, HirVec<P<Pat>>, Option<usize>),
/// A path pattern for an unit struct/variant or a (maybe-associated) constant.
Path(QPath),
- /// A tuple pattern `(a, b)`.
+ /// A tuple pattern (e.g., `(a, b)`).
/// If the `..` pattern fragment is present, then `Option<usize>` denotes its position.
- /// 0 <= position <= subpats.len()
+ /// `0 <= position <= subpats.len()`
Tuple(HirVec<P<Pat>>, Option<usize>),
- /// A `box` pattern
+ /// A `box` pattern.
Box(P<Pat>),
- /// A reference pattern, e.g., `&mut (a, b)`
+ /// A reference pattern (e.g., `&mut (a, b)`).
Ref(P<Pat>, Mutability),
- /// A literal
+ /// A literal.
Lit(P<Expr>),
- /// A range pattern, e.g., `1...2` or `1..2`
+ /// A range pattern (e.g., `1...2` or `1..2`).
Range(P<Expr>, P<Expr>, RangeEnd),
/// `[a, b, ..i, y, z]` is represented as:
- /// `PatKind::Slice(box [a, b], Some(i), box [y, z])`
+ /// `PatKind::Slice(box [a, b], Some(i), box [y, z])`.
Slice(HirVec<P<Pat>>, Option<P<Pat>>, HirVec<P<Pat>>),
}
}
impl Mutability {
- /// Return MutMutable only if both arguments are mutable.
+ /// Returns `MutMutable` only if both arguments are mutable.
pub fn and(self, other: Self) -> Self {
match self {
MutMutable => other,
#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy, Hash)]
pub enum BinOpKind {
- /// The `+` operator (addition)
+ /// The `+` operator (addition).
Add,
- /// The `-` operator (subtraction)
+ /// The `-` operator (subtraction).
Sub,
- /// The `*` operator (multiplication)
+ /// The `*` operator (multiplication).
Mul,
- /// The `/` operator (division)
+ /// The `/` operator (division).
Div,
- /// The `%` operator (modulus)
+ /// The `%` operator (modulus).
Rem,
- /// The `&&` operator (logical and)
+ /// The `&&` operator (logical and).
And,
- /// The `||` operator (logical or)
+ /// The `||` operator (logical or).
Or,
- /// The `^` operator (bitwise xor)
+ /// The `^` operator (bitwise xor).
BitXor,
- /// The `&` operator (bitwise and)
+ /// The `&` operator (bitwise and).
BitAnd,
- /// The `|` operator (bitwise or)
+ /// The `|` operator (bitwise or).
BitOr,
- /// The `<<` operator (shift left)
+ /// The `<<` operator (shift left).
Shl,
- /// The `>>` operator (shift right)
+ /// The `>>` operator (shift right).
Shr,
- /// The `==` operator (equality)
+ /// The `==` operator (equality).
Eq,
- /// The `<` operator (less than)
+ /// The `<` operator (less than).
Lt,
- /// The `<=` operator (less than or equal to)
+ /// The `<=` operator (less than or equal to).
Le,
- /// The `!=` operator (not equal to)
+ /// The `!=` operator (not equal to).
Ne,
- /// The `>=` operator (greater than or equal to)
+ /// The `>=` operator (greater than or equal to).
Ge,
- /// The `>` operator (greater than)
+ /// The `>` operator (greater than).
Gt,
}
}
}
- /// Returns `true` if the binary operator takes its arguments by value
+ /// Returns `true` if the binary operator takes its arguments by value.
pub fn is_by_value(self) -> bool {
!self.is_comparison()
}
#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy, Hash)]
pub enum UnOp {
- /// The `*` operator for dereferencing
+ /// The `*` operator (deferencing).
UnDeref,
- /// The `!` operator for logical inversion
+ /// The `!` operator (logical negation).
UnNot,
- /// The `-` operator for negation
+ /// The `-` operator (negation).
UnNeg,
}
}
}
- /// Returns `true` if the unary operator takes its argument by value
+ /// Returns `true` if the unary operator takes its argument by value.
pub fn is_by_value(self) -> bool {
match self {
UnNeg | UnNot => true,
}
}
-/// A statement
+/// A statement.
#[derive(Clone, RustcEncodable, RustcDecodable)]
pub struct Stmt {
pub id: NodeId,
#[derive(Clone, RustcEncodable, RustcDecodable)]
pub enum StmtKind {
- /// A local (let) binding:
+ /// A local (`let`) binding.
Local(P<Local>),
- /// An item binding:
+ /// An item binding.
Item(P<ItemId>),
- /// Expr without trailing semi-colon (must have unit type):
+ /// An expression without a trailing semi-colon (must have unit type).
Expr(P<Expr>),
- /// Expr with trailing semi-colon (may have any type):
+ /// An expression with a trailing semi-colon (may have any type).
Semi(P<Expr>),
}
}
}
-/// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;`
+/// Represents a `let` statement (i.e., `let <pat>:<ty> = <expr>;`).
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct Local {
pub pat: P<Pat>,
pub ty: Option<P<Ty>>,
- /// Initializer expression to set the value, if any
+ /// Initializer expression to set the value, if any.
pub init: Option<P<Expr>>,
pub id: NodeId,
pub hir_id: HirId,
pub source: LocalSource,
}
-/// represents one arm of a 'match'
+/// Represents a single arm of a `match` expression.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct Arm {
pub attrs: HirVec<Attribute>,
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct BodyId {
- pub node_id: NodeId,
+ pub hir_id: HirId,
}
/// The body of a function, closure, or constant value. In the case of
impl Body {
pub fn id(&self) -> BodyId {
BodyId {
- node_id: self.value.id
+ hir_id: self.value.hir_id,
}
}
}
pub hir_id: HirId,
}
+// `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
+#[cfg(target_arch = "x86_64")]
+static_assert!(MEM_SIZE_OF_EXPR: std::mem::size_of::<Expr>() == 72);
+
impl Expr {
pub fn precedence(&self) -> ExprPrecedence {
match self.node {
pub enum ExprKind {
/// A `box x` expression.
Box(P<Expr>),
- /// An array (`[a, b, c, d]`)
+ /// An array (e.g., `[a, b, c, d]`).
Array(HirVec<Expr>),
- /// A function call
+ /// A function call.
///
/// The first field resolves to the function itself (usually an `ExprKind::Path`),
/// and the second field is the list of arguments.
/// This also represents calling the constructor of
/// tuple-like ADTs such as tuple structs and enum variants.
Call(P<Expr>, HirVec<Expr>),
- /// A method call (`x.foo::<'static, Bar, Baz>(a, b, c, d)`)
+ /// A method call (e.g., `x.foo::<'static, Bar, Baz>(a, b, c, d)`).
///
/// The `PathSegment`/`Span` represent the method name and its generic arguments
/// (within the angle brackets).
/// and the remaining elements are the rest of the arguments.
/// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
/// `ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, [x, a, b, c, d])`.
- MethodCall(PathSegment, Span, HirVec<Expr>),
- /// A tuple (`(a, b, c ,d)`)
+ MethodCall(P<PathSegment>, Span, HirVec<Expr>),
+ /// A tuple (e.g., `(a, b, c ,d)`).
Tup(HirVec<Expr>),
- /// A binary operation (For example: `a + b`, `a * b`)
+ /// A binary operation (e.g., `a + b`, `a * b`).
Binary(BinOp, P<Expr>, P<Expr>),
- /// A unary operation (For example: `!x`, `*x`)
+ /// A unary operation (e.g., `!x`, `*x`).
Unary(UnOp, P<Expr>),
- /// A literal (For example: `1`, `"foo"`)
+ /// A literal (e.g., `1`, `"foo"`).
Lit(Lit),
- /// A cast (`foo as f64`)
+ /// A cast (e.g., `foo as f64`).
Cast(P<Expr>, P<Ty>),
+ /// A type reference (e.g., `Foo`).
Type(P<Expr>, P<Ty>),
- /// An `if` block, with an optional else block
+ /// An `if` block, with an optional else block.
///
- /// `if expr { expr } else { expr }`
+ /// I.e., `if <expr> { <expr> } else { <expr> }`.
If(P<Expr>, P<Expr>, Option<P<Expr>>),
/// A while loop, with an optional label
///
- /// `'label: while expr { block }`
+ /// I.e., `'label: while expr { <block> }`.
While(P<Expr>, P<Block>, Option<Label>),
- /// Conditionless loop (can be exited with break, continue, or return)
+ /// A conditionless loop (can be exited with `break`, `continue`, or `return`).
///
- /// `'label: loop { block }`
+ /// I.e., `'label: loop { <block> }`.
Loop(P<Block>, Option<Label>, LoopSource),
/// A `match` block, with a source that indicates whether or not it is
/// the result of a desugaring, and if so, which kind.
Match(P<Expr>, HirVec<Arm>, MatchSource),
- /// A closure (for example, `move |a, b, c| {a + b + c}`).
+ /// A closure (e.g., `move |a, b, c| {a + b + c}`).
///
- /// The final span is the span of the argument block `|...|`
+ /// The final span is the span of the argument block `|...|`.
///
/// This may also be a generator literal, indicated by the final boolean,
- /// in that case there is an GeneratorClause.
+ /// in that case there is an `GeneratorClause`.
Closure(CaptureClause, P<FnDecl>, BodyId, Span, Option<GeneratorMovability>),
- /// A block (`'label: { ... }`)
+ /// A block (e.g., `'label: { ... }`).
Block(P<Block>, Option<Label>),
- /// An assignment (`a = foo()`)
+ /// An assignment (e.g., `a = foo()`).
Assign(P<Expr>, P<Expr>),
- /// An assignment with an operator
+ /// An assignment with an operator.
///
- /// For example, `a += 1`.
+ /// E.g., `a += 1`.
AssignOp(BinOp, P<Expr>, P<Expr>),
- /// Access of a named (`obj.foo`) or unnamed (`obj.0`) struct or tuple field
+ /// Access of a named (e.g., `obj.foo`) or unnamed (e.g., `obj.0`) struct or tuple field.
Field(P<Expr>, Ident),
- /// An indexing operation (`foo[2]`)
+ /// An indexing operation (`foo[2]`).
Index(P<Expr>, P<Expr>),
/// Path to a definition, possibly containing lifetime or type parameters.
Path(QPath),
- /// A referencing operation (`&a` or `&mut a`)
+ /// A referencing operation (i.e., `&a` or `&mut a`).
AddrOf(Mutability, P<Expr>),
- /// A `break`, with an optional label to break
+ /// A `break`, with an optional label to break.
Break(Destination, Option<P<Expr>>),
- /// A `continue`, with an optional label
+ /// A `continue`, with an optional label.
Continue(Destination),
- /// A `return`, with an optional value to be returned
+ /// A `return`, with an optional value to be returned.
Ret(Option<P<Expr>>),
/// Inline assembly (from `asm!`), with its outputs and inputs.
///
/// For example, `Foo {x: 1, y: 2}`, or
/// `Foo {x: 1, .. base}`, where `base` is the `Option<Expr>`.
- Struct(
QPath, HirVec<Field>, Option<P<Expr>>),
+ Struct(
P<QPath>, HirVec<Field>, Option<P<Expr>>),
/// An array literal constructed from one repeated element.
///
/// to be repeated; the second is the number of times to repeat it.
Repeat(P<Expr>, AnonConst),
- /// A suspension point for generators. This is `yield <expr>` in Rust.
+ /// A suspension point for generators (i.e., `yield <expr>`).
Yield(P<Expr>),
- /// Placeholder for an expression that wasn't syntactically well formed in some way.
+ /// A placeholder for an expression that wasn't syntactically well formed in some way.
Err,
}
/// Path to a definition, optionally "fully-qualified" with a `Self`
/// type, if the path points to an associated item in a trait.
///
- /// e.g., an unqualified path like `Clone::clone` has `None` for `Self`,
+ /// E.g., an unqualified path like `Clone::clone` has `None` for `Self`,
/// while `<Vec<T> as Clone>::clone` has `Some(Vec<T>)` for `Self`,
/// even though they both have the same two-segment `Clone::clone` `Path`.
Resolved(Option<P<Ty>>, P<Path>),
- /// Type-related paths, e.g., `<T>::default` or `<T>::Output`.
+ /// Type-related paths (e.g., `<T>::default` or `<T>::Output`).
/// Will be resolved by type-checking to an associated item.
///
/// UFCS source paths can desugar into this, with `Vec::new` turning into
TypeRelative(P<Ty>, P<PathSegment>)
}
-/// Hints at the original code for a let statement
+/// Hints at the original code for a let statement.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)]
pub enum LocalSource {
- /// A `match _ { .. }`
+ /// A `match _ { .. }`.
Normal,
- /// A desugared `for _ in _ { .. }` loop
+ /// A desugared `for _ in _ { .. }` loop.
ForLoopDesugar,
}
-/// Hints at the original code for a `match _ { .. }`
+/// Hints at the original code for a `match _ { .. }`.
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum MatchSource {
- /// A `match _ { .. }`
+ /// A `match _ { .. }`.
Normal,
- /// An `if let _ = _ { .. }` (optionally with `else { .. }`)
+ /// An `if let _ = _ { .. }` (optionally with `else { .. }`).
IfLetDesugar {
contains_else_clause: bool,
},
/// A `while let _ = _ { .. }` (which was desugared to a
- /// `loop { match _ { .. } }`)
+ /// `loop { match _ { .. } }`).
WhileLetDesugar,
- /// A desugared `for _ in _ { .. }` loop
+ /// A desugared `for _ in _ { .. }` loop.
ForLoopDesugar,
- /// A desugared `?` operator
+ /// A desugared `?` operator.
TryDesugar,
}
-/// The loop type that yielded an ExprKind::Loop
+/// The loop type that yielded an `ExprKind::Loop`.
#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)]
pub enum LoopSource {
- /// A `loop { .. }` loop
+ /// A `loop { .. }` loop.
Loop,
- /// A `while let _ = _ { .. }` loop
+ /// A `while let _ = _ { .. }` loop.
WhileLet,
- /// A `for _ in _ { .. }` loop
+ /// A `for _ in _ { .. }` loop.
ForLoop,
}
}
}
-/// Not represented directly in the AST, referred to by name through a ty_path.
+/// Not represented directly in the AST; referred to by name through a `ty_path`.
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum PrimTy {
Int(IntTy),
pub impl_trait_fn: Option<DefId>,
}
+/// The various kinds of types recognized by the compiler.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
-/// The different kinds of types recognized by the compiler
pub enum TyKind {
- /// A variable length slice (`[T]`)
+ /// A variable length slice (i.e., `[T]`).
Slice(P<Ty>),
- /// A fixed length array (`[T; n]`)
+ /// A fixed length array (i.e., `[T; n]`).
Array(P<Ty>, AnonConst),
- /// A raw pointer (`*const T` or `*mut T`)
+ /// A raw pointer (i.e., `*const T` or `*mut T`).
Ptr(MutTy),
- /// A reference (`&'a T` or `&'a mut T`)
+ /// A reference (i.e., `&'a T` or `&'a mut T`).
Rptr(Lifetime, MutTy),
- /// A bare function (e.g., `fn(usize) -> bool`)
+ /// A bare function (e.g., `fn(usize) -> bool`).
BareFn(P<BareFnTy>),
- /// The never type (`!`)
+ /// The never type (`!`).
Never,
- /// A tuple (`(A, B, C, D,...)`)
+ /// A tuple (`(A, B, C, D,...)`).
Tup(HirVec<Ty>),
/// A path to a type definition (`module::module::...::Type`), or an
- /// associated type, e.g., `<Vec<T> as Trait>::Type` or `<T>::Target`.
+ /// associated type (e.g., `<Vec<T> as Trait>::Type` or `<T>::Target`).
///
/// Type parameters may be stored in each `PathSegment`.
Path(QPath),
/// A type definition itself. This is currently only used for the `existential type`
/// item that `impl Trait` in return position desugars to.
///
- /// The generic arg list are the lifetimes (and in the future possibly parameters) that are
- /// actually bound on the `impl Trait`.
+ /// The generic argument list contains the lifetimes (and in the future possibly parameters)
+ /// that are actually bound on the `impl Trait`.
Def(ItemId, HirVec<GenericArg>),
/// A trait object type `Bound1 + Bound2 + Bound3`
/// where `Bound` is a trait or a lifetime.
TraitObject(HirVec<PolyTraitRef>, Lifetime),
- /// Unused for now
+ /// Unused for now.
Typeof(AnonConst),
/// `TyKind::Infer` means the type should be inferred instead of it having been
/// specified. This can appear anywhere in a type.
pub ctxt: SyntaxContext,
}
-/// represents an argument in a function header
+/// Represents an argument in a function header.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct Arg {
pub pat: P<Pat>,
pub hir_id: HirId,
}
-/// Represents the header (not the body) of a function declaration
+/// Represents the header (not the body) of a function declaration.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct FnDecl {
pub inputs: HirVec<Ty>,
/// closures default to inference. Span points to where return
/// type would be inserted.
DefaultReturn(Span),
- /// Everything else
+ /// Everything else.
Return(P<Ty>),
}
pub ident: Ident,
pub attrs: HirVec<Attribute>,
pub data: VariantData,
- /// Explicit discriminant, e.g., `Foo = 1`
+ /// Explicit discriminant (e.g., `Foo = 1`).
pub disr_expr: Option<AnonConst>,
}
}
impl TraitRef {
- /// Get the `DefId` of the referenced trait. It _must_ actually be a trait or trait alias.
+ /// Gets the `DefId` of the referenced trait. It _must_ actually be a trait or trait alias.
pub fn trait_def_id(&self) -> DefId {
match self.path.def {
Def::Trait(did) => did,
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct PolyTraitRef {
- /// The `'a` in `<'a> Foo<&'a T>`
+ /// The `'a` in `<'a> Foo<&'a T>`.
pub bound_generic_params: HirVec<GenericParam>,
- /// The `Foo<&'a T>` in `<'a> Foo<&'a T>`
+ /// The `Foo<&'a T>` in `<'a> Foo<&'a T>`.
pub trait_ref: TraitRef,
pub span: Span,
pub enum ItemKind {
/// An `extern crate` item, with optional *original* crate name if the crate was renamed.
///
- /// e.g., `extern crate foo` or `extern crate foo_bar as foo`
+ /// E.g., `extern crate foo` or `extern crate foo_bar as foo`.
ExternCrate(Option<Name>),
/// `use foo::bar::*;` or `use foo::bar::baz as quux;`
ItemKind::Union(..) => "union",
ItemKind::Trait(..) => "trait",
ItemKind::TraitAlias(..) => "trait alias",
- ItemKind::Impl(..) => "item",
+ ItemKind::Impl(..) => "impl",
}
}
/// contains the item's id, naturally, but also the item's name and
/// some other high-level details (like whether it is an associated
/// type or method, and whether it is public). This allows other
-/// passes to find the impl they want without loading the id (which
+/// passes to find the impl they want without loading the ID (which
/// means fewer edges in the incremental compilation graph).
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct TraitItemRef {
}
/// A reference from an impl to one of its associated items. This
-/// contains the item's id, naturally, but also the item's name and
+/// contains the item's ID, naturally, but also the item's name and
/// some other high-level details (like whether it is an associated
/// type or method, and whether it is public). This allows other
-/// passes to find the impl they want without loading the id (which
+/// passes to find the impl they want without loading the ID (which
/// means fewer edges in the incremental compilation graph).
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct ImplItemRef {
pub vis: Visibility,
}
-/// An item within an `extern` block
+/// An item within an `extern` block.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub enum ForeignItemKind {
- /// A foreign function
+ /// A foreign function.
Fn(P<FnDecl>, HirVec<Ident>, Generics),
/// A foreign static item (`static ext: u8`), with optional mutability
- /// (the boolean is true when mutable)
+ /// (the boolean is true when mutable).
Static(P<Ty>, bool),
- /// A foreign type
+ /// A foreign type.
Type,
}
bitflags! {
#[derive(RustcEncodable, RustcDecodable)]
pub struct CodegenFnAttrFlags: u32 {
- /// #[cold], a hint to LLVM that this function, when called, is never on
- /// the hot path
+ /// `#[cold]`: a hint to LLVM that this function, when called, is never on
+ /// the hot path.
const COLD = 1 << 0;
- /// #[allocator], a hint to LLVM that the pointer returned from this
- /// function is never null
+ /// `#[allocator]`: a hint to LLVM that the pointer returned from this
+ /// function is never null.
const ALLOCATOR = 1 << 1;
- /// #[unwind], an indicator that this function may unwind despite what
- /// its ABI signature may otherwise imply
+ /// `#[unwind]`: an indicator that this function may unwind despite what
+ /// its ABI signature may otherwise imply.
const UNWIND = 1 << 2;
- /// #[rust_allocator_nounwind], an indicator that an imported FFI
+ /// `#[rust_allocator_nounwind]`, an indicator that an imported FFI
/// function will never unwind. Probably obsolete by recent changes with
/// #[unwind], but hasn't been removed/migrated yet
const RUSTC_ALLOCATOR_NOUNWIND = 1 << 3;
- /// #[naked], indicates to LLVM that no function prologue/epilogue
- /// should be generated
+ /// `#[naked]`: an indicator to LLVM that no function prologue/epilogue
+ /// should be generated.
const NAKED = 1 << 4;
- /// #[no_mangle], the function's name should be the same as its symbol
+ /// `#[no_mangle]`: an indicator that the function's name should be the same
+ /// as its symbol.
const NO_MANGLE = 1 << 5;
- /// #[rustc_std_internal_symbol], and indicator that this symbol is a
+ /// `#[rustc_std_internal_symbol]`: an indicator that this symbol is a
/// "weird symbol" for the standard library in that it has slightly
/// different linkage, visibility, and reachability rules.
const RUSTC_STD_INTERNAL_SYMBOL = 1 << 6;
- /// #[no_debug], indicates that no debugging information should be
- /// generated for this function by LLVM
+ /// `#[no_debug]`: an indicator that no debugging information should be
+ /// generated for this function by LLVM.
const NO_DEBUG = 1 << 7;
- /// #[thread_local], indicates a static is actually a thread local
+ /// `#[thread_local]`: indicates a static is actually a thread local
/// piece of memory
const THREAD_LOCAL = 1 << 8;
- /// #[used], indicates that LLVM can't eliminate this function (but the
- /// linker can!)
+ /// `#[used]`: indicates that LLVM can't eliminate this function (but the
+ /// linker can!).
const USED = 1 << 9;
}
}
}
}
- /// True if `#[inline]` or `#[inline(always)]` is present.
+ /// Returns `true` if `#[inline]` or `#[inline(always)]` is present.
pub fn requests_inline(&self) -> bool {
match self.inline {
InlineAttr::Hint | InlineAttr::Always => true,
}
}
- /// Return variants that are necessary to exist for the pattern to match.
+ /// Returns variants that are necessary to exist for the pattern to match.
pub fn necessary_variants(&self) -> Vec<DefId> {
let mut variants = vec![];
self.walk(|p| {
/// Checks if the pattern contains any `ref` or `ref mut` bindings, and if
/// yes whether it contains mutable or just immutables ones.
- ///
- /// FIXME(tschottdorf): this is problematic as the HIR is being scraped, but
- /// ref bindings are be implicit after #42640 (default match binding modes).
- ///
- /// See #44848.
+ //
+ // FIXME(tschottdorf): this is problematic as the HIR is being scraped, but
+ // ref bindings are be implicit after #42640 (default match binding modes). See issue #44848.
pub fn contains_explicit_ref_binding(&self) -> Option<hir::Mutability> {
let mut result = None;
self.each_binding(|annotation, _, _, _| {
fn to_stable_hash_key(&self,
hcx: &StableHashingContext<'a>)
-> (DefPathHash, hir::ItemLocalId) {
- let hir::BodyId { node_id } = *self;
- node_id.to_stable_hash_key(hcx)
+ let hir::BodyId { hir_id } = *self;
+ hir_id.to_stable_hash_key(hcx)
}
}
-//! A nice interface for working with the infcx. The basic idea is to
+//! A nice interface for working with the infcx. The basic idea is to
//! do `infcx.at(cause, param_env)`, which sets the "cause" of the
-//! operation as well as the surrounding parameter environment. Then
+//! operation as well as the surrounding parameter environment. Then
//! you can do something like `.sub(a, b)` or `.eq(a, b)` to create a
//! subtype or equality relationship respectively. The first argument
//! is always the "expected" output from the POV of diagnostics.
}
}
- /// Make `a <: b` where `a` may or may not be expected
+ /// Makes `a <: b`, where `a` may or may not be expected.
pub fn sub_exp<T>(self,
a_is_expected: bool,
a: T,
self.trace_exp(a_is_expected, a, b).sub(&a, &b)
}
- /// Make `actual <: expected`. For example, if type-checking a
+ /// Makes `actual <: expected`. For example, if type-checking a
/// call like `foo(x)`, where `foo: fn(i32)`, you might have
/// `sup(i32, x)`, since the "expected" type is the type that
/// appears in the signature.
self.sub_exp(false, actual, expected)
}
- /// Make `expected <: actual`
+ /// Makes `expected <: actual`.
pub fn sub<T>(self,
expected: T,
actual: T)
self.sub_exp(true, expected, actual)
}
- /// Make `expected <: actual`
+ /// Makes `expected <: actual`.
pub fn eq_exp<T>(self,
a_is_expected: bool,
a: T,
self.trace_exp(a_is_expected, a, b).eq(&a, &b)
}
- /// Make `expected <: actual`
+ /// Makes `expected <: actual`.
pub fn eq<T>(self,
expected: T,
actual: T)
}
}
- /// Compute the least-upper-bound, or mutual supertype, of two
+ /// Computes the least-upper-bound, or mutual supertype, of two
/// values. The order of the arguments doesn't matter, but since
/// this can result in an error (e.g., if asked to compute LUB of
/// u32 and i32), it is meaningful to call one of them the
self.trace(expected, actual).lub(&expected, &actual)
}
- /// Compute the greatest-lower-bound, or mutual subtype, of two
+ /// Computes the greatest-lower-bound, or mutual subtype, of two
/// values. As with `lub` order doesn't matter, except for error
/// cases.
pub fn glb<T>(self,
}
impl<'a, 'gcx, 'tcx> Trace<'a, 'gcx, 'tcx> {
- /// Make `a <: b` where `a` may or may not be expected (if
+ /// Makes `a <: b` where `a` may or may not be expected (if
/// `a_is_expected` is true, then `a` is expected).
- /// Make `expected <: actual`
+ /// Makes `expected <: actual`.
pub fn sub<T>(self,
a: &T,
b: &T)
})
}
- /// Make `a == b`; the expectation is set by the call to
+ /// Makes `a == b`; the expectation is set by the call to
/// `trace()`.
pub fn eq<T>(self,
a: &T,
}
/// A hacky variant of `canonicalize_query` that does not
- /// canonicalize `'static`. Unfortunately, the existing leak
+ /// canonicalize `'static`. Unfortunately, the existing leak
/// check treaks `'static` differently in some cases (see also
/// #33684), so if we are performing an operation that may need to
/// prove "leak-check" related things, we leave `'static`
/// alone.
- ///
- /// FIXME(#48536) -- once we have universes, we can remove this and just use
- /// `canonicalize_query`.
+ //
+ // FIXME(#48536): once we have universes, we can remove this and just use
+ // `canonicalize_query`.
pub fn canonicalize_hr_query_hack<V>(
&self,
value: &V,
.var_universe(vid)
}
- /// Create a canonical variable (with the given `info`)
+ /// Creates a canonical variable (with the given `info`)
/// representing the region `r`; return a region referencing it.
fn canonical_var_for_region(
&mut self,
///
/// This is only meant to be invoked as part of constructing an
/// inference context at the start of a query (see
- /// `InferCtxtBuilder::enter_with_canonical`). It basically
+ /// `InferCtxtBuilder::enter_with_canonical`). It basically
/// brings the canonical value "into scope" within your new infcx.
///
/// At the end of processing, the substitution S (once
self.var_values.len()
}
- /// Make an identity substitution from this one: each bound var
+ /// Makes an identity substitution from this one: each bound var
/// is matched to the same bound var, preserving the original kinds.
/// For example, if we have:
/// `self.var_values == [Type(u32), Lifetime('a), Type(u64)]`
/// If you DO want to keep track of pending obligations (which
/// include all region obligations, so this includes all cases
/// that care about regions) with this function, you have to
- /// do it yourself, by e.g. having them be a part of the answer.
+ /// do it yourself, by e.g., having them be a part of the answer.
pub fn make_query_response_ignoring_pending_obligations<T>(
&self,
inference_vars: CanonicalVarValues<'tcx>,
/// they should be ignored).
/// - It **can happen** (though it rarely does currently) that
/// equating types and things will give rise to subobligations
- /// that must be processed. In this case, those subobligations
+ /// that must be processed. In this case, those subobligations
/// are propagated back in the return value.
/// - Finally, the query result (of type `R`) is propagated back,
/// after applying the substitution `S`.
/// Given a "guess" at the values for the canonical variables in
/// the input, try to unify with the *actual* values found in the
- /// query result. Often, but not always, this is a no-op, because
+ /// query result. Often, but not always, this is a no-op, because
/// we already found the mapping in the "guessing" step.
///
/// See also: `query_response_substitution_guess`
Glb::new(self, a_is_expected)
}
- /// Here dir is either EqTo, SubtypeOf, or SupertypeOf. The
- /// idea is that we should ensure that the type `a_ty` is equal
+ /// Here, `dir` is either `EqTo`, `SubtypeOf`, or `SupertypeOf`.
+ /// The idea is that we should ensure that the type `a_ty` is equal
/// to, a subtype of, or a supertype of (respectively) the type
/// to which `b_vid` is bound.
///
struct Generalizer<'cx, 'gcx: 'cx+'tcx, 'tcx: 'cx> {
infcx: &'cx InferCtxt<'cx, 'gcx, 'tcx>,
- /// Span, used when creating new type variables and things.
+ /// The span, used when creating new type variables and things.
span: Span,
/// The vid of the type variable that is in the process of being
/// particular around 'bivariant' type parameters that are only
/// constrained by a where-clause. As an example, imagine a type:
///
- /// struct Foo<A, B> where A: Iterator<Item=B> {
+ /// struct Foo<A, B> where A: Iterator<Item = B> {
/// data: A
/// }
///
/// <: ?C`, but no particular relationship between `?B` and `?D`
/// (after all, we do not know the variance of the normalized form
/// of `A::Item` with respect to `A`). If we do nothing else, this
- /// may mean that `?D` goes unconstrained (as in #41677). So, in
+ /// may mean that `?D` goes unconstrained (as in #41677). So, in
/// this scenario where we create a new type variable in a
/// bivariant context, we set the `needs_wf` flag to true. This
/// will force the calling code to check that `WF(Foo<?C, ?D>)`
use super::{InferCtxt, RegionVariableOrigin, SubregionOrigin, TypeTrace, ValuePairs};
use crate::infer::{self, SuppressRegionErrors};
-use crate::errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString};
use crate::hir;
use crate::hir::def_id::DefId;
use crate::hir::Node;
use crate::middle::region;
-use std::{cmp, fmt};
-use syntax::ast::DUMMY_NODE_ID;
-use syntax_pos::{Pos, Span};
use crate::traits::{ObligationCause, ObligationCauseCode};
use crate::ty::error::TypeError;
use crate::ty::{self, subst::Subst, Region, Ty, TyCtxt, TyKind, TypeFoldable};
+use errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString};
+use std::{cmp, fmt};
+use syntax_pos::{Pos, Span};
mod note;
let cm = self.sess.source_map();
let scope = region.free_region_binding_scope(self);
- let node = self.hir().as_local_node_id(scope).unwrap_or(DUMMY_NODE_ID);
- let tag = match self.hir().find(node) {
+ let node = self.hir().as_local_hir_id(scope).unwrap_or(hir::DUMMY_HIR_ID);
+ let tag = match self.hir().find_by_hir_id(node) {
Some(Node::Block(_)) | Some(Node::Expr(_)) => "body",
Some(Node::Item(it)) => Self::item_scope_tag(&it),
Some(Node::TraitItem(it)) => Self::trait_item_scope_tag(&it),
};
let (prefix, span) = match *region {
ty::ReEarlyBound(ref br) => {
- let mut sp = cm.def_span(self.hir().span(node));
+ let mut sp = cm.def_span(self.hir().span_by_hir_id(node));
if let Some(param) = self.hir()
.get_generics(scope)
.and_then(|generics| generics.get_named(&br.name))
bound_region: ty::BoundRegion::BrNamed(_, ref name),
..
}) => {
- let mut sp = cm.def_span(self.hir().span(node));
+ let mut sp = cm.def_span(self.hir().span_by_hir_id(node));
if let Some(param) = self.hir()
.get_generics(scope)
.and_then(|generics| generics.get_named(&name))
ty::ReFree(ref fr) => match fr.bound_region {
ty::BrAnon(idx) => (
format!("the anonymous lifetime #{} defined on", idx + 1),
- self.hir().span(node),
+ self.hir().span_by_hir_id(node),
),
ty::BrFresh(_) => (
"an anonymous lifetime defined on".to_owned(),
- self.hir().span(node),
+ self.hir().span_by_hir_id(node),
),
_ => (
format!("the lifetime {} as defined on", fr.bound_region),
- cm.def_span(self.hir().span(node)),
+ cm.def_span(self.hir().span_by_hir_id(node)),
),
},
_ => bug!(),
}
}
}
- ObligationCauseCode::MatchExpressionArm { arm_span, source } => match source {
+ ObligationCauseCode::MatchExpressionArm {
+ source,
+ ref prior_arms,
+ last_ty,
+ ..
+ } => match source {
hir::MatchSource::IfLetDesugar { .. } => {
- let msg = "`if let` arm with an incompatible type";
- if self.tcx.sess.source_map().is_multiline(arm_span) {
- err.span_note(arm_span, msg);
- } else {
- err.span_label(arm_span, msg);
- }
+ let msg = "`if let` arms have incompatible types";
+ err.span_label(cause.span, msg);
}
hir::MatchSource::TryDesugar => {}
_ => {
- let msg = "match arm with an incompatible type";
- if self.tcx.sess.source_map().is_multiline(arm_span) {
- err.span_note(arm_span, msg);
- } else {
- err.span_label(arm_span, msg);
+ let msg = "`match` arms have incompatible types";
+ err.span_label(cause.span, msg);
+ if prior_arms.len() <= 4 {
+ for sp in prior_arms {
+ err.span_label(*sp, format!(
+ "this is found to be of type `{}`",
+ last_ty,
+ ));
+ }
+ } else if let Some(sp) = prior_arms.last() {
+ err.span_label(*sp, format!(
+ "this and all prior arms are found to be of type `{}`", last_ty,
+ ));
}
}
},
None
}
- /// Add a `,` to the type representation only if it is appropriate.
+ /// Adds a `,` to the type representation only if it is appropriate.
fn push_comma(
&self,
value: &mut DiagnosticStyledString,
substs.truncate_to(self.tcx, &generics)
}
- /// Compare two given types, eliding parts that are the same between them and highlighting
+ /// Compares two given types, eliding parts that are the same between them and highlighting
/// relevant differences, and return two representation of those types for highlighted printing.
fn cmp(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) -> (DiagnosticStyledString, DiagnosticStyledString) {
fn equals<'tcx>(a: &Ty<'tcx>, b: &Ty<'tcx>) -> bool {
format!(" for lifetime parameter `{}` in coherence check", name)
}
infer::UpvarRegion(ref upvar_id, _) => {
- let var_node_id = self.tcx.hir().hir_to_node_id(upvar_id.var_path.hir_id);
- let var_name = self.tcx.hir().name(var_node_id);
+ let var_name = self.tcx.hir().name_by_hir_id(upvar_id.var_path.hir_id);
format!(" for capture of `{}` by closure", var_name)
}
infer::NLL(..) => bug!("NLL variable found in lexical phase"),
use crate::ty::{self, Ty, Infer, TyVar};
use syntax::source_map::CompilerDesugaringKind;
use syntax_pos::Span;
-use crate::errors::DiagnosticBuilder;
+use errors::DiagnosticBuilder;
struct FindLocalByTypeVisitor<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
}
impl<'a, 'gcx, 'tcx> FindLocalByTypeVisitor<'a, 'gcx, 'tcx> {
- fn node_matches_type(&mut self, node_id: HirId) -> bool {
+ fn node_matches_type(&mut self, hir_id: HirId) -> bool {
let ty_opt = self.infcx.in_progress_tables.and_then(|tables| {
- tables.borrow().node_id_to_type_opt(node_id)
+ tables.borrow().node_type_opt(hir_id)
});
match ty_opt {
Some(ty) => {
};
if let Some(body_id) = body_id {
- let expr = self.tcx.hir().expect_expr(body_id.node_id);
+ let expr = self.tcx.hir().expect_expr_by_hir_id(body_id.hir_id);
local_visitor.visit_expr(expr);
}
/// x.push(y);
/// ^ ...but data from `y` flows into `x` here
/// }
- /// ````
+ /// ```
///
/// It will later be extended to trait objects.
pub(super) fn try_report_anon_anon_conflict(&self) -> Option<ErrorReported> {
use crate::infer::InferCtxt;
use crate::infer::lexical_region_resolve::RegionResolutionError;
use crate::infer::lexical_region_resolve::RegionResolutionError::*;
-use syntax::source_map::Span;
use crate::ty::{self, TyCtxt};
use crate::util::common::ErrorReported;
+use errors::DiagnosticBuilder;
+use syntax::source_map::Span;
mod different_lifetimes;
mod find_anon_type;
self.infcx.tcx
}
- pub fn try_report_from_nll(&self) -> Option<ErrorReported> {
+ pub fn try_report_from_nll(&self) -> Option<DiagnosticBuilder<'cx>> {
// Due to the improved diagnostics returned by the MIR borrow checker, only a subset of
// the nice region errors are required when running under the MIR borrow checker.
self.try_report_named_anon_conflict()
pub fn try_report(&self) -> Option<ErrorReported> {
self.try_report_from_nll()
+ .map(|mut diag| { diag.emit(); ErrorReported })
.or_else(|| self.try_report_anon_anon_conflict())
.or_else(|| self.try_report_outlives_closure())
.or_else(|| self.try_report_static_impl_trait())
//! where one region is named and the other is anonymous.
use crate::infer::error_reporting::nice_region_error::NiceRegionError;
use crate::ty;
-use crate::util::common::ErrorReported;
-use crate::errors::Applicability;
+use errors::{Applicability, DiagnosticBuilder};
impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> {
/// When given a `ConcreteFailure` for a function with arguments containing a named region and
/// an anonymous region, emit an descriptive diagnostic error.
- pub(super) fn try_report_named_anon_conflict(&self) -> Option<ErrorReported> {
+ pub(super) fn try_report_named_anon_conflict(&self) -> Option<DiagnosticBuilder<'a>> {
let (span, sub, sup) = self.get_regions();
debug!(
("parameter type".to_owned(), "type".to_owned())
};
- struct_span_err!(
+ let mut diag = struct_span_err!(
self.tcx().sess,
span,
E0621,
"explicit lifetime required in {}",
error_var
- ).span_suggestion(
- new_ty_span,
- &format!("add explicit lifetime `{}` to {}", named, span_label_var),
- new_ty.to_string(),
- Applicability::Unspecified,
- )
- .span_label(span, format!("lifetime `{}` required", named))
- .emit();
- return Some(ErrorReported);
+ );
+
+ diag.span_suggestion(
+ new_ty_span,
+ &format!("add explicit lifetime `{}` to {}", named, span_label_var),
+ new_ty.to_string(),
+ Applicability::Unspecified,
+ )
+ .span_label(span, format!("lifetime `{}` required", named));
+
+ Some(diag)
}
// This method returns whether the given Region is Named
-use crate::errors::DiagnosticBuilder;
+use errors::DiagnosticBuilder;
use crate::hir::def_id::DefId;
use crate::infer::error_reporting::nice_region_error::NiceRegionError;
use crate::infer::lexical_region_resolve::RegionResolutionError;
use crate::ty;
use crate::ty::error::ExpectedFound;
use crate::ty::subst::Substs;
-use crate::util::common::ErrorReported;
use crate::util::ppaux::RegionHighlightMode;
impl NiceRegionError<'me, 'gcx, 'tcx> {
/// When given a `ConcreteFailure` for a function with arguments containing a named region and
/// an anonymous region, emit a descriptive diagnostic error.
- pub(super) fn try_report_placeholder_conflict(&self) -> Option<ErrorReported> {
+ pub(super) fn try_report_placeholder_conflict(&self) -> Option<DiagnosticBuilder<'me>> {
match &self.error {
///////////////////////////////////////////////////////////////////////////
// NB. The ordering of cases in this match is very
trait_def_id: DefId,
expected_substs: &'tcx Substs<'tcx>,
actual_substs: &'tcx Substs<'tcx>,
- ) -> ErrorReported {
+ ) -> DiagnosticBuilder<'me> {
debug!(
"try_report_placeholders_trait(\
vid={:?}, \
any_self_ty_has_vid,
);
- err.emit();
- ErrorReported
+ err
}
/// Add notes with details about the expected and actual trait refs, with attention to cases
use crate::infer::lexical_region_resolve::RegionResolutionError;
use crate::ty::{BoundRegion, FreeRegion, RegionKind};
use crate::util::common::ErrorReported;
-use crate::errors::Applicability;
+use errors::Applicability;
impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> {
/// Print the error message for lifetime errors when the return type is a static impl Trait.
// May return None; sometimes the tables are not yet populated.
let ty_hir_id = fn_decl.inputs[index].hir_id;
let arg_ty_span = hir.span(hir.hir_to_node_id(ty_hir_id));
- let ty = tables.node_id_to_type_opt(arg.hir_id)?;
+ let ty = tables.node_type_opt(arg.hir_id)?;
let mut found_anon_region = false;
let new_arg_ty = self.tcx().fold_regions(&ty, &mut false, |r, _| {
if *r == *anon_region {
use crate::middle::region;
use crate::ty::{self, Region};
use crate::ty::error::TypeError;
-use crate::errors::DiagnosticBuilder;
+use errors::DiagnosticBuilder;
impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
pub(super) fn note_region_origin(&self,
"...so that reference does not outlive borrowed content");
}
infer::ReborrowUpvar(span, ref upvar_id) => {
- let var_node_id = self.tcx.hir().hir_to_node_id(upvar_id.var_path.hir_id);
- let var_name = self.tcx.hir().name(var_node_id);
+ let var_name = self.tcx.hir().name_by_hir_id(upvar_id.var_path.hir_id);
err.span_note(span,
&format!("...so that closure can access `{}`", var_name));
}
err
}
infer::ReborrowUpvar(span, ref upvar_id) => {
- let var_node_id = self.tcx.hir().hir_to_node_id(upvar_id.var_path.hir_id);
- let var_name = self.tcx.hir().name(var_node_id);
+ let var_name = self.tcx.hir().name_by_hir_id(upvar_id.var_path.hir_id);
let mut err = struct_span_err!(self.tcx.sess,
span,
E0313,
/// closure `f`. In our example above, what this closure will do
/// is to unify the expectation (`Option<&[u32]>`) with the actual
/// return type (`Option<?T>`, where `?T` represents the variable
- /// instantiated for `T`). This will cause `?T` to be unified
+ /// instantiated for `T`). This will cause `?T` to be unified
/// with `&?a [u32]`, where `?a` is a fresh lifetime variable. The
/// input type (`?T`) is then returned by `f()`.
///
/// At this point, `fudge_regions_if_ok` will normalize all type
/// variables, converting `?T` to `&?a [u32]` and end the
- /// snapshot. The problem is that we can't just return this type
+ /// snapshot. The problem is that we can't just return this type
/// out, because it references the region variable `?a`, and that
/// region variable was popped when we popped the snapshot.
///
}
impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
- /// Replace all regions (resp. types) bound by `binder` with placeholder
+ /// Replaces all regions (resp. types) bound by `binder` with placeholder
/// regions (resp. types) and return a map indicating which bound-region
/// placeholder region. This is the first step of checking subtyping
/// when higher-ranked things are involved.
//! # Lattice Variables
//!
//! This file contains generic code for operating on inference variables
-//! that are characterized by an upper- and lower-bound. The logic and
+//! that are characterized by an upper- and lower-bound. The logic and
//! reasoning is explained in detail in the large comment in `infer.rs`.
//!
//! The code in here is defined quite generically so that it can be
//!
//! Although all the functions are generic, we generally write the
//! comments in a way that is specific to type variables and the LUB
-//! operation. It's just easier that way.
+//! operation. It's just easier that way.
//!
//! In general all of the functions are defined parametrically
//! over a `LatticeValue`, which is a value defined with respect to
-//! The code to do lexical region resolution.
+//! Lexical region resolution.
use crate::infer::region_constraints::Constraint;
use crate::infer::region_constraints::GenericKind;
match *value {
VarValue::Value(_) => { /* Inference successful */ }
VarValue::ErrorValue => {
- /* Inference impossible, this value contains
+ /* Inference impossible: this value contains
inconsistent constraints.
I think that in this case we should report an
- error now---unlike the case above, we can't
+ error now -- unlike the case above, we can't
wait to see whether the user needs the result
- of this variable. The reason is that the mere
+ of this variable. The reason is that the mere
existence of this variable implies that the
region graph is inconsistent, whether or not it
is used.
For example, we may have created a region
variable that is the GLB of two other regions
- which do not have a GLB. Even if that variable
+ which do not have a GLB. Even if that variable
is not used, it implies that those two regions
*should* have a GLB.
pub use self::ValuePairs::*;
pub use crate::ty::IntVarValue;
-use arena::SyncDroplessArena;
-use crate::errors::DiagnosticBuilder;
+use crate::hir;
use crate::hir::def_id::DefId;
use crate::infer::canonical::{Canonical, CanonicalVarValues};
use crate::middle::free_region::RegionRelations;
use crate::middle::lang_items;
use crate::middle::region;
-use rustc_data_structures::unify as ut;
use crate::session::config::BorrowckMode;
-use std::cell::{Cell, Ref, RefCell, RefMut};
-use std::collections::BTreeMap;
-use std::fmt;
-use syntax::ast;
-use syntax_pos::symbol::InternedString;
-use syntax_pos::{self, Span};
use crate::traits::{self, ObligationCause, PredicateObligations, TraitEngine};
use crate::ty::error::{ExpectedFound, TypeError, UnconstrainedNumeric};
use crate::ty::fold::TypeFoldable;
use crate::ty::{FloatVid, IntVid, TyVid};
use crate::util::nodemap::FxHashMap;
+use arena::SyncDroplessArena;
+use errors::DiagnosticBuilder;
+use rustc_data_structures::unify as ut;
+use std::cell::{Cell, Ref, RefCell, RefMut};
+use std::collections::BTreeMap;
+use std::fmt;
+use syntax::ast;
+use syntax_pos::symbol::InternedString;
+use syntax_pos::Span;
+
use self::combine::CombineFields;
use self::lexical_region_resolve::LexicalRegionResolutions;
use self::outlives::env::OutlivesEnvironment;
// for each body-id in this map, which will process the
// obligations within. This is expected to be done 'late enough'
// that all type inference variables have been bound and so forth.
- pub region_obligations: RefCell<Vec<(ast::NodeId, RegionObligation<'tcx>)>>,
+ pub region_obligations: RefCell<Vec<(hir::HirId, RegionObligation<'tcx>)>>,
/// What is the innermost universe we have created? Starts out as
/// `UniverseIndex::root()` but grows from there as we enter
/// replaced with.
pub type PlaceholderMap<'tcx> = BTreeMap<ty::BoundRegion, ty::Region<'tcx>>;
-/// See `error_reporting` module for more details
+/// See the `error_reporting` module for more details.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ValuePairs<'tcx> {
Types(ExpectedFound<Ty<'tcx>>),
/// The trace designates the path through inference that we took to
/// encounter an error or subtyping constraint.
///
-/// See `error_reporting` module for more details.
+/// See the `error_reporting` module for more details.
#[derive(Clone)]
pub struct TypeTrace<'tcx> {
cause: ObligationCause<'tcx>,
}
}
-/// Helper type of a temporary returned by tcx.infer_ctxt().
+/// Helper type of a temporary returned by `tcx.infer_ctxt()`.
/// Necessary because we can't write the following bound:
-/// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(InferCtxt<'b, 'gcx, 'tcx>).
+/// `F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(InferCtxt<'b, 'gcx, 'tcx>)`.
pub struct InferCtxtBuilder<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
global_tcx: TyCtxt<'a, 'gcx, 'gcx>,
arena: SyncDroplessArena,
/// inference context that contains each of the bound values
/// within instantiated as a fresh variable. The `f` closure is
/// invoked with the new infcx, along with the instantiated value
- /// `V` and a substitution `S`. This substitution `S` maps from
+ /// `V` and a substitution `S`. This substitution `S` maps from
/// the bound values in `C` to their instantiated values in `V`
/// (in other words, `S(C) = V`).
pub fn enter_with_canonical<T, R>(
}
}
- /// Extract `value`, registering any obligations into `fulfill_cx`
+ /// Extracts `value`, registering any obligations into `fulfill_cx`.
pub fn into_value_registering_obligations(
self,
infcx: &InferCtxt<'_, '_, 'tcx>,
.commit(region_constraints_snapshot);
}
- /// Execute `f` and commit the bindings
+ /// Executes `f` and commit the bindings.
pub fn commit_unconditionally<R, F>(&self, f: F) -> R
where
F: FnOnce() -> R,
r
}
- /// Execute `f` and commit the bindings if closure `f` returns `Ok(_)`
+ /// Executes `f` and commit the bindings if closure `f` returns `Ok(_)`.
pub fn commit_if_ok<T, E, F>(&self, f: F) -> Result<T, E>
where
F: FnOnce(&CombinedSnapshot<'a, 'tcx>) -> Result<T, E>,
r
}
- /// Execute `f` then unroll any bindings it creates
+ /// Executes `f` then unroll any bindings it creates.
pub fn probe<R, F>(&self, f: F) -> R
where
F: FnOnce(&CombinedSnapshot<'a, 'tcx>) -> R,
self.float_unification_table.borrow_mut().new_key(None)
}
- /// Create a fresh region variable with the next available index.
+ /// Creates a fresh region variable with the next available index.
/// The variable will be created in the maximum universe created
/// thus far, allowing it to name any region created thus far.
pub fn next_region_var(&self, origin: RegionVariableOrigin) -> ty::Region<'tcx> {
self.next_region_var_in_universe(origin, self.universe())
}
- /// Create a fresh region variable with the next available index
+ /// Creates a fresh region variable with the next available index
/// in the given universe; typically, you can use
/// `next_region_var` and just use the maximal universe.
pub fn next_region_var_in_universe(
Substs::for_item(self.tcx, def_id, |param, _| self.var_for_def(span, param))
}
- /// True if errors have been reported since this infcx was
- /// created. This is sometimes used as a heuristic to skip
+ /// Returns `true` if errors have been reported since this infcx was
+ /// created. This is sometimes used as a heuristic to skip
/// reporting errors that often occur as a result of earlier
/// errors, but where it's hard to be 100% sure (e.g., unresolved
/// inference variables, regionck errors).
value.fold_with(&mut r)
}
- /// Returns true if `T` contains unresolved type variables. In the
+ /// Returns `true` if `T` contains unresolved type variables. In the
/// process of visiting `T`, this will resolve (where possible)
/// type variables in `T`, but it never constructs the final,
/// resolved type, so it's more efficient than
value.visit_with(&mut r)
}
- pub fn resolve_type_and_region_vars_if_possible<T>(&self, value: &T) -> T
- where
- T: TypeFoldable<'tcx>,
- {
- let mut r = resolve::OpportunisticTypeAndRegionResolver::new(self);
- value.fold_with(&mut r)
- }
-
pub fn fully_resolve<T: TypeFoldable<'tcx>>(&self, value: &T) -> FixupResult<T> {
/*!
* Attempts to resolve all type/region variables in
self.tcx.replace_bound_vars(value, fld_r, fld_t)
}
- /// See `verify_generic_bound` method in `region_constraints`
+ /// See the [`region_constraints::verify_generic_bound`] method.
pub fn verify_generic_bound(
&self,
origin: SubregionOrigin<'tcx>,
closure_kind_ty.to_opt_closure_kind()
}
- /// Obtain the signature of a closure. For closures, unlike
+ /// Obtain the signature of a closure. For closures, unlike
/// `tcx.fn_sig(def_id)`, this method will work during the
/// type-checking of the enclosing function and return the closure
/// signature in its partially inferred state.
pub fn partially_normalize_associated_types_in<T>(
&self,
span: Span,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
param_env: ty::ParamEnv<'tcx>,
value: &T,
) -> InferOk<'tcx, T>
}
/// Clears the selection, evaluation, and projection caches. This is useful when
- /// repeatedly attempting to select an Obligation while changing only
- /// its ParamEnv, since FulfillmentContext doesn't use 'probe'
+ /// repeatedly attempting to select an `Obligation` while changing only
+ /// its `ParamEnv`, since `FulfillmentContext` doesn't use probing.
pub fn clear_caches(&self) {
self.selection_cache.clear();
self.evaluation_cache.clear();
self.universe.get()
}
- /// Create and return a fresh universe that extends all previous
+ /// Creates and return a fresh universe that extends all previous
/// universes. Updates `self.universe` to that new universe.
pub fn create_next_universe(&self) -> ty::UniverseIndex {
let u = self.universe.get().next_universe();
/// How are we relating `a` and `b`?
///
- /// - covariant means `a <: b`
- /// - contravariant means `b <: a`
- /// - invariant means `a == b
- /// - bivariant means that it doesn't matter
+ /// - Covariant means `a <: b`.
+ /// - Contravariant means `b <: a`.
+ /// - Invariant means `a == b.
+ /// - Bivariant means that it doesn't matter.
ambient_variance: ty::Variance,
/// When we pass through a set of binders (e.g., when looking into
- /// a `fn` type), we push a new bound region scope onto here. This
+ /// a `fn` type), we push a new bound region scope onto here. This
/// will contain the instantiated region for each region in those
/// binders. When we then encounter a `ReLateBound(d, br)`, we can
- /// use the debruijn index `d` to find the right scope, and then
+ /// use the De Bruijn index `d` to find the right scope, and then
/// bound region name `br` to find the specific instantiation from
/// within that scope. See `replace_bound_region`.
///
/// Define the normalization strategy to use, eager or lazy.
fn normalization() -> NormalizationStrategy;
- /// Enable some optimizations if we do not expect inference variables
+ /// Enables some optimizations if we do not expect inference variables
/// in the RHS of the relation.
fn forbid_inference_vars() -> bool;
}
/// When we encounter binders during the type traversal, we record
/// the value to substitute for each of the things contained in
/// that binder. (This will be either a universal placeholder or
- /// an existential inference variable.) Given the debruijn index
+ /// an existential inference variable.) Given the De Bruijn index
/// `debruijn` (and name `br`) of some binder we have now
/// encountered, this routine finds the value that we instantiated
/// the region with; to do so, it indexes backwards into the list
/// lifetime parameter on `foo`.)
pub concrete_ty: Ty<'tcx>,
- /// True if the `impl Trait` bounds include region bounds.
+ /// Returns `true` if the `impl Trait` bounds include region bounds.
/// For example, this would be true for:
///
/// fn foo<'a, 'b, 'c>() -> impl Trait<'c> + 'a + 'b
}
impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
- /// Replace all opaque types in `value` with fresh inference variables
+ /// Replaces all opaque types in `value` with fresh inference variables
/// and creates appropriate obligations. For example, given the input:
///
/// impl Iterator<Item = impl Debug>
///
/// # Parameters
///
- /// - `parent_def_id` -- the def-id of the function in which the opaque type
+ /// - `parent_def_id` -- the `DefId` of the function in which the opaque type
/// is defined
/// - `body_id` -- the body-id with which the resulting obligations should
/// be associated
pub fn instantiate_opaque_types<T: TypeFoldable<'tcx>>(
&self,
parent_def_id: DefId,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
param_env: ty::ParamEnv<'tcx>,
value: &T,
) -> InferOk<'tcx, (T, OpaqueTypeMap<'tcx>)> {
///
/// # The Problem
///
- /// Let's work through an example to explain how it works. Assume
+ /// Let's work through an example to explain how it works. Assume
/// the current function is as follows:
///
/// ```text
/// replace each of the references (`Foo1<'a>`, `Foo2<'b>`) with
/// fresh inference variables C1 and C2. We wish to use the values
/// of these variables to infer the underlying types of `Foo1` and
- /// `Foo2`. That is, this gives rise to higher-order (pattern) unification
+ /// `Foo2`. That is, this gives rise to higher-order (pattern) unification
/// constraints like:
///
/// ```text
///
/// Ordinarily, the subtyping rules would ensure that these are
/// sufficiently large. But since `impl Bar<'a>` isn't a specific
- /// type per se, we don't get such constraints by default. This
+ /// type per se, we don't get such constraints by default. This
/// is where this function comes into play. It adds extra
/// constraints to ensure that all the regions which appear in the
/// inferred type are regions that could validly appear.
struct Instantiator<'a, 'gcx: 'tcx, 'tcx: 'a> {
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
parent_def_id: DefId,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
param_env: ty::ParamEnv<'tcx>,
opaque_types: OpaqueTypeMap<'tcx>,
obligations: Vec<PredicateObligation<'tcx>>,
}
}
-/// Whether `opaque_node_id` is a sibling or a child of a sibling of `def_id`
+/// Returns `true` if `opaque_node_id` is a sibling or a child of a sibling of `def_id`.
///
/// ```rust
/// pub mod foo {
/// }
/// ```
///
-/// Here, `def_id` will be the `DefId` of the existential type `Baz`.
-/// `opaque_node_id` is the `NodeId` of the reference to Baz --
-/// so either the return type of f1 or f2.
-/// We will return true if the reference is within the same module as the existential type
-/// So true for f1, false for f2.
+/// Here, `def_id` is the `DefId` of the existential type `Baz` and `opaque_node_id` is the
+/// `NodeId` of the reference to `Baz` (i.e., the return type of both `f1` and `f2`).
+/// We return `true` if the reference is within the same module as the existential type
+/// (i.e., `true` for `f1`, `false` for `f2`).
pub fn may_define_existential_type(
tcx: TyCtxt<'_, '_, '_>,
def_id: DefId,
use crate::infer::outlives::free_region_map::FreeRegionMap;
use crate::infer::{GenericKind, InferCtxt};
+use crate::hir;
use rustc_data_structures::fx::FxHashMap;
-use syntax::ast;
use syntax_pos::Span;
use crate::traits::query::outlives_bounds::{self, OutlivesBound};
use crate::ty::{self, Ty};
// results when proving outlives obligations like `T: 'x` later
// (e.g., if `T: 'x` must be proven within the body B1, then we
// know it is true if either `'a: 'x` or `'b: 'x`).
- region_bound_pairs_map: FxHashMap<ast::NodeId, RegionBoundPairs<'tcx>>,
+ region_bound_pairs_map: FxHashMap<hir::HirId, RegionBoundPairs<'tcx>>,
// Used to compute `region_bound_pairs_map`: contains the set of
// in-scope region-bound pairs thus far.
}
/// "Region-bound pairs" tracks outlives relations that are known to
-/// be true, either because of explicit where clauses like `T: 'a` or
+/// be true, either because of explicit where-clauses like `T: 'a` or
/// because of implied bounds.
pub type RegionBoundPairs<'tcx> = Vec<(ty::Region<'tcx>, GenericKind<'tcx>)>;
}
/// Borrows current value of the `region_bound_pairs`.
- pub fn region_bound_pairs_map(&self) -> &FxHashMap<ast::NodeId, RegionBoundPairs<'tcx>> {
+ pub fn region_bound_pairs_map(&self) -> &FxHashMap<hir::HirId, RegionBoundPairs<'tcx>> {
&self.region_bound_pairs_map
}
&mut self,
infcx: &InferCtxt<'a, 'gcx, 'tcx>,
fn_sig_tys: &[Ty<'tcx>],
- body_id: ast::NodeId,
+ body_id: hir::HirId,
span: Span,
) {
debug!("add_implied_bounds()");
}
/// Save the current set of region-bound pairs under the given `body_id`.
- pub fn save_implied_bounds(&mut self, body_id: ast::NodeId) {
+ pub fn save_implied_bounds(&mut self, body_id: hir::HirId) {
let old = self.region_bound_pairs_map.insert(
body_id,
self.region_bound_pairs_accum.clone(),
}
}
- /// Compute the least-upper-bound of two free regions. In some
+ /// Computes the least-upper-bound of two free regions. In some
/// cases, this is more conservative than necessary, in order to
/// avoid making arbitrary choices. See
/// `TransitiveRelation::postdom_upper_bound` for more details.
//! fn foo<U, F: for<'a> FnMut(&'a U)>(_f: F) {}
//! ```
//!
-//! the type of the closure's first argument would be `&'a ?U`. We
+//! the type of the closure's first argument would be `&'a ?U`. We
//! might later infer `?U` to something like `&'b u32`, which would
//! imply that `'b: 'a`.
use crate::infer::outlives::verify::VerifyBoundCx;
use crate::infer::{self, GenericKind, InferCtxt, RegionObligation, SubregionOrigin, VerifyBound};
use rustc_data_structures::fx::FxHashMap;
-use syntax::ast;
+use crate::hir;
use crate::traits::ObligationCause;
use crate::ty::outlives::Component;
use crate::ty::{self, Region, Ty, TyCtxt, TypeFoldable};
/// information).
pub fn register_region_obligation(
&self,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
obligation: RegionObligation<'tcx>,
) {
debug!(
}
/// Trait queries just want to pass back type obligations "as is"
- pub fn take_registered_region_obligations(&self) -> Vec<(ast::NodeId, RegionObligation<'tcx>)> {
+ pub fn take_registered_region_obligations(&self) -> Vec<(hir::HirId, RegionObligation<'tcx>)> {
::std::mem::replace(&mut *self.region_obligations.borrow_mut(), vec![])
}
/// processed.
pub fn process_registered_region_obligations(
&self,
- region_bound_pairs_map: &FxHashMap<ast::NodeId, RegionBoundPairs<'tcx>>,
+ region_bound_pairs_map: &FxHashMap<hir::HirId, RegionBoundPairs<'tcx>>,
implicit_region_bound: Option<ty::Region<'tcx>>,
param_env: ty::ParamEnv<'tcx>,
) {
/// This is an "approximate" check -- it may not find all
/// applicable bounds, and not all the bounds it returns can be
/// relied upon. In particular, this check ignores region
- /// identity. So, for example, if we have `<T as
+ /// identity. So, for example, if we have `<T as
/// Trait<'0>>::Item` where `'0` is a region variable, and the
/// user has `<T as Trait<'a>>::Item: 'b` in the environment, then
/// the clause from the environment only applies if `'0 = 'a`,
})
}
- /// Searches the where clauses in scope for regions that
+ /// Searches the where-clauses in scope for regions that
/// `projection_ty` is known to outlive. Currently requires an
/// exact match.
pub fn projection_declared_bounds_from_trait(
.map(move |r| r.subst(tcx, projection_ty.substs))
}
- /// Given the def-id of an associated item, returns any region
+ /// Given the `DefId` of an associated item, returns any region
/// bounds attached to that associated item from the trait definition.
///
/// For example:
/// }
/// ```
///
- /// If we were given the def-id of `Foo::Bar`, we would return
+ /// If we were given the `DefId` of `Foo::Bar`, we would return
/// `'a`. You could then apply the substitutions from the
/// projection to convert this into your namespace. This also
/// works if the user writes `where <Self as Foo<'a>>::Bar: 'a` on
-//! See README.md
+//! See `README.md`.
use self::CombineMapType::*;
use self::UndoLog::*;
pub givens: FxHashSet<(Region<'tcx>, ty::RegionVid)>,
}
-/// A constraint that influences the inference process.
+/// Represents a constraint that influences the inference process.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
pub enum Constraint<'tcx> {
- /// One region variable is subregion of another
+ /// A region variable is a subregion of another.
VarSubVar(RegionVid, RegionVid),
- /// Concrete region is subregion of region variable
+ /// A concrete region is a subregion of region variable.
RegSubVar(Region<'tcx>, RegionVid),
- /// Region variable is subregion of concrete region. This does not
+ /// A region variable is a subregion of a concrete region. This does not
/// directly affect inference, but instead is checked after
/// inference is complete.
VarSubReg(RegionVid, Region<'tcx>),
}
}
-/// VerifyGenericBound(T, _, R, RS): The parameter type `T` (or
+/// `VerifyGenericBound(T, _, R, RS)`: the parameter type `T` (or
/// associated type) must outlive the region `R`. `T` is known to
-/// outlive `RS`. Therefore verify that `R <= RS[i]` for some
+/// outlive `RS`. Therefore, verify that `R <= RS[i]` for some
/// `i`. Inference variables may be involved (but this verification
/// step doesn't influence inference).
#[derive(Debug, Clone)]
}
}
-/// Describes the things that some `GenericKind` value G is known to
+/// Describes the things that some `GenericKind` value `G` is known to
/// outlive. Each variant of `VerifyBound` can be thought of as a
/// function:
///
/// following, where `G` is the generic for which this verify
/// bound was created:
///
- /// fn(min) -> bool {
- /// if G == K {
+ /// ```rust
+ /// fn(min) -> bool {
+ /// if G == K {
/// B(min)
- /// } else {
+ /// } else {
/// false
- /// }
/// }
+ /// }
+ /// ```
///
/// In other words, if the generic `G` that we are checking is
/// equal to `K`, then check the associated verify bound
/// This is used when we have something in the environment that
/// may or may not be relevant, depending on the region inference
/// results. For example, we may have `where <T as
- /// Trait<'a>>::Item: 'b` in our where clauses. If we are
+ /// Trait<'a>>::Item: 'b` in our where-clauses. If we are
/// generating the verify-bound for `<T as Trait<'0>>::Item`, then
/// this where-clause is only relevant if `'0` winds up inferred
/// to `'a`.
///
/// So we would compile to a verify-bound like
///
- /// IfEq(<T as Trait<'a>>::Item, AnyRegion('a))
+ /// ```
+ /// IfEq(<T as Trait<'a>>::Item, AnyRegion('a))
+ /// ```
///
/// meaning, if the subject G is equal to `<T as Trait<'a>>::Item`
/// (after inference), and `'a: min`, then `G: min`.
/// Given a region `R`, expands to the function:
///
- /// fn(min) -> bool {
- /// R: min
- /// }
+ /// ```
+ /// fn(min) -> bool {
+ /// R: min
+ /// }
+ /// ```
///
/// This is used when we can establish that `G: R` -- therefore,
/// if `R: min`, then by transitivity `G: min`.
/// Given a set of bounds `B`, expands to the function:
///
- /// fn(min) -> bool {
- /// exists (b in B) { b(min) }
- /// }
+ /// ```rust
+ /// fn(min) -> bool {
+ /// exists (b in B) { b(min) }
+ /// }
+ /// ```
///
/// In other words, if we meet some bound in `B`, that suffices.
- /// This is used when all the bounds in `B` are known to apply to
- /// G.
+ /// This is used when all the bounds in `B` are known to apply to `G`.
AnyBound(Vec<VerifyBound<'tcx>>),
/// Given a set of bounds `B`, expands to the function:
///
- /// fn(min) -> bool {
- /// forall (b in B) { b(min) }
- /// }
+ /// ```rust
+ /// fn(min) -> bool {
+ /// forall (b in B) { b(min) }
+ /// }
+ /// ```
///
/// In other words, if we meet *all* bounds in `B`, that suffices.
/// This is used when *some* bound in `B` is known to suffice, but
#[derive(Copy, Clone, PartialEq)]
enum UndoLog<'tcx> {
- /// We added `RegionVid`
+ /// We added `RegionVid`.
AddVar(RegionVid),
- /// We added the given `constraint`
+ /// We added the given `constraint`.
AddConstraint(Constraint<'tcx>),
- /// We added the given `verify`
+ /// We added the given `verify`.
AddVerify(usize),
- /// We added the given `given`
+ /// We added the given `given`.
AddGiven(Region<'tcx>, ty::RegionVid),
- /// We added a GLB/LUB "combination variable"
+ /// We added a GLB/LUB "combination variable".
AddCombination(CombineMapType, TwoRegions<'tcx>),
/// During skolemization, we sometimes purge entries from the undo
/// When working with placeholder regions, we often wish to find all of
/// the regions that are either reachable from a placeholder region, or
/// which can reach a placeholder region, or both. We call such regions
-/// *tainted* regions. This struct allows you to decide what set of
+/// *tainted* regions. This struct allows you to decide what set of
/// tainted regions you want.
#[derive(Debug)]
pub struct TaintDirections {
/// Takes (and clears) the current set of constraints. Note that
/// the set of variables remains intact, but all relationships
- /// between them are reset. This is used during NLL checking to
+ /// between them are reset. This is used during NLL checking to
/// grab the set of constraints that arose from a particular
/// operation.
///
}
}
- /// See `Verify::VerifyGenericBound`
+ /// See [`Verify::VerifyGenericBound`].
pub fn verify_generic_bound(
&mut self,
origin: SubregionOrigin<'tcx>,
}).collect()
}
- /// See [`RegionInference::region_constraints_added_in_snapshot`]
+ /// See [`RegionInference::region_constraints_added_in_snapshot`].
pub fn region_constraints_added_in_snapshot(&self, mark: &RegionSnapshot) -> Option<bool> {
self.undo_log[mark.length..]
.iter()
}
impl<'tcx> RegionConstraintData<'tcx> {
- /// True if this region constraint data contains no constraints.
+ /// Returns `true` if this region constraint data contains no constraints, and `false`
+ /// otherwise.
pub fn is_empty(&self) -> bool {
let RegionConstraintData {
constraints,
self.sub_relations.find(vid)
}
- /// True if `a` and `b` have same "sub-root" (i.e., exists some
+ /// Returns `true` if `a` and `b` have same "sub-root" (i.e., exists some
/// type X such that `forall i in {a, b}. (i <: X || X <: i)`.
pub fn sub_unified(&mut self, a: ty::TyVid, b: ty::TyVid) -> bool {
self.sub_root_var(a) == self.sub_root_var(b)
}
}
- /// Creates a snapshot of the type variable state. This snapshot
+ /// Creates a snapshot of the type variable state. This snapshot
/// must later be committed (`commit()`) or rolled back
- /// (`rollback_to()`). Nested snapshots are permitted, but must
+ /// (`rollback_to()`). Nested snapshots are permitted, but must
/// be processed in a stack-like fashion.
pub fn snapshot(&mut self) -> Snapshot<'tcx> {
Snapshot {
.collect()
}
- /// Find the set of type variables that existed *before* `s`
+ /// Finds the set of type variables that existed *before* `s`
/// but which have only been unified since `s` started, and
/// return the types with which they were unified. So if we had
/// a type variable `V0`, then we started the snapshot, then we
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_attrs)]
#![feature(slice_patterns)]
-#![feature(slice_sort_by_cached_key)]
#![feature(specialization)]
#![feature(unboxed_closures)]
#![feature(thread_local)]
pub use crate::lint;
}
-use rustc_errors as errors;
-
// FIXME(#27438): right now the unit tests of librustc don't refer to any actual
// functions generated in librustc_data_structures (all
// references are through generic functions), but statics are
//! compiler code, rather than using their own custom pass. Those
//! lints are all available in `rustc_lint::builtin`.
-use crate::errors::{Applicability, DiagnosticBuilder};
use crate::lint::{LintPass, LateLintPass, LintArray};
use crate::session::Session;
+use errors::{Applicability, DiagnosticBuilder};
use syntax::ast;
use syntax::source_map::Span;
"outlives requirements can be inferred"
}
+declare_lint! {
+ pub DUPLICATE_MATCHER_BINDING_NAME,
+ Warn,
+ "duplicate macro matcher binding name"
+}
+
/// Some lints that are buffered from `libsyntax`. See `syntax::early_buffered_lints`.
pub mod parser {
declare_lint! {
MacroExpandedMacroExportsAccessedByAbsolutePaths(Span),
ElidedLifetimesInPaths(usize, Span, bool, Span, String),
UnknownCrateTypes(Span, String, String),
+ UnusedImports(String, Vec<(Span, String)>),
}
impl BuiltinLintDiagnostics {
BuiltinLintDiagnostics::UnknownCrateTypes(span, note, sugg) => {
db.span_suggestion(span, ¬e, sugg, Applicability::MaybeIncorrect);
}
+ BuiltinLintDiagnostics::UnusedImports(message, replaces) => {
+ if !replaces.is_empty() {
+ db.tool_only_multipart_suggestion(
+ &message,
+ replaces,
+ Applicability::MachineApplicable,
+ );
+ }
+ }
}
}
}
//! The lint checking is mostly consolidated into one pass which runs
//! after all other analyses. Throughout compilation, lint warnings
//! can be added via the `add_lint` method on the Session structure. This
-//! requires a span and an id of the node that the lint is being added to. The
+//! requires a span and an ID of the node that the lint is being added to. The
//! lint isn't actually emitted at that time because it is unknown what the
//! actual lint level at that location is.
//!
//! A context keeps track of the current state of all lint levels.
//! Upon entering a node of the ast which can modify the lint settings, the
//! previous lint state is pushed onto a stack and the ast is then recursed
-//! upon. As the ast is traversed, this keeps track of the current lint level
+//! upon. As the ast is traversed, this keeps track of the current lint level
//! for all lint attributes.
use self::TargetLint::*;
use syntax::ast;
use syntax::edition;
use syntax_pos::{MultiSpan, Span, symbol::{LocalInternedString, Symbol}};
-use crate::errors::DiagnosticBuilder;
+use errors::DiagnosticBuilder;
use crate::hir;
use crate::hir::def_id::LOCAL_CRATE;
use crate::hir::intravisit as hir_visit;
impl<'a, 'tcx> LintContext<'tcx> for LateContext<'a, 'tcx> {
type PassObject = LateLintPassObject;
- /// Get the overall compiler `Session` object.
+ /// Gets the overall compiler `Session` object.
fn sess(&self) -> &Session {
&self.tcx.sess
}
impl<'a> LintContext<'a> for EarlyContext<'a> {
type PassObject = EarlyLintPassObject;
- /// Get the overall compiler `Session` object.
+ /// Gets the overall compiler `Session` object.
fn sess(&self) -> &Session {
&self.sess
}
}
-/// Perform lint checking on a crate.
+/// Performs lint checking on a crate.
///
/// Consumes the `lint_store` field of the `Session`.
pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
use std::cmp;
-use crate::errors::{Applicability, DiagnosticBuilder};
use crate::hir::HirId;
use crate::ich::StableHashingContext;
use crate::lint::builtin;
use crate::lint::context::CheckLintNameResult;
use crate::lint::{self, Lint, LintId, Level, LintSource};
+use crate::session::Session;
+use crate::util::nodemap::FxHashMap;
+use errors::{Applicability, DiagnosticBuilder};
use rustc_data_structures::stable_hasher::{HashStable, ToStableHashKey,
StableHasher, StableHasherResult};
-use crate::session::Session;
use syntax::ast;
use syntax::attr;
use syntax::feature_gate;
use syntax::source_map::MultiSpan;
use syntax::symbol::Symbol;
-use crate::util::nodemap::FxHashMap;
pub struct LintLevelSets {
list: Vec<LintSet>,
use rustc_data_structures::sync::{self, Lrc};
-use crate::errors::{DiagnosticBuilder, DiagnosticId};
use crate::hir::def_id::{CrateNum, LOCAL_CRATE};
use crate::hir::intravisit;
use crate::hir;
-use crate::lint::builtin::BuiltinLintDiagnostics;
+use crate::lint::builtin::{BuiltinLintDiagnostics, DUPLICATE_MATCHER_BINDING_NAME};
use crate::lint::builtin::parser::{QUESTION_MARK_MACRO_SEP, ILL_FORMED_ATTRIBUTE_INPUT};
use crate::session::{Session, DiagnosticMessageId};
+use crate::ty::TyCtxt;
+use crate::ty::query::Providers;
+use crate::util::nodemap::NodeMap;
+use errors::{DiagnosticBuilder, DiagnosticId};
use std::{hash, ptr};
use syntax::ast;
use syntax::source_map::{MultiSpan, ExpnFormat};
use syntax::edition::Edition;
use syntax::symbol::Symbol;
use syntax_pos::Span;
-use crate::ty::TyCtxt;
-use crate::ty::query::Providers;
-use crate::util::nodemap::NodeMap;
pub use crate::lint::context::{LateContext, EarlyContext, LintContext, LintStore,
check_crate, check_ast_crate, CheckLintNameResult,
/// `default_level`.
pub edition_lint_opts: Option<(Edition, Level)>,
- /// Whether this lint is reported even inside expansions of external macros
+ /// `true` if this lint is reported even inside expansions of external macros.
pub report_in_external_macro: bool,
}
match lint_id {
BufferedEarlyLintId::QuestionMarkMacroSep => QUESTION_MARK_MACRO_SEP,
BufferedEarlyLintId::IllFormedAttributeInput => ILL_FORMED_ATTRIBUTE_INPUT,
+ BufferedEarlyLintId::DuplicateMacroMatcherBindingName => DUPLICATE_MATCHER_BINDING_NAME,
}
}
- /// Get the lint's name, with ASCII letters converted to lowercase.
+ /// Gets the lint's name, with ASCII letters converted to lowercase.
pub fn name_lower(&self) -> String {
self.name.to_ascii_lowercase()
}
}
}
-/// Declare a static item of type `&'static Lint`.
+/// Declares a static item of type `&'static Lint`.
#[macro_export]
macro_rules! declare_lint {
($vis: vis $NAME: ident, $Level: ident, $desc: expr) => (
);
}
-/// Declare a static `LintArray` and return it as an expression.
+/// Declares a static `LintArray` and return it as an expression.
#[macro_export]
macro_rules! lint_array {
($( $lint:expr ),* ,) => { lint_array!( $($lint),* ) };
pub trait LintPass {
fn name(&self) -> &'static str;
- /// Get descriptions of the lints this `LintPass` object can emit.
+ /// Gets descriptions of the lints this `LintPass` object can emit.
///
/// N.B., there is no enforcement that the object only emits lints it registered.
/// And some `rustc` internal `LintPass`es register lints to be emitted by other
}
impl LintId {
- /// Get the `LintId` for a `Lint`.
+ /// Gets the `LintId` for a `Lint`.
pub fn of(lint: &'static Lint) -> LintId {
LintId {
lint,
self.lint.name
}
- /// Get the name of the lint.
+ /// Gets the name of the lint.
pub fn to_string(&self) -> String {
self.lint.name_lower()
}
});
impl Level {
- /// Convert a level to a lower-case string.
+ /// Converts a level to a lower-case string.
pub fn as_str(self) -> &'static str {
match self {
Allow => "allow",
}
}
- /// Convert a lower-case string to a level.
+ /// Converts a lower-case string to a level.
pub fn from_str(x: &str) -> Option<Level> {
match x {
"allow" => Some(Allow),
#[macro_export]
macro_rules! impl_stable_hash_for {
// Enums
- // FIXME(mark-i-m): Some of these should be `?` rather than `*`. See the git blame and change
- // them back when `?` is supported again.
(enum $enum_name:path {
$( $variant:ident
// this incorrectly allows specifying both tuple-like and struct-like fields, as in `Variant(a,b){c,d}`,
// when it should be only one or the other
- $( ( $($field:ident $(-> $delegate:tt)*),* ) )*
- $( { $($named_field:ident $(-> $named_delegate:tt)*),* } )*
- ),* $(,)*
+ $( ( $($field:ident $(-> $delegate:tt)?),* ) )?
+ $( { $($named_field:ident $(-> $named_delegate:tt)?),* } )?
+ ),* $(,)?
}) => {
impl_stable_hash_for!(
impl<> for enum $enum_name [ $enum_name ] { $( $variant
- $( ( $($field $(-> $delegate)*),* ) )*
- $( { $($named_field $(-> $named_delegate)*),* } )*
+ $( ( $($field $(-> $delegate)?),* ) )?
+ $( { $($named_field $(-> $named_delegate)?),* } )?
),* }
);
};
// We want to use the enum name both in the `impl ... for $enum_name` as well as for
// importing all the variants. Unfortunately it seems we have to take the name
// twice for this purpose
- (impl<$($lt:lifetime $(: $lt_bound:lifetime)* ),* $(,)* $($T:ident),* $(,)*>
+ (impl<$($lt:lifetime $(: $lt_bound:lifetime)? ),* $(,)? $($T:ident),* $(,)?>
for enum $enum_name:path
[ $enum_path:path ]
{
$( $variant:ident
// this incorrectly allows specifying both tuple-like and struct-like fields, as in `Variant(a,b){c,d}`,
// when it should be only one or the other
- $( ( $($field:ident $(-> $delegate:tt)*),* ) )*
- $( { $($named_field:ident $(-> $named_delegate:tt)*),* } )*
- ),* $(,)*
+ $( ( $($field:ident $(-> $delegate:tt)?),* ) )?
+ $( { $($named_field:ident $(-> $named_delegate:tt)?),* } )?
+ ),* $(,)?
}) => {
- impl<'a, $($lt $(: $lt_bound)*,)* $($T,)*>
+ impl<'a, $($lt $(: $lt_bound)?,)* $($T,)*>
::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>>
for $enum_name
where $($T: ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>>),*
match *self {
$(
- $variant $( ( $(ref $field),* ) )* $( { $(ref $named_field),* } )* => {
- $($( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)*) );*)*
- $($( __impl_stable_hash_field!($named_field, __ctx, __hasher $(, $named_delegate)*) );*)*
+ $variant $( ( $(ref $field),* ) )? $( { $(ref $named_field),* } )? => {
+ $($( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)?) );*)?
+ $($( __impl_stable_hash_field!($named_field, __ctx, __hasher $(, $named_delegate)?) );*)?
}
)*
}
}
};
// Structs
- // FIXME(mark-i-m): same here.
- (struct $struct_name:path { $($field:ident $(-> $delegate:tt)*),* $(,)* }) => {
+ (struct $struct_name:path { $($field:ident $(-> $delegate:tt)?),* $(,)? }) => {
impl_stable_hash_for!(
- impl<'tcx> for struct $struct_name { $($field $(-> $delegate)*),* }
+ impl<'tcx> for struct $struct_name { $($field $(-> $delegate)?),* }
);
};
- (impl<$($lt:lifetime $(: $lt_bound:lifetime)* ),* $(,)* $($T:ident),* $(,)*> for struct $struct_name:path {
- $($field:ident $(-> $delegate:tt)*),* $(,)*
+ (impl<$($lt:lifetime $(: $lt_bound:lifetime)? ),* $(,)? $($T:ident),* $(,)?> for struct $struct_name:path {
+ $($field:ident $(-> $delegate:tt)?),* $(,)?
}) => {
- impl<'a, $($lt $(: $lt_bound)*,)* $($T,)*>
+ impl<'a, $($lt $(: $lt_bound)?,)* $($T,)*>
::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>> for $struct_name
where $($T: ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>>),*
{
$(ref $field),*
} = *self;
- $( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)*) );*
+ $( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)?) );*
}
}
};
// Tuple structs
- // We cannot use normale parentheses here, the parser won't allow it
- // FIXME(mark-i-m): same here.
- (tuple_struct $struct_name:path { $($field:ident $(-> $delegate:tt)*),* $(,)* }) => {
+ // We cannot use normal parentheses here, the parser won't allow it
+ (tuple_struct $struct_name:path { $($field:ident $(-> $delegate:tt)?),* $(,)? }) => {
impl_stable_hash_for!(
- impl<'tcx> for tuple_struct $struct_name { $($field $(-> $delegate)*),* }
+ impl<'tcx> for tuple_struct $struct_name { $($field $(-> $delegate)?),* }
);
};
- (impl<$($lt:lifetime $(: $lt_bound:lifetime)* ),* $(,)* $($T:ident),* $(,)*>
- for tuple_struct $struct_name:path { $($field:ident $(-> $delegate:tt)*),* $(,)* }) => {
- impl<'a, $($lt $(: $lt_bound)*,)* $($T,)*>
+ (impl<$($lt:lifetime $(: $lt_bound:lifetime)? ),* $(,)? $($T:ident),* $(,)?>
+ for tuple_struct $struct_name:path { $($field:ident $(-> $delegate:tt)?),* $(,)? }) => {
+ impl<'a, $($lt $(: $lt_bound)?,)* $($T,)*>
::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>> for $struct_name
where $($T: ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>>),*
{
$(ref $field),*
) = *self;
- $( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)*) );*
+ $( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)?) );*
}
}
};
fn handle_field_pattern_match(&mut self, lhs: &hir::Pat, def: Def,
pats: &[source_map::Spanned<hir::FieldPat>]) {
- let variant = match self.tables.node_id_to_type(lhs.hir_id).sty {
+ let variant = match self.tables.node_type(lhs.hir_id).sty {
ty::Adt(adt, _) => adt.variant_of_def(def),
_ => span_bug!(lhs.span, "non-ADT in struct pattern")
};
-//! A different sort of visitor for walking fn bodies. Unlike the
+//! A different sort of visitor for walking fn bodies. Unlike the
//! normal visitor, which just walks the entire body in one shot, the
//! `ExprUseVisitor` determines how expressions are being used.
self.consume_expr(&arm.body);
}
- /// Walks a pat that occurs in isolation (i.e., top-level of fn
- /// arg or let binding. *Not* a match arm or nested pat.)
+ /// Walks a pat that occurs in isolation (i.e., top-level of fn argument or
+ /// let binding, and *not* a match arm or nested pat.)
fn walk_irrefutable_pat(&mut self, cmt_discr: mc::cmt<'tcx>, pat: &hir::Pat) {
let mut mode = Unknown;
self.determine_pat_move_mode(cmt_discr.clone(), pat, &mut mode);
-//! This file handles the relationships between free regions --
-//! meaning lifetime parameters. Ordinarily, free regions are
-//! unrelated to one another, but they can be related via implied or
-//! explicit bounds. In that case, we track the bounds using the
-//! `TransitiveRelation` type and use that to decide when one free
-//! region outlives another and so forth.
+//! This module handles the relationships between "free regions", i.e., lifetime parameters.
+//! Ordinarily, free regions are unrelated to one another, but they can be related via implied
+//! or explicit bounds. In that case, we track the bounds using the `TransitiveRelation` type,
+//! and use that to decide when one free region outlives another, and so forth.
use crate::infer::outlives::free_region_map::{FreeRegionMap, FreeRegionRelations};
use crate::hir::def_id::DefId;
/// regions.
///
/// This stuff is a bit convoluted and should be refactored, but as we
-/// move to NLL it'll all go away anyhow.
+/// transition to NLL, it'll all go away anyhow.
pub struct RegionRelations<'a, 'gcx: 'tcx, 'tcx: 'a> {
pub tcx: TyCtxt<'a, 'gcx, 'tcx>,
- /// context used to fetch the region maps
+ /// The context used to fetch the region maps.
pub context: DefId,
- /// region maps for the given context
+ /// The region maps for the given context.
pub region_scope_tree: &'a region::ScopeTree,
- /// free-region relationships
+ /// Free-region relationships.
pub free_regions: &'a FreeRegionMap<'tcx>,
}
}
}
- /// Determines whether one region is a subregion of another. This is intended to run *after
+ /// Determines whether one region is a subregion of another. This is intended to run *after
/// inference* and sadly the logic is somewhat duplicated with the code in infer.rs.
pub fn is_subregion_of(&self,
sub_region: ty::Region<'tcx>,
result
}
- /// Determines whether this free-region is required to be 'static
+ /// Determines whether this free region is required to be `'static`.
fn is_static(&self, super_region: ty::Region<'tcx>) -> bool {
debug!("is_static(super_region={:?})", super_region);
match *super_region {
};
if let Def::Fn(did) = def {
if self.def_id_is_transmute(did) {
- let typ = self.tables.node_id_to_type(expr.hir_id);
+ let typ = self.tables.node_type(expr.hir_id);
let sig = typ.fn_sig(self.tcx);
let from = sig.inputs().skip_binder()[0];
let to = *sig.output().skip_binder();
// (unlike lang features), which means we need to collect them instead.
use crate::ty::TyCtxt;
+use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
use syntax::symbol::Symbol;
use syntax::ast::{Attribute, MetaItem, MetaItemKind};
use syntax_pos::Span;
-use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
use rustc_data_structures::fx::{FxHashSet, FxHashMap};
-use crate::errors::DiagnosticId;
+use errors::DiagnosticId;
pub struct LibFeatures {
// A map from feature to stabilisation version.
-//! A classic liveness analysis based on dataflow over the AST. Computes,
+//! A classic liveness analysis based on dataflow over the AST. Computes,
//! for each local variable in a function, whether that variable is live
-//! at a given point. Program execution points are identified by their
-//! id.
+//! at a given point. Program execution points are identified by their
+//! IDs.
//!
//! # Basic idea
//!
-//! The basic model is that each local variable is assigned an index. We
+//! The basic model is that each local variable is assigned an index. We
//! represent sets of local variables using a vector indexed by this
-//! index. The value in the vector is either 0, indicating the variable
-//! is dead, or the id of an expression that uses the variable.
+//! index. The value in the vector is either 0, indicating the variable
+//! is dead, or the ID of an expression that uses the variable.
//!
-//! We conceptually walk over the AST in reverse execution order. If we
-//! find a use of a variable, we add it to the set of live variables. If
+//! We conceptually walk over the AST in reverse execution order. If we
+//! find a use of a variable, we add it to the set of live variables. If
//! we find an assignment to a variable, we remove it from the set of live
-//! variables. When we have to merge two flows, we take the union of
-//! those two flows---if the variable is live on both paths, we simply
-//! pick one id. In the event of loops, we continue doing this until a
+//! variables. When we have to merge two flows, we take the union of
+//! those two flows -- if the variable is live on both paths, we simply
+//! pick one ID. In the event of loops, we continue doing this until a
//! fixed point is reached.
//!
//! ## Checking initialization
//!
-//! At the function entry point, all variables must be dead. If this is
-//! not the case, we can report an error using the id found in the set of
+//! At the function entry point, all variables must be dead. If this is
+//! not the case, we can report an error using the ID found in the set of
//! live variables, which identifies a use of the variable which is not
//! dominated by an assignment.
//!
//!
//! The actual implementation contains two (nested) walks over the AST.
//! The outer walk has the job of building up the ir_maps instance for the
-//! enclosing function. On the way down the tree, it identifies those AST
+//! enclosing function. On the way down the tree, it identifies those AST
//! nodes and variable IDs that will be needed for the liveness analysis
-//! and assigns them contiguous IDs. The liveness id for an AST node is
-//! called a `live_node` (it's a newtype'd u32) and the id for a variable
-//! is called a `variable` (another newtype'd u32).
+//! and assigns them contiguous IDs. The liveness ID for an AST node is
+//! called a `live_node` (it's a newtype'd `u32`) and the ID for a variable
+//! is called a `variable` (another newtype'd `u32`).
//!
//! On the way back up the tree, as we are about to exit from a function
-//! declaration we allocate a `liveness` instance. Now that we know
+//! declaration we allocate a `liveness` instance. Now that we know
//! precisely how many nodes and variables we need, we can allocate all
-//! the various arrays that we will need to precisely the right size. We then
+//! the various arrays that we will need to precisely the right size. We then
//! perform the actual propagation on the `liveness` instance.
//!
//! This propagation is encoded in the various `propagate_through_*()`
-//! methods. It effectively does a reverse walk of the AST; whenever we
+//! methods. It effectively does a reverse walk of the AST; whenever we
//! reach a loop node, we iterate until a fixed point is reached.
//!
//! ## The `RWU` struct
//! variable `V` (these are encapsulated in the `RWU` struct):
//!
//! - `reader`: the `LiveNode` ID of some node which will read the value
-//! that `V` holds on entry to `N`. Formally: a node `M` such
+//! that `V` holds on entry to `N`. Formally: a node `M` such
//! that there exists a path `P` from `N` to `M` where `P` does not
-//! write `V`. If the `reader` is `invalid_node()`, then the current
+//! write `V`. If the `reader` is `invalid_node()`, then the current
//! value will never be read (the variable is dead, essentially).
//!
//! - `writer`: the `LiveNode` ID of some node which will write the
-//! variable `V` and which is reachable from `N`. Formally: a node `M`
+//! variable `V` and which is reachable from `N`. Formally: a node `M`
//! such that there exists a path `P` from `N` to `M` and `M` writes
-//! `V`. If the `writer` is `invalid_node()`, then there is no writer
+//! `V`. If the `writer` is `invalid_node()`, then there is no writer
//! of `V` that follows `N`.
//!
-//! - `used`: a boolean value indicating whether `V` is *used*. We
+//! - `used`: a boolean value indicating whether `V` is *used*. We
//! distinguish a *read* from a *use* in that a *use* is some read that
-//! is not just used to generate a new value. For example, `x += 1` is
-//! a read but not a use. This is used to generate better warnings.
+//! is not just used to generate a new value. For example, `x += 1` is
+//! a read but not a use. This is used to generate better warnings.
//!
//! ## Special Variables
//!
//! - `fallthrough_ln`: a live node that represents a fallthrough
//!
//! - `clean_exit_var`: a synthetic variable that is only 'read' from the
-//! fallthrough node. It is only live if the function could converge
+//! fallthrough node. It is only live if the function could converge
//! via means other than an explicit `return` expression. That is, it is
//! only dead if the end of the function's block can never be reached.
//! It is the responsibility of typeck to ensure that there are no
use crate::ty::{self, TyCtxt};
use crate::ty::query::Providers;
use crate::lint;
-use crate::errors::Applicability;
use crate::util::nodemap::{NodeMap, HirIdMap, HirIdSet};
+use errors::Applicability;
use std::collections::{BTreeMap, VecDeque};
use std::{fmt, u32};
use std::io::prelude::*;
//! The job of the categorization module is to analyze an expression to
//! determine what kind of memory is used in evaluating it (for example,
//! where dereferences occur and what kind of pointer is dereferenced;
-//! whether the memory is mutable; etc)
+//! whether the memory is mutable, etc.).
//!
//! Categorization effectively transforms all of our expressions into
//! expressions of the following forms (the actual enum has many more
//! | E.comp // access to an interior component
//!
//! Imagine a routine ToAddr(Expr) that evaluates an expression and returns an
-//! address where the result is to be found. If Expr is a place, then this
-//! is the address of the place. If Expr is an rvalue, this is the address of
+//! address where the result is to be found. If Expr is a place, then this
+//! is the address of the place. If `Expr` is an rvalue, this is the address of
//! some temporary spot in memory where the result is stored.
//!
-//! Now, cat_expr() classifies the expression Expr and the address A=ToAddr(Expr)
+//! Now, `cat_expr()` classifies the expression `Expr` and the address `A = ToAddr(Expr)`
//! as follows:
//!
-//! - cat: what kind of expression was this? This is a subset of the
+//! - `cat`: what kind of expression was this? This is a subset of the
//! full expression forms which only includes those that we care about
//! for the purpose of the analysis.
-//! - mutbl: mutability of the address A
-//! - ty: the type of data found at the address A
+//! - `mutbl`: mutability of the address `A`.
+//! - `ty`: the type of data found at the address `A`.
//!
//! The resulting categorization tree differs somewhat from the expressions
-//! themselves. For example, auto-derefs are explicit. Also, an index a[b] is
+//! themselves. For example, auto-derefs are explicit. Also, an index a[b] is
//! decomposed into two operations: a dereference to reach the array data and
//! then an index to jump forward to the relevant item.
//!
// which the value is stored.
//
// *WARNING* The field `cmt.type` is NOT necessarily the same as the
-// result of `node_id_to_type(cmt.id)`.
+// result of `node_type(cmt.id)`.
//
// (FIXME: rewrite the following comment given that `@x` managed
// pointers have been obsolete for quite some time.)
hir_id: hir::HirId)
-> McResult<Ty<'tcx>> {
self.resolve_type_vars_or_error(hir_id,
- self.tables.node_id_to_type_opt(hir_id))
+ self.tables.node_type_opt(hir_id))
}
pub fn expr_ty(&self, expr: &hir::Expr) -> McResult<Ty<'tcx>> {
// Check the impl. If the generics on the self
// type of the impl require inlining, this method
// does too.
- let impl_node_id = self.tcx.hir().as_local_node_id(impl_did).unwrap();
- match self.tcx.hir().expect_item(impl_node_id).node {
+ let impl_hir_id = self.tcx.hir().as_local_hir_id(impl_did).unwrap();
+ match self.tcx.hir().expect_item_by_hir_id(impl_hir_id).node {
hir::ItemKind::Impl(..) => {
let generics = self.tcx.generics_of(impl_did);
generics.requires_monomorphization(self.tcx)
/// values live long enough; phrased another way, the starting point
/// of each range is not really the important thing in the above
/// picture, but rather the ending point.
-///
-/// FIXME (pnkfelix): This currently derives `PartialOrd` and `Ord` to
-/// placate the same deriving in `ty::FreeRegion`, but we may want to
-/// actually attach a more meaningful ordering to scopes than the one
-/// generated via deriving here.
+//
+// FIXME(pnkfelix): this currently derives `PartialOrd` and `Ord` to
+// placate the same deriving in `ty::FreeRegion`, but we may want to
+// actually attach a more meaningful ordering to scopes than the one
+// generated via deriving here.
#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Copy, RustcEncodable, RustcDecodable)]
pub struct Scope {
pub id: hir::ItemLocalId,
///
/// For example, given `{ let (a, b) = EXPR_1; let c = EXPR_2; ... }`:
///
-/// * the subscope with `first_statement_index == 0` is scope of both
+/// * The subscope with `first_statement_index == 0` is scope of both
/// `a` and `b`; it does not include EXPR_1, but does include
/// everything after that first `let`. (If you want a scope that
/// includes EXPR_1 as well, then do not use `Scope::Remainder`,
/// but instead another `Scope` that encompasses the whole block,
/// e.g., `Scope::Node`.
///
-/// * the subscope with `first_statement_index == 1` is scope of `c`,
+/// * The subscope with `first_statement_index == 1` is scope of `c`,
/// and thus does not include EXPR_2, but covers the `...`.
newtype_index! {
static_assert!(ASSERT_SCOPE_DATA: mem::size_of::<ScopeData>() == 4);
impl Scope {
- /// Returns a item-local id associated with this scope.
+ /// Returns a item-local ID associated with this scope.
///
/// N.B., likely to be replaced as API is refined; e.g., pnkfelix
/// anticipates `fn entry_node_id` and `fn each_exit_node_id`.
}
}
- /// Returns the span of this Scope. Note that in general the
- /// returned span may not correspond to the span of any node id in
+ /// Returns the span of this `Scope`. Note that in general the
+ /// returned span may not correspond to the span of any `NodeId` in
/// the AST.
pub fn span(&self, tcx: TyCtxt<'_, '_, '_>, scope_tree: &ScopeTree) -> Span {
let node_id = self.node_id(tcx, scope_tree);
/// have lifetime parameters free in this body.
root_parent: Option<ast::NodeId>,
- /// `parent_map` maps from a scope id to the enclosing scope id;
+ /// `parent_map` maps from a scope ID to the enclosing scope id;
/// this is usually corresponding to the lexical nesting, though
/// in the case of closures the parent scope is the innermost
/// conditional expression or repeating block. (Note that the
- /// enclosing scope id for the block associated with a closure is
+ /// enclosing scope ID for the block associated with a closure is
/// the closure itself.)
parent_map: FxHashMap<Scope, (Scope, ScopeDepth)>,
- /// `var_map` maps from a variable or binding id to the block in
+ /// `var_map` maps from a variable or binding ID to the block in
/// which that variable is declared.
var_map: FxHashMap<hir::ItemLocalId, Scope>,
- /// maps from a node-id to the associated destruction scope (if any)
+ /// maps from a `NodeId` to the associated destruction scope (if any)
destruction_scopes: FxHashMap<hir::ItemLocalId, Scope>,
/// `rvalue_scopes` includes entries for those expressions whose cleanup scope is
/// Encodes the hierarchy of fn bodies. Every fn body (including
/// closures) forms its own distinct region hierarchy, rooted in
- /// the block that is the fn body. This map points from the id of
- /// that root block to the id of the root block for the enclosing
+ /// the block that is the fn body. This map points from the ID of
+ /// that root block to the ID of the root block for the enclosing
/// fn, if any. Thus the map structures the fn bodies into a
/// hierarchy based on their lexical mapping. This is used to
/// handle the relationships between regions in a fn and in a
/// upon exiting the parent scope, we cannot statically know how
/// many times the expression executed, and thus if the expression
/// creates temporaries we cannot know statically how many such
- /// temporaries we would have to cleanup. Therefore we ensure that
+ /// temporaries we would have to cleanup. Therefore, we ensure that
/// the temporaries never outlast the conditional/repeating
/// expression, preventing the need for dynamic checks and/or
/// arbitrary amounts of stack space. Terminating scopes end
}
/// Records that `sub_closure` is defined within `sup_closure`. These ids
- /// should be the id of the block that is the fn body, which is
+ /// should be the ID of the block that is the fn body, which is
/// also the root of the region hierarchy for that fn.
fn record_closure_parent(&mut self,
sub_closure: hir::ItemLocalId,
self.is_subscope_of(scope2, scope1)
}
- /// Returns true if `subscope` is equal to or is lexically nested inside `superscope` and false
- /// otherwise.
+ /// Returns `true` if `subscope` is equal to or is lexically nested inside `superscope`, and
+ /// `false` otherwise.
pub fn is_subscope_of(&self,
subscope: Scope,
superscope: Scope)
return true;
}
- /// Returns the id of the innermost containing body
+ /// Returns the ID of the innermost containing body
pub fn containing_body(&self, mut scope: Scope) -> Option<hir::ItemLocalId> {
loop {
if let ScopeData::CallSite = scope.data {
}
}
- /// Finds the nearest common ancestor of two scopes. That is, finds the
+ /// Finds the nearest common ancestor of two scopes. That is, finds the
/// smallest scope which is greater than or equal to both `scope_a` and
/// `scope_b`.
pub fn nearest_common_ancestor(&self, scope_a: Scope, scope_b: Scope) -> Scope {
visitor.visit_pat(pat);
}
- /// True if `pat` match the `P&` nonterminal:
+ /// Returns `true` if `pat` match the `P&` non-terminal.
///
/// P& = ref X
/// | StructName { ..., P&, ... }
//! Name resolution for lifetimes follows MUCH simpler rules than the
//! full resolve. For example, lifetime names are never exported or
//! used between functions, and they operate in a purely top-down
-//! way. Therefore we break lifetime name resolution into a separate pass.
+//! way. Therefore, we break lifetime name resolution into a separate pass.
use crate::hir::def::Def;
use crate::hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
use crate::hir::{GenericArg, GenericParam, ItemLocalId, LifetimeName, Node, ParamName};
use crate::ty::{self, DefIdTree, GenericParamDefKind, TyCtxt};
-use crate::errors::{Applicability, DiagnosticBuilder};
use crate::rustc::lint;
-use rustc_data_structures::sync::Lrc;
use crate::session::Session;
+use crate::util::nodemap::{DefIdMap, FxHashMap, FxHashSet, NodeMap, NodeSet};
+use errors::{Applicability, DiagnosticBuilder};
+use rustc_data_structures::sync::Lrc;
use std::borrow::Cow;
use std::cell::Cell;
use std::mem::replace;
use syntax::ptr::P;
use syntax::symbol::keywords;
use syntax_pos::Span;
-use crate::util::nodemap::{DefIdMap, FxHashMap, FxHashSet, NodeMap, NodeSet};
use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
use crate::hir::{self, GenericParamKind, LifetimeParamKind};
pub object_lifetime_defaults: NodeMap<Vec<ObjectLifetimeDefault>>,
}
-/// See `NamedRegionMap`.
+/// See [`NamedRegionMap`].
#[derive(Default)]
pub struct ResolveLifetimes {
defs: FxHashMap<LocalDefId, Lrc<FxHashMap<ItemLocalId, Region>>>,
map: &'a mut NamedRegionMap,
scope: ScopeRef<'a>,
- /// Deep breath. Our representation for poly trait refs contains a single
+ /// This is slightly complicated. Our representation for poly-trait-refs contains a single
/// binder and thus we only allow a single level of quantification. However,
/// the syntax of Rust permits quantification in two places, e.g., `T: for <'a> Foo<'a>`
- /// and `for <'a, 'b> &'b T: Foo<'a>`. In order to get the de Bruijn indices
+ /// and `for <'a, 'b> &'b T: Foo<'a>`. In order to get the De Bruijn indices
/// correct when representing these constraints, we should only introduce one
/// scope. However, we want to support both locations for the quantifier and
/// during lifetime resolution we want precise information (so we can't
/// desugar in an earlier phase).
///
- /// SO, if we encounter a quantifier at the outer scope, we set
- /// trait_ref_hack to true (and introduce a scope), and then if we encounter
- /// a quantifier at the inner scope, we error. If trait_ref_hack is false,
+ /// So, if we encounter a quantifier at the outer scope, we set
+ /// `trait_ref_hack` to `true` (and introduce a scope), and then if we encounter
+ /// a quantifier at the inner scope, we error. If `trait_ref_hack` is `false`,
/// then we introduce the scope at the inner quantifier.
- ///
- /// I'm sorry.
trait_ref_hack: bool,
/// Used to disallow the use of in-band lifetimes in `fn` or `Fn` syntax.
} => {
// FIXME (#24278): non-hygienic comparison
if let Some(def) = lifetimes.get(&hir::ParamName::Plain(label.modern())) {
- let node_id = tcx.hir().as_local_node_id(def.id().unwrap()).unwrap();
+ let hir_id = tcx.hir().as_local_hir_id(def.id().unwrap()).unwrap();
signal_shadowing_problem(
tcx,
label.name,
- original_lifetime(tcx.hir().span(node_id)),
+ original_lifetime(tcx.hir().span_by_hir_id(hir_id)),
shadower_label(label.span),
);
return;
/// If early bound lifetimes are present, we separate them into their own list (and likewise
/// for late bound). They will be numbered sequentially, starting from the lowest index that is
/// already in scope (for a fn item, that will be 0, but for a method it might not be). Late
- /// bound lifetimes are resolved by name and associated with a binder id (`binder_id`), so the
+ /// bound lifetimes are resolved by name and associated with a binder ID (`binder_id`), so the
/// ordering is not important there.
fn visit_early_late<F>(
&mut self,
ref lifetimes, s, ..
} => {
if let Some(&def) = lifetimes.get(¶m.name.modern()) {
- let node_id = self.tcx.hir().as_local_node_id(def.id().unwrap()).unwrap();
+ let hir_id = self.tcx.hir().as_local_hir_id(def.id().unwrap()).unwrap();
signal_shadowing_problem(
self.tcx,
param.name.ident().name,
- original_lifetime(self.tcx.hir().span(node_id)),
+ original_lifetime(self.tcx.hir().span_by_hir_id(hir_id)),
shadower_lifetime(¶m),
);
return;
}
}
- /// Returns true if, in the current scope, replacing `'_` would be
+ /// Returns `true` if, in the current scope, replacing `'_` would be
/// equivalent to a single-use lifetime.
fn track_lifetime_uses(&self) -> bool {
let mut scope = self.scope;
/// - it does not appear in a where-clause.
///
/// "Constrained" basically means that it appears in any type but
-/// not amongst the inputs to a projection. In other words, `<&'a
+/// not amongst the inputs to a projection. In other words, `<&'a
/// T as Trait<''b>>::Foo` does not constrain `'a` or `'b`.
fn insert_late_bound_lifetimes(
map: &mut NamedRegionMap,
pub struct DeprecationEntry {
/// The metadata of the attribute associated with this entry.
pub attr: Deprecation,
- /// The def id where the attr was originally attached. `None` for non-local
+ /// The `DefId` where the attr was originally attached. `None` for non-local
/// `DefId`'s.
origin: Option<HirId>,
}
}
impl<'a, 'tcx: 'a> MissingStabilityAnnotations<'a, 'tcx> {
- fn check_missing_stability(&self, id: NodeId, span: Span) {
+ fn check_missing_stability(&self, id: NodeId, span: Span, name: &str) {
let hir_id = self.tcx.hir().node_to_hir_id(id);
let stab = self.tcx.stability().local_stability(hir_id);
let is_error = !self.tcx.sess.opts.test &&
stab.is_none() &&
self.access_levels.is_reachable(id);
if is_error {
- self.tcx.sess.span_err(span, "This node does not have a stability attribute");
+ self.tcx.sess.span_err(
+ span,
+ &format!("{} has missing stability attribute", name),
+ );
}
}
}
// optional. They inherit stability from their parents when unannotated.
hir::ItemKind::Impl(.., None, _, _) | hir::ItemKind::ForeignMod(..) => {}
- _ => self.check_missing_stability(i.id, i.span)
+ _ => self.check_missing_stability(i.id, i.span, i.node.descriptive_variant())
}
intravisit::walk_item(self, i)
}
fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem) {
- self.check_missing_stability(ti.id, ti.span);
+ self.check_missing_stability(ti.id, ti.span, "item");
intravisit::walk_trait_item(self, ti);
}
fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem) {
let impl_def_id = self.tcx.hir().local_def_id(self.tcx.hir().get_parent(ii.id));
if self.tcx.impl_trait_ref(impl_def_id).is_none() {
- self.check_missing_stability(ii.id, ii.span);
+ self.check_missing_stability(ii.id, ii.span, "item");
}
intravisit::walk_impl_item(self, ii);
}
fn visit_variant(&mut self, var: &'tcx Variant, g: &'tcx Generics, item_id: NodeId) {
- self.check_missing_stability(var.node.data.id(), var.span);
+ self.check_missing_stability(var.node.data.id(), var.span, "variant");
intravisit::walk_variant(self, var, g, item_id);
}
fn visit_struct_field(&mut self, s: &'tcx StructField) {
- self.check_missing_stability(s.id, s.span);
+ self.check_missing_stability(s.id, s.span, "field");
intravisit::walk_struct_field(self, s);
}
fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem) {
- self.check_missing_stability(i.id, i.span);
+ self.check_missing_stability(i.id, i.span, i.node.descriptive_variant());
intravisit::walk_foreign_item(self, i);
}
fn visit_macro_def(&mut self, md: &'tcx hir::MacroDef) {
- self.check_missing_stability(md.id, md.span);
+ self.check_missing_stability(md.id, md.span, "macro");
}
}
};
}
-/// Check whether an item marked with `deprecated(since="X")` is currently
+/// Checks whether an item marked with `deprecated(since="X")` is currently
/// deprecated (i.e., whether X is not greater than the current rustc version).
pub fn deprecation_in_effect(since: &str) -> bool {
fn parse_version(ver: &str) -> Vec<u32> {
/// deprecated. If the item is indeed deprecated, we will emit a deprecation lint attached to
/// `id`.
pub fn eval_stability(self, def_id: DefId, id: Option<NodeId>, span: Span) -> EvalResult {
- if span.allows_unstable() {
- debug!("stability: skipping span={:?} since it is internal", span);
- return EvalResult::Allow;
- }
-
let lint_deprecated = |def_id: DefId,
id: NodeId,
note: Option<Symbol>,
// Deprecated attributes apply in-crate and cross-crate.
if let Some(id) = id {
if let Some(depr_entry) = self.lookup_deprecation_entry(def_id) {
- // If the deprecation is scheduled for a future Rust
- // version, then we should display no warning message.
- let deprecated_in_future_version = if let Some(sym) = depr_entry.attr.since {
- let since = sym.as_str();
- if !deprecation_in_effect(&since) {
- Some(since)
- } else {
- None
- }
- } else {
- None
- };
-
let parent_def_id = self.hir().local_def_id(self.hir().get_parent(id));
let skip = self.lookup_deprecation_entry(parent_def_id)
.map_or(false, |parent_depr| parent_depr.same_origin(&depr_entry));
- if let Some(since) = deprecated_in_future_version {
- let path = self.item_path_str(def_id);
- let message = format!("use of item '{}' \
- that will be deprecated in future version {}",
- path,
- since);
-
- lint_deprecated(def_id,
- id,
- depr_entry.attr.note,
- None,
- &message,
- lint::builtin::DEPRECATED_IN_FUTURE);
- } else if !skip {
+ if !skip {
let path = self.item_path_str(def_id);
let message = format!("use of deprecated item '{}'", path);
lint_deprecated(def_id,
match stability {
Some(&Stability { level: attr::Unstable { reason, issue }, feature, .. }) => {
+ if span.allows_unstable(&feature.as_str()) {
+ debug!("stability: skipping span={:?} since it is internal", span);
+ return EvalResult::Allow;
+ }
if self.stability().active_features.contains(&feature) {
return EvalResult::Allow;
}
tcx,
access_levels,
};
- missing.check_missing_stability(ast::CRATE_NODE_ID, krate.span);
+ missing.check_missing_stability(ast::CRATE_NODE_ID, krate.span, "crate");
intravisit::walk_crate(&mut missing, krate);
krate.visit_all_item_likes(&mut missing.as_deep_visitor());
}
})
}
-/// Returns whether the specified `lang_item` doesn't actually need to be
+/// Returns `true` if the specified `lang_item` doesn't actually need to be
/// present for this compilation.
///
/// Not all lang items are always required for each compilation, particularly in
-//! The virtual memory representation of the MIR interpreter
+//! The virtual memory representation of the MIR interpreter.
use super::{
Pointer, EvalResult, AllocId, ScalarMaybeUndef, write_target_uint, read_target_uint, Scalar,
/// Hook for performing extra checks on a memory read access.
///
/// Takes read-only access to the allocation so we can keep all the memory read
- /// operations take `&self`. Use a `RefCell` in `AllocExtra` if you
+ /// operations take `&self`. Use a `RefCell` in `AllocExtra` if you
/// need to mutate.
#[inline(always)]
fn memory_read(
/// Alignment and bounds checks
impl<'tcx, Tag, Extra> Allocation<Tag, Extra> {
- /// Check if the pointer is "in-bounds". Notice that a pointer pointing at the end
+ /// Checks if the pointer is "in-bounds". Notice that a pointer pointing at the end
/// of an allocation (i.e., at the first *inaccessible* location) *is* considered
/// in-bounds! This follows C's/LLVM's rules.
/// If you want to check bounds before doing a memory access, better use `check_bounds`.
ptr.check_in_alloc(Size::from_bytes(allocation_size), InboundsCheck::Live)
}
- /// Check if the memory range beginning at `ptr` and of size `Size` is "in-bounds".
+ /// Checks if the memory range beginning at `ptr` and of size `Size` is "in-bounds".
#[inline(always)]
pub fn check_bounds(
&self,
/// Byte accessors
impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra> {
/// The last argument controls whether we error out when there are undefined
- /// or pointer bytes. You should never call this, call `get_bytes` or
+ /// or pointer bytes. You should never call this, call `get_bytes` or
/// `get_bytes_with_undef_and_ptr` instead,
///
/// This function also guarantees that the resulting pointer will remain stable
/// Relocations
impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra> {
- /// Return all relocations overlapping with the given ptr-offset pair.
+ /// Returns all relocations overlapping with the given ptr-offset pair.
pub fn relocations(
&self,
cx: &impl HasDataLayout,
self.relocations.range(Size::from_bytes(start)..end)
}
- /// Check that there are no relocations overlapping with the given range.
+ /// Checks that there are no relocations overlapping with the given range.
#[inline(always)]
fn check_relocations(
&self,
}
}
- /// Remove all relocations inside the given range.
+ /// Removes all relocations inside the given range.
/// If there are relocations overlapping with the edges, they
/// are removed as well *and* the bytes they cover are marked as
- /// uninitialized. This is a somewhat odd "spooky action at a distance",
+ /// uninitialized. This is a somewhat odd "spooky action at a distance",
/// but it allows strictly more code to run than if we would just error
/// immediately in that case.
fn clear_relocations(
m
}
- /// Check whether the range `start..end` (end-exclusive) is entirely defined.
+ /// Checks whether the range `start..end` (end-exclusive) is entirely defined.
///
/// Returns `Ok(())` if it's defined. Otherwise returns the index of the byte
/// at which the first undefined access begins.
use backtrace::Backtrace;
use crate::ty::query::TyCtxtAt;
-use crate::errors::DiagnosticBuilder;
+use errors::DiagnosticBuilder;
use syntax_pos::{Pos, Span};
use syntax::ast;
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum ErrorHandled {
- /// Already reported a lint or an error for this evaluation
+ /// Already reported a lint or an error for this evaluation.
Reported,
/// Don't emit an error, the evaluation failed because the MIR was generic
/// and the substs didn't fully monomorphize it.
#[derive(Clone, RustcEncodable, RustcDecodable)]
pub enum EvalErrorKind<'tcx, O> {
/// This variant is used by machines to signal their own errors that do not
- /// match an existing variant
+ /// match an existing variant.
MachineError(String),
FunctionAbiMismatch(Abi, Abi),
use std::fmt;
use crate::mir;
use crate::hir::def_id::DefId;
-use crate::ty::{self, TyCtxt, Instance};
+use crate::ty::{self, TyCtxt, Instance, subst::UnpackedKind};
use crate::ty::layout::{self, Size};
use std::io;
use crate::rustc_serialize::{Encoder, Decodable, Encodable};
#[derive(Debug, Clone, Eq, PartialEq, Hash, RustcDecodable, RustcEncodable)]
pub enum AllocKind<'tcx> {
- /// The alloc id is used as a function pointer
+ /// The alloc ID is used as a function pointer
Function(Instance<'tcx>),
- /// The alloc id points to a "lazy" static variable that did not get computed (yet).
+ /// The alloc ID points to a "lazy" static variable that did not get computed (yet).
/// This is also used to break the cycle in recursive statics.
Static(DefId),
- /// The alloc id points to memory
+ /// The alloc ID points to memory.
Memory(&'tcx Allocation),
}
pub struct AllocMap<'tcx> {
- /// Lets you know what an AllocId refers to
+ /// Lets you know what an `AllocId` refers to.
id_to_kind: FxHashMap<AllocId, AllocKind<'tcx>>,
- /// Used to ensure that statics only get one associated AllocId
+ /// Used to ensure that statics only get one associated `AllocId`.
type_interner: FxHashMap<AllocKind<'tcx>, AllocId>,
- /// The AllocId to assign to the next requested id.
+ /// The `AllocId` to assign to the next requested ID.
/// Always incremented, never gets smaller.
next_id: AllocId,
}
id
}
- /// Functions cannot be identified by pointers, as asm-equal functions can get deduplicated
- /// by the linker and functions can be duplicated across crates.
- /// We thus generate a new `AllocId` for every mention of a function. This means that
- /// `main as fn() == main as fn()` is false, while `let x = main as fn(); x == x` is true.
pub fn create_fn_alloc(&mut self, instance: Instance<'tcx>) -> AllocId {
- let id = self.reserve();
- self.id_to_kind.insert(id, AllocKind::Function(instance));
- id
+ // Functions cannot be identified by pointers, as asm-equal functions can get deduplicated
+ // by the linker (we set the "unnamed_addr" attribute for LLVM) and functions can be
+ // duplicated across crates.
+ // We thus generate a new `AllocId` for every mention of a function. This means that
+ // `main as fn() == main as fn()` is false, while `let x = main as fn(); x == x` is true.
+ // However, formatting code relies on function identity (see #58320), so we only do
+ // this for generic functions. Lifetime parameters are ignored.
+ let is_generic = instance.substs.into_iter().any(|kind| {
+ match kind.unpack() {
+ UnpackedKind::Lifetime(_) => false,
+ _ => true,
+ }
+ });
+ if is_generic {
+ // Get a fresh ID
+ let id = self.reserve();
+ self.id_to_kind.insert(id, AllocKind::Function(instance));
+ id
+ } else {
+ // Deduplicate
+ self.intern(AllocKind::Function(instance))
+ }
}
/// Returns `None` in case the `AllocId` is dangling. An `EvalContext` can still have a
}
}
- /// Generate an `AllocId` for a static or return a cached one in case this function has been
+ /// Generates an `AllocId` for a static or return a cached one in case this function has been
/// called on the same static before.
pub fn intern_static(&mut self, static_id: DefId) -> AllocId {
self.intern(AllocKind::Static(static_id))
pub ty: Ty<'tcx>,
}
-/// Represents a constant value in Rust. Scalar and ScalarPair are optimizations which
-/// matches the LocalState optimizations for easy conversions between Value and ConstValue.
+/// Represents a constant value in Rust. `Scalar` and `ScalarPair` are optimizations that
+/// match the `LocalState` optimizations for easy conversions between `Value` and `ConstValue`.
#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash)]
pub enum ConstValue<'tcx> {
- /// Used only for types with layout::abi::Scalar ABI and ZSTs
+ /// Used only for types with `layout::abi::Scalar` ABI and ZSTs.
///
- /// Not using the enum `Value` to encode that this must not be `Undef`
+ /// Not using the enum `Value` to encode that this must not be `Undef`.
Scalar(Scalar),
- /// Used only for slices and strings (`&[T]`, `&str`, `*const [T]`, `*mut str`, `Box<str>`, ...)
+ /// Used only for slices and strings (`&[T]`, `&str`, `*const [T]`, `*mut str`, `Box<str>`,
+ /// etc.).
///
/// Empty slices don't necessarily have an address backed by an `AllocId`, thus we also need to
/// enable integer pointers. The `Scalar` type covers exactly those two cases. While we could
/// it.
Slice(Scalar, u64),
- /// An allocation + offset into the allocation.
- /// Invariant: The AllocId matches the allocation.
+ /// An allocation together with an offset into the allocation.
+ /// Invariant: the `AllocId` matches the allocation.
ByRef(AllocId, &'tcx Allocation, Size),
}
/// in scope, but a separate set of locals.
pub promoted: IndexVec<Promoted, Mir<'tcx>>,
- /// Yield type of the function, if it is a generator.
+ /// Yields type of the function, if it is a generator.
pub yield_ty: Option<Ty<'tcx>>,
/// Generator drop glue
}
}
- /// Check if `sub` is a sub scope of `sup`
+ /// Checks if `sub` is a sub scope of `sup`
pub fn is_sub_scope(&self, mut sub: SourceScope, sup: SourceScope) -> bool {
while sub != sup {
match self.source_scopes[sub].parent_scope {
true
}
- /// Return the return type, it always return first element from `local_decls` array
+ /// Returns the return type, it always return first element from `local_decls` array
pub fn return_ty(&self) -> Ty<'tcx> {
self.local_decls[RETURN_PLACE].ty
}
- /// Get the location of the terminator for the given block
+ /// Gets the location of the terminator for the given block
pub fn terminator_loc(&self, bb: BasicBlock) -> Location {
Location {
block: bb,
/// We can also report errors with this kind of borrow differently.
Shallow,
- /// Data must be immutable but not aliasable. This kind of borrow
+ /// Data must be immutable but not aliasable. This kind of borrow
/// cannot currently be expressed by the user and is used only in
/// implicit closure bindings. It is needed when the closure is
/// borrowing or mutating a mutable referent, e.g.:
/// Data is mutable and not aliasable.
Mut {
- /// True if this borrow arose from method-call auto-ref
- /// (i.e., `adjustment::Adjust::Borrow`)
+ /// `true` if this borrow arose from method-call auto-ref
+ /// (i.e., `adjustment::Adjust::Borrow`).
allow_two_phase_borrow: bool,
},
}
/// If an explicit type was provided for this variable binding,
/// this holds the source Span of that type.
///
- /// NOTE: If you want to change this to a `HirId`, be wary that
+ /// NOTE: if you want to change this to a `HirId`, be wary that
/// doing so breaks incremental compilation (as of this writing),
/// while a `Span` does not cause our tests to fail.
pub opt_ty_info: Option<Span>,
/// `ClearCrossCrate` as long as it carries as `HirId`.
pub is_user_variable: Option<ClearCrossCrate<BindingForm<'tcx>>>,
- /// True if this is an internal local
+ /// `true` if this is an internal local.
///
/// These locals are not based on types in the source code and are only used
/// for a few desugarings at the moment.
}
impl<'tcx> LocalDecl<'tcx> {
- /// Returns true only if local is a binding that can itself be
+ /// Returns `true` only if local is a binding that can itself be
/// made mutable via the addition of the `mut` keyword, namely
/// something like the occurrences of `x` in:
/// - `fn foo(x: Type) { ... }`,
}
}
- /// Returns true if local is definitely not a `ref ident` or
+ /// Returns `true` if local is definitely not a `ref ident` or
/// `ref mut ident` binding. (Such bindings cannot be made into
/// mutable bindings, but the inverse does not necessarily hold).
pub fn is_nonref_binding(&self) -> bool {
}
}
- /// Create a new `LocalDecl` for a temporary.
+ /// Creates a new `LocalDecl` for a temporary.
#[inline]
pub fn new_temp(ty: Ty<'tcx>, span: Span) -> Self {
Self::new_local(ty, Mutability::Mut, false, span)
self
}
- /// Create a new `LocalDecl` for a internal temporary.
+ /// Creates a new `LocalDecl` for a internal temporary.
#[inline]
pub fn new_internal(ty: Ty<'tcx>, span: Span) -> Self {
Self::new_local(ty, Mutability::Mut, true, span)
/// Terminator for this block.
///
- /// NB. This should generally ONLY be `None` during construction.
+ /// N.B., this should generally ONLY be `None` during construction.
/// Therefore, you should generally access it via the
/// `terminator()` or `terminator_mut()` methods. The only
/// exception is that certain passes, such as `simplify_cfg`, swap
}
}
- /// Return the list of labels for the edges to the successor basic blocks.
+ /// Returns the list of labels for the edges to the successor basic blocks.
pub fn fmt_successor_labels(&self) -> Vec<Cow<'static, str>> {
use self::TerminatorKind::*;
match *self {
/// error messages to these specific patterns.
///
/// Note that this also is emitted for regular `let` bindings to ensure that locals that are
- /// never accessed still get some sanity checks for e.g. `let x: ! = ..;`
+ /// never accessed still get some sanity checks for, e.g., `let x: ! = ..;`
FakeRead(FakeReadCause, Place<'tcx>),
/// Write the discriminant for a variant to the enum Place.
/// End the current live range for the storage of the local.
StorageDead(Local),
- /// Execute a piece of inline Assembly.
+ /// Executes a piece of inline Assembly.
InlineAsm {
asm: Box<InlineAsm>,
outputs: Box<[Place<'tcx>]>,
inputs: Box<[(Span, Operand<'tcx>)]>,
},
- /// Retag references in the given place, ensuring they got fresh tags. This is
+ /// Retag references in the given place, ensuring they got fresh tags. This is
/// part of the Stacked Borrows model. These statements are currently only interpreted
/// by miri and only generated when "-Z mir-emit-retag" is passed.
/// See <https://internals.rust-lang.org/t/stacked-borrows-an-aliasing-model-for-rust/8153/>
Projection(Box<PlaceProjection<'tcx>>),
}
-/// The def-id of a static, along with its normalized type (which is
+/// The `DefId` of a static, along with its normalized type (which is
/// stored to avoid requiring normalization when reading MIR).
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
pub struct Static<'tcx> {
Place::Projection(Box::new(PlaceProjection { base: self, elem }))
}
- /// Find the innermost `Local` from this `Place`, *if* it is either a local itself or
+ /// Finds the innermost `Local` from this `Place`, *if* it is either a local itself or
/// a single deref of a local.
- ///
- /// FIXME: can we safely swap the semantics of `fn base_local` below in here instead?
+ //
+ // FIXME: can we safely swap the semantics of `fn base_local` below in here instead?
pub fn local(&self) -> Option<Local> {
match self {
Place::Local(local) |
}
}
- /// Find the innermost `Local` from this `Place`.
+ /// Finds the innermost `Local` from this `Place`.
pub fn base_local(&self) -> Option<Local> {
match self {
Place::Local(local) => Some(*local),
impl<'tcx> Operand<'tcx> {
/// Convenience helper to make a constant that refers to the fn
- /// with given def-id and substs. Since this is used to synthesize
+ /// with given `DefId` and substs. Since this is used to synthesize
/// MIR, assumes `user_ty` is None.
pub fn function_handle<'a>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
span,
ty,
user_ty: None,
- literal: tcx.intern_lazy_const(
+ literal: tcx.mk_lazy_const(
ty::LazyConst::Evaluated(ty::Const::zero_sized(ty)),
),
})
/// be defined to return, say, a 0) if ADT is not an enum.
Discriminant(Place<'tcx>),
- /// Create an aggregate value, like a tuple or struct. This is
+ /// Creates an aggregate value, like a tuple or struct. This is
/// only needed because we want to distinguish `dest = Foo { x:
/// ..., y: ... }` from `dest.x = ...; dest.y = ...;` in the case
/// that `Foo` has a destructor. These rvalues can be optimized
pub enum CastKind {
Misc,
- /// Convert unique, zero-sized type for a fn to fn()
+ /// Converts unique, zero-sized type for a fn to fn()
ReifyFnPointer,
- /// Convert non capturing closure to fn()
+ /// Converts non capturing closure to fn()
ClosureFnPointer,
- /// Convert safe fn() to unsafe fn()
+ /// Converts safe fn() to unsafe fn()
UnsafeFnPointer,
/// "Unsize" -- convert a thin-or-fat pointer to a fat pointer.
#[derive(Copy, Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
pub enum NullOp {
- /// Return the size of a value of that type
+ /// Returns the size of a value of that type
SizeOf,
- /// Create a new uninitialized box for a value of that type
+ /// Creates a new uninitialized box for a value of that type
Box,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
pub enum UnsafetyViolationKind {
General,
- /// Permitted in const fn and regular fns
+ /// Permitted in const fn and regular fns.
GeneralAndConstFn,
ExternStatic(ast::NodeId),
BorrowPacked(ast::NodeId),
/// After we borrow check a closure, we are left with various
/// requirements that we have inferred between the free regions that
-/// appear in the closure's signature or on its field types. These
+/// appear in the closure's signature or on its field types. These
/// requirements are then verified and proved by the closure's
/// creating function. This struct encodes those requirements.
///
/// internally within the rest of the NLL code).
#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
pub struct ClosureRegionRequirements<'gcx> {
- /// The number of external regions defined on the closure. In our
+ /// The number of external regions defined on the closure. In our
/// example above, it would be 3 -- one for `'static`, then `'1`
/// and `'2`. This is just used for a sanity check later on, to
/// make sure that the number of regions we see at the callsite
pub struct CodegenUnit<'tcx> {
/// A name for this CGU. Incremental compilation requires that
- /// name be unique amongst **all** crates. Therefore, it should
+ /// name be unique amongst **all** crates. Therefore, it should
/// contain something unique to this crate (e.g., a module path)
/// as well as the crate name and disambiguator.
name: InternedString,
}
#[inline]
- /// Returns whether this rvalue is deeply initialized (most rvalues) or
+ /// Returns `true` if this rvalue is deeply initialized (most rvalues) or
/// whether its only shallowly initialized (`Rvalue::Box`).
pub fn initialization_state(&self) -> RvalueInitializationState {
match *self {
// ```rust
// fn super_basic_block_data(&mut self,
// block: BasicBlock,
-// data: & $($mutability)* BasicBlockData<'tcx>) {
+// data: & $($mutability)? BasicBlockData<'tcx>) {
// let BasicBlockData {
-// ref $($mutability)* statements,
-// ref $($mutability)* terminator,
+// statements,
+// terminator,
// is_cleanup: _
// } = *data;
//
// `is_cleanup` above.
macro_rules! make_mir_visitor {
- ($visitor_trait_name:ident, $($mutability:ident)*) => {
+ ($visitor_trait_name:ident, $($mutability:ident)?) => {
pub trait $visitor_trait_name<'tcx> {
// Override these, and call `self.super_xxx` to revert back to the
// default behavior.
- fn visit_mir(&mut self, mir: & $($mutability)* Mir<'tcx>) {
+ fn visit_mir(&mut self, mir: & $($mutability)? Mir<'tcx>) {
self.super_mir(mir);
}
fn visit_basic_block_data(&mut self,
block: BasicBlock,
- data: & $($mutability)* BasicBlockData<'tcx>) {
+ data: & $($mutability)? BasicBlockData<'tcx>) {
self.super_basic_block_data(block, data);
}
fn visit_source_scope_data(&mut self,
- scope_data: & $($mutability)* SourceScopeData) {
+ scope_data: & $($mutability)? SourceScopeData) {
self.super_source_scope_data(scope_data);
}
fn visit_statement(&mut self,
block: BasicBlock,
- statement: & $($mutability)* Statement<'tcx>,
+ statement: & $($mutability)? Statement<'tcx>,
location: Location) {
self.super_statement(block, statement, location);
}
fn visit_assign(&mut self,
block: BasicBlock,
- place: & $($mutability)* Place<'tcx>,
- rvalue: & $($mutability)* Rvalue<'tcx>,
+ place: & $($mutability)? Place<'tcx>,
+ rvalue: & $($mutability)? Rvalue<'tcx>,
location: Location) {
self.super_assign(block, place, rvalue, location);
}
fn visit_terminator(&mut self,
block: BasicBlock,
- terminator: & $($mutability)* Terminator<'tcx>,
+ terminator: & $($mutability)? Terminator<'tcx>,
location: Location) {
self.super_terminator(block, terminator, location);
}
fn visit_terminator_kind(&mut self,
block: BasicBlock,
- kind: & $($mutability)* TerminatorKind<'tcx>,
+ kind: & $($mutability)? TerminatorKind<'tcx>,
location: Location) {
self.super_terminator_kind(block, kind, location);
}
fn visit_assert_message(&mut self,
- msg: & $($mutability)* AssertMessage<'tcx>,
+ msg: & $($mutability)? AssertMessage<'tcx>,
location: Location) {
self.super_assert_message(msg, location);
}
fn visit_rvalue(&mut self,
- rvalue: & $($mutability)* Rvalue<'tcx>,
+ rvalue: & $($mutability)? Rvalue<'tcx>,
location: Location) {
self.super_rvalue(rvalue, location);
}
fn visit_operand(&mut self,
- operand: & $($mutability)* Operand<'tcx>,
+ operand: & $($mutability)? Operand<'tcx>,
location: Location) {
self.super_operand(operand, location);
}
fn visit_ascribe_user_ty(&mut self,
- place: & $($mutability)* Place<'tcx>,
- variance: & $($mutability)* ty::Variance,
- user_ty: & $($mutability)* UserTypeProjection<'tcx>,
+ place: & $($mutability)? Place<'tcx>,
+ variance: & $($mutability)? ty::Variance,
+ user_ty: & $($mutability)? UserTypeProjection<'tcx>,
location: Location) {
self.super_ascribe_user_ty(place, variance, user_ty, location);
}
fn visit_retag(&mut self,
- kind: & $($mutability)* RetagKind,
- place: & $($mutability)* Place<'tcx>,
+ kind: & $($mutability)? RetagKind,
+ place: & $($mutability)? Place<'tcx>,
location: Location) {
self.super_retag(kind, place, location);
}
fn visit_place(&mut self,
- place: & $($mutability)* Place<'tcx>,
+ place: & $($mutability)? Place<'tcx>,
context: PlaceContext<'tcx>,
location: Location) {
self.super_place(place, context, location);
}
fn visit_static(&mut self,
- static_: & $($mutability)* Static<'tcx>,
+ static_: & $($mutability)? Static<'tcx>,
context: PlaceContext<'tcx>,
location: Location) {
self.super_static(static_, context, location);
}
fn visit_projection(&mut self,
- place: & $($mutability)* PlaceProjection<'tcx>,
+ place: & $($mutability)? PlaceProjection<'tcx>,
context: PlaceContext<'tcx>,
location: Location) {
self.super_projection(place, context, location);
}
fn visit_projection_elem(&mut self,
- place: & $($mutability)* PlaceElem<'tcx>,
+ place: & $($mutability)? PlaceElem<'tcx>,
location: Location) {
self.super_projection_elem(place, location);
}
}
fn visit_constant(&mut self,
- constant: & $($mutability)* Constant<'tcx>,
+ constant: & $($mutability)? Constant<'tcx>,
location: Location) {
self.super_constant(constant, location);
}
fn visit_def_id(&mut self,
- def_id: & $($mutability)* DefId,
+ def_id: & $($mutability)? DefId,
_: Location) {
self.super_def_id(def_id);
}
fn visit_span(&mut self,
- span: & $($mutability)* Span) {
+ span: & $($mutability)? Span) {
self.super_span(span);
}
fn visit_source_info(&mut self,
- source_info: & $($mutability)* SourceInfo) {
+ source_info: & $($mutability)? SourceInfo) {
self.super_source_info(source_info);
}
fn visit_ty(&mut self,
- ty: & $($mutability)* Ty<'tcx>,
+ ty: & $($mutability)? Ty<'tcx>,
_: TyContext) {
self.super_ty(ty);
}
fn visit_user_type_projection(
&mut self,
- ty: & $($mutability)* UserTypeProjection<'tcx>,
+ ty: & $($mutability)? UserTypeProjection<'tcx>,
) {
self.super_user_type_projection(ty);
}
fn visit_user_type_annotation(
&mut self,
index: UserTypeAnnotationIndex,
- ty: & $($mutability)* CanonicalUserTypeAnnotation<'tcx>,
+ ty: & $($mutability)? CanonicalUserTypeAnnotation<'tcx>,
) {
self.super_user_type_annotation(index, ty);
}
fn visit_region(&mut self,
- region: & $($mutability)* ty::Region<'tcx>,
+ region: & $($mutability)? ty::Region<'tcx>,
_: Location) {
self.super_region(region);
}
fn visit_const(&mut self,
- constant: & $($mutability)* &'tcx ty::LazyConst<'tcx>,
+ constant: & $($mutability)? &'tcx ty::LazyConst<'tcx>,
_: Location) {
self.super_const(constant);
}
fn visit_substs(&mut self,
- substs: & $($mutability)* &'tcx Substs<'tcx>,
+ substs: & $($mutability)? &'tcx Substs<'tcx>,
_: Location) {
self.super_substs(substs);
}
fn visit_closure_substs(&mut self,
- substs: & $($mutability)* ClosureSubsts<'tcx>,
+ substs: & $($mutability)? ClosureSubsts<'tcx>,
_: Location) {
self.super_closure_substs(substs);
}
fn visit_generator_substs(&mut self,
- substs: & $($mutability)* GeneratorSubsts<'tcx>,
+ substs: & $($mutability)? GeneratorSubsts<'tcx>,
_: Location) {
self.super_generator_substs(substs);
}
fn visit_local_decl(&mut self,
local: Local,
- local_decl: & $($mutability)* LocalDecl<'tcx>) {
+ local_decl: & $($mutability)? LocalDecl<'tcx>) {
self.super_local_decl(local, local_decl);
}
fn visit_local(&mut self,
- _local: & $($mutability)* Local,
+ _local: & $($mutability)? Local,
_context: PlaceContext<'tcx>,
_location: Location) {
}
fn visit_source_scope(&mut self,
- scope: & $($mutability)* SourceScope) {
+ scope: & $($mutability)? SourceScope) {
self.super_source_scope(scope);
}
// not meant to be overridden.
fn super_mir(&mut self,
- mir: & $($mutability)* Mir<'tcx>) {
- if let Some(yield_ty) = &$($mutability)* mir.yield_ty {
+ mir: & $($mutability)? Mir<'tcx>) {
+ if let Some(yield_ty) = &$($mutability)? mir.yield_ty {
self.visit_ty(yield_ty, TyContext::YieldTy(SourceInfo {
span: mir.span,
scope: OUTERMOST_SOURCE_SCOPE,
(mut) => (mir.basic_blocks_mut().iter_enumerated_mut());
() => (mir.basic_blocks().iter_enumerated());
};
- for (bb, data) in basic_blocks!($($mutability)*) {
+ for (bb, data) in basic_blocks!($($mutability)?) {
self.visit_basic_block_data(bb, data);
}
- for scope in &$($mutability)* mir.source_scopes {
+ for scope in &$($mutability)? mir.source_scopes {
self.visit_source_scope_data(scope);
}
- self.visit_ty(&$($mutability)* mir.return_ty(), TyContext::ReturnTy(SourceInfo {
+ self.visit_ty(&$($mutability)? mir.return_ty(), TyContext::ReturnTy(SourceInfo {
span: mir.span,
scope: OUTERMOST_SOURCE_SCOPE,
}));
for local in mir.local_decls.indices() {
- self.visit_local_decl(local, & $($mutability)* mir.local_decls[local]);
+ self.visit_local_decl(local, & $($mutability)? mir.local_decls[local]);
}
macro_rules! type_annotations {
() => (mir.user_type_annotations.iter_enumerated());
};
- for (index, annotation) in type_annotations!($($mutability)*) {
+ for (index, annotation) in type_annotations!($($mutability)?) {
self.visit_user_type_annotation(
index, annotation
);
}
- self.visit_span(&$($mutability)* mir.span);
+ self.visit_span(&$($mutability)? mir.span);
}
fn super_basic_block_data(&mut self,
block: BasicBlock,
- data: & $($mutability)* BasicBlockData<'tcx>) {
+ data: & $($mutability)? BasicBlockData<'tcx>) {
let BasicBlockData {
- ref $($mutability)* statements,
- ref $($mutability)* terminator,
+ statements,
+ terminator,
is_cleanup: _
- } = *data;
+ } = data;
let mut index = 0;
for statement in statements {
index += 1;
}
- if let Some(ref $($mutability)* terminator) = *terminator {
+ if let Some(terminator) = terminator {
let location = Location { block: block, statement_index: index };
self.visit_terminator(block, terminator, location);
}
}
- fn super_source_scope_data(&mut self,
- scope_data: & $($mutability)* SourceScopeData) {
+ fn super_source_scope_data(&mut self, scope_data: & $($mutability)? SourceScopeData) {
let SourceScopeData {
- ref $($mutability)* span,
- ref $($mutability)* parent_scope,
- } = *scope_data;
+ span,
+ parent_scope,
+ } = scope_data;
self.visit_span(span);
- if let Some(ref $($mutability)* parent_scope) = *parent_scope {
+ if let Some(parent_scope) = parent_scope {
self.visit_source_scope(parent_scope);
}
}
fn super_statement(&mut self,
block: BasicBlock,
- statement: & $($mutability)* Statement<'tcx>,
+ statement: & $($mutability)? Statement<'tcx>,
location: Location) {
let Statement {
- ref $($mutability)* source_info,
- ref $($mutability)* kind,
- } = *statement;
+ source_info,
+ kind,
+ } = statement;
self.visit_source_info(source_info);
- match *kind {
- StatementKind::Assign(ref $($mutability)* place,
- ref $($mutability)* rvalue) => {
+ match kind {
+ StatementKind::Assign(place, rvalue) => {
self.visit_assign(block, place, rvalue, location);
}
- StatementKind::FakeRead(_, ref $($mutability)* place) => {
+ StatementKind::FakeRead(_, place) => {
self.visit_place(
place,
PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect),
location
);
}
- StatementKind::SetDiscriminant{ ref $($mutability)* place, .. } => {
+ StatementKind::SetDiscriminant { place, .. } => {
self.visit_place(
place,
PlaceContext::MutatingUse(MutatingUseContext::Store),
location
);
}
- StatementKind::StorageLive(ref $($mutability)* local) => {
+ StatementKind::StorageLive(local) => {
self.visit_local(
local,
PlaceContext::NonUse(NonUseContext::StorageLive),
location
);
}
- StatementKind::StorageDead(ref $($mutability)* local) => {
+ StatementKind::StorageDead(local) => {
self.visit_local(
local,
PlaceContext::NonUse(NonUseContext::StorageDead),
location
);
}
- StatementKind::InlineAsm { ref $($mutability)* outputs,
- ref $($mutability)* inputs,
- asm: _ } => {
- for output in & $($mutability)* outputs[..] {
+ StatementKind::InlineAsm { outputs, inputs, asm: _ } => {
+ for output in & $($mutability)? outputs[..] {
self.visit_place(
output,
PlaceContext::MutatingUse(MutatingUseContext::AsmOutput),
location
);
}
- for (span, input) in & $($mutability)* inputs[..] {
+ for (span, input) in & $($mutability)? inputs[..] {
self.visit_span(span);
self.visit_operand(input, location);
}
}
- StatementKind::Retag ( ref $($mutability)* kind,
- ref $($mutability)* place ) => {
+ StatementKind::Retag(kind, place) => {
self.visit_retag(kind, place, location);
}
- StatementKind::AscribeUserType(
- ref $($mutability)* place,
- ref $($mutability)* variance,
- ref $($mutability)* user_ty,
- ) => {
+ StatementKind::AscribeUserType(place, variance, user_ty) => {
self.visit_ascribe_user_ty(place, variance, user_ty, location);
}
StatementKind::Nop => {}
fn super_assign(&mut self,
_block: BasicBlock,
- place: &$($mutability)* Place<'tcx>,
- rvalue: &$($mutability)* Rvalue<'tcx>,
+ place: &$($mutability)? Place<'tcx>,
+ rvalue: &$($mutability)? Rvalue<'tcx>,
location: Location) {
self.visit_place(
place,
fn super_terminator(&mut self,
block: BasicBlock,
- terminator: &$($mutability)* Terminator<'tcx>,
+ terminator: &$($mutability)? Terminator<'tcx>,
location: Location) {
- let Terminator {
- ref $($mutability)* source_info,
- ref $($mutability)* kind,
- } = *terminator;
+ let Terminator { source_info, kind } = terminator;
self.visit_source_info(source_info);
self.visit_terminator_kind(block, kind, location);
fn super_terminator_kind(&mut self,
block: BasicBlock,
- kind: & $($mutability)* TerminatorKind<'tcx>,
+ kind: & $($mutability)? TerminatorKind<'tcx>,
source_location: Location) {
- match *kind {
+ match kind {
TerminatorKind::Goto { target } => {
- self.visit_branch(block, target);
+ self.visit_branch(block, *target);
}
- TerminatorKind::SwitchInt { ref $($mutability)* discr,
- ref $($mutability)* switch_ty,
- values: _,
- ref targets } => {
+ TerminatorKind::SwitchInt {
+ discr,
+ switch_ty,
+ values: _,
+ targets
+ } => {
self.visit_operand(discr, source_location);
self.visit_ty(switch_ty, TyContext::Location(source_location));
- for &target in targets {
- self.visit_branch(block, target);
+ for target in targets {
+ self.visit_branch(block, *target);
}
}
TerminatorKind::Unreachable => {
}
- TerminatorKind::Drop { ref $($mutability)* location,
- target,
- unwind } => {
+ TerminatorKind::Drop {
+ location,
+ target,
+ unwind,
+ } => {
self.visit_place(
location,
PlaceContext::MutatingUse(MutatingUseContext::Drop),
source_location
);
- self.visit_branch(block, target);
+ self.visit_branch(block, *target);
unwind.map(|t| self.visit_branch(block, t));
}
- TerminatorKind::DropAndReplace { ref $($mutability)* location,
- ref $($mutability)* value,
- target,
- unwind } => {
+ TerminatorKind::DropAndReplace {
+ location,
+ value,
+ target,
+ unwind,
+ } => {
self.visit_place(
location,
PlaceContext::MutatingUse(MutatingUseContext::Drop),
source_location
);
self.visit_operand(value, source_location);
- self.visit_branch(block, target);
+ self.visit_branch(block, *target);
unwind.map(|t| self.visit_branch(block, t));
}
- TerminatorKind::Call { ref $($mutability)* func,
- ref $($mutability)* args,
- ref $($mutability)* destination,
- cleanup,
- from_hir_call: _, } => {
+ TerminatorKind::Call {
+ func,
+ args,
+ destination,
+ cleanup,
+ from_hir_call: _,
+ } => {
self.visit_operand(func, source_location);
for arg in args {
self.visit_operand(arg, source_location);
}
- if let Some((ref $($mutability)* destination, target)) = *destination {
+ if let Some((destination, target)) = destination {
self.visit_place(
destination,
PlaceContext::MutatingUse(MutatingUseContext::Call),
source_location
);
- self.visit_branch(block, target);
+ self.visit_branch(block, *target);
}
cleanup.map(|t| self.visit_branch(block, t));
}
- TerminatorKind::Assert { ref $($mutability)* cond,
- expected: _,
- ref $($mutability)* msg,
- target,
- cleanup } => {
+ TerminatorKind::Assert {
+ cond,
+ expected: _,
+ msg,
+ target,
+ cleanup,
+ } => {
self.visit_operand(cond, source_location);
self.visit_assert_message(msg, source_location);
- self.visit_branch(block, target);
+ self.visit_branch(block, *target);
cleanup.map(|t| self.visit_branch(block, t));
}
- TerminatorKind::Yield { ref $($mutability)* value,
- resume,
- drop } => {
+ TerminatorKind::Yield {
+ value,
+ resume,
+ drop,
+ } => {
self.visit_operand(value, source_location);
- self.visit_branch(block, resume);
+ self.visit_branch(block, *resume);
drop.map(|t| self.visit_branch(block, t));
}
- TerminatorKind::FalseEdges { real_target, ref imaginary_targets} => {
- self.visit_branch(block, real_target);
+ TerminatorKind::FalseEdges { real_target, imaginary_targets } => {
+ self.visit_branch(block, *real_target);
for target in imaginary_targets {
self.visit_branch(block, *target);
}
}
TerminatorKind::FalseUnwind { real_target, unwind } => {
- self.visit_branch(block, real_target);
+ self.visit_branch(block, *real_target);
if let Some(unwind) = unwind {
- self.visit_branch(block, unwind);
+ self.visit_branch(block, *unwind);
}
}
}
}
fn super_assert_message(&mut self,
- msg: & $($mutability)* AssertMessage<'tcx>,
+ msg: & $($mutability)? AssertMessage<'tcx>,
location: Location) {
use crate::mir::interpret::EvalErrorKind::*;
- if let BoundsCheck {
- ref $($mutability)* len,
- ref $($mutability)* index
- } = *msg {
+ if let BoundsCheck { len, index } = msg {
self.visit_operand(len, location);
self.visit_operand(index, location);
}
}
fn super_rvalue(&mut self,
- rvalue: & $($mutability)* Rvalue<'tcx>,
+ rvalue: & $($mutability)? Rvalue<'tcx>,
location: Location) {
- match *rvalue {
- Rvalue::Use(ref $($mutability)* operand) => {
+ match rvalue {
+ Rvalue::Use(operand) => {
self.visit_operand(operand, location);
}
- Rvalue::Repeat(ref $($mutability)* value, _) => {
+ Rvalue::Repeat(value, _) => {
self.visit_operand(value, location);
}
- Rvalue::Ref(ref $($mutability)* r, bk, ref $($mutability)* path) => {
+ Rvalue::Ref(r, bk, path) => {
self.visit_region(r, location);
let ctx = match bk {
BorrowKind::Shared => PlaceContext::NonMutatingUse(
self.visit_place(path, ctx, location);
}
- Rvalue::Len(ref $($mutability)* path) => {
+ Rvalue::Len(path) => {
self.visit_place(
path,
PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect),
);
}
- Rvalue::Cast(_cast_kind,
- ref $($mutability)* operand,
- ref $($mutability)* ty) => {
+ Rvalue::Cast(_cast_kind, operand, ty) => {
self.visit_operand(operand, location);
self.visit_ty(ty, TyContext::Location(location));
}
- Rvalue::BinaryOp(_bin_op,
- ref $($mutability)* lhs,
- ref $($mutability)* rhs) |
- Rvalue::CheckedBinaryOp(_bin_op,
- ref $($mutability)* lhs,
- ref $($mutability)* rhs) => {
+ Rvalue::BinaryOp(_bin_op, lhs, rhs)
+ | Rvalue::CheckedBinaryOp(_bin_op, lhs, rhs) => {
self.visit_operand(lhs, location);
self.visit_operand(rhs, location);
}
- Rvalue::UnaryOp(_un_op, ref $($mutability)* op) => {
+ Rvalue::UnaryOp(_un_op, op) => {
self.visit_operand(op, location);
}
- Rvalue::Discriminant(ref $($mutability)* place) => {
+ Rvalue::Discriminant(place) => {
self.visit_place(
place,
PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect),
);
}
- Rvalue::NullaryOp(_op, ref $($mutability)* ty) => {
+ Rvalue::NullaryOp(_op, ty) => {
self.visit_ty(ty, TyContext::Location(location));
}
- Rvalue::Aggregate(ref $($mutability)* kind,
- ref $($mutability)* operands) => {
- let kind = &$($mutability)* **kind;
- match *kind {
- AggregateKind::Array(ref $($mutability)* ty) => {
+ Rvalue::Aggregate(kind, operands) => {
+ let kind = &$($mutability)? **kind;
+ match kind {
+ AggregateKind::Array(ty) => {
self.visit_ty(ty, TyContext::Location(location));
}
AggregateKind::Tuple => {
}
- AggregateKind::Adt(_adt_def,
- _variant_index,
- ref $($mutability)* substs,
- _user_substs,
- _active_field_index) => {
+ AggregateKind::Adt(
+ _adt_def,
+ _variant_index,
+ substs,
+ _user_substs,
+ _active_field_index
+ ) => {
self.visit_substs(substs, location);
}
- AggregateKind::Closure(ref $($mutability)* def_id,
- ref $($mutability)* closure_substs) => {
+ AggregateKind::Closure(
+ def_id,
+ closure_substs
+ ) => {
self.visit_def_id(def_id, location);
self.visit_closure_substs(closure_substs, location);
}
- AggregateKind::Generator(ref $($mutability)* def_id,
- ref $($mutability)* generator_substs,
- _movability) => {
+ AggregateKind::Generator(
+ def_id,
+ generator_substs,
+ _movability,
+ ) => {
self.visit_def_id(def_id, location);
self.visit_generator_substs(generator_substs, location);
}
}
fn super_operand(&mut self,
- operand: & $($mutability)* Operand<'tcx>,
+ operand: & $($mutability)? Operand<'tcx>,
location: Location) {
- match *operand {
- Operand::Copy(ref $($mutability)* place) => {
+ match operand {
+ Operand::Copy(place) => {
self.visit_place(
place,
PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
location
);
}
- Operand::Move(ref $($mutability)* place) => {
+ Operand::Move(place) => {
self.visit_place(
place,
PlaceContext::NonMutatingUse(NonMutatingUseContext::Move),
location
);
}
- Operand::Constant(ref $($mutability)* constant) => {
+ Operand::Constant(constant) => {
self.visit_constant(constant, location);
}
}
}
fn super_ascribe_user_ty(&mut self,
- place: & $($mutability)* Place<'tcx>,
- _variance: & $($mutability)* ty::Variance,
- user_ty: & $($mutability)* UserTypeProjection<'tcx>,
+ place: & $($mutability)? Place<'tcx>,
+ _variance: & $($mutability)? ty::Variance,
+ user_ty: & $($mutability)? UserTypeProjection<'tcx>,
location: Location) {
self.visit_place(
place,
}
fn super_retag(&mut self,
- _kind: & $($mutability)* RetagKind,
- place: & $($mutability)* Place<'tcx>,
+ _kind: & $($mutability)? RetagKind,
+ place: & $($mutability)? Place<'tcx>,
location: Location) {
self.visit_place(
place,
}
fn super_place(&mut self,
- place: & $($mutability)* Place<'tcx>,
+ place: & $($mutability)? Place<'tcx>,
context: PlaceContext<'tcx>,
location: Location) {
- match *place {
- Place::Local(ref $($mutability)* local) => {
+ match place {
+ Place::Local(local) => {
self.visit_local(local, context, location);
}
- Place::Static(ref $($mutability)* static_) => {
+ Place::Static(static_) => {
self.visit_static(static_, context, location);
}
- Place::Promoted(ref $($mutability)* promoted) => {
- self.visit_ty(& $($mutability)* promoted.1, TyContext::Location(location));
+ Place::Promoted(promoted) => {
+ self.visit_ty(& $($mutability)? promoted.1, TyContext::Location(location));
},
- Place::Projection(ref $($mutability)* proj) => {
+ Place::Projection(proj) => {
self.visit_projection(proj, context, location);
}
}
}
fn super_static(&mut self,
- static_: & $($mutability)* Static<'tcx>,
+ static_: & $($mutability)? Static<'tcx>,
_context: PlaceContext<'tcx>,
location: Location) {
- let Static {
- ref $($mutability)* def_id,
- ref $($mutability)* ty,
- } = *static_;
+ let Static { def_id, ty } = static_;
self.visit_def_id(def_id, location);
self.visit_ty(ty, TyContext::Location(location));
}
fn super_projection(&mut self,
- proj: & $($mutability)* PlaceProjection<'tcx>,
+ proj: & $($mutability)? PlaceProjection<'tcx>,
context: PlaceContext<'tcx>,
location: Location) {
- let Projection {
- ref $($mutability)* base,
- ref $($mutability)* elem,
- } = *proj;
+ let Projection { base, elem } = proj;
let context = if context.is_mutating_use() {
PlaceContext::MutatingUse(MutatingUseContext::Projection)
} else {
}
fn super_projection_elem(&mut self,
- proj: & $($mutability)* PlaceElem<'tcx>,
+ proj: & $($mutability)? PlaceElem<'tcx>,
location: Location) {
- match *proj {
+ match proj {
ProjectionElem::Deref => {
}
ProjectionElem::Subslice { from: _, to: _ } => {
}
- ProjectionElem::Field(_field, ref $($mutability)* ty) => {
+ ProjectionElem::Field(_field, ty) => {
self.visit_ty(ty, TyContext::Location(location));
}
- ProjectionElem::Index(ref $($mutability)* local) => {
+ ProjectionElem::Index(local) => {
self.visit_local(
local,
PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
fn super_local_decl(&mut self,
local: Local,
- local_decl: & $($mutability)* LocalDecl<'tcx>) {
+ local_decl: & $($mutability)? LocalDecl<'tcx>) {
let LocalDecl {
mutability: _,
- ref $($mutability)* ty,
- ref $($mutability)* user_ty,
+ ty,
+ user_ty,
name: _,
- ref $($mutability)* source_info,
- ref $($mutability)* visibility_scope,
+ source_info,
+ visibility_scope,
internal: _,
is_user_variable: _,
is_block_tail: _,
- } = *local_decl;
+ } = local_decl;
self.visit_ty(ty, TyContext::LocalDecl {
local,
source_info: *source_info,
});
- for (user_ty, _) in & $($mutability)* user_ty.contents {
+ for (user_ty, _) in & $($mutability)? user_ty.contents {
self.visit_user_type_projection(user_ty);
}
self.visit_source_info(source_info);
}
fn super_source_scope(&mut self,
- _scope: & $($mutability)* SourceScope) {
+ _scope: & $($mutability)? SourceScope) {
}
fn super_branch(&mut self,
}
fn super_constant(&mut self,
- constant: & $($mutability)* Constant<'tcx>,
+ constant: & $($mutability)? Constant<'tcx>,
location: Location) {
let Constant {
- ref $($mutability)* span,
- ref $($mutability)* ty,
- ref $($mutability)* user_ty,
- ref $($mutability)* literal,
- } = *constant;
+ span,
+ ty,
+ user_ty,
+ literal,
+ } = constant;
self.visit_span(span);
self.visit_ty(ty, TyContext::Location(location));
self.visit_const(literal, location);
}
- fn super_def_id(&mut self, _def_id: & $($mutability)* DefId) {
+ fn super_def_id(&mut self, _def_id: & $($mutability)? DefId) {
}
- fn super_span(&mut self, _span: & $($mutability)* Span) {
+ fn super_span(&mut self, _span: & $($mutability)? Span) {
}
- fn super_source_info(&mut self, source_info: & $($mutability)* SourceInfo) {
+ fn super_source_info(&mut self, source_info: & $($mutability)? SourceInfo) {
let SourceInfo {
- ref $($mutability)* span,
- ref $($mutability)* scope,
- } = *source_info;
+ span,
+ scope,
+ } = source_info;
self.visit_span(span);
self.visit_source_scope(scope);
fn super_user_type_projection(
&mut self,
- _ty: & $($mutability)* UserTypeProjection<'tcx>,
+ _ty: & $($mutability)? UserTypeProjection<'tcx>,
) {
}
fn super_user_type_annotation(
&mut self,
_index: UserTypeAnnotationIndex,
- ty: & $($mutability)* CanonicalUserTypeAnnotation<'tcx>,
+ ty: & $($mutability)? CanonicalUserTypeAnnotation<'tcx>,
) {
- self.visit_span(& $($mutability)* ty.span);
- self.visit_ty(& $($mutability)* ty.inferred_ty, TyContext::UserTy(ty.span));
+ self.visit_span(& $($mutability)? ty.span);
+ self.visit_ty(& $($mutability)? ty.inferred_ty, TyContext::UserTy(ty.span));
}
- fn super_ty(&mut self, _ty: & $($mutability)* Ty<'tcx>) {
+ fn super_ty(&mut self, _ty: & $($mutability)? Ty<'tcx>) {
}
- fn super_region(&mut self, _region: & $($mutability)* ty::Region<'tcx>) {
+ fn super_region(&mut self, _region: & $($mutability)? ty::Region<'tcx>) {
}
- fn super_const(&mut self, _const: & $($mutability)* &'tcx ty::LazyConst<'tcx>) {
+ fn super_const(&mut self, _const: & $($mutability)? &'tcx ty::LazyConst<'tcx>) {
}
- fn super_substs(&mut self, _substs: & $($mutability)* &'tcx Substs<'tcx>) {
+ fn super_substs(&mut self, _substs: & $($mutability)? &'tcx Substs<'tcx>) {
}
fn super_generator_substs(&mut self,
- _substs: & $($mutability)* GeneratorSubsts<'tcx>) {
+ _substs: & $($mutability)? GeneratorSubsts<'tcx>) {
}
fn super_closure_substs(&mut self,
- _substs: & $($mutability)* ClosureSubsts<'tcx>) {
+ _substs: & $($mutability)? ClosureSubsts<'tcx>) {
}
// Convenience methods
- fn visit_location(&mut self, mir: & $($mutability)* Mir<'tcx>, location: Location) {
- let basic_block = & $($mutability)* mir[location.block];
+ fn visit_location(&mut self, mir: & $($mutability)? Mir<'tcx>, location: Location) {
+ let basic_block = & $($mutability)? mir[location.block];
if basic_block.statements.len() == location.statement_index {
- if let Some(ref $($mutability)* terminator) = basic_block.terminator {
+ if let Some(ref $($mutability)? terminator) = basic_block.terminator {
self.visit_terminator(location.block, terminator, location)
}
} else {
- let statement = & $($mutability)*
+ let statement = & $($mutability)?
basic_block.statements[location.statement_index];
self.visit_statement(location.block, statement, location)
}
use syntax::symbol::Symbol;
use syntax::feature_gate::UnstableFeatures;
-use crate::errors::{ColorConfig, FatalError, Handler};
+use errors::{ColorConfig, FatalError, Handler};
use getopts;
use std::collections::{BTreeMap, BTreeSet};
}
#[derive(Clone, PartialEq, Hash)]
-pub enum CrossLangLto {
+pub enum LinkerPluginLto {
LinkerPlugin(PathBuf),
LinkerPluginAuto,
Disabled
}
-impl CrossLangLto {
+impl LinkerPluginLto {
pub fn enabled(&self) -> bool {
match *self {
- CrossLangLto::LinkerPlugin(_) |
- CrossLangLto::LinkerPluginAuto => true,
- CrossLangLto::Disabled => false,
+ LinkerPluginLto::LinkerPlugin(_) |
+ LinkerPluginLto::LinkerPluginAuto => true,
+ LinkerPluginLto::Disabled => false,
}
}
}
}
pub enum Input {
- /// Load source from file
+ /// Loads source from file
File(PathBuf),
Str {
/// String that is shown in place of a filename
.unwrap_or_else(|| self.temp_path(flavor, None))
}
- /// Get the path where a compilation artifact of the given type for the
+ /// Gets the path where a compilation artifact of the given type for the
/// given codegen unit should be placed on disk. If codegen_unit_name is
/// None, a path distinct from those of any codegen unit will be generated.
pub fn temp_path(&self, flavor: OutputType, codegen_unit_name: Option<&str>) -> PathBuf {
}
/// Like temp_path, but also supports things where there is no corresponding
- /// OutputType, like no-opt-bitcode or lto-bitcode.
+ /// OutputType, like noopt-bitcode or lto-bitcode.
pub fn temp_path_ext(&self, ext: &str, codegen_unit_name: Option<&str>) -> PathBuf {
let base = self.out_directory.join(&self.filestem());
}
impl Options {
- /// True if there is a reason to build the dep graph.
+ /// Returns `true` if there is a reason to build the dep graph.
pub fn build_dep_graph(&self) -> bool {
self.incremental.is_some() || self.debugging_opts.dump_dep_graph
|| self.debugging_opts.query_dep_graph
FilePathMapping::new(self.remap_path_prefix.clone())
}
- /// True if there will be an output file generated
+ /// Returns `true` if there will be an output file generated
pub fn will_create_output_file(&self) -> bool {
!self.debugging_opts.parse_only && // The file is just being parsed
!self.debugging_opts.ls // The file is just being queried
pub const parse_lto: Option<&str> =
Some("either a boolean (`yes`, `no`, `on`, `off`, etc), `thin`, \
`fat`, or omitted");
- pub const parse_cross_lang_lto: Option<&str> =
+ pub const parse_linker_plugin_lto: Option<&str> =
Some("either a boolean (`yes`, `no`, `on`, `off`, etc), \
or the path to the linker plugin");
pub const parse_merge_functions: Option<&str> =
#[allow(dead_code)]
mod $mod_set {
- use super::{$struct_name, Passes, Sanitizer, LtoCli, CrossLangLto};
+ use super::{$struct_name, Passes, Sanitizer, LtoCli, LinkerPluginLto};
use rustc_target::spec::{LinkerFlavor, MergeFunctions, PanicStrategy, RelroLevel};
use std::path::PathBuf;
use std::str::FromStr;
true
}
- fn parse_cross_lang_lto(slot: &mut CrossLangLto, v: Option<&str>) -> bool {
+ fn parse_linker_plugin_lto(slot: &mut LinkerPluginLto, v: Option<&str>) -> bool {
if v.is_some() {
let mut bool_arg = None;
if parse_opt_bool(&mut bool_arg, v) {
*slot = if bool_arg.unwrap() {
- CrossLangLto::LinkerPluginAuto
+ LinkerPluginLto::LinkerPluginAuto
} else {
- CrossLangLto::Disabled
+ LinkerPluginLto::Disabled
};
return true
}
}
*slot = match v {
- None => CrossLangLto::LinkerPluginAuto,
- Some(path) => CrossLangLto::LinkerPlugin(PathBuf::from(path)),
+ None => LinkerPluginLto::LinkerPluginAuto,
+ Some(path) => LinkerPluginLto::LinkerPlugin(PathBuf::from(path)),
};
true
}
"allow the linker to link its default libraries"),
linker_flavor: Option<LinkerFlavor> = (None, parse_linker_flavor, [UNTRACKED],
"Linker flavor"),
+ linker_plugin_lto: LinkerPluginLto = (LinkerPluginLto::Disabled,
+ parse_linker_plugin_lto, [TRACKED],
+ "generate build artifacts that are compatible with linker-based LTO."),
+
}
options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
"show extended diagnostic help"),
continue_parse_after_error: bool = (false, parse_bool, [TRACKED],
"attempt to recover from parse errors (experimental)"),
+ dep_tasks: bool = (false, parse_bool, [UNTRACKED],
+ "print tasks that execute and the color their dep node gets (requires debug build)"),
incremental: Option<String> = (None, parse_opt_string, [UNTRACKED],
"enable incremental compilation (experimental)"),
incremental_queries: bool = (true, parse_bool, [UNTRACKED],
"make the current crate share its generic instantiations"),
chalk: bool = (false, parse_bool, [TRACKED],
"enable the experimental Chalk-based trait solving engine"),
- cross_lang_lto: CrossLangLto = (CrossLangLto::Disabled, parse_cross_lang_lto, [TRACKED],
- "generate build artifacts that are compatible with linker-based LTO."),
no_parallel_llvm: bool = (false, parse_bool, [UNTRACKED],
"don't run LLVM in parallel (while keeping codegen-units and ThinLTO)"),
no_leak_check: bool = (false, parse_bool, [UNTRACKED],
use std::path::PathBuf;
use std::collections::hash_map::DefaultHasher;
use super::{CrateType, DebugInfo, ErrorOutputType, OptLevel, OutputTypes,
- Passes, Sanitizer, LtoCli, CrossLangLto};
+ Passes, Sanitizer, LtoCli, LinkerPluginLto};
use syntax::feature_gate::UnstableFeatures;
use rustc_target::spec::{MergeFunctions, PanicStrategy, RelroLevel, TargetTriple};
use syntax::edition::Edition;
impl_dep_tracking_hash_via_hash!(Option<Sanitizer>);
impl_dep_tracking_hash_via_hash!(TargetTriple);
impl_dep_tracking_hash_via_hash!(Edition);
- impl_dep_tracking_hash_via_hash!(CrossLangLto);
+ impl_dep_tracking_hash_via_hash!(LinkerPluginLto);
impl_dep_tracking_hash_for_sortable_vec_of!(String);
impl_dep_tracking_hash_for_sortable_vec_of!(PathBuf);
#[cfg(test)]
mod tests {
- use crate::errors;
use getopts;
use crate::lint;
use crate::middle::cstore;
use crate::session::config::{build_configuration, build_session_options_and_crate_config};
- use crate::session::config::{LtoCli, CrossLangLto};
+ use crate::session::config::{LtoCli, LinkerPluginLto};
use crate::session::build_session;
use crate::session::search_paths::SearchPath;
use std::collections::{BTreeMap, BTreeSet};
opts = reference.clone();
opts.cg.panic = Some(PanicStrategy::Abort);
assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
+
+ opts = reference.clone();
+ opts.cg.linker_plugin_lto = LinkerPluginLto::LinkerPluginAuto;
+ assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
}
#[test]
opts.debugging_opts.relro_level = Some(RelroLevel::Full);
assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
- opts = reference.clone();
- opts.debugging_opts.cross_lang_lto = CrossLangLto::LinkerPluginAuto;
- assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
-
opts = reference.clone();
opts.debugging_opts.merge_functions = Some(MergeFunctions::Disabled);
assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
use crate::lint::builtin::BuiltinLintDiagnostics;
use crate::middle::allocator::AllocatorKind;
use crate::middle::dependency_format;
-use crate::session::config::{OutputType, Lto};
+use crate::session::config::OutputType;
use crate::session::search_paths::{PathKind, SearchPath};
use crate::util::nodemap::{FxHashMap, FxHashSet};
use crate::util::common::{duration_to_secs_str, ErrorReported};
Ordering::SeqCst,
};
-use crate::errors::{self, DiagnosticBuilder, DiagnosticId, Applicability};
-use crate::errors::emitter::{Emitter, EmitterWriter};
+use errors::{DiagnosticBuilder, DiagnosticId, Applicability};
+use errors::emitter::{Emitter, EmitterWriter};
use syntax::ast::{self, NodeId};
use syntax::edition::Edition;
use syntax::feature_gate::{self, AttributeType};
pub mod search_paths;
pub struct OptimizationFuel {
- /// If -zfuel=crate=n is specified, initially set to n. Otherwise 0.
+ /// If `-zfuel=crate=n` is specified, initially set to `n`, otherwise `0`.
remaining: u64,
/// We're rejecting all further optimizations.
out_of_fuel: bool,
pub host: Target,
pub opts: config::Options,
pub host_tlib_path: SearchPath,
- /// This is `None` if the host and target are the same.
+ /// `None` if the host and target are the same.
pub target_tlib_path: Option<SearchPath>,
pub parse_sess: ParseSess,
pub sysroot: PathBuf,
/// The maximum length of types during monomorphization.
pub type_length_limit: Once<usize>,
- /// The maximum number of stackframes allowed in const eval
+ /// The maximum number of stackframes allowed in const eval.
pub const_eval_stack_frame_limit: usize,
/// The metadata::creader module may inject an allocator/panic_runtime
/// `-Zquery-dep-graph` is specified.
pub cgu_reuse_tracker: CguReuseTracker,
- /// Used by -Z profile-queries in util::common
+ /// Used by `-Z profile-queries` in `util::common`.
pub profile_channel: Lock<Option<mpsc::Sender<ProfileQueriesMsg>>>,
- /// Used by -Z self-profile
+ /// Used by `-Z self-profile`.
pub self_profiling_active: bool,
- /// Used by -Z self-profile
+ /// Used by `-Z self-profile`.
pub self_profiling: Lock<SelfProfiler>,
/// Some measurements that are being gathered during compilation.
next_node_id: OneThread<Cell<ast::NodeId>>,
- /// If -zfuel=crate=n is specified, Some(crate).
+ /// If `-zfuel=crate=n` is specified, `Some(crate)`.
optimization_fuel_crate: Option<String>,
- /// Tracks fuel info if If -zfuel=crate=n is specified
+ /// Tracks fuel info if `-zfuel=crate=n` is specified.
optimization_fuel: Lock<OptimizationFuel>,
// The next two are public because the driver needs to read them.
- /// If -zprint-fuel=crate, Some(crate).
+ /// If `-zprint-fuel=crate`, `Some(crate)`.
pub print_fuel_crate: Option<String>,
/// Always set to zero and incremented so that we can print fuel expended by a crate.
pub print_fuel: AtomicU64,
/// false positives about a job server in our environment.
pub jobserver: Client,
- /// Metadata about the allocators for the current crate being compiled
+ /// Metadata about the allocators for the current crate being compiled.
pub has_global_allocator: Once<bool>,
- /// Metadata about the panic handlers for the current crate being compiled
+ /// Metadata about the panic handlers for the current crate being compiled.
pub has_panic_handler: Once<bool>,
/// Cap lint level specified by a driver specifically.
}
pub struct PerfStats {
- /// The accumulated time spent on computing symbol hashes
+ /// The accumulated time spent on computing symbol hashes.
pub symbol_hash_time: Lock<Duration>,
- /// The accumulated time spent decoding def path tables from metadata
+ /// The accumulated time spent decoding def path tables from metadata.
pub decode_def_path_tables_time: Lock<Duration>,
/// Total number of values canonicalized queries constructed.
pub queries_canonicalized: AtomicUsize,
self.opts.debugging_opts.print_llvm_passes
}
- /// Get the features enabled for the current compilation session.
+ /// Gets the features enabled for the current compilation session.
/// DO NOT USE THIS METHOD if there is a TyCtxt available, as it circumvents
/// dependency tracking. Use tcx.features() instead.
#[inline]
self.opts.edition
}
- /// True if we cannot skip the PLT for shared library calls.
+ /// Returns `true` if we cannot skip the PLT for shared library calls.
pub fn needs_plt(&self) -> bool {
// Check if the current target usually needs PLT to be enabled.
// The user can use the command line flag to override it.
// If it is useful to have a Session available already for validating a
// commandline argument, you can do so here.
fn validate_commandline_args_with_session_available(sess: &Session) {
-
- if sess.opts.incremental.is_some() {
- match sess.lto() {
- Lto::Thin |
- Lto::Fat => {
- sess.err("can't perform LTO when compiling incrementally");
- }
- Lto::ThinLocal |
- Lto::No => {
- // This is fine
- }
- }
- }
-
// Since we don't know if code in an rlib will be linked to statically or
// dynamically downstream, rustc generates `__imp_` symbols that help the
// MSVC linker deal with this lack of knowledge (#27438). Unfortunately,
// bitcode during ThinLTO. Therefore we disallow dynamic linking on MSVC
// when compiling for LLD ThinLTO. This way we can validly just not generate
// the `dllimport` attributes and `__imp_` symbols in that case.
- if sess.opts.debugging_opts.cross_lang_lto.enabled() &&
+ if sess.opts.cg.linker_plugin_lto.enabled() &&
sess.opts.cg.prefer_dynamic &&
sess.target.target.options.is_like_msvc {
sess.err("Linker plugin based LTO is not supported together with \
AutoTraitFinder { tcx }
}
- /// Make a best effort to determine whether and under which conditions an auto trait is
+ /// Makes a best effort to determine whether and under which conditions an auto trait is
/// implemented for a type. For example, if you have
///
/// ```
full_env,
ty,
trait_did,
- ObligationCause::misc(DUMMY_SP, ast::DUMMY_NODE_ID),
+ ObligationCause::misc(DUMMY_SP, hir::DUMMY_HIR_ID),
);
fulfill.select_all_or_error(&infcx).unwrap_or_else(|e| {
panic!(
user_env.caller_bounds.iter().cloned().collect();
let mut new_env = param_env.clone();
- let dummy_cause = ObligationCause::misc(DUMMY_SP, ast::DUMMY_NODE_ID);
+ let dummy_cause = ObligationCause::misc(DUMMY_SP, hir::DUMMY_HIR_ID);
while let Some(pred) = predicates.pop_front() {
infcx.clear_caches();
select: &mut SelectionContext<'c, 'd, 'cx>,
only_projections: bool,
) -> bool {
- let dummy_cause = ObligationCause::misc(DUMMY_SP, ast::DUMMY_NODE_ID);
+ let dummy_cause = ObligationCause::misc(DUMMY_SP, hir::DUMMY_HIR_ID);
for (obligation, mut predicate) in nested
.map(|o| (o.clone(), o.predicate.clone()))
use crate::ty::subst::{Subst, Substs};
use crate::ty::fold::TypeFoldable;
-/// Attempts to resolve an obligation to a vtable.. The result is
-/// a shallow vtable resolution -- meaning that we do not
+/// Attempts to resolve an obligation to a vtable. The result is
+/// a shallow vtable resolution, meaning that we do not
/// (necessarily) resolve all nested obligations on the impl. Note
/// that type check should guarantee to us that all nested
/// obligations *could be* resolved if we wanted to.
-//! See rustc guide chapters on [trait-resolution] and [trait-specialization] for more info on how
+//! See Rustc Guide chapters on [trait-resolution] and [trait-specialization] for more info on how
//! this works.
//!
//! [trait-resolution]: https://rust-lang.github.io/rustc-guide/traits/resolution.html
pub impl_header: ty::ImplHeader<'tcx>,
pub intercrate_ambiguity_causes: Vec<IntercrateAmbiguityCause>,
- /// True if the overlap might've been permitted before the shift
+ /// `true` if the overlap might've been permitted before the shift
/// to universes.
pub involves_placeholder: bool,
}
-pub fn add_placeholder_note(err: &mut crate::errors::DiagnosticBuilder<'_>) {
+pub fn add_placeholder_note(err: &mut errors::DiagnosticBuilder<'_>) {
err.note(&format!(
"this behavior recently changed as a result of a bug fix; \
see rust-lang/rust#56105 for details"
}
/// Can both impl `a` and impl `b` be satisfied by a common type (including
-/// `where` clauses)? If so, returns an `ImplHeader` that unifies the two impls.
+/// where-clauses)? If so, returns an `ImplHeader` that unifies the two impls.
fn overlap<'cx, 'gcx, 'tcx>(
selcx: &mut SelectionContext<'cx, 'gcx, 'tcx>,
a_def_id: DefId,
}
/// Checks the coherence orphan rules. `impl_def_id` should be the
-/// def-id of a trait impl. To pass, either the trait must be local, or else
+/// `DefId` of a trait impl. To pass, either the trait must be local, or else
/// two conditions must be satisfied:
///
/// 1. All type parameters in `Self` must be "covered" by some local type constructor.
orphan_check_trait_ref(tcx, trait_ref, InCrate::Local)
}
-/// Check whether a trait-ref is potentially implementable by a crate.
+/// Checks whether a trait-ref is potentially implementable by a crate.
///
/// The current rule is that a trait-ref orphan checks in a crate C:
///
Overflow,
};
-use crate::errors::{Applicability, DiagnosticBuilder};
use crate::hir;
use crate::hir::Node;
use crate::hir::def_id::DefId;
use crate::infer::{self, InferCtxt};
use crate::infer::type_variable::TypeVariableOrigin;
-use std::fmt;
-use syntax::ast;
use crate::session::DiagnosticMessageId;
use crate::ty::{self, AdtKind, ToPredicate, ToPolyTraitRef, Ty, TyCtxt, TypeFoldable};
use crate::ty::GenericParamDefKind;
use crate::ty::SubtypePredicate;
use crate::util::nodemap::{FxHashMap, FxHashSet};
+use errors::{Applicability, DiagnosticBuilder};
+use std::fmt;
+use syntax::ast;
use syntax_pos::{DUMMY_SP, Span, ExpnInfo, ExpnFormat};
impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
}
- /// Get the parent trait chain start
+ /// Gets the parent trait chain start
fn get_parent_trait_ref(&self, code: &ObligationCauseCode<'tcx>) -> Option<String> {
match code {
&ObligationCauseCode::BuiltinDerivedObligation(ref data) => {
).collect::<Vec<_>>())
}
Node::StructCtor(ref variant_data) => {
- (self.tcx.sess.source_map().def_span(self.tcx.hir().span(variant_data.id())),
+ (self.tcx.sess.source_map().def_span(
+ self.tcx.hir().span_by_hir_id(variant_data.hir_id())),
vec![ArgKind::empty(); variant_data.fields().len()])
}
_ => panic!("non-FnLike node found: {:?}", node),
}
}
- /// Returns whether the trait predicate may apply for *some* assignment
+ /// Returns `true` if the trait predicate may apply for *some* assignment
/// to the type parameters.
fn predicate_can_apply(&self,
param_env: ty::ParamEnv<'tcx>,
fn as_predicate(&self) -> &Self::Predicate { &self.obligation.predicate }
}
-/// The fulfillment context is used to drive trait resolution. It
+/// The fulfillment context is used to drive trait resolution. It
/// consists of a list of obligations that must be (eventually)
/// satisfied. The job is to track which are satisfied, which yielded
/// errors, and which are still pending. At any point, users can call
/// creating a fresh type variable `$0` as well as a projection
/// predicate `<SomeType as SomeTrait>::X == $0`. When the
/// inference engine runs, it will attempt to find an impl of
- /// `SomeTrait` or a where clause that lets us unify `$0` with
+ /// `SomeTrait` or a where-clause that lets us unify `$0` with
/// something concrete. If this fails, we'll unify `$0` with
/// `projection_ty` again.
fn normalize_projection_type<'a, 'gcx>(&mut self,
}
}
-/// Return the set of type variables contained in a trait ref
+/// Returns the set of type variables contained in a trait ref
fn trait_ref_type_vars<'a, 'gcx, 'tcx>(selcx: &mut SelectionContext<'a, 'gcx, 'tcx>,
t: ty::PolyTraitRef<'tcx>) -> Vec<Ty<'tcx>>
{
pub use self::SelectionError::*;
pub use self::Vtable::*;
-// Whether to enable bug compatibility with issue #43355
+/// Whether to enable bug compatibility with issue #43355.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum IntercrateMode {
Issue43355,
Fixed
}
-// The mode that trait queries run in
+/// The mode that trait queries run in.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum TraitQueryMode {
// Standard/un-canonicalized queries get accurate
Canonical,
}
-/// An `Obligation` represents some trait reference (e.g., `int:Eq`) for
-/// which the vtable must be found. The process of finding a vtable is
+/// An `Obligation` represents some trait reference (e.g., `int: Eq`) for
+/// which the vtable must be found. The process of finding a vtable is
/// called "resolving" the `Obligation`. This process consists of
/// either identifying an `impl` (e.g., `impl Eq for int`) that
/// provides the required vtable, or else finding a bound that is in
/// scope. The eventual result is usually a `Selection` (defined below).
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct Obligation<'tcx, T> {
- /// Why do we have to prove this thing?
+ /// The reason we have to prove this thing.
pub cause: ObligationCause<'tcx>,
- /// In which environment should we prove this thing?
+ /// The environment in which we should prove this thing.
pub param_env: ty::ParamEnv<'tcx>,
- /// What are we trying to prove?
+ /// The thing we are trying to prove.
pub predicate: T,
/// If we started proving this as a result of trying to prove
/// something else, track the total depth to ensure termination.
/// If this goes over a certain threshold, we abort compilation --
/// in such cases, we can not say whether or not the predicate
- /// holds for certain. Stupid halting problem. Such a drag.
+ /// holds for certain. Stupid halting problem; such a drag.
pub recursion_depth: usize,
}
pub type PredicateObligation<'tcx> = Obligation<'tcx, ty::Predicate<'tcx>>;
pub type TraitObligation<'tcx> = Obligation<'tcx, ty::PolyTraitPredicate<'tcx>>;
-/// Why did we incur this obligation? Used for error reporting.
+/// The reason why we incurred this obligation; used for error reporting.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct ObligationCause<'tcx> {
pub span: Span,
- // The id of the fn body that triggered this obligation. This is
- // used for region obligations to determine the precise
- // environment in which the region obligation should be evaluated
- // (in particular, closures can add new assumptions). See the
- // field `region_obligations` of the `FulfillmentContext` for more
- // information.
- pub body_id: ast::NodeId,
+ /// The ID of the fn body that triggered this obligation. This is
+ /// used for region obligations to determine the precise
+ /// environment in which the region obligation should be evaluated
+ /// (in particular, closures can add new assumptions). See the
+ /// field `region_obligations` of the `FulfillmentContext` for more
+ /// information.
+ pub body_id: hir::HirId,
pub code: ObligationCauseCode<'tcx>
}
ObligationCauseCode::StartFunctionType => {
tcx.sess.source_map().def_span(self.span)
}
+ ObligationCauseCode::MatchExpressionArm { arm_span, .. } => arm_span,
_ => self.span,
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum ObligationCauseCode<'tcx> {
- /// Not well classified or should be obvious from span.
+ /// Not well classified or should be obvious from the span.
MiscObligation,
- /// A slice or array is WF only if `T: Sized`
+ /// A slice or array is WF only if `T: Sized`.
SliceOrArrayElem,
- /// A tuple is WF only if its middle elements are Sized
+ /// A tuple is WF only if its middle elements are `Sized`.
TupleElem,
- /// This is the trait reference from the given projection
+ /// This is the trait reference from the given projection.
ProjectionWf(ty::ProjectionTy<'tcx>),
- /// In an impl of trait X for type Y, type Y must
- /// also implement all supertraits of X.
+ /// In an impl of trait `X` for type `Y`, type `Y` must
+ /// also implement all supertraits of `X`.
ItemObligation(DefId),
/// A type like `&'a T` is WF only if `T: 'a`.
MatchExpressionArm {
arm_span: Span,
source: hir::MatchSource,
+ prior_arms: Vec<Span>,
+ last_ty: Ty<'tcx>,
},
/// Computing common supertype in the pattern guard for the arms of a match expression
/// directly.
parent_trait_ref: ty::PolyTraitRef<'tcx>,
- /// The parent trait had this cause
+ /// The parent trait had this cause.
parent_code: Rc<ObligationCauseCode<'tcx>>
}
pub type TraitObligations<'tcx> = Vec<TraitObligation<'tcx>>;
/// The following types:
-/// * `WhereClause`
-/// * `WellFormed`
-/// * `FromEnv`
-/// * `DomainGoal`
-/// * `Goal`
-/// * `Clause`
-/// * `Environment`
-/// * `InEnvironment`
+/// * `WhereClause`,
+/// * `WellFormed`,
+/// * `FromEnv`,
+/// * `DomainGoal`,
+/// * `Goal`,
+/// * `Clause`,
+/// * `Environment`,
+/// * `InEnvironment`,
/// are used for representing the trait system in the form of
/// logic programming clauses. They are part of the interface
/// for the chalk SLG solver.
/// with the goal to solve and proceeds from there).
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
pub struct ProgramClause<'tcx> {
- /// This goal will be considered true...
+ /// This goal will be considered true ...
pub goal: DomainGoal<'tcx>,
- /// ...if we can prove these hypotheses (there may be no hypotheses at all):
+ /// ... if we can prove these hypotheses (there may be no hypotheses at all):
pub hypotheses: Goals<'tcx>,
/// Useful for filtering clauses.
/// For example, the vtable may be tied to a specific impl (case A),
/// or it may be relative to some bound that is in scope (case B).
///
-///
/// ```
/// impl<T:Clone> Clone<T> for Option<T> { ... } // Impl_1
/// impl<T:Clone> Clone<T> for Box<T> { ... } // Impl_2
/// Vtable identifying a particular impl.
VtableImpl(VtableImplData<'tcx, N>),
- /// Vtable for auto trait implementations
+ /// Vtable for auto trait implementations.
/// This carries the information and nested obligations with regards
/// to an auto implementation for a trait `Trait`. The nested obligations
/// ensure the trait implementation holds for all the constituent types.
/// any).
VtableParam(Vec<N>),
- /// Virtual calls through an object
+ /// Virtual calls through an object.
VtableObject(VtableObjectData<'tcx, N>),
/// Successful resolution for a builtin trait.
VtableBuiltin(VtableBuiltinData<N>),
- /// Vtable automatically generated for a closure. The def ID is the ID
+ /// Vtable automatically generated for a closure. The `DefId` is the ID
/// of the closure expression. This is a `VtableImpl` in spirit, but the
/// impl is generated by the compiler and does not appear in the source.
VtableClosure(VtableClosureData<'tcx, N>),
- /// Same as above, but for a fn pointer type with the given signature.
+ /// Same as above, but for a function pointer type with the given signature.
VtableFnPointer(VtableFnPointerData<'tcx, N>),
/// Vtable automatically generated for a generator.
};
let obligation = Obligation {
param_env,
- cause: ObligationCause::misc(span, ast::DUMMY_NODE_ID),
+ cause: ObligationCause::misc(span, hir::DUMMY_HIR_ID),
recursion_depth: 0,
predicate: trait_ref.to_predicate(),
};
// We can use a dummy node-id here because we won't pay any mind
// to region obligations that arise (there shouldn't really be any
// anyhow).
- let cause = ObligationCause::misc(span, ast::DUMMY_NODE_ID);
+ let cause = ObligationCause::misc(span, hir::DUMMY_HIR_ID);
fulfill_cx.register_bound(infcx, param_env, ty, def_id, cause);
}
pub fn misc(span: Span,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
param_env: ty::ParamEnv<'tcx>,
trait_ref: O)
-> Obligation<'tcx, O> {
impl<'tcx> ObligationCause<'tcx> {
#[inline]
pub fn new(span: Span,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
code: ObligationCauseCode<'tcx>)
-> ObligationCause<'tcx> {
- ObligationCause { span: span, body_id: body_id, code: code }
+ ObligationCause { span, body_id, code }
}
- pub fn misc(span: Span, body_id: ast::NodeId) -> ObligationCause<'tcx> {
- ObligationCause { span: span, body_id: body_id, code: MiscObligation }
+ pub fn misc(span: Span, body_id: hir::HirId) -> ObligationCause<'tcx> {
+ ObligationCause { span, body_id, code: MiscObligation }
}
pub fn dummy() -> ObligationCause<'tcx> {
- ObligationCause { span: DUMMY_SP, body_id: ast::CRATE_NODE_ID, code: MiscObligation }
+ ObligationCause { span: DUMMY_SP, body_id: hir::CRATE_HIR_ID, code: MiscObligation }
}
}
//! - have a suitable receiver from which we can extract a vtable and coerce to a "thin" version
//! that doesn't contain the vtable;
//! - not reference the erased type `Self` except for in this receiver;
-//! - not have generic type parameters
+//! - not have generic type parameters.
use super::elaborate_predicates;
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum ObjectSafetyViolation {
- /// Self : Sized declared on the trait
+ /// `Self: Sized` declared on the trait.
SizedSelf,
/// Supertrait reference references `Self` an in illegal location
- /// (e.g., `trait Foo : Bar<Self>`)
+ /// (e.g., `trait Foo : Bar<Self>`).
SupertraitSelf,
- /// Method has something illegal
+ /// Method has something illegal.
Method(ast::Name, MethodViolationCode),
- /// Associated const
+ /// Associated const.
AssociatedConst(ast::Name),
}
impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
/// Returns the object safety violations that affect
- /// astconv - currently, Self in supertraits. This is needed
+ /// astconv -- currently, `Self` in supertraits. This is needed
/// because `object_safety_violations` can't be used during
/// type collection.
pub fn astconv_object_safety_violations(self, trait_def_id: DefId)
None
}
- /// performs a type substitution to produce the version of receiver_ty when `Self = self_ty`
- /// e.g., for receiver_ty = `Rc<Self>` and self_ty = `Foo`, returns `Rc<Foo>`
+ /// Performs a type substitution to produce the version of receiver_ty when `Self = self_ty`
+ /// e.g., for receiver_ty = `Rc<Self>` and self_ty = `Foo`, returns `Rc<Foo>`.
fn receiver_for_self_ty(
self, receiver_ty: Ty<'tcx>, self_ty: Ty<'tcx>, method_def_id: DefId
) -> Ty<'tcx> {
result
}
- /// creates the object type for the current trait. For example,
+ /// Creates the object type for the current trait. For example,
/// if the current trait is `Deref`, then this will be
- /// `dyn Deref<Target=Self::Target> + 'static`
+ /// `dyn Deref<Target = Self::Target> + 'static`.
fn object_ty_for_trait(self, trait_def_id: DefId, lifetime: ty::Region<'tcx>) -> Ty<'tcx> {
debug!("object_ty_for_trait: trait_def_id={:?}", trait_def_id);
object_ty
}
- /// checks the method's receiver (the `self` argument) can be dispatched on when `Self` is a
+ /// Checks the method's receiver (the `self` argument) can be dispatched on when `Self` is a
/// trait object. We require that `DispatchableFromDyn` be implemented for the receiver type
/// in the following way:
- /// - let `Receiver` be the type of the `self` argument, i.e `Self`, `&Self`, `Rc<Self>`
+ /// - let `Receiver` be the type of the `self` argument, i.e `Self`, `&Self`, `Rc<Self>`,
/// - require the following bound:
///
- /// Receiver[Self => T]: DispatchFromDyn<Receiver[Self => dyn Trait]>
+ /// ```
+ /// Receiver[Self => T]: DispatchFromDyn<Receiver[Self => dyn Trait]>
+ /// ```
///
- /// where `Foo[X => Y]` means "the same type as `Foo`, but with `X` replaced with `Y`"
+ /// where `Foo[X => Y]` means "the same type as `Foo`, but with `X` replaced with `Y`"
/// (substitution notation).
///
- /// some examples of receiver types and their required obligation
- /// - `&'a mut self` requires `&'a mut Self: DispatchFromDyn<&'a mut dyn Trait>`
- /// - `self: Rc<Self>` requires `Rc<Self>: DispatchFromDyn<Rc<dyn Trait>>`
- /// - `self: Pin<Box<Self>>` requires `Pin<Box<Self>>: DispatchFromDyn<Pin<Box<dyn Trait>>>`
+ /// Some examples of receiver types and their required obligation:
+ /// - `&'a mut self` requires `&'a mut Self: DispatchFromDyn<&'a mut dyn Trait>`,
+ /// - `self: Rc<Self>` requires `Rc<Self>: DispatchFromDyn<Rc<dyn Trait>>`,
+ /// - `self: Pin<Box<Self>>` requires `Pin<Box<Self>>: DispatchFromDyn<Pin<Box<dyn Trait>>>`.
///
/// The only case where the receiver is not dispatchable, but is still a valid receiver
/// type (just not object-safe), is when there is more than one level of pointer indirection.
- /// e.g., `self: &&Self`, `self: &Rc<Self>`, `self: Box<Box<Self>>`. In these cases, there
+ /// E.g., `self: &&Self`, `self: &Rc<Self>`, `self: Box<Box<Self>>`. In these cases, there
/// is no way, or at least no inexpensive way, to coerce the receiver from the version where
/// `Self = dyn Trait` to the version where `Self = T`, where `T` is the unknown erased type
/// contained by the trait object, because the object that needs to be coerced is behind
/// Also, `impl Trait` is normalized to the concrete type,
/// which has to be already collected by type-checking.
///
- /// NOTE: As `impl Trait`'s concrete type should *never*
+ /// NOTE: as `impl Trait`'s concrete type should *never*
/// be observable directly by the user, `Reveal::All`
/// should not be used by checks which may expose
/// type equality or type contents to the user.
if let Ok(evaluated) = tcx.const_eval(param_env.and(cid)) {
let substs = tcx.lift_to_global(&substs).unwrap();
let evaluated = evaluated.subst(tcx, substs);
- return tcx.intern_lazy_const(ty::LazyConst::Evaluated(evaluated));
+ return tcx.mk_lazy_const(ty::LazyConst::Evaluated(evaluated));
}
}
} else {
promoted: None
};
if let Ok(evaluated) = tcx.const_eval(param_env.and(cid)) {
- return tcx.intern_lazy_const(ty::LazyConst::Evaluated(evaluated));
+ return tcx.mk_lazy_const(ty::LazyConst::Evaluated(evaluated));
}
}
}
///
/// Concern #2. Even within the snapshot, if those original
/// obligations are not yet proven, then we are able to do projections
-/// that may yet turn out to be wrong. This *may* lead to some sort
+/// that may yet turn out to be wrong. This *may* lead to some sort
/// of trouble, though we don't have a concrete example of how that
-/// can occur yet. But it seems risky at best.
+/// can occur yet. But it seems risky at best.
fn get_paranoid_cache_value_obligation<'a, 'gcx, 'tcx>(
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
/// cycles to arise, where you basically had a setup like `<MyType<$0>
/// as Trait>::Foo == $0`. Here, normalizing `<MyType<$0> as
/// Trait>::Foo> to `[type error]` would lead to an obligation of
-/// `<MyType<[type error]> as Trait>::Foo`. We are supposed to report
+/// `<MyType<[type error]> as Trait>::Foo`. We are supposed to report
/// an error for this obligation, but we legitimately should not,
/// because it contains `[type error]`. Yuck! (See issue #29857 for
/// one case where this arose.)
}
}
-/// Compute the result of a projection type (if we can).
+/// Computes the result of a projection type (if we can).
///
/// IMPORTANT:
/// - `obligation` must be fully normalized
// # Cache
/// The projection cache. Unlike the standard caches, this can include
-/// infcx-dependent type variables - therefore, we have to roll the
+/// infcx-dependent type variables, therefore we have to roll the
/// cache back each time we roll a snapshot back, to avoid assumptions
/// on yet-unresolved inference variables. Types with placeholder
/// regions also have to be removed when the respective snapshot ends.
/// (for the lifetime of the infcx).
///
/// Entries in the projection cache might contain inference variables
-/// that will be resolved by obligations on the projection cache entry - e.g.
+/// that will be resolved by obligations on the projection cache entry (e.g.,
/// when a type parameter in the associated type is constrained through
-/// an "RFC 447" projection on the impl.
+/// an "RFC 447" projection on the impl).
///
/// When working with a fulfillment context, the derived obligations of each
/// projection cache entry will be registered on the fulfillcx, so any users
/// If that is done, after evaluation the obligations, it is a good idea to
/// call `ProjectionCache::complete` to make sure the obligations won't be
/// re-evaluated and avoid an exponential worst-case.
-///
-/// FIXME: we probably also want some sort of cross-infcx cache here to
-/// reduce the amount of duplication. Let's see what we get with the Chalk
-/// reforms.
+//
+// FIXME: we probably also want some sort of cross-infcx cache here to
+// reduce the amount of duplication. Let's see what we get with the Chalk reforms.
#[derive(Default)]
pub struct ProjectionCache<'tcx> {
map: SnapshotMap<ProjectionCacheKey<'tcx>, ProjectionCacheEntry<'tcx>>,
/// outlive. This is similar but not *quite* the same as the
/// `needs_drop` test in the compiler already -- that is, for every
/// type T for which this function return true, needs-drop would
-/// return false. But the reverse does not hold: in particular,
+/// return `false`. But the reverse does not hold: in particular,
/// `needs_drop` returns false for `PhantomData`, but it is not
/// trivial for dropck-outlives.
///
/// the normalized value along with various outlives relations (in
/// the form of obligations that must be discharged).
///
- /// NB. This will *eventually* be the main means of
+ /// N.B., this will *eventually* be the main means of
/// normalizing, but for now should be used only when we actually
/// know that normalization will succeed, since error reporting
/// and other details are still "under development".
if let Ok(evaluated) = tcx.const_eval(param_env.and(cid)) {
let substs = tcx.lift_to_global(&substs).unwrap();
let evaluated = evaluated.subst(tcx, substs);
- return tcx.intern_lazy_const(ty::LazyConst::Evaluated(evaluated));
+ return tcx.mk_lazy_const(ty::LazyConst::Evaluated(evaluated));
}
}
} else {
promoted: None,
};
if let Ok(evaluated) = tcx.const_eval(param_env.and(cid)) {
- return tcx.intern_lazy_const(ty::LazyConst::Evaluated(evaluated));
+ return tcx.mk_lazy_const(ty::LazyConst::Evaluated(evaluated));
}
}
}
/// a `T` (with regions erased). This is appropriate when the
/// binder is being instantiated at the call site.
///
- /// NB. Currently, higher-ranked type bounds inhibit
+ /// N.B., currently, higher-ranked type bounds inhibit
/// normalization. Therefore, each time we erase them in
/// codegen, we need to normalize the contents.
pub fn normalize_erasing_late_bound_regions<T>(
use crate::infer::InferCtxt;
use crate::infer::canonical::OriginalQueryValues;
-use syntax::ast;
+use crate::hir;
use syntax::source_map::Span;
use crate::traits::{FulfillmentContext, ObligationCause, TraitEngine, TraitEngineExt};
use crate::traits::query::NoSolution;
/// Outlives bounds are relationships between generic parameters,
/// whether they both be regions (`'a: 'b`) or whether types are
-/// involved (`T: 'a`). These relationships can be extracted from the
+/// involved (`T: 'a`). These relationships can be extracted from the
/// full set of predicates we understand or also from types (in which
/// case they are called implied bounds). They are fed to the
/// `OutlivesEnv` which in turn is supplied to the region checker and
impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
/// Implied bounds are region relationships that we deduce
- /// automatically. The idea is that (e.g.) a caller must check that a
+ /// automatically. The idea is that (e.g.) a caller must check that a
/// function's argument types are well-formed immediately before
/// calling that fn, and hence the *callee* can assume that its
/// argument types are well-formed. This may imply certain relationships
pub fn implied_outlives_bounds(
&self,
param_env: ty::ParamEnv<'tcx>,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
ty: Ty<'tcx>,
span: Span,
) -> Vec<OutlivesBound<'tcx>> {
canonicalized: Canonicalized<'gcx, ParamEnvAnd<'tcx, Normalize<Self>>>,
) -> Fallible<CanonicalizedQueryResponse<'gcx, Self>>;
- /// Convert from the `'gcx` (lifted) form of `Self` into the `tcx`
+ /// Converts from the `'gcx` (lifted) form of `Self` into the `tcx`
/// form of `Self`.
fn shrink_to_tcx_lifetime(
v: &'a CanonicalizedQueryResponse<'gcx, Self>,
/// See #23980 for details.
pub fn add_intercrate_ambiguity_hint<'a, 'tcx>(
&self,
- err: &mut crate::errors::DiagnosticBuilder<'_>,
+ err: &mut errors::DiagnosticBuilder<'_>,
) {
err.note(&self.intercrate_ambiguity_hint());
}
}
/// The selection process begins by considering all impls, where
-/// clauses, and so forth that might resolve an obligation. Sometimes
+/// clauses, and so forth that might resolve an obligation. Sometimes
/// we'll be able to say definitively that (e.g.) an impl does not
/// apply to the obligation: perhaps it is defined for `usize` but the
/// obligation is for `int`. In that case, we drop the impl out of the
-/// list. But the other cases are considered *candidates*.
+/// list. But the other cases are considered *candidates*.
///
/// For selection to succeed, there must be exactly one matching
/// candidate. If the obligation is fully known, this is guaranteed
/// - `EvaluatedToErr` implies `EvaluatedToRecur`
/// - the "union" of evaluation results is equal to their maximum -
/// all the "potential success" candidates can potentially succeed,
-/// so they are no-ops when unioned with a definite error, and within
+/// so they are noops when unioned with a definite error, and within
/// the categories it's easy to see that the unions are correct.
pub enum EvaluationResult {
/// Evaluation successful
/// ```
///
/// When we try to prove it, we first go the first option, which
- /// recurses. This shows us that the impl is "useless" - it won't
+ /// recurses. This shows us that the impl is "useless" -- it won't
/// tell us that `T: Trait` unless it already implemented `Trait`
/// by some other means. However, that does not prevent `T: Trait`
/// does not hold, because of the bound (which can indeed be satisfied
/// by `SomeUnsizedType` from another crate).
- ///
- /// FIXME: when an `EvaluatedToRecur` goes past its parent root, we
- /// ought to convert it to an `EvaluatedToErr`, because we know
- /// there definitely isn't a proof tree for that obligation. Not
- /// doing so is still sound - there isn't any proof tree, so the
- /// branch still can't be a part of a minimal one - but does not
- /// re-enable caching.
+ //
+ // FIXME: when an `EvaluatedToRecur` goes past its parent root, we
+ // ought to convert it to an `EvaluatedToErr`, because we know
+ // there definitely isn't a proof tree for that obligation. Not
+ // doing so is still sound -- there isn't any proof tree, so the
+ // branch still can't be a part of a minimal one -- but does not re-enable caching.
EvaluatedToRecur,
- /// Evaluation failed
+ /// Evaluation failed.
EvaluatedToErr,
}
impl EvaluationResult {
- /// True if this evaluation result is known to apply, even
+ /// Returns `true` if this evaluation result is known to apply, even
/// considering outlives constraints.
pub fn must_apply_considering_regions(self) -> bool {
self == EvaluatedToOk
}
- /// True if this evaluation result is known to apply, ignoring
+ /// Returns `true` if this evaluation result is known to apply, ignoring
/// outlives constraints.
pub fn must_apply_modulo_regions(self) -> bool {
self <= EvaluatedToOkModuloRegions
/// that recursion is ok. This routine returns true if the top of the
/// stack (`cycle[0]`):
///
- /// - is a defaulted trait, and
- /// - it also appears in the backtrace at some position `X`; and,
+ /// - is a defaulted trait,
+ /// - it also appears in the backtrace at some position `X`,
/// - all the predicates at positions `X..` between `X` an the top are
/// also defaulted traits.
pub fn coinductive_match<I>(&mut self, cycle: I) -> bool
}
/// Further evaluate `candidate` to decide whether all type parameters match and whether nested
- /// obligations are met. Returns true if `candidate` remains viable after this further
+ /// obligations are met. Returns whether `candidate` remains viable after this further
/// scrutiny.
fn evaluate_candidate<'o>(
&mut self,
}
}
- /// Returns true if the global caches can be used.
+ /// Returns `true` if the global caches can be used.
/// Do note that if the type itself is not in the
/// global tcx, the local caches will be used.
fn can_use_global_caches(&self, param_env: ty::ParamEnv<'tcx>) -> bool {
Ok(())
}
- /// Check for the artificial impl that the compiler will create for an obligation like `X :
+ /// Checks for the artificial impl that the compiler will create for an obligation like `X :
/// FnMut<..>` where `X` is a closure type.
///
/// Note: the type parameters on a closure candidate are modeled as *output* type
// type variables and then we also attempt to evaluate recursive
// bounds to see if they are satisfied.
- /// Returns true if `victim` should be dropped in favor of
- /// `other`. Generally speaking we will drop duplicate
+ /// Returns `true` if `victim` should be dropped in favor of
+ /// `other`. Generally speaking we will drop duplicate
/// candidates and prefer where-clause candidates.
///
/// See the comment for "SelectionCandidate" for more details.
/// we currently treat the input type parameters on the trait as
/// outputs. This means that when we have a match we have only
/// considered the self type, so we have to go back and make sure
- /// to relate the argument types too. This is kind of wrong, but
+ /// to relate the argument types too. This is kind of wrong, but
/// since we control the full set of impls, also not that wrong,
/// and it DOES yield better error messages (since we don't report
/// errors as if there is no applicable impl, but rather report
/// impl Fn(int) for Closure { ... }
///
/// Now imagine our obligation is `Fn(usize) for Closure`. So far
- /// we have matched the self-type `Closure`. At this point we'll
+ /// we have matched the self type `Closure`. At this point we'll
/// compare the `int` to `usize` and generate an error.
///
/// Note that this checking occurs *after* the impl has selected,
}
/// Normalize `where_clause_trait_ref` and try to match it against
- /// `obligation`. If successful, return any predicates that
+ /// `obligation`. If successful, return any predicates that
/// result from the normalization. Normalization is necessary
/// because where-clauses are stored in the parameter environment
/// unnormalized.
/// Suppose we have selected "source impl" with `V` instantiated with `u32`.
/// This function will produce a substitution with `T` and `U` both mapping to `u32`.
///
-/// Where clauses add some trickiness here, because they can be used to "define"
+/// where-clauses add some trickiness here, because they can be used to "define"
/// an argument indirectly:
///
/// ```rust
/// impl<'a, I, T: 'a> Iterator for Cloned<I>
-/// where I: Iterator<Item=&'a T>, T: Clone
+/// where I: Iterator<Item = &'a T>, T: Clone
/// ```
///
/// In a case like this, the substitution for `T` is determined indirectly,
}
}
-/// Is impl1 a specialization of impl2?
+/// Is `impl1` a specialization of `impl2`?
///
/// Specialization is determined by the sets of types to which the impls apply;
-/// impl1 specializes impl2 if it applies to a subset of the types impl2 applies
+/// `impl1` specializes `impl2` if it applies to a subset of the types `impl2` applies
/// to.
pub(super) fn specializes<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
(impl1_def_id, impl2_def_id): (DefId, DefId))
}
}
- /// Remove an impl from this set of children. Used when replacing
+ /// Removes an impl from this set of children. Used when replacing
/// an impl with a parent. The impl must be present in the list of
/// children already.
fn remove_existing(&mut self,
self.children.entry(parent).or_default().insert_blindly(tcx, child);
}
- /// The parent of a given impl, which is the def id of the trait when the
+ /// The parent of a given impl, which is the `DefId` of the trait when the
/// impl is a "specialization root".
pub fn parent(&self, child: DefId) -> DefId {
*self.parent.get(&child).unwrap()
trait_item_def_id,
}),
super::ExprAssignable => Some(super::ExprAssignable),
- super::MatchExpressionArm { arm_span, source } => Some(super::MatchExpressionArm {
+ super::MatchExpressionArm {
arm_span,
- source: source,
- }),
+ source,
+ ref prior_arms,
+ last_ty,
+ } => {
+ tcx.lift(&last_ty).map(|last_ty| {
+ super::MatchExpressionArm {
+ arm_span,
+ source,
+ prior_arms: prior_arms.clone(),
+ last_ty,
+ }
+ })
+ }
super::MatchExpressionArmPattern { span, ty } => {
tcx.lift(&ty).map(|ty| super::MatchExpressionArmPattern { span, ty })
}
}
pub fn impl_is_default(self, node_item_def_id: DefId) -> bool {
- match self.hir().as_local_node_id(node_item_def_id) {
- Some(node_id) => {
- let item = self.hir().expect_item(node_id);
+ match self.hir().as_local_hir_id(node_item_def_id) {
+ Some(hir_id) => {
+ let item = self.hir().expect_item_by_hir_id(hir_id);
if let hir::ItemKind::Impl(_, _, defaultness, ..) = item.node {
defaultness.is_default()
} else {
/// Here the pointer will be dereferenced N times (where a dereference can
/// happen to raw or borrowed pointers or any smart pointer which implements
/// Deref, including Box<_>). The types of dereferences is given by
-/// `autoderefs`. It can then be auto-referenced zero or one times, indicated
+/// `autoderefs`. It can then be auto-referenced zero or one times, indicated
/// by `autoref`, to either a raw or borrowed pointer. In these cases unsize is
/// `false`.
///
/// stored in `unsize` is `Foo<[i32]>`, we don't store any further detail about
/// the underlying conversions from `[i32; 4]` to `[i32]`.
///
-/// 3. Coercing a `Box<T>` to `Box<dyn Trait>` is an interesting special case. In
+/// 3. Coercing a `Box<T>` to `Box<dyn Trait>` is an interesting special case. In
/// that case, we have the pointer we need coming in, so there are no
/// autoderefs, and no autoref. Instead we just do the `Unsize` transformation.
/// At some point, of course, `Box` should move out of the compiler, in which
/// This will do things like convert thin pointers to fat
/// pointers, or convert structs containing thin pointers to
/// structs containing fat pointers, or convert between fat
- /// pointers. We don't store the details of how the transform is
+ /// pointers. We don't store the details of how the transform is
/// done (in fact, we don't know that, because it might depend on
/// the precise type parameters). We just store the target
/// type. Codegen backends and miri figure out what has to be done
}
/// At least for initial deployment, we want to limit two-phase borrows to
-/// only a few specific cases. Right now, those mostly "things that desugar"
-/// into method calls
-/// - using x.some_method() syntax, where some_method takes &mut self
-/// - using Foo::some_method(&mut x, ...) syntax
-/// - binary assignment operators (+=, -=, *=, etc.)
-/// Anything else should be rejected until generalized two phase borrow support
+/// only a few specific cases. Right now, those are mostly "things that desugar"
+/// into method calls:
+/// - using `x.some_method()` syntax, where some_method takes `&mut self`,
+/// - using `Foo::some_method(&mut x, ...)` syntax,
+/// - binary assignment operators (`+=`, `-=`, `*=`, etc.).
+/// Anything else should be rejected until generalized two-phase borrow support
/// is implemented. Right now, dataflow can't handle the general case where there
/// is more than one use of a mutable borrow, and we don't want to accept too much
/// new code via two-phase borrows, so we try to limit where we create two-phase
#[derive(Copy, Clone, PartialEq, Debug, RustcEncodable, RustcDecodable)]
pub enum AutoBorrow<'tcx> {
- /// Convert from T to &T.
+ /// Converts from T to &T.
Ref(ty::Region<'tcx>, AutoBorrowMutability),
- /// Convert from T to *T.
+ /// Converts from T to *T.
RawPtr(hir::Mutability),
}
where D: TyDecoder<'a, 'tcx>,
'tcx: 'a,
{
- Ok(decoder.tcx().intern_lazy_const(Decodable::decode(decoder)?))
+ Ok(decoder.tcx().mk_lazy_const(Decodable::decode(decoder)?))
}
#[inline]
}
}
- /// Returns true if this function must conform to `min_const_fn`
+ /// Returns `true` if this function must conform to `min_const_fn`
pub fn is_min_const_fn(self, def_id: DefId) -> bool {
// Bail out if the signature doesn't contain `const`
if !self.is_const_fn_raw(def_id) {
-//! type context book-keeping
+//! Type context book-keeping.
use crate::dep_graph::DepGraph;
-use crate::dep_graph::{DepNode, DepConstructor};
-use crate::errors::DiagnosticBuilder;
+use crate::dep_graph::{self, DepNode, DepConstructor};
use crate::session::Session;
use crate::session::config::{BorrowckMode, OutputFilenames};
use crate::session::config::CrateType;
use crate::ty::CanonicalPolyFnSig;
use crate::util::nodemap::{DefIdMap, DefIdSet, ItemLocalMap};
use crate::util::nodemap::{FxHashMap, FxHashSet};
+use errors::DiagnosticBuilder;
use rustc_data_structures::interner::HashInterner;
use smallvec::SmallVec;
use rustc_data_structures::stable_hasher::{HashStable, hash_stable_hashmap,
goal: InternedSet<'tcx, GoalKind<'tcx>>,
goal_list: InternedSet<'tcx, List<Goal<'tcx>>>,
projs: InternedSet<'tcx, List<ProjectionKind<'tcx>>>,
+ lazy_const: InternedSet<'tcx, LazyConst<'tcx>>,
}
impl<'gcx: 'tcx, 'tcx> CtxtInterners<'tcx> {
goal: Default::default(),
goal_list: Default::default(),
projs: Default::default(),
+ lazy_const: Default::default(),
}
}
/// belongs, but it may not exist if it's a tuple field (`tuple.0`).
field_indices: ItemLocalMap<usize>,
- /// Stores the types for various nodes in the AST. Note that this table
- /// is not guaranteed to be populated until after typeck. See
+ /// Stores the types for various nodes in the AST. Note that this table
+ /// is not guaranteed to be populated until after typeck. See
/// typeck::check::fn_ctxt for details.
node_types: ItemLocalMap<Ty<'tcx>>,
/// Stores the type parameters which were substituted to obtain the type
- /// of this node. This only applies to nodes that refer to entities
+ /// of this node. This only applies to nodes that refer to entities
/// parameterized by type parameters, such as generic fns, types, or
/// other items.
node_substs: ItemLocalMap<&'tcx Substs<'tcx>>,
pub tainted_by_errors: bool,
/// Stores the free-region relationships that were deduced from
- /// its where clauses and parameter types. These are then
+ /// its where-clauses and parameter types. These are then
/// read-again by borrowck.
pub free_region_map: FreeRegionMap<'tcx>,
}
}
- pub fn node_id_to_type(&self, id: hir::HirId) -> Ty<'tcx> {
- self.node_id_to_type_opt(id).unwrap_or_else(||
- bug!("node_id_to_type: no type for node `{}`",
- tls::with(|tcx| {
- let id = tcx.hir().hir_to_node_id(id);
- tcx.hir().node_to_string(id)
- }))
+ pub fn node_type(&self, id: hir::HirId) -> Ty<'tcx> {
+ self.node_type_opt(id).unwrap_or_else(||
+ bug!("node_type: no type for node `{}`",
+ tls::with(|tcx| tcx.hir().hir_to_string(id)))
)
}
- pub fn node_id_to_type_opt(&self, id: hir::HirId) -> Option<Ty<'tcx>> {
+ pub fn node_type_opt(&self, id: hir::HirId) -> Option<Ty<'tcx>> {
validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
self.node_types.get(&id.local_id).cloned()
}
// Returns the type of a pattern as a monotype. Like @expr_ty, this function
// doesn't provide type parameter substitutions.
pub fn pat_ty(&self, pat: &hir::Pat) -> Ty<'tcx> {
- self.node_id_to_type(pat.hir_id)
+ self.node_type(pat.hir_id)
}
pub fn pat_ty_opt(&self, pat: &hir::Pat) -> Option<Ty<'tcx>> {
- self.node_id_to_type_opt(pat.hir_id)
+ self.node_type_opt(pat.hir_id)
}
// Returns the type of an expression as a monotype.
// ask for the type of "id" in "id(3)", it will return "fn(&isize) -> isize"
// instead of "fn(ty) -> T with T = isize".
pub fn expr_ty(&self, expr: &hir::Expr) -> Ty<'tcx> {
- self.node_id_to_type(expr.hir_id)
+ self.node_type(expr.hir_id)
}
pub fn expr_ty_opt(&self, expr: &hir::Expr) -> Option<Ty<'tcx>> {
- self.node_id_to_type_opt(expr.hir_id)
+ self.node_type_opt(expr.hir_id)
}
pub fn adjustments(&self) -> LocalTableInContext<'_, Vec<ty::adjustment::Adjustment<'tcx>>> {
impl CanonicalUserType<'gcx> {
/// Returns `true` if this represents a substitution of the form `[?0, ?1, ?2]`,
- /// i.e. each thing is mapped to a canonical variable with the same index.
+ /// i.e., each thing is mapped to a canonical variable with the same index.
pub fn is_identity(&self) -> bool {
match self.value {
UserType::Ty(_) => false,
}
}
-/// A user-given type annotation attached to a constant. These arise
+/// A user-given type annotation attached to a constant. These arise
/// from constants that are named via paths, like `Foo::<A>::new` and
/// so forth.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
}
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
- /// Get the global TyCtxt.
+ /// Gets the global `TyCtxt`.
#[inline]
pub fn global_tcx(self) -> TyCtxt<'gcx, 'gcx, 'gcx> {
TyCtxt {
self.global_arenas.adt_def.alloc(def)
}
- pub fn intern_const_alloc(
- self,
- alloc: Allocation,
- ) -> &'gcx Allocation {
+ pub fn intern_const_alloc(self, alloc: Allocation) -> &'gcx Allocation {
self.allocation_interner.borrow_mut().intern(alloc, |alloc| {
self.global_arenas.const_allocs.alloc(alloc)
})
})
}
- pub fn intern_lazy_const(self, c: ty::LazyConst<'tcx>) -> &'tcx ty::LazyConst<'tcx> {
- self.global_interners.arena.alloc(c)
- }
-
pub fn intern_layout(self, layout: LayoutDetails) -> &'gcx LayoutDetails {
self.layout_interner.borrow_mut().intern(layout, |layout| {
self.global_arenas.layout.alloc(layout)
value.lift_to_tcx(self.global_tcx())
}
- /// Returns true if self is the same as self.global_tcx().
+ /// Returns `true` if self is the same as self.global_tcx().
fn is_global(self) -> bool {
ptr::eq(self.interners, &self.global_interners)
}
- /// Create a type context and call the closure with a `TyCtxt` reference
+ /// Creates a type context and call the closure with a `TyCtxt` reference
/// to the context. The closure enforces that the type context and any interned
/// value (types, substs, etc.) can only be used while `ty::tls` has a valid
/// reference to the context, to allow formatting values that need it.
}
}
- /// Convert a `DefId` into its fully expanded `DefPath` (every
+ /// Converts a `DefId` into its fully expanded `DefPath` (every
/// `DefId` is really just an interned def-path).
///
/// Note that if `id` is not local to this crate, the result will
self.dep_graph.with_task(dep_node,
self,
crate_hash,
- |_, x| x // No transformation needed
+ |_, x| x, // No transformation needed
+ dep_graph::hash_result,
);
}
}
use std::ptr;
use syntax_pos;
use crate::ty::query;
- use crate::errors::{Diagnostic, TRACK_DIAGNOSTICS};
+ use errors::{Diagnostic, TRACK_DIAGNOSTICS};
use rustc_data_structures::OnDrop;
use rustc_data_structures::sync::{self, Lrc, Lock};
use rustc_data_structures::thin_vec::ThinVec;
}
}
+impl<'tcx: 'lcx, 'lcx> Borrow<LazyConst<'lcx>> for Interned<'tcx, LazyConst<'tcx>> {
+ fn borrow<'a>(&'a self) -> &'a LazyConst<'lcx> {
+ &self.0
+ }
+}
+
impl<'tcx: 'lcx, 'lcx> Borrow<[ExistentialPredicate<'lcx>]>
for Interned<'tcx, List<ExistentialPredicate<'tcx>>> {
fn borrow<'a>(&'a self) -> &'a [ExistentialPredicate<'lcx>] {
direct_interners!('tcx,
region: mk_region(|r: &RegionKind| r.keep_in_local_tcx()) -> RegionKind,
- goal: mk_goal(|c: &GoalKind<'_>| keep_local(c)) -> GoalKind<'tcx>
+ goal: mk_goal(|c: &GoalKind<'_>| keep_local(c)) -> GoalKind<'tcx>,
+ lazy_const: mk_lazy_const(|c: &LazyConst<'_>| keep_local(&c)) -> LazyConst<'tcx>
);
macro_rules! slice_interners {
#[inline]
pub fn mk_array(self, ty: Ty<'tcx>, n: u64) -> Ty<'tcx> {
- self.mk_ty(Array(ty, self.intern_lazy_const(
+ self.mk_ty(Array(ty, self.mk_lazy_const(
ty::LazyConst::Evaluated(ty::Const::from_usize(self.global_tcx(), n))
)))
}
use std::fmt;
use rustc_target::spec::abi;
use syntax::ast;
-use crate::errors::{Applicability, DiagnosticBuilder};
+use errors::{Applicability, DiagnosticBuilder};
use syntax_pos::Span;
use crate::hir;
//! instance of a "folder" (a type which implements `TypeFolder`). Then
//! the setup is intended to be:
//!
-//! T.fold_with(F) --calls--> F.fold_T(T) --calls--> T.super_fold_with(F)
+//! T.fold_with(F) --calls--> F.fold_T(T) --calls--> T.super_fold_with(F)
//!
//! This way, when you define a new folder F, you can override
//! `fold_T()` to customize the behavior, and invoke `T.super_fold_with()`
//! proper thing.
//!
//! A `TypeFoldable` T can also be visited by a `TypeVisitor` V using similar setup:
-//! T.visit_with(V) --calls--> V.visit_T(T) --calls--> T.super_visit_with(V).
-//! These methods return true to indicate that the visitor has found what it is looking for
-//! and does not need to visit anything else.
+//!
+//! T.visit_with(V) --calls--> V.visit_T(T) --calls--> T.super_visit_with(V).
+//!
+//! These methods return true to indicate that the visitor has found what it is
+//! looking for, and does not need to visit anything else.
use crate::hir::def_id::DefId;
use crate::ty::{self, Binder, Ty, TyCtxt, TypeFlags};
self.super_visit_with(visitor)
}
- /// True if `self` has any late-bound regions that are either
+ /// Returns `true` if `self` has any late-bound regions that are either
/// bound by `binder` or bound by some binder outside of `binder`.
/// If `binder` is `ty::INNERMOST`, this indicates whether
/// there are any late-bound regions that appear free.
self.visit_with(&mut HasEscapingVarsVisitor { outer_index: binder })
}
- /// True if this `self` has any regions that escape `binder` (and
+ /// Returns `true` if this `self` has any regions that escape `binder` (and
/// hence are not bound by it).
fn has_vars_bound_above(&self, binder: ty::DebruijnIndex) -> bool {
self.has_vars_bound_at_or_above(binder.shifted_in(1))
}
}
-/// The TypeFolder trait defines the actual *folding*. There is a
+/// The `TypeFolder` trait defines the actual *folding*. There is a
/// method defined for every foldable type. Each of these has a
/// default implementation that does an "identity" fold. Within each
/// identity fold, it should invoke `foo.fold_with(self)` to fold each
});
}
- /// True if `callback` returns true for every region appearing free in `value`.
+ /// Returns `true` if `callback` returns true for every region appearing free in `value`.
pub fn all_free_regions_meet(
self,
value: &impl TypeFoldable<'tcx>,
!self.any_free_region_meets(value, |r| !callback(r))
}
- /// True if `callback` returns true for some region appearing free in `value`.
+ /// Returns `true` if `callback` returns true for some region appearing free in `value`.
pub fn any_free_region_meets(
self,
value: &impl TypeFoldable<'tcx>,
/// ^ ^ ^ ^
/// | | | | here, would be shifted in 1
/// | | | here, would be shifted in 2
- /// | | here, would be INNERMOST shifted in by 1
- /// | here, initially, binder would be INNERMOST
+ /// | | here, would be `INNERMOST` shifted in by 1
+ /// | here, initially, binder would be `INNERMOST`
/// ```
///
/// You see that, initially, *any* bound value is free,
}
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
- /// Replace all regions bound by the given `Binder` with the
+ /// Replaces all regions bound by the given `Binder` with the
/// results returned by the closure; the closure is expected to
/// return a free region (relative to this binder), and hence the
/// binder is removed in the return type. The closure is invoked
/// once for each unique `BoundRegion`; multiple references to the
- /// same `BoundRegion` will reuse the previous result. A map is
+ /// same `BoundRegion` will reuse the previous result. A map is
/// returned at the end with each bound region and the free region
/// that replaced it.
///
self.replace_escaping_bound_vars(value.skip_binder(), fld_r, fld_t)
}
- /// Replace all escaping bound vars. The `fld_r` closure replaces escaping
+ /// Replaces all escaping bound vars. The `fld_r` closure replaces escaping
/// bound regions while the `fld_t` closure replaces escaping bound types.
pub fn replace_escaping_bound_vars<T, F, G>(
self,
}
}
- /// Replace all types or regions bound by the given `Binder`. The `fld_r`
+ /// Replaces all types or regions bound by the given `Binder`. The `fld_r`
/// closure replaces bound regions while the `fld_t` closure replaces bound
/// types.
pub fn replace_bound_vars<T, F, G>(
self.replace_escaping_bound_vars(value.skip_binder(), fld_r, fld_t)
}
- /// Replace any late-bound regions bound in `value` with
+ /// Replaces any late-bound regions bound in `value` with
/// free variants attached to `all_outlive_scope`.
pub fn liberate_late_bound_regions<T>(
&self,
}).0
}
- /// Flattens multiple binding levels into one. So `for<'a> for<'b> Foo`
- /// becomes `for<'a,'b> Foo`.
- pub fn flatten_late_bound_regions<T>(self, bound2_value: &Binder<Binder<T>>)
- -> Binder<T>
- where T: TypeFoldable<'tcx>
- {
- let bound0_value = bound2_value.skip_binder().skip_binder();
- let value = self.fold_regions(bound0_value, &mut false, |region, current_depth| {
- match *region {
- ty::ReLateBound(debruijn, br) => {
- // We assume no regions bound *outside* of the
- // binders in `bound2_value` (nmatsakis added in
- // the course of this PR; seems like a reasonable
- // sanity check though).
- assert!(debruijn == current_depth);
- self.mk_region(ty::ReLateBound(current_depth, br))
- }
- _ => {
- region
- }
- }
- });
- Binder::bind(value)
- }
-
/// Returns a set of all late-bound regions that are constrained
/// by `value`, meaning that if we instantiate those LBR with
/// variables and equate `value` with something else, those
collector.regions
}
- /// Replace any late-bound regions bound in `value` with `'erased`. Useful in codegen but also
+ /// Replaces any late-bound regions bound in `value` with `'erased`. Useful in codegen but also
/// method lookup and a few other places where precise region relationships are not required.
pub fn erase_late_bound_regions<T>(self, value: &Binder<T>) -> T
where T : TypeFoldable<'tcx>
self.replace_late_bound_regions(value, |_| self.types.re_erased).0
}
- /// Rewrite any late-bound regions so that they are anonymous. Region numbers are
+ /// Rewrite any late-bound regions so that they are anonymous. Region numbers are
/// assigned starting at 1 and increasing monotonically in the order traversed
/// by the fold operation.
///
/// The chief purpose of this function is to canonicalize regions so that two
/// `FnSig`s or `TraitRef`s which are equivalent up to region naming will become
- /// structurally identical. For example, `for<'a, 'b> fn(&'a isize, &'b isize)` and
+ /// structurally identical. For example, `for<'a, 'b> fn(&'a isize, &'b isize)` and
/// `for<'a, 'b> fn(&'b isize, &'a isize)` will become identical after anonymization.
pub fn anonymize_late_bound_regions<T>(self, sig: &Binder<T>) -> Binder<T>
where T : TypeFoldable<'tcx>,
/// scope to which it is attached, etc. An escaping var represents
/// a bound var for which this processing has not yet been done.
struct HasEscapingVarsVisitor {
- /// Anything bound by `outer_index` or "above" is escaping
+ /// Anything bound by `outer_index` or "above" is escaping.
outer_index: ty::DebruijnIndex,
}
current_index: ty::DebruijnIndex,
regions: FxHashSet<ty::BoundRegion>,
- /// If true, we only want regions that are known to be
+ /// `true` if we only want regions that are known to be
/// "constrained" when you equate this type with another type. In
/// particular, if you have e.g., `&'a u32` and `&'b u32`, equating
- /// them constraints `'a == 'b`. But if you have `<&'a u32 as
+ /// them constraints `'a == 'b`. But if you have `<&'a u32 as
/// Trait>::Foo` and `<&'b u32 as Trait>::Foo`, normalizing those
/// types may mean that `'a` and `'b` don't appear in the results,
/// so they are not considered *constrained*.
}
impl<'a, 'gcx, 'tcx> DefIdForest {
- /// Create an empty forest.
+ /// Creates an empty forest.
pub fn empty() -> DefIdForest {
DefIdForest {
root_ids: SmallVec::new(),
}
}
- /// Create a forest consisting of a single tree representing the entire
+ /// Creates a forest consisting of a single tree representing the entire
/// crate.
#[inline]
pub fn full(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> DefIdForest {
DefIdForest::from_id(crate_id)
}
- /// Create a forest containing a DefId and all its descendants.
+ /// Creates a forest containing a DefId and all its descendants.
pub fn from_id(id: DefId) -> DefIdForest {
let mut root_ids = SmallVec::new();
root_ids.push(id);
}
}
- /// Test whether the forest is empty.
+ /// Tests whether the forest is empty.
pub fn is_empty(&self) -> bool {
self.root_ids.is_empty()
}
- /// Test whether the forest contains a given DefId.
+ /// Tests whether the forest contains a given DefId.
pub fn contains(&self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
id: DefId) -> bool
/// `<T as Trait>::method` where `method` receives unsizeable `self: Self`.
VtableShim(DefId),
- /// \<fn() as FnTrait>::call_*
- /// def-id is FnTrait::call_*
+ /// `<fn() as FnTrait>::call_*`
+ /// `DefId` is `FnTrait::call_*`
FnPtrShim(DefId, Ty<'tcx>),
- /// <Trait as Trait>::fn
+ /// `<Trait as Trait>::fn`
Virtual(DefId, usize),
- /// <[mut closure] as FnOnce>::call_once
+ /// `<[mut closure] as FnOnce>::call_once`
ClosureOnceShim { call_once: DefId },
- /// drop_in_place::<T>; None for empty drop glue.
+ /// `drop_in_place::<T>; None` for empty drop glue.
DropGlue(DefId, Option<Ty<'tcx>>),
///`<T as Clone>::clone` shim.
self.def.def_id()
}
- /// Resolve a (def_id, substs) pair to an (optional) instance -- most commonly,
+ /// Resolves a `(def_id, substs)` pair to an (optional) instance -- most commonly,
/// this is used to find the precise code that will run for a trait method invocation,
/// if known.
///
-use crate::hir;
use crate::hir::map::DefPathData;
use crate::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
use crate::ty::{self, DefIdTree, Ty, TyCtxt};
})
}
-/// Add the `crate::` prefix to paths where appropriate.
+/// Adds the `crate::` prefix to paths where appropriate.
pub fn with_crate_prefix<F: FnOnce() -> R, R>(f: F) -> R {
SHOULD_PREFIX_WITH_CRATE.with(|flag| {
let old = flag.get();
}
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
- /// Returns a string identifying this def-id. This string is
+ /// Returns a string identifying this `DefId`. This string is
/// suitable for user output. It is relative to the current crate
/// root, unless with_forced_absolute_paths was used.
pub fn item_path_str(self, def_id: DefId) -> String {
self.item_path_str(self.hir().local_def_id(id))
}
- // FIXME(@ljedrz): replace the NodeId variant
- pub fn hir_path_str(self, id: hir::HirId) -> String {
- self.item_path_str(self.hir().local_def_id_from_hir_id(id))
- }
-
/// Returns a string identifying this def-id. This string is
/// suitable for user output. It always begins with a crate identifier.
pub fn absolute_item_path_str(self, def_id: DefId) -> String {
// only occur very early in the compiler pipeline.
let parent_def_id = self.parent_def_id(impl_def_id).unwrap();
self.push_item_path(buffer, parent_def_id, pushed_prelude_crate);
- let node_id = self.hir().as_local_node_id(impl_def_id).unwrap();
- let item = self.hir().expect_item(node_id);
+ let hir_id = self.hir().as_local_hir_id(impl_def_id).unwrap();
+ let item = self.hir().expect_item_by_hir_id(hir_id);
let span_str = self.sess.source_map().span_to_string(item.span);
buffer.push(&format!("<impl at {}>", span_str));
}
- /// Returns the def-id of `def_id`'s parent in the def tree. If
+ /// Returns the `DefId` of `def_id`'s parent in the def tree. If
/// this returns `None`, then `def_id` represents a crate root or
/// inlined root.
pub fn parent_def_id(self, def_id: DefId) -> Option<DefId> {
}
/// As a heuristic, when we see an impl, if we see that the
-/// 'self-type' is a type defined in the same module as the impl,
+/// 'self type' is a type defined in the same module as the impl,
/// we can omit including the path to the impl itself. This
-/// function tries to find a "characteristic def-id" for a
+/// function tries to find a "characteristic `DefId`" for a
/// type. It's just a heuristic so it makes some questionable
/// decisions and we may want to adjust it later.
pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {
#[derive(Debug)]
pub enum RootMode {
- /// Try to make a path relative to the local crate. In
+ /// Try to make a path relative to the local crate. In
/// particular, local paths have no prefix, and if the path comes
/// from an extern crate, start with the path to the `extern
/// crate` declaration.
}
}
- /// Get the Integer type from an attr::IntType.
+ /// Gets the Integer type from an attr::IntType.
fn from_attr<C: HasDataLayout>(cx: &C, ity: attr::IntType) -> Integer {
let dl = cx.data_layout();
}
}
- /// Find the appropriate Integer type and signedness for the given
+ /// Finds the appropriate Integer type and signedness for the given
/// signed discriminant range and #[repr] attribute.
/// N.B.: u128 values above i128::MAX will be treated as signed, but
/// that shouldn't affect anything, other than maybe debuginfo.
tcx.types.re_static,
tcx.mk_array(tcx.types.usize, 3),
)
- /* FIXME use actual fn pointers
+ /* FIXME: use actual fn pointers
Warning: naively computing the number of entries in the
vtable by counting the methods on the trait + methods on
all parent traits does not work, because some methods can
use rustc_data_structures::sync::{self, Lrc, ParallelIterator, par_iter};
use std::slice;
use std::{mem, ptr};
-use syntax::ast::{self, DUMMY_NODE_ID, Name, Ident, NodeId};
+use syntax::ast::{self, Name, Ident, NodeId};
use syntax::attr;
use syntax::ext::hygiene::Mark;
use syntax::symbol::{keywords, Symbol, LocalInternedString, InternedString};
}
impl AssociatedItemContainer {
- /// Asserts that this is the def-id of an associated item declared
- /// in a trait, and returns the trait def-id.
+ /// Asserts that this is the `DefId` of an associated item declared
+ /// in a trait, and returns the trait `DefId`.
pub fn assert_trait(&self) -> DefId {
match *self {
TraitContainer(id) => id,
/// The "header" of an impl is everything outside the body: a Self type, a trait
/// ref (in the case of a trait impl), and a set of predicates (from the
-/// bounds/where clauses).
+/// bounds / where-clauses).
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub struct ImplHeader<'tcx> {
pub impl_def_id: DefId,
/// item.
pub struct CrateVariancesMap {
/// For each item with generics, maps to a vector of the variance
- /// of its generics. If an item has no generics, it will have no
+ /// of its generics. If an item has no generics, it will have no
/// entry.
pub variances: FxHashMap<DefId, Lrc<Vec<ty::Variance>>>,
impl Variance {
/// `a.xform(b)` combines the variance of a context with the
- /// variance of a type with the following meaning. If we are in a
+ /// variance of a type with the following meaning. If we are in a
/// context with variance `a`, and we encounter a type argument in
/// a position with variance `b`, then `a.xform(b)` is the new
/// variance with which the argument appears.
/// The ambient variance is covariant. A `fn` type is
/// contravariant with respect to its parameters, so the variance
/// within which both pointer types appear is
- /// `Covariant.xform(Contravariant)`, or `Contravariant`. `*const
+ /// `Covariant.xform(Contravariant)`, or `Contravariant`. `*const
/// T` is covariant with respect to `T`, so the variance within
/// which the first `Vec<i32>` appears is
- /// `Contravariant.xform(Covariant)` or `Contravariant`. The same
+ /// `Contravariant.xform(Covariant)` or `Contravariant`. The same
/// is true for its `i32` argument. In the `*mut T` case, the
/// variance of `Vec<i32>` is `Contravariant.xform(Invariant)`,
/// and hence the outermost type is `Invariant` with respect to
/// So, for a type without any late-bound things, like `u32`, this
/// will be *innermost*, because that is the innermost binder that
/// captures nothing. But for a type `&'D u32`, where `'D` is a
- /// late-bound region with debruijn index `D`, this would be `D + 1`
+ /// late-bound region with De Bruijn index `D`, this would be `D + 1`
/// -- the binder itself does not capture `D`, but `D` is captured
/// by an inner binder.
///
/// We call this concept an "exclusive" binder `D` because all
- /// debruijn indices within the type are contained within `0..D`
+ /// De Bruijn indices within the type are contained within `0..D`
/// (exclusive).
outer_exclusive_binder: ty::DebruijnIndex,
}
pub hir_id: hir::HirId,
}
-/// Upvars do not get their own node-id. Instead, we use the pair of
-/// the original var id (that is, the root variable that is referenced
-/// by the upvar) and the id of the closure expression.
+/// Upvars do not get their own `NodeId`. Instead, we use the pair of
+/// the original var ID (that is, the root variable that is referenced
+/// by the upvar) and the ID of the closure expression.
#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
pub struct UpvarId {
pub var_path: UpvarPath,
/// Data must be immutable and is aliasable.
ImmBorrow,
- /// Data must be immutable but not aliasable. This kind of borrow
+ /// Data must be immutable but not aliasable. This kind of borrow
/// cannot currently be expressed by the user and is used only in
/// implicit closure bindings. It is needed when the closure
/// is borrowing or mutating a mutable referent, e.g.:
/// Performs a substitution suitable for going from a
/// poly-trait-ref to supertraits that must hold if that
/// poly-trait-ref holds. This is slightly different from a normal
- /// substitution in terms of what happens with bound regions. See
+ /// substitution in terms of what happens with bound regions. See
/// lengthy comment below for details.
pub fn subst_supertrait(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>,
trait_ref: &ty::PolyTraitRef<'tcx>)
/// This kind of predicate has no *direct* correspondent in the
/// syntax, but it roughly corresponds to the syntactic forms:
///
-/// 1. `T: TraitRef<..., Item=Type>`
+/// 1. `T: TraitRef<..., Item = Type>`
/// 2. `<T as TraitRef<...>>::Item == Type` (NYI)
///
/// In particular, form #1 is "desugared" to the combination of a
}
/// Represents the bounds declared on a particular set of type
-/// parameters. Should eventually be generalized into a flag list of
-/// where clauses. You can obtain a `InstantiatedPredicates` list from a
+/// parameters. Should eventually be generalized into a flag list of
+/// where-clauses. You can obtain a `InstantiatedPredicates` list from a
/// `GenericPredicates` by using the `instantiate` method. Note that this method
/// reflects an important semantic invariant of `InstantiatedPredicates`: while
/// the `GenericPredicates` are expressed in terms of the bound type
/// struct Foo<T,U:Bar<T>> { ... }
///
/// Here, the `GenericPredicates` for `Foo` would contain a list of bounds like
-/// `[[], [U:Bar<T>]]`. Now if there were some particular reference
+/// `[[], [U:Bar<T>]]`. Now if there were some particular reference
/// like `Foo<isize,usize>`, then the `InstantiatedPredicates` would be `[[],
/// [usize:Bar<isize>]]`.
#[derive(Clone)]
/// Returns the "next" universe index in order -- this new index
/// is considered to extend all previous universes. This
- /// corresponds to entering a `forall` quantifier. So, for
+ /// corresponds to entering a `forall` quantifier. So, for
/// example, suppose we have this type in universe `U`:
///
/// ```
impl<'tcx> ParamEnv<'tcx> {
/// Construct a trait environment suitable for contexts where
- /// there are no where clauses in scope. Hidden types (like `impl
+ /// there are no where-clauses in scope. Hidden types (like `impl
/// Trait`) are left hidden, so this is suitable for ordinary
/// type-checking.
#[inline]
Self::new(List::empty(), Reveal::UserFacing, None)
}
- /// Construct a trait environment with no where clauses in scope
+ /// Construct a trait environment with no where-clauses in scope
/// where the values of all `impl Trait` and other hidden types
/// are revealed. This is suitable for monomorphized, post-typeck
/// environments like codegen or doing optimizations.
///
- /// N.B. If you want to have predicates in scope, use `ParamEnv::new`,
+ /// N.B., if you want to have predicates in scope, use `ParamEnv::new`,
/// or invoke `param_env.with_reveal_all()`.
#[inline]
pub fn reveal_all() -> Self {
/// Returns a new parameter environment with the same clauses, but
/// which "reveals" the true results of projections in all cases
- /// (even for associated types that are specializable). This is
+ /// (even for associated types that are specializable). This is
/// the desired behavior during codegen and certain other special
/// contexts; normally though we want to use `Reveal::UserFacing`,
/// which is the default.
#[derive(Copy, Clone, Debug)]
pub struct Destructor {
- /// The def-id of the destructor method
+ /// The `DefId` of the destructor method
pub did: DefId,
}
}
impl<'a, 'gcx, 'tcx> VariantDef {
- /// Create a new `VariantDef`.
+ /// Creates a new `VariantDef`.
///
- /// - `did` is the DefId used for the variant - for tuple-structs, it is the constructor DefId,
- /// and for everything else, it is the variant DefId.
+ /// - `did` is the `DefId` used for the variant.
+ /// This is the constructor `DefId` for tuple stucts, and the variant `DefId` for everything
+ /// else.
/// - `attribute_def_id` is the DefId that has the variant's attributes.
- /// this is the struct DefId for structs, and the variant DefId for variants.
+ /// This is the struct `DefId` for structs, and the variant `DefId` for variants.
///
- /// Note that we *could* use the constructor DefId, because the constructor attributes
+ /// Note that we *could* use the constructor `DefId`, because the constructor attributes
/// redirect to the base attributes, but compiling a small crate requires
- /// loading the AdtDefs for all the structs in the universe (e.g., coherence for any
+ /// loading the `AdtDef`s for all the structs in the universe (e.g., coherence for any
/// built-in trait), and we do not want to load attributes twice.
///
/// If someone speeds up attribute loading to not be a performance concern, they can
- /// remove this hack and use the constructor DefId everywhere.
+ /// remove this hack and use the constructor `DefId` everywhere.
pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>,
did: DefId,
ident: Ident,
}
/// Returns `true` if this `#[repr()]` should inhibit struct field reordering
- /// optimizations, such as with repr(C), repr(packed(1)), or repr(<int>).
+ /// optimizations, such as with `repr(C)`, `repr(packed(1))`, or `repr(<int>)`.
pub fn inhibit_struct_field_reordering_opt(&self) -> bool {
self.flags.intersects(ReprFlags::IS_UNOPTIMISABLE) || self.pack == 1 ||
self.int.is_some()
}
- /// Returns true if this `#[repr()]` should inhibit union abi optimisations
+ /// Returns `true` if this `#[repr()]` should inhibit union ABI optimisations.
pub fn inhibit_union_abi_opt(&self) -> bool {
self.c()
}
self.flags.contains(AdtFlags::HAS_CTOR)
}
- /// Returns whether this type is `#[fundamental]` for the purposes
+ /// Returns `true` if this type is `#[fundamental]` for the purposes
/// of coherence checking.
#[inline]
pub fn is_fundamental(&self) -> bool {
self.flags.contains(AdtFlags::IS_FUNDAMENTAL)
}
- /// Returns `true` if this is PhantomData<T>.
+ /// Returns `true` if this is `PhantomData<T>`.
#[inline]
pub fn is_phantom_data(&self) -> bool {
self.flags.contains(AdtFlags::IS_PHANTOM_DATA)
self.flags.contains(AdtFlags::IS_BOX)
}
- /// Returns whether this type has a destructor.
+ /// Returns `true` if this type has a destructor.
pub fn has_dtor(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> bool {
self.destructor(tcx).is_some()
}
})
}
- /// Compute the discriminant value used by a specific variant.
+ /// Computes the discriminant value used by a specific variant.
/// Unlike `discriminants`, this is (amortized) constant-time,
/// only doing at most one query for evaluating an explicit
/// discriminant (the last one before the requested variant),
explicit_value.checked_add(tcx, offset as u128).0
}
- /// Yields a DefId for the discriminant and an offset to add to it
+ /// Yields a `DefId` for the discriminant and an offset to add to it
/// Alternatively, if there is no explicit discriminant, returns the
- /// inferred discriminant directly
+ /// inferred discriminant directly.
pub fn discriminant_def_for_variant(
&self,
variant_index: VariantIdx,
}
/// Returns a list of types such that `Self: Sized` if and only
- /// if that type is Sized, or `TyErr` if this type is recursive.
+ /// if that type is `Sized`, or `TyErr` if this type is recursive.
///
- /// Oddly enough, checking that the sized-constraint is Sized is
+ /// Oddly enough, checking that the sized-constraint is `Sized` is
/// actually more expressive than checking all members:
- /// the Sized trait is inductive, so an associated type that references
- /// Self would prevent its containing ADT from being Sized.
+ /// the `Sized` trait is inductive, so an associated type that references
+ /// `Self` would prevent its containing ADT from being `Sized`.
///
/// Due to normalization being eager, this applies even if
- /// the associated type is behind a pointer, e.g., issue #31299.
+ /// the associated type is behind a pointer (e.g., issue #31299).
pub fn sized_constraint(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> &'tcx [Ty<'tcx>] {
match tcx.try_adt_sized_constraint(DUMMY_SP, self.did) {
Ok(tys) => tys,
}
}
-/// Represents the various closure traits in the Rust language. This
+/// Represents the various closure traits in the language. This
/// will determine the type of the environment (`self`, in the
/// desugaring) argument that the closure expects.
///
TypeWalker::new(self)
}
- /// Iterator that walks the immediate children of `self`. Hence
+ /// Iterator that walks the immediate children of `self`. Hence
/// `Foo<Bar<i32>, u32>` yields the sequence `[Bar<i32>, u32]`
/// (but not `i32`, like `walk`).
pub fn walk_shallow(&'tcx self) -> smallvec::IntoIter<walk::TypeWalkerArray<'tcx>> {
}
/// Walks `ty` and any types appearing within `ty`, invoking the
- /// callback `f` on each type. If the callback returns false, then the
+ /// callback `f` on each type. If the callback returns `false`, then the
/// children of the current type are ignored.
///
/// Note: prefer `ty.walk()` where possible.
self.typeck_tables_of(self.hir().body_owner_def_id(body))
}
- /// Returns an iterator of the def-ids for all body-owners in this
+ /// Returns an iterator of the `DefId`s for all body-owners in this
/// crate. If you would prefer to iterate over the bodies
/// themselves, you can do `self.hir().krate().body_ids.iter()`.
pub fn body_owners(
pub fn find_field_index(self, ident: Ident, variant: &VariantDef) -> Option<usize> {
variant.fields.iter().position(|field| {
- self.adjust_ident(ident, variant.did, DUMMY_NODE_ID).0 == field.ident.modern()
+ self.adjust_ident(ident, variant.did, hir::DUMMY_HIR_ID).0 == field.ident.modern()
})
}
}
}
- /// Return the possibly-auto-generated MIR of a (DefId, Subst) pair.
+ /// Returns the possibly-auto-generated MIR of a `(DefId, Subst)` pair.
pub fn instance_mir(self, instance: ty::InstanceDef<'gcx>)
-> &'gcx Mir<'gcx>
{
}
}
- /// Get the attributes of a definition.
+ /// Gets the attributes of a definition.
pub fn get_attrs(self, did: DefId) -> Attributes<'gcx> {
- if let Some(id) = self.hir().as_local_node_id(did) {
- Attributes::Borrowed(self.hir().attrs(id))
+ if let Some(id) = self.hir().as_local_hir_id(did) {
+ Attributes::Borrowed(self.hir().attrs_by_hir_id(id))
} else {
Attributes::Owned(self.item_attrs(did))
}
}
- /// Determine whether an item is annotated with an attribute.
+ /// Determines whether an item is annotated with an attribute.
pub fn has_attr(self, did: DefId, attr: &str) -> bool {
attr::contains_name(&self.get_attrs(did), attr)
}
self.optimized_mir(def_id).generator_layout.as_ref().unwrap()
}
- /// Given the def-id of an impl, return the def_id of the trait it implements.
- /// If it implements no trait, return `None`.
+ /// Given the `DefId` of an impl, returns the `DefId` of the trait it implements.
+ /// If it implements no trait, returns `None`.
pub fn trait_id_of_impl(self, def_id: DefId) -> Option<DefId> {
self.impl_trait_ref(def_id).map(|tr| tr.def_id)
}
- /// If the given defid describes a method belonging to an impl, return the
- /// def-id of the impl that the method belongs to. Otherwise, return `None`.
+ /// If the given defid describes a method belonging to an impl, returns the
+ /// `DefId` of the impl that the method belongs to; otherwise, returns `None`.
pub fn impl_of_method(self, def_id: DefId) -> Option<DefId> {
let item = if def_id.krate != LOCAL_CRATE {
if let Some(Def::Method(_)) = self.describe_def(def_id) {
/// with the name of the crate containing the impl.
pub fn span_of_impl(self, impl_did: DefId) -> Result<Span, Symbol> {
if impl_did.is_local() {
- let node_id = self.hir().as_local_node_id(impl_did).unwrap();
- Ok(self.hir().span(node_id))
+ let hir_id = self.hir().as_local_hir_id(impl_did).unwrap();
+ Ok(self.hir().span_by_hir_id(hir_id))
} else {
Err(self.crate_name(impl_did.krate))
}
}
- // Hygienically compare a use-site name (`use_name`) for a field or an associated item with its
- // supposed definition name (`def_name`). The method also needs `DefId` of the supposed
- // definition's parent/scope to perform comparison.
+ /// Hygienically compares a use-site name (`use_name`) for a field or an associated item with
+ /// its supposed definition name (`def_name`). The method also needs `DefId` of the supposed
+ /// definition's parent/scope to perform comparison.
pub fn hygienic_eq(self, use_name: Ident, def_name: Ident, def_parent_def_id: DefId) -> bool {
- self.adjust_ident(use_name, def_parent_def_id, DUMMY_NODE_ID).0 == def_name.modern()
+ self.adjust_ident(use_name, def_parent_def_id, hir::DUMMY_HIR_ID).0 == def_name.modern()
}
- pub fn adjust_ident(self, mut ident: Ident, scope: DefId, block: NodeId) -> (Ident, DefId) {
+ pub fn adjust_ident(self, mut ident: Ident, scope: DefId, block: hir::HirId) -> (Ident, DefId) {
ident = ident.modern();
let target_expansion = match scope.krate {
LOCAL_CRATE => self.hir().definitions().expansion_that_defined(scope.index),
let scope = match ident.span.adjust(target_expansion) {
Some(actual_expansion) =>
self.hir().definitions().parent_module_of_macro_def(actual_expansion),
- None if block == DUMMY_NODE_ID => DefId::local(CRATE_DEF_INDEX), // Dummy DefId
- None => self.hir().get_module_parent(block),
+ None if block == hir::DUMMY_HIR_ID => DefId::local(CRATE_DEF_INDEX), // Dummy DefId
+ None => self.hir().get_module_parent_by_hir_id(block),
};
(ident, scope)
}
parent_item.node)
}
-/// Calculates the Sized-constraint.
+/// Calculates the `Sized` constraint.
///
/// In fact, there are only a few options for the types in the constraint:
/// - an obviously-unsized type
fn associated_item_def_ids<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId)
-> Lrc<Vec<DefId>> {
- let id = tcx.hir().as_local_node_id(def_id).unwrap();
- let item = tcx.hir().expect_item(id);
+ let id = tcx.hir().as_local_hir_id(def_id).unwrap();
+ let item = tcx.hir().expect_item_by_hir_id(id);
let vec: Vec<_> = match item.node {
hir::ItemKind::Trait(.., ref trait_item_refs) => {
trait_item_refs.iter()
tcx.hir().span_if_local(def_id).unwrap()
}
-/// If the given def ID describes an item belonging to a trait,
-/// return the ID of the trait that the trait item belongs to.
-/// Otherwise, return `None`.
+/// If the given `DefId` describes an item belonging to a trait,
+/// returns the `DefId` of the trait that the trait item belongs to;
+/// otherwise, returns `None`.
fn trait_of_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Option<DefId> {
tcx.opt_associated_item(def_id)
.and_then(|associated_item| {
if tcx.sess.opts.debugging_opts.chalk { Some(def_id) } else { None }
);
- let body_id = tcx.hir().as_local_node_id(def_id).map_or(DUMMY_NODE_ID, |id| {
- tcx.hir().maybe_body_owned_by(id).map_or(id, |body| body.node_id)
+ let body_id = tcx.hir().as_local_hir_id(def_id).map_or(hir::DUMMY_HIR_ID, |id| {
+ tcx.hir().maybe_body_owned_by_by_hir_id(id).map_or(id, |body| body.hir_id)
});
let cause = traits::ObligationCause::misc(tcx.def_span(def_id), body_id);
traits::normalize_param_env_or_error(tcx, def_id, unnormalized_env, cause)
}
}
-/// If `def_id` is an issue 33140 hack impl, return its self type. Otherwise
-/// return None.
+/// If `def_id` is an issue 33140 hack impl, returns its self type; otherwise, returns `None`.
///
-/// See ImplOverlapKind::Issue33140 for more details.
+/// See [`ImplOverlapKind::Issue33140`] for more details.
fn issue33140_self_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId)
-> Option<Ty<'tcx>>
use std::fmt::Debug;
use syntax_pos::symbol::InternedString;
use rustc_data_structures::sync::Lock;
-use rustc_data_structures::stable_hasher::HashStable;
+use rustc_data_structures::fingerprint::Fingerprint;
use crate::ich::StableHashingContext;
// Query configuration and description traits.
const CATEGORY: ProfileCategory;
type Key: Eq + Hash + Clone + Debug;
- type Value: Clone + for<'a> HashStable<StableHashingContext<'a>>;
+ type Value: Clone;
}
pub(super) trait QueryAccessors<'tcx>: QueryConfig<'tcx> {
// Don't use this method to compute query results, instead use the methods on TyCtxt
fn compute(tcx: TyCtxt<'_, 'tcx, '_>, key: Self::Key) -> Self::Value;
+ fn hash_result(
+ hcx: &mut StableHashingContext<'_>,
+ result: &Self::Value
+ ) -> Option<Fingerprint>;
+
fn handle_cycle_error(tcx: TyCtxt<'_, 'tcx, '_>) -> Self::Value;
}
rustc_data_structures::stable_hasher::{StableHasherResult, StableHasher, HashStable},
};
-/// Indicates the state of a query for a given key in a query map
+/// Indicates the state of a query for a given key in a query map.
pub(super) enum QueryResult<'tcx> {
- /// An already executing query. The query job can be used to await for its completion
+ /// An already executing query. The query job can be used to await for its completion.
Started(Lrc<QueryJob<'tcx>>),
- /// The query panicked. Queries trying to wait on this will raise a fatal error / silently panic
+ /// The query panicked. Queries trying to wait on this will raise a fatal error or
+ /// silently panic.
Poisoned,
}
-/// A span and a query key
+/// Represents a span and a query key.
#[derive(Clone, Debug)]
pub struct QueryInfo<'tcx> {
- /// The span for a reason this query was required
+ /// The span corresponding to the reason for which this query was required.
pub span: Span,
pub query: Query<'tcx>,
}
-/// A object representing an active query job.
+/// Representss an object representing an active query job.
pub struct QueryJob<'tcx> {
pub info: QueryInfo<'tcx>,
/// The parent query job which created this job and is implicitly waiting on it.
pub parent: Option<Lrc<QueryJob<'tcx>>>,
- /// The latch which is used to wait on this job
+ /// The latch that is used to wait on this job.
#[cfg(parallel_compiler)]
latch: QueryLatch<'tcx>,
}
impl<'tcx> QueryJob<'tcx> {
- /// Creates a new query job
+ /// Creates a new query job.
pub fn new(info: QueryInfo<'tcx>, parent: Option<Lrc<QueryJob<'tcx>>>) -> Self {
QueryJob {
info,
}
}
- /// Remove a single waiter from the list of waiters.
+ /// Removes a single waiter from the list of waiters.
/// This is used to break query cycles.
fn extract_waiter(
&self,
-use crate::dep_graph::{DepConstructor, DepNode};
-use crate::errors::DiagnosticBuilder;
+use crate::dep_graph::{self, DepConstructor, DepNode};
use crate::hir::def_id::{CrateNum, DefId, DefIndex};
use crate::hir::def::{Def, Export};
use crate::hir::{self, TraitCandidate, ItemLocalId, CodegenFnAttrs};
-use rustc_data_structures::svh::Svh;
use crate::infer::canonical::{self, Canonical};
use crate::lint;
use crate::middle::borrowck::BorrowCheckResult;
use crate::util::profiling::ProfileCategory::*;
use crate::session::Session;
+use errors::DiagnosticBuilder;
+use rustc_data_structures::svh::Svh;
use rustc_data_structures::bit_set::BitSet;
use rustc_data_structures::indexed_vec::IndexVec;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::stable_hasher::StableVec;
use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::fingerprint::Fingerprint;
use rustc_target::spec::PanicStrategy;
use std::borrow::Cow;
/// Records the type of every item.
[] fn type_of: TypeOfItem(DefId) -> Ty<'tcx>,
- /// Maps from the def-id of an item (trait/struct/enum/fn) to its
+ /// Maps from the `DefId` of an item (trait/struct/enum/fn) to its
/// associated generics.
[] fn generics_of: GenericsOfItem(DefId) -> &'tcx ty::Generics,
- /// Maps from the def-id of an item (trait/struct/enum/fn) to the
- /// predicates (where clauses) that must be proven true in order
+ /// Maps from the `DefId` of an item (trait/struct/enum/fn) to the
+ /// predicates (where-clauses) that must be proven true in order
/// to reference it. This is almost always the "predicates query"
/// that you want.
///
/// user.)
[] fn predicates_of: PredicatesOfItem(DefId) -> Lrc<ty::GenericPredicates<'tcx>>,
- /// Maps from the def-id of an item (trait/struct/enum/fn) to the
- /// predicates (where clauses) directly defined on it. This is
+ /// Maps from the `DefId` of an item (trait/struct/enum/fn) to the
+ /// predicates (where-clauses) directly defined on it. This is
/// equal to the `explicit_predicates_of` predicates plus the
/// `inferred_outlives_of` predicates.
[] fn predicates_defined_on: PredicatesDefinedOnItem(DefId)
/// Foo<'a, T> { x: &'a T }`, this would return `T: 'a`).
[] fn inferred_outlives_of: InferredOutlivesOf(DefId) -> Lrc<Vec<ty::Predicate<'tcx>>>,
- /// Maps from the def-id of a trait to the list of
+ /// Maps from the `DefId` of a trait to the list of
/// super-predicates. This is a subset of the full list of
/// predicates. We store these in a separate map because we must
/// evaluate them even during type conversion, often before the
},
Codegen {
- /// Set of all the def-ids in this crate that have MIR associated with
+ /// Set of all the `DefId`s in this crate that have MIR associated with
/// them. This includes all the body owners, but also things like struct
/// constructors.
[] fn mir_keys: mir_keys(CrateNum) -> Lrc<DefIdSet>,
/// the value isn't known except to the pass itself.
[] fn mir_const_qualif: MirConstQualif(DefId) -> (u8, Lrc<BitSet<mir::Local>>),
- /// Fetch the MIR for a given def-id right after it's built - this includes
+ /// Fetch the MIR for a given `DefId` right after it's built - this includes
/// unreachable code.
[] fn mir_built: MirBuilt(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
- /// Fetch the MIR for a given def-id up till the point where it is
+ /// Fetch the MIR for a given `DefId` up till the point where it is
/// ready for const evaluation.
///
/// See the README for the `mir` module for details.
- [] fn mir_const: MirConst(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
+ [no_hash] fn mir_const: MirConst(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
- [] fn mir_validated: MirValidated(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
+ [no_hash] fn mir_validated: MirValidated(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
/// MIR after our optimization passes have run. This is MIR that is ready
/// for codegen. This is also the only query that can fetch non-local MIR, at present.
},
TypeChecking {
- /// The result of unsafety-checking this def-id.
+ /// The result of unsafety-checking this `DefId`.
[] fn unsafety_check_result: UnsafetyCheckResult(DefId) -> mir::UnsafetyCheckResult,
/// HACK: when evaluated, this reports a "unsafe derive on repr(packed)" error
TypeChecking {
/// Gets a complete map from all types to their inherent impls.
/// Not meant to be used directly outside of coherence.
- /// (Defined only for LOCAL_CRATE)
+ /// (Defined only for `LOCAL_CRATE`.)
[] fn crate_inherent_impls: crate_inherent_impls_dep_node(CrateNum)
-> Lrc<CrateInherentImpls>,
- /// Checks all types in the krate for overlap in their inherent impls. Reports errors.
+ /// Checks all types in the crate for overlap in their inherent impls. Reports errors.
/// Not meant to be used directly outside of coherence.
- /// (Defined only for LOCAL_CRATE)
+ /// (Defined only for `LOCAL_CRATE`.)
[] fn crate_inherent_impls_overlap_check: inherent_impls_overlap_check_dep_node(CrateNum)
-> (),
},
Other {
/// Evaluate a constant without running sanity checks
///
- /// DO NOT USE THIS outside const eval. Const eval uses this to break query cycles during
- /// validation. Please add a comment to every use site explaining why using `const_eval`
- /// isn't sufficient
+ /// **Do not use this** outside const eval. Const eval uses this to break query cycles
+ /// during validation. Please add a comment to every use site explaining why using
+ /// `const_eval` isn't sufficient
[] fn const_eval_raw: const_eval_raw_dep_node(ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>)
-> ConstEvalRawResult<'tcx>,
Other {
[] fn reachable_set: reachability_dep_node(CrateNum) -> ReachableSet,
- /// Per-body `region::ScopeTree`. The `DefId` should be the owner-def-id for the body;
+ /// Per-body `region::ScopeTree`. The `DefId` should be the owner `DefId` for the body;
/// in the case of closures, this will be redirected to the enclosing function.
[] fn region_scope_tree: RegionScopeTree(DefId) -> Lrc<region::ScopeTree>,
-> Lrc<specialization_graph::Graph>,
[] fn is_object_safe: ObjectSafety(DefId) -> bool,
- /// Get the ParameterEnvironment for a given item; this environment
+ /// Gets the ParameterEnvironment for a given item; this environment
/// will be in "user-facing" mode, meaning that it is suitabe for
/// type-checking etc, and it does not normalize specializable
/// associated types. This is almost always what you want,
[] fn foreign_modules: ForeignModules(CrateNum) -> Lrc<Vec<ForeignModule>>,
- /// Identifies the entry-point (e.g. the `main` function) for a given
+ /// Identifies the entry-point (e.g., the `main` function) for a given
/// crate, returning `None` if there is no entry point (such as for library crates).
[] fn entry_fn: EntryFn(CrateNum) -> Option<(DefId, EntryFnType)>,
[] fn plugin_registrar_fn: PluginRegistrarFn(CrateNum) -> Option<DefId>,
use crate::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
-use crate::errors::Diagnostic;
use crate::hir;
use crate::hir::def_id::{CrateNum, DefIndex, DefId, LocalDefId, LOCAL_CRATE};
use crate::hir::map::definitions::DefPathHash;
use crate::ich::{CachingSourceMapView, Fingerprint};
use crate::mir::{self, interpret};
use crate::mir::interpret::{AllocDecodingSession, AllocDecodingState};
-use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::thin_vec::ThinVec;
-use rustc_data_structures::sync::{Lrc, Lock, HashMapExt, Once};
-use rustc_data_structures::indexed_vec::{IndexVec, Idx};
use crate::rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque,
SpecializedDecoder, SpecializedEncoder,
UseSpecializedDecodable, UseSpecializedEncodable};
use crate::session::{CrateDisambiguator, Session};
+use crate::ty;
+use crate::ty::codec::{self as ty_codec, TyDecoder, TyEncoder};
+use crate::ty::context::TyCtxt;
+use crate::util::common::time;
+
+use errors::Diagnostic;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::thin_vec::ThinVec;
+use rustc_data_structures::sync::{Lrc, Lock, HashMapExt, Once};
+use rustc_data_structures::indexed_vec::{IndexVec, Idx};
use std::mem;
use syntax::ast::NodeId;
use syntax::source_map::{SourceMap, StableSourceFileId};
use syntax_pos::{BytePos, Span, DUMMY_SP, SourceFile};
use syntax_pos::hygiene::{Mark, SyntaxContext, ExpnInfo};
-use crate::ty;
-use crate::ty::codec::{self as ty_codec, TyDecoder, TyEncoder};
-use crate::ty::context::TyCtxt;
-use crate::util::common::time;
const TAG_FILE_FOOTER: u128 = 0xC0FFEE_C0FFEE_C0FFEE_C0FFEE_C0FFEE;
}
impl<'sess> OnDiskCache<'sess> {
- /// Create a new OnDiskCache instance from the serialized data in `data`.
+ /// Creates a new OnDiskCache instance from the serialized data in `data`.
pub fn new(sess: &'sess Session, data: Vec<u8>, start_pos: usize) -> OnDiskCache<'sess> {
debug_assert!(sess.opts.incremental.is_some());
})
}
- /// Load a diagnostic emitted during the previous compilation session.
+ /// Loads a diagnostic emitted during the previous compilation session.
pub fn load_diagnostics<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
dep_node_index: SerializedDepNodeIndex)
diagnostics.unwrap_or_default()
}
- /// Store a diagnostic emitted during the current compilation session.
+ /// Stores a diagnostic emitted during the current compilation session.
/// Anything stored like this will be available via `load_diagnostics` in
/// the next compilation session.
#[inline(never)]
}
/// Returns the cached query result if there is something in the cache for
- /// the given SerializedDepNodeIndex. Otherwise returns None.
+ /// the given `SerializedDepNodeIndex`; otherwise returns `None`.
pub fn try_load_query_result<'tcx, T>(&self,
tcx: TyCtxt<'_, 'tcx, 'tcx>,
dep_node_index: SerializedDepNodeIndex)
"query result")
}
- /// Store a diagnostic emitted during computation of an anonymous query.
+ /// Stores a diagnostic emitted during computation of an anonymous query.
/// Since many anonymous queries can share the same `DepNode`, we aggregate
/// them -- as opposed to regular queries where we assume that there is a
/// 1:1 relationship between query-key and `DepNode`.
-//! The implementation of the query system itself. Defines the macros
-//! that generate the actual methods on tcx which find and execute the
-//! provider, manage the caches, and so forth.
+//! The implementation of the query system itself. This defines the macros that
+//! generate the actual methods on tcx which find and execute the provider,
+//! manage the caches, and so forth.
use crate::dep_graph::{DepNodeIndex, DepNode, DepKind, SerializedDepNodeIndex};
-use crate::errors::DiagnosticBuilder;
-use crate::errors::Level;
-use crate::errors::Diagnostic;
-use crate::errors::FatalError;
use crate::ty::tls;
use crate::ty::{TyCtxt};
use crate::ty::query::Query;
use crate::util::common::{profq_msg, ProfileQueriesMsg, QueryMsg};
+use errors::DiagnosticBuilder;
+use errors::Level;
+use errors::Diagnostic;
+use errors::FatalError;
use rustc_data_structures::fx::{FxHashMap};
use rustc_data_structures::sync::{Lrc, Lock};
use rustc_data_structures::thin_vec::ThinVec;
let mut lock = cache.borrow_mut();
if let Some(value) = lock.results.get(key) {
profq_msg!(tcx, ProfileQueriesMsg::CacheHit);
- tcx.sess.profiler(|p| p.record_query_hit(Q::CATEGORY));
+ tcx.sess.profiler(|p| p.record_query_hit(Q::NAME, Q::CATEGORY));
let result = Ok((value.value.clone(), value.index));
#[cfg(debug_assertions)]
{
let job = match lock.active.entry((*key).clone()) {
Entry::Occupied(entry) => {
match *entry.get() {
- QueryResult::Started(ref job) => job.clone(),
+ QueryResult::Started(ref job) => {
+ //For parallel queries, we'll block and wait until the query running
+ //in another thread has completed. Record how long we wait in the
+ //self-profiler
+ #[cfg(parallel_compiler)]
+ tcx.sess.profiler(|p| p.query_blocked_start(Q::NAME, Q::CATEGORY));
+
+ job.clone()
+ },
QueryResult::Poisoned => FatalError.raise(),
}
}
// thread
#[cfg(parallel_compiler)]
{
- if let Err(cycle) = job.r#await(tcx, span) {
+ let result = job.r#await(tcx, span);
+ tcx.sess.profiler(|p| p.query_blocked_end(Q::NAME, Q::CATEGORY));
+
+ if let Err(cycle) = result {
return TryGetJob::JobCompleted(Err(cycle));
}
}
job.signal_complete();
}
-
- /// Executes a job by changing the ImplicitCtxt to point to the
- /// new query job while it executes. It returns the diagnostics
- /// captured during execution and the actual result.
- #[inline(always)]
- pub(super) fn start<'lcx, F, R>(
- &self,
- tcx: TyCtxt<'_, 'tcx, 'lcx>,
- diagnostics: Option<&Lock<ThinVec<Diagnostic>>>,
- compute: F)
- -> R
- where
- F: for<'b> FnOnce(TyCtxt<'b, 'tcx, 'lcx>) -> R
- {
- // The TyCtxt stored in TLS has the same global interner lifetime
- // as `tcx`, so we use `with_related_context` to relate the 'gcx lifetimes
- // when accessing the ImplicitCtxt
- tls::with_related_context(tcx, move |current_icx| {
- // Update the ImplicitCtxt to point to our new query job
- let new_icx = tls::ImplicitCtxt {
- tcx: tcx.global_tcx(),
- query: Some(self.job.clone()),
- diagnostics,
- layout_depth: current_icx.layout_depth,
- task_deps: current_icx.task_deps,
- };
-
- // Use the ImplicitCtxt while we execute the query
- tls::enter_context(&new_icx, |_| {
- compute(tcx)
- })
- })
- }
-
}
#[inline(always)]
}
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
+ /// Executes a job by changing the ImplicitCtxt to point to the
+ /// new query job while it executes. It returns the diagnostics
+ /// captured during execution and the actual result.
+ #[inline(always)]
+ pub(super) fn start_query<F, R>(
+ self,
+ job: Lrc<QueryJob<'gcx>>,
+ diagnostics: Option<&Lock<ThinVec<Diagnostic>>>,
+ compute: F)
+ -> R
+ where
+ F: for<'b, 'lcx> FnOnce(TyCtxt<'b, 'gcx, 'lcx>) -> R
+ {
+ // The TyCtxt stored in TLS has the same global interner lifetime
+ // as `self`, so we use `with_related_context` to relate the 'gcx lifetimes
+ // when accessing the ImplicitCtxt
+ tls::with_related_context(self, move |current_icx| {
+ // Update the ImplicitCtxt to point to our new query job
+ let new_icx = tls::ImplicitCtxt {
+ tcx: self.global_tcx(),
+ query: Some(job),
+ diagnostics,
+ layout_depth: current_icx.layout_depth,
+ task_deps: current_icx.task_deps,
+ };
+
+ // Use the ImplicitCtxt while we execute the query
+ tls::enter_context(&new_icx, |_| {
+ compute(self.global_tcx())
+ })
+ })
+ }
+
#[inline(never)]
#[cold]
pub(super) fn report_cycle(
if dep_node.kind.is_anon() {
profq_msg!(self, ProfileQueriesMsg::ProviderBegin);
- self.sess.profiler(|p| p.start_activity(Q::CATEGORY));
+ self.sess.profiler(|p| p.start_query(Q::NAME, Q::CATEGORY));
let ((result, dep_node_index), diagnostics) = with_diagnostics(|diagnostics| {
- job.start(self, diagnostics, |tcx| {
+ self.start_query(job.job.clone(), diagnostics, |tcx| {
tcx.dep_graph.with_anon_task(dep_node.kind, || {
Q::compute(tcx.global_tcx(), key)
})
})
});
- self.sess.profiler(|p| p.end_activity(Q::CATEGORY));
+ self.sess.profiler(|p| p.end_query(Q::NAME, Q::CATEGORY));
profq_msg!(self, ProfileQueriesMsg::ProviderEnd);
self.dep_graph.read_index(dep_node_index);
}
if !dep_node.kind.is_input() {
- if let Some((prev_dep_node_index,
- dep_node_index)) = self.dep_graph.try_mark_green_and_read(self,
- &dep_node) {
- return Ok(self.load_from_disk_and_cache_in_memory::<Q>(
- key,
- job,
- prev_dep_node_index,
- dep_node_index,
- &dep_node
- ))
+ // The diagnostics for this query will be
+ // promoted to the current session during
+ // try_mark_green(), so we can ignore them here.
+ let loaded = self.start_query(job.job.clone(), None, |tcx| {
+ let marked = tcx.dep_graph.try_mark_green_and_read(tcx, &dep_node);
+ marked.map(|(prev_dep_node_index, dep_node_index)| {
+ (tcx.load_from_disk_and_cache_in_memory::<Q>(
+ key.clone(),
+ prev_dep_node_index,
+ dep_node_index,
+ &dep_node
+ ), dep_node_index)
+ })
+ });
+ if let Some((result, dep_node_index)) = loaded {
+ job.complete(&result, dep_node_index);
+ return Ok(result);
}
}
fn load_from_disk_and_cache_in_memory<Q: QueryDescription<'gcx>>(
self,
key: Q::Key,
- job: JobOwner<'a, 'gcx, Q>,
prev_dep_node_index: SerializedDepNodeIndex,
dep_node_index: DepNodeIndex,
dep_node: &DepNode
// First we try to load the result from the on-disk cache
let result = if Q::cache_on_disk(self.global_tcx(), key.clone()) &&
self.sess.opts.debugging_opts.incremental_queries {
+ self.sess.profiler(|p| p.incremental_load_result_start(Q::NAME));
let result = Q::try_load_from_disk(self.global_tcx(), prev_dep_node_index);
+ self.sess.profiler(|p| p.incremental_load_result_end(Q::NAME));
// We always expect to find a cached result for things that
// can be forced from DepNode.
let result = if let Some(result) = result {
profq_msg!(self, ProfileQueriesMsg::CacheHit);
- self.sess.profiler(|p| p.record_query_hit(Q::CATEGORY));
+ self.sess.profiler(|p| p.record_query_hit(Q::NAME, Q::CATEGORY));
result
} else {
// We could not load a result from the on-disk cache, so
// recompute.
- self.sess.profiler(|p| p.start_activity(Q::CATEGORY));
+ self.sess.profiler(|p| p.start_query(Q::NAME, Q::CATEGORY));
- // The diagnostics for this query have already been
- // promoted to the current session during
- // try_mark_green(), so we can ignore them here.
- let result = job.start(self, None, |tcx| {
- // The dep-graph for this computation is already in
- // place
- tcx.dep_graph.with_ignore(|| {
- Q::compute(tcx, key)
- })
+ // The dep-graph for this computation is already in
+ // place
+ let result = self.dep_graph.with_ignore(|| {
+ Q::compute(self, key)
});
- self.sess.profiler(|p| p.end_activity(Q::CATEGORY));
+ self.sess.profiler(|p| p.end_query(Q::NAME, Q::CATEGORY));
result
};
self.dep_graph.mark_loaded_from_cache(dep_node_index, true);
}
- job.complete(&result, dep_node_index);
-
result
}
dep_node: &DepNode,
dep_node_index: DepNodeIndex,
) {
- use rustc_data_structures::stable_hasher::{StableHasher, HashStable};
use crate::ich::Fingerprint;
assert!(Some(self.dep_graph.fingerprint_of(dep_node_index)) ==
debug!("BEGIN verify_ich({:?})", dep_node);
let mut hcx = self.create_stable_hashing_context();
- let mut hasher = StableHasher::new();
-
- result.hash_stable(&mut hcx, &mut hasher);
- let new_hash: Fingerprint = hasher.finish();
+ let new_hash = Q::hash_result(&mut hcx, result).unwrap_or(Fingerprint::ZERO);
debug!("END verify_ich({:?})", dep_node);
let old_hash = self.dep_graph.fingerprint_of(dep_node_index);
key, dep_node);
profq_msg!(self, ProfileQueriesMsg::ProviderBegin);
- self.sess.profiler(|p| p.start_activity(Q::CATEGORY));
+ self.sess.profiler(|p| p.start_query(Q::NAME, Q::CATEGORY));
let ((result, dep_node_index), diagnostics) = with_diagnostics(|diagnostics| {
- job.start(self, diagnostics, |tcx| {
+ self.start_query(job.job.clone(), diagnostics, |tcx| {
if dep_node.kind.is_eval_always() {
tcx.dep_graph.with_eval_always_task(dep_node,
tcx,
key,
- Q::compute)
+ Q::compute,
+ Q::hash_result)
} else {
tcx.dep_graph.with_task(dep_node,
tcx,
key,
- Q::compute)
+ Q::compute,
+ Q::hash_result)
}
})
});
- self.sess.profiler(|p| p.end_activity(Q::CATEGORY));
+ self.sess.profiler(|p| p.end_query(Q::NAME, Q::CATEGORY));
profq_msg!(self, ProfileQueriesMsg::ProviderEnd);
if unlikely!(self.sess.opts.debugging_opts.query_dep_graph) {
let _ = self.get_query::<Q>(DUMMY_SP, key);
} else {
profq_msg!(self, ProfileQueriesMsg::CacheHit);
- self.sess.profiler(|p| p.record_query_hit(Q::CATEGORY));
+ self.sess.profiler(|p| p.record_query_hit(Q::NAME, Q::CATEGORY));
}
}
};
}
+macro_rules! hash_result {
+ ([][$hcx:expr, $result:expr]) => {{
+ dep_graph::hash_result($hcx, &$result)
+ }};
+ ([no_hash$(, $modifiers:ident)*][$hcx:expr, $result:expr]) => {{
+ None
+ }};
+ ([$other:ident$(, $modifiers:ident)*][$($args:tt)*]) => {
+ hash_result!([$($modifiers),*][$($args)*])
+ };
+}
+
macro_rules! define_queries {
(<$tcx:tt> $($category:tt {
$($(#[$attr:meta])* [$($modifiers:tt)*] fn $name:ident: $node:ident($K:ty) -> $V:ty,)*
sess.profiler(|p| {
$(
p.record_computed_queries(
+ <queries::$name<'_> as QueryConfig<'_>>::NAME,
<queries::$name<'_> as QueryConfig<'_>>::CATEGORY,
self.$name.lock().results.len()
);
})
}
+ fn hash_result(
+ _hcx: &mut StableHashingContext<'_>,
+ _result: &Self::Value
+ ) -> Option<Fingerprint> {
+ hash_result!([$($modifiers)*][_hcx, _result])
+ }
+
fn handle_cycle_error(tcx: TyCtxt<'_, 'tcx, '_>) -> Self::Value {
handle_cycle_error!([$($modifiers)*][tcx])
}
}
impl<'a, $tcx, 'lcx> TyCtxt<'a, $tcx, 'lcx> {
- /// Return a transparent wrapper for `TyCtxt` which ensures queries
- /// are executed instead of returing their result
+ /// Returns a transparent wrapper for `TyCtxt`, which ensures queries
+ /// are executed instead of just returing their results.
#[inline(always)]
pub fn ensure(self) -> TyCtxtEnsure<'a, $tcx, 'lcx> {
TyCtxtEnsure {
}
}
- /// Return a transparent wrapper for `TyCtxt` which uses
+ /// Returns a transparent wrapper for `TyCtxt` which uses
/// `span` as the location of queries performed through it.
#[inline(always)]
pub fn at(self, span: Span) -> TyCtxtAt<'a, $tcx, 'lcx> {
(tcx: $tcx:tt,
input: ($(([$($modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => {
pub struct Queries<$tcx> {
- /// This provides access to the incr. comp. on-disk cache for query results.
+ /// This provides access to the incrimental comilation on-disk cache for query results.
/// Do not access this directly. It is only meant to be used by
/// `DepGraph::try_mark_green()` and the query infrastructure.
pub(crate) on_disk_cache: OnDiskCache<'tcx>,
///
/// Now, if force_from_dep_node() would always fail, it would be pretty useless.
/// Fortunately, we can use some contextual information that will allow us to
-/// reconstruct query-keys for certain kinds of DepNodes. In particular, we
-/// enforce by construction that the GUID/fingerprint of certain DepNodes is a
-/// valid DefPathHash. Since we also always build a huge table that maps every
-/// DefPathHash in the current codebase to the corresponding DefId, we have
+/// reconstruct query-keys for certain kinds of `DepNode`s. In particular, we
+/// enforce by construction that the GUID/fingerprint of certain `DepNode`s is a
+/// valid `DefPathHash`. Since we also always build a huge table that maps every
+/// `DefPathHash` in the current codebase to the corresponding `DefId`, we have
/// everything we need to re-run the query.
///
/// Take the `mir_validated` query as an example. Like many other queries, it
-/// just has a single parameter: the DefId of the item it will compute the
-/// validated MIR for. Now, when we call `force_from_dep_node()` on a dep-node
-/// with kind `MirValidated`, we know that the GUID/fingerprint of the dep-node
-/// is actually a DefPathHash, and can therefore just look up the corresponding
-/// DefId in `tcx.def_path_hash_to_def_id`.
+/// just has a single parameter: the `DefId` of the item it will compute the
+/// validated MIR for. Now, when we call `force_from_dep_node()` on a `DepNode`
+/// with kind `MirValidated`, we know that the GUID/fingerprint of the `DepNode`
+/// is actually a `DefPathHash`, and can therefore just look up the corresponding
+/// `DefId` in `tcx.def_path_hash_to_def_id`.
///
/// When you implement a new query, it will likely have a corresponding new
-/// DepKind, and you'll have to support it here in `force_from_dep_node()`. As
-/// a rule of thumb, if your query takes a DefId or DefIndex as sole parameter,
+/// `DepKind`, and you'll have to support it here in `force_from_dep_node()`. As
+/// a rule of thumb, if your query takes a `DefId` or `DefIndex` as sole parameter,
/// then `force_from_dep_node()` should not fail for it. Otherwise, you can just
/// add it to the "We don't have enough information to reconstruct..." group in
/// the match below.
/// Returns a static string we can use for printouts.
fn tag(&self) -> &'static str;
- /// Returns true if the value `a` is the "expected" type in the
+ /// Returns `true` if the value `a` is the "expected" type in the
/// relation. Just affects error messages.
fn a_is_expected(&self) -> bool;
/// Steal<Mir<'tcx>>` (to be very specific). Now we can read from this
/// as much as we want (using `borrow()`), but you can also
/// `steal()`. Once you steal, any further attempt to read will panic.
-/// Therefore we know that -- assuming no ICE -- nobody is observing
+/// Therefore, we know that -- assuming no ICE -- nobody is observing
/// the fact that the MIR was updated.
///
/// Obviously, whenever you have a query that yields a `Steal` value,
/// you must treat it with caution, and make sure that you know that
/// -- once the value is stolen -- it will never be read from again.
-///
-/// FIXME(#41710) -- what is the best way to model linear queries?
+//
+// FIXME(#41710): what is the best way to model linear queries?
pub struct Steal<T> {
value: RwLock<Option<T>>
}
ty::LazyConst::Unevaluated(*def_id, substs.fold_with(folder))
}
};
- folder.tcx().intern_lazy_const(new)
+ folder.tcx().mk_lazy_const(new)
}
fn fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self {
/// Named region parameters for functions (a in &'a T)
///
- /// The def-id is needed to distinguish free regions in
+ /// The `DefId` is needed to distinguish free regions in
/// the event of shadowing.
BrNamed(DefId, InternedString),
Bool,
/// The primitive character type; holds a Unicode scalar value
- /// (a non-surrogate code point). Written as `char`.
+ /// (a non-surrogate code point). Written as `char`.
Char,
/// A primitive signed integer type. For example, `i32`.
/// An array with the given length. Written as `[T; n]`.
Array(Ty<'tcx>, &'tcx ty::LazyConst<'tcx>),
- /// The pointee of an array slice. Written as `[T]`.
+ /// The pointee of an array slice. Written as `[T]`.
Slice(Ty<'tcx>),
/// A raw pointer. Written as `*mut T` or `*const T`
/// ```
FnDef(DefId, &'tcx Substs<'tcx>),
- /// A pointer to a function. Written as `fn() -> i32`.
+ /// A pointer to a function. Written as `fn() -> i32`.
///
/// For example the type of `bar` here:
///
/// The never type `!`
Never,
- /// A tuple type. For example, `(i32, bool)`.
+ /// A tuple type. For example, `(i32, bool)`.
Tuple(&'tcx List<Ty<'tcx>>),
- /// The projection of an associated type. For example,
+ /// The projection of an associated type. For example,
/// `<T as Trait<..>>::N`.
Projection(ProjectionTy<'tcx>),
///
/// All right, you say, but why include the type parameters from the
/// original function then? The answer is that codegen may need them
-/// when monomorphizing, and they may not appear in the upvars. A
+/// when monomorphizing, and they may not appear in the upvars. A
/// closure could capture no variables but still make use of some
/// in-scope type parameter with a bound (e.g., if our example above
/// had an extra `U: Default`, and the closure called `U::default()`).
/// ## Generators
///
/// Perhaps surprisingly, `ClosureSubsts` are also used for
-/// generators. In that case, what is written above is only half-true
+/// generators. In that case, what is written above is only half-true
/// -- the set of type parameters is similar, but the role of CK and
-/// CS are different. CK represents the "yield type" and CS
+/// CS are different. CK represents the "yield type" and CS
/// represents the "return type" of the generator.
///
/// It'd be nice to split this struct into ClosureSubsts and
self.split(def_id, tcx).return_ty
}
- /// Return the "generator signature", which consists of its yield
+ /// Returns the "generator signature", which consists of its yield
/// and return types.
///
- /// NB. Some bits of the code prefers to see this wrapped in a
+ /// N.B., some bits of the code prefers to see this wrapped in a
/// binder, but it never contains bound regions. Probably this
/// function should be removed.
pub fn poly_sig(self, def_id: DefId, tcx: TyCtxt<'_, '_, '_>) -> PolyGenSig<'tcx> {
ty::Binder::dummy(self.sig(def_id, tcx))
}
- /// Return the "generator signature", which consists of its yield
+ /// Returns the "generator signature", which consists of its yield
/// and return types.
pub fn sig(self, def_id: DefId, tcx: TyCtxt<'_, '_, '_>) -> GenSig<'tcx> {
ty::GenSig {
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Hash, RustcEncodable, RustcDecodable)]
pub enum ExistentialPredicate<'tcx> {
- /// e.g., Iterator
+ /// E.g., `Iterator`.
Trait(ExistentialTraitRef<'tcx>),
- /// e.g., Iterator::Item = T
+ /// E.g., `Iterator::Item = T`.
Projection(ExistentialProjection<'tcx>),
- /// e.g., Send
+ /// E.g., `Send`.
AutoTrait(DefId),
}
}
/// A complete reference to a trait. These take numerous guises in syntax,
-/// but perhaps the most recognizable form is in a where clause:
+/// but perhaps the most recognizable form is in a where-clause:
///
/// T: Foo<U>
///
-/// This would be represented by a trait-reference where the def-id is the
-/// def-id for the trait `Foo` and the substs define `T` as parameter 0,
+/// This would be represented by a trait-reference where the `DefId` is the
+/// `DefId` for the trait `Foo` and the substs define `T` as parameter 0,
/// and `U` as parameter 1.
///
/// Trait references also appear in object types like `Foo<U>`, but in
}
}
- /// Object types don't have a self-type specified. Therefore, when
+ /// Object types don't have a self type specified. Therefore, when
/// we convert the principal trait-ref into a normal trait-ref,
- /// you must give *some* self-type. A common choice is `mk_err()`
+ /// you must give *some* self type. A common choice is `mk_err()`
/// or some placeholder type.
pub fn with_self_ty(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, self_ty: Ty<'tcx>)
-> ty::TraitRef<'tcx> {
self.skip_binder().def_id
}
- /// Object types don't have a self-type specified. Therefore, when
+ /// Object types don't have a self type specified. Therefore, when
/// we convert the principal trait-ref into a normal trait-ref,
- /// you must give *some* self-type. A common choice is `mk_err()`
+ /// you must give *some* self type. A common choice is `mk_err()`
/// or some placeholder type.
pub fn with_self_ty(&self, tcx: TyCtxt<'_, '_, 'tcx>,
self_ty: Ty<'tcx>)
/// Skips the binder and returns the "bound" value. This is a
/// risky thing to do because it's easy to get confused about
- /// debruijn indices and the like. It is usually better to
+ /// De Bruijn indices and the like. It is usually better to
/// discharge the binder using `no_bound_vars` or
/// `replace_late_bound_regions` or something like
/// that. `skip_binder` is only valid when you are either
///
/// Some examples where `skip_binder` is reasonable:
///
- /// - extracting the def-id from a PolyTraitRef;
+ /// - extracting the `DefId` from a PolyTraitRef;
/// - comparing the self type of a PolyTraitRef to see if it is equal to
/// a type parameter `X`, since the type `X` does not reference any regions
pub fn skip_binder(&self) -> &T {
}
/// Given two things that have the same binder level,
- /// and an operation that wraps on their contents, execute the operation
- /// and then wrap its result.
+ /// and an operation that wraps on their contents, executes the operation
+ /// and then wraps its result.
///
/// `f` should consider bound regions at depth 1 to be free, and
/// anything it produces with bound regions at depth 1 will be
Binder(f(self.0, u.0))
}
- /// Split the contents into two things that share the same binder
+ /// Splits the contents into two things that share the same binder
/// level as the original, returning two distinct binders.
///
/// `f` should consider bound regions at depth 1 to be free, and
/// ## Bound Regions
///
/// These are regions that are stored behind a binder and must be substituted
-/// with some concrete region before being used. There are 2 kind of
-/// bound regions: early-bound, which are bound in an item's Generics,
-/// and are substituted by a Substs, and late-bound, which are part of
-/// higher-ranked types (e.g., `for<'a> fn(&'a ())`) and are substituted by
+/// with some concrete region before being used. There are two kind of
+/// bound regions: early-bound, which are bound in an item's `Generics`,
+/// and are substituted by a `Substs`, and late-bound, which are part of
+/// higher-ranked types (e.g., `for<'a> fn(&'a ())`), and are substituted by
/// the likes of `liberate_late_bound_regions`. The distinction exists
/// because higher-ranked lifetimes aren't supported in all places. See [1][2].
///
-/// Unlike Param-s, bound regions are not supposed to exist "in the wild"
+/// Unlike `Param`s, bound regions are not supposed to exist "in the wild"
/// outside their binder, e.g., in types passed to type inference, and
/// should first be substituted (by placeholder regions, free regions,
/// or region variables).
/// To do this, we replace the bound regions with placeholder markers,
/// which don't satisfy any relation not explicitly provided.
///
-/// There are 2 kinds of placeholder regions in rustc: `ReFree` and
+/// There are two kinds of placeholder regions in rustc: `ReFree` and
/// `RePlaceholder`. When checking an item's body, `ReFree` is supposed
/// to be used. These also support explicit bounds: both the internally-stored
/// *scope*, which the region is assumed to outlive, as well as other
/// Static data that has an "infinite" lifetime. Top in the region lattice.
ReStatic,
- /// A region variable. Should not exist after typeck.
+ /// A region variable. Should not exist after typeck.
ReVar(RegionVid),
/// A placeholder region - basically the higher-ranked version of ReFree.
impl DebruijnIndex {
/// Returns the resulting index when this value is moved into
- /// `amount` number of new binders. So e.g., if you had
+ /// `amount` number of new binders. So, e.g., if you had
///
/// for<'a> fn(&'a x)
///
- /// and you wanted to change to
+ /// and you wanted to change it to
///
/// for<'a> fn(for<'b> fn(&'a x))
///
*self = self.shifted_out(amount);
}
- /// Adjusts any Debruijn Indices so as to make `to_binder` the
+ /// Adjusts any De Bruijn indices so as to make `to_binder` the
/// innermost binder. That is, if we have something bound at `to_binder`,
/// it will now be bound at INNERMOST. This is an appropriate thing to do
/// when moving a region out from inside binders:
/// // Binder: D3 D2 D1 ^^
/// ```
///
- /// Here, the region `'a` would have the debruijn index D3,
+ /// Here, the region `'a` would have the De Bruijn index D3,
/// because it is the bound 3 binders out. However, if we wanted
/// to refer to that region `'a` in the second argument (the `_`),
/// those two binders would not be in scope. In that case, we
/// might invoke `shift_out_to_binder(D3)`. This would adjust the
- /// debruijn index of `'a` to D1 (the innermost binder).
+ /// De Bruijn index of `'a` to D1 (the innermost binder).
///
/// If we invoke `shift_out_to_binder` and the region is in fact
/// bound by one of the binders we are shifting out of, that is an
}
}
- /// Adjusts any Debruijn Indices so as to make `to_binder` the
+ /// Adjusts any De Bruijn indices so as to make `to_binder` the
/// innermost binder. That is, if we have something bound at `to_binder`,
/// it will now be bound at INNERMOST. This is an appropriate thing to do
/// when moving a region out from inside binders:
/// // Binder: D3 D2 D1 ^^
/// ```
///
- /// Here, the region `'a` would have the debruijn index D3,
+ /// Here, the region `'a` would have the De Bruijn index D3,
/// because it is the bound 3 binders out. However, if we wanted
/// to refer to that region `'a` in the second argument (the `_`),
/// those two binders would not be in scope. In that case, we
/// might invoke `shift_out_to_binder(D3)`. This would adjust the
- /// debruijn index of `'a` to D1 (the innermost binder).
+ /// De Bruijn index of `'a` to D1 (the innermost binder).
///
/// If we invoke `shift_out_to_binder` and the region is in fact
/// bound by one of the binders we are shifting out of, that is an
flags
}
- /// Given an early-bound or free region, returns the def-id where it was bound.
+ /// Given an early-bound or free region, returns the `DefId` where it was bound.
/// For example, consider the regions in this snippet of code:
///
/// ```
/// }
/// ```
///
- /// Here, `free_region_binding_scope('a)` would return the def-id
+ /// Here, `free_region_binding_scope('a)` would return the `DefId`
/// of the impl, and for all the other highlighted regions, it
- /// would return the def-id of the function. In other cases (not shown), this
- /// function might return the def-id of a closure.
+ /// would return the `DefId` of the function. In other cases (not shown), this
+ /// function might return the `DefId` of a closure.
pub fn free_region_binding_scope(&self, tcx: TyCtxt<'_, '_, '_>) -> DefId {
match self {
ty::ReEarlyBound(br) => {
}
}
- /// Returns true if this type is a floating point type and false otherwise.
+ /// Returns `true` if this type is a floating point type.
pub fn is_floating_point(&self) -> bool {
match self.sty {
Float(_) |
/// Creates a `Substs` that maps each generic parameter to a higher-ranked
/// var bound at index `0`. For types, we use a `BoundVar` index equal to
/// the type parameter index. For regions, we use the `BoundRegion::BrNamed`
- /// variant (which has a def-id).
+ /// variant (which has a `DefId`).
pub fn bound_vars_for_item(
tcx: TyCtxt<'a, 'gcx, 'tcx>,
def_id: DefId
self.shift_vars_through_binders(ty)
}
- /// It is sometimes necessary to adjust the debruijn indices during substitution. This occurs
+ /// It is sometimes necessary to adjust the De Bruijn indices during substitution. This occurs
/// when we are substituting a type with escaping bound vars into a context where we have
/// passed through binders. That's quite a mouthful. Let's see an example:
///
///
/// Here the `'a` lifetime is bound in the outer function, but appears as an argument of the
/// inner one. Therefore, that appearance will have a DebruijnIndex of 2, because we must skip
- /// over the inner binder (remember that we count Debruijn indices from 1). However, in the
+ /// over the inner binder (remember that we count De Bruijn indices from 1). However, in the
/// definition of `MetaFunc`, the binder is not visible, so the type `&'a int` will have a
- /// debruijn index of 1. It's only during the substitution that we can see we must increase the
+ /// De Bruijn index of 1. It's only during the substitution that we can see we must increase the
/// depth by 1 to account for the binder that we passed through.
///
/// As a second example, consider this twist:
/// DebruijnIndex of 2
///
/// As indicated in the diagram, here the same type `&'a int` is substituted once, but in the
- /// first case we do not increase the Debruijn index and in the second case we do. The reason
+ /// first case we do not increase the De Bruijn index and in the second case we do. The reason
/// is that only in the second case have we passed through a fn binder.
fn shift_vars_through_binders(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
debug!("shift_vars(ty={:?}, binders_passed={:?}, has_escaping_bound_vars={:?})",
/// The substitutions for the item as given by the user.
pub substs: &'tcx Substs<'tcx>,
- /// The self-type, in the case of a `<T>::Item` path (when applied
+ /// The self type, in the case of a `<T>::Item` path (when applied
/// to an inherent impl). See `UserSelfTy` below.
pub user_self_ty: Option<UserSelfTy<'tcx>>,
}
}
}
-/// Specifies the user-given self-type. In the case of a path that
-/// refers to a member in an inherent impl, this self-type is
+/// Specifies the user-given self type. In the case of a path that
+/// refers to a member in an inherent impl, this self type is
/// sometimes needed to constrain the type parameters on the impl. For
/// example, in this code:
///
/// ```
///
/// when you then have a path like `<Foo<&'static u32>>::method`,
-/// this struct would carry the def-id of the impl along with the
-/// self-type `Foo<u32>`. Then we can instantiate the parameters of
+/// this struct would carry the `DefId` of the impl along with the
+/// self type `Foo<u32>`. Then we can instantiate the parameters of
/// the impl (with the substs from `UserSubsts`) and apply those to
-/// the self-type, giving `Foo<?A>`. Finally, we unify that with
-/// the self-type here, which contains `?A` to be `&'static u32`
+/// the self type, giving `Foo<?A>`. Finally, we unify that with
+/// the self type here, which contains `?A` to be `&'static u32`
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
pub struct UserSelfTy<'tcx> {
pub impl_def_id: DefId,
#[derive(Default)]
pub struct TraitImpls {
blanket_impls: Vec<DefId>,
- /// Impls indexed by their simplified self-type, for fast lookup.
+ /// Impls indexed by their simplified self type, for fast lookup.
non_blanket_impls: FxHashMap<fast_reject::SimplifiedType, Vec<DefId>>,
}
}
/// Iterate over every impl that could possibly match the
- /// self-type `self_ty`.
+ /// self type `self_ty`.
pub fn for_each_relevant_impl<F: FnMut(DefId)>(self,
def_id: DefId,
self_ty: Ty<'tcx>,
}
}
- /// Return a vector containing all impls
+ /// Returns a vector containing all impls
pub fn all_impls(self, def_id: DefId) -> Vec<DefId> {
let impls = self.trait_impls_of(def_id);
-//! misc. type-system utilities too small to deserve their own file
+//! Miscellaneous type-system utilities that are too small to deserve their own modules.
use crate::hir::def::Def;
use crate::hir::def_id::DefId;
#[derive(Copy, Clone, Debug)]
pub struct Discr<'tcx> {
- /// bit representation of the discriminant, so `-128i8` is `0xFF_u128`
+ /// Bit representation of the discriminant (e.g., `-128i8` is `0xFF_u128`).
pub val: u128,
pub ty: Ty<'tcx>
}
}
impl<'tcx> Discr<'tcx> {
- /// Adds 1 to the value and wraps around if the maximum for the type is reached
+ /// Adds `1` to the value and wraps around if the maximum for the type is reached.
pub fn wrap_incr<'a, 'gcx>(self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Self {
self.checked_add(tcx, 1).0
}
///
/// Requires that trait definitions have been processed so that we can
/// elaborate predicates and walk supertraits.
- ///
- /// FIXME callers may only have a &[Predicate], not a Vec, so that's
- /// what this code should accept.
+ //
+ // FIXME: callers may only have a `&[Predicate]`, not a `Vec`, so that's
+ // what this code should accept.
pub fn required_region_bounds(self,
erased_self_ty: Ty<'tcx>,
predicates: Vec<ty::Predicate<'tcx>>)
Some(ty::Destructor { did: dtor_did? })
}
- /// Return the set of types that are required to be alive in
+ /// Returns the set of types that are required to be alive in
/// order to run the destructor of `def` (see RFCs 769 and
/// 1238).
///
result
}
- /// True if `def_id` refers to a closure (e.g., `|x| x * 2`). Note
- /// that closures have a def-id, but the closure *expression* also
+ /// Returns `true` if `def_id` refers to a closure (e.g., `|x| x * 2`). Note
+ /// that closures have a `DefId`, but the closure *expression* also
/// has a `HirId` that is located within the context where the
/// closure appears (and, sadly, a corresponding `NodeId`, since
/// those are not yet phased out). The parent of the closure's
- /// def-id will also be the context where it appears.
+ /// `DefId` will also be the context where it appears.
pub fn is_closure(self, def_id: DefId) -> bool {
self.def_key(def_id).disambiguated_data.data == DefPathData::ClosureExpr
}
- /// True if `def_id` refers to a trait (i.e., `trait Foo { ... }`).
+ /// Returns `true` if `def_id` refers to a trait (i.e., `trait Foo { ... }`).
pub fn is_trait(self, def_id: DefId) -> bool {
if let DefPathData::Trait(_) = self.def_key(def_id).disambiguated_data.data {
true
}
}
- /// True if `def_id` refers to a trait alias (i.e., `trait Foo = ...;`).
+ /// Returns `true` if `def_id` refers to a trait alias (i.e., `trait Foo = ...;`),
+ /// and `false` otherwise.
pub fn is_trait_alias(self, def_id: DefId) -> bool {
if let DefPathData::TraitAlias(_) = self.def_key(def_id).disambiguated_data.data {
true
}
}
- /// True if this def-id refers to the implicit constructor for
- /// a tuple struct like `struct Foo(u32)`.
+ /// Returns `true` if this `DefId` refers to the implicit constructor for
+ /// a tuple struct like `struct Foo(u32)`, and `false` otherwise.
pub fn is_struct_constructor(self, def_id: DefId) -> bool {
self.def_key(def_id).disambiguated_data.data == DefPathData::StructCtor
}
/// Given the `DefId` of a fn or closure, returns the `DefId` of
/// the innermost fn item that the closure is contained within.
- /// This is a significant def-id because, when we do
+ /// This is a significant `DefId` because, when we do
/// type-checking, we type-check this fn item and all of its
- /// (transitive) closures together. Therefore, when we fetch the
+ /// (transitive) closures together. Therefore, when we fetch the
/// `typeck_tables_of` the closure, for example, we really wind up
/// fetching the `typeck_tables_of` the enclosing fn item.
pub fn closure_base_def_id(self, def_id: DefId) -> DefId {
def_id
}
- /// Given the def-id and substs a closure, creates the type of
+ /// Given the `DefId` and substs a closure, creates the type of
/// `self` argument that the closure expects. For example, for a
/// `Fn` closure, this would return a reference type `&T` where
- /// `T=closure_ty`.
+ /// `T = closure_ty`.
///
/// Returns `None` if this closure's kind has not yet been inferred.
/// This should only be possible during type checking.
Some(ty::Binder::bind(env_ty))
}
- /// Given the def-id of some item that has no type parameters, make
+ /// Given the `DefId` of some item that has no type parameters, make
/// a suitable "empty substs" for it.
pub fn empty_substs_for_def_id(self, item_def_id: DefId) -> &'tcx Substs<'tcx> {
Substs::for_item(self, item_def_id, |param, _| {
})
}
- /// Return whether the node pointed to by def_id is a static item, and its mutability
+ /// Returns `true` if the node pointed to by `def_id` is a static item, and its mutability.
pub fn is_static(&self, def_id: DefId) -> Option<hir::Mutability> {
if let Some(node) = self.hir().get_if_local(def_id) {
match node {
/// Checks whether values of this type `T` implement the `Freeze`
/// trait -- frozen types are those that do not contain a
- /// `UnsafeCell` anywhere. This is a language concept used to
+ /// `UnsafeCell` anywhere. This is a language concept used to
/// distinguish "true immutability", which is relevant to
/// optimization as well as the rules around static values. Note
/// that the `Freeze` trait is not exposed to end users and is
+use crate::hir;
use crate::hir::def_id::DefId;
use crate::infer::InferCtxt;
use crate::ty::subst::Substs;
use crate::traits;
use crate::ty::{self, ToPredicate, Ty, TyCtxt, TypeFoldable};
use std::iter::once;
-use syntax::ast;
use syntax_pos::Span;
use crate::middle::lang_items;
/// say "$0 is WF if $0 is WF".
pub fn obligations<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
ty: Ty<'tcx>,
span: Span)
-> Option<Vec<traits::PredicateObligation<'tcx>>>
/// if `Bar: Eq`.
pub fn trait_obligations<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
trait_ref: &ty::TraitRef<'tcx>,
span: Span)
-> Vec<traits::PredicateObligation<'tcx>>
pub fn predicate_obligations<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
predicate: &ty::Predicate<'tcx>,
span: Span)
-> Vec<traits::PredicateObligation<'tcx>>
struct WfPredicates<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
span: Span,
out: Vec<traits::PredicateObligation<'tcx>>,
}
}
}
- /// Push new obligations into `out`. Returns true if it was able
+ /// Pushes new obligations into `out`. Returns `true` if it was able
/// to generate all the predicates needed to validate that `ty0`
/// is WF. Returns false if `ty0` is an unresolved type variable,
/// in which case we are not able to simplify at all.
}
}
-/// Given an object type like `SomeTrait+Send`, computes the lifetime
+/// Given an object type like `SomeTrait + Send`, computes the lifetime
/// bounds that must hold on the elided self type. These are derived
/// from the declarations of `SomeTrait`, `Send`, and friends -- if
/// they declare `trait SomeTrait : 'static`, for example, then
/// Parameters to the `Dump` variant of type `ProfileQueriesMsg`.
#[derive(Clone,Debug)]
pub struct ProfQDumpParams {
- /// A base path for the files we will dump
+ /// A base path for the files we will dump.
pub path:String,
- /// To ensure that the compiler waits for us to finish our dumps
+ /// To ensure that the compiler waits for us to finish our dumps.
pub ack:Sender<()>,
- /// toggle dumping a log file with every `ProfileQueriesMsg`
+ /// Toggle dumping a log file with every `ProfileQueriesMsg`.
pub dump_profq_msg_log:bool,
}
TIME_DEPTH.with(|slot| slot.get())
}
-/// Set the current depth of `time()` calls. The idea is to call
+/// Sets the current depth of `time()` calls. The idea is to call
/// `set_time_depth()` with the result from `time_depth()` in the
/// parent thread.
pub fn set_time_depth(depth: usize) {
-//! An efficient hash map for node IDs
+//! An efficient hash map for `NodeId`s.
use crate::hir::def_id::DefId;
use crate::hir::{HirId, ItemLocalId};
/// The "region highlights" are used to control region printing during
/// specific error messages. When a "region highlight" is enabled, it
/// gives an alternate way to print specific regions. For now, we
-/// always print those regions using a number, so something like `'0`.
+/// always print those regions using a number, so something like "`'0`".
///
/// Regions not selected by the region highlight mode are presently
/// unaffected.
#[derive(Copy, Clone, Default)]
pub struct RegionHighlightMode {
- /// If enabled, when we see the selected region, use `"'N"`
+ /// If enabled, when we see the selected region, use "`'N`"
/// instead of the ordinary behavior.
highlight_regions: [Option<(ty::RegionKind, usize)>; 3],
/// If enabled, when printing a "free region" that originated from
- /// the given `ty::BoundRegion`, print it as `'1`. Free regions that would ordinarily
+ /// the given `ty::BoundRegion`, print it as "`'1`". Free regions that would ordinarily
/// have names print as normal.
///
/// This is used when you have a signature like `fn foo(x: &u32,
}
impl RegionHighlightMode {
- /// Read and return current region highlight settings (accesses thread-local state).a
+ /// Reads and returns the current region highlight settings (accesses thread-local state).
pub fn get() -> Self {
REGION_HIGHLIGHT_MODE.with(|c| c.get())
}
- /// Internal helper to update current settings during the execution of `op`.
+ // Internal helper to update current settings during the execution of `op`.
fn set<R>(
old_mode: Self,
new_mode: Self,
})
}
- /// If `region` and `number` are both `Some`, invoke
- /// `highlighting_region`. Otherwise, just invoke `op` directly.
+ /// If `region` and `number` are both `Some`, invokes
+ /// `highlighting_region`; otherwise, just invokes `op` directly.
pub fn maybe_highlighting_region<R>(
region: Option<ty::Region<'_>>,
number: Option<usize>,
op()
}
- /// During the execution of `op`, highlight the region inference
- /// vairable `vid` as `'N`. We can only highlight one region vid
+ /// During the execution of `op`, highlights the region inference
+ /// variable `vid` as `'N`. We can only highlight one region `vid`
/// at a time.
pub fn highlighting_region<R>(
region: ty::Region<'_>,
Self::set(old_mode, new_mode, op)
}
- /// Convenience wrapper for `highlighting_region`
+ /// Convenience wrapper for `highlighting_region`.
pub fn highlighting_region_vid<R>(
vid: ty::RegionVid,
number: usize,
Self::highlighting_region(&ty::ReVar(vid), number, op)
}
- /// Returns true if any placeholders are highlighted.
+ /// Returns `true` if any placeholders are highlighted, and `false` otherwise.
fn any_region_vids_highlighted(&self) -> bool {
Self::get()
.highlight_regions
})
}
- /// Returns `Some(n)` with the number to use for the given region,
- /// if any.
+ /// Returns `Some(n)` with the number to use for the given region, if any.
fn region_highlighted(&self, region: ty::Region<'_>) -> Option<usize> {
Self::get()
.highlight_regions
}
/// During the execution of `op`, highlight the given bound
- /// region. We can only highlight one bound region at a time. See
+ /// region. We can only highlight one bound region at a time. See
/// the field `highlight_bound_region` for more detailed notes.
pub fn highlighting_bound_region<R>(
br: ty::BoundRegion,
)
}
- /// Returns true if any placeholders are highlighted.
+ /// Returns `true` if any placeholders are highlighted, and `false` otherwise.
pub fn any_placeholders_highlighted(&self) -> bool {
Self::get()
.highlight_regions
})
}
- /// Returns `Some(N)` if the placeholder `p` is highlighted to print as `'N`.
+ /// Returns `Some(N)` if the placeholder `p` is highlighted to print as "`'N`".
pub fn placeholder_highlight(&self, p: ty::PlaceholderRegion) -> Option<usize> {
self.region_highlighted(&ty::RePlaceholder(p))
}
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "UpvarId({:?};`{}`;{:?})",
self.var_path.hir_id,
- ty::tls::with(|tcx| tcx.hir().name(tcx.hir().hir_to_node_id(self.var_path.hir_id))),
+ ty::tls::with(|tcx| tcx.hir().name_by_hir_id(self.var_path.hir_id)),
self.closure_expr_id)
}
}
-use crate::session::config::Options;
-
+use std::collections::{BTreeMap, HashMap};
use std::fs;
-use std::io::{self, StderrLock, Write};
+use std::io::{self, Write};
+use std::thread::ThreadId;
use std::time::Instant;
-macro_rules! define_categories {
- ($($name:ident,)*) => {
- #[derive(Clone, Copy, Debug, PartialEq, Eq)]
- pub enum ProfileCategory {
- $($name),*
- }
+use crate::session::config::{Options, OptLevel};
- #[allow(nonstandard_style)]
- struct Categories<T> {
- $($name: T),*
- }
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)]
+pub enum ProfileCategory {
+ Parsing,
+ Expansion,
+ TypeChecking,
+ BorrowChecking,
+ Codegen,
+ Linking,
+ Other,
+}
- impl<T: Default> Categories<T> {
- fn new() -> Categories<T> {
- Categories {
- $($name: T::default()),*
- }
- }
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ProfilerEvent {
+ QueryStart { query_name: &'static str, category: ProfileCategory, time: Instant },
+ QueryEnd { query_name: &'static str, category: ProfileCategory, time: Instant },
+ GenericActivityStart { category: ProfileCategory, time: Instant },
+ GenericActivityEnd { category: ProfileCategory, time: Instant },
+ QueryCacheHit { query_name: &'static str, category: ProfileCategory },
+ QueryCount { query_name: &'static str, category: ProfileCategory, count: usize },
+ IncrementalLoadResultStart { query_name: &'static str, time: Instant },
+ IncrementalLoadResultEnd { query_name: &'static str, time: Instant },
+ QueryBlockedStart { query_name: &'static str, category: ProfileCategory, time: Instant },
+ QueryBlockedEnd { query_name: &'static str, category: ProfileCategory, time: Instant },
+}
+
+impl ProfilerEvent {
+ fn is_start_event(&self) -> bool {
+ use self::ProfilerEvent::*;
+
+ match self {
+ QueryStart { .. } |
+ GenericActivityStart { .. } |
+ IncrementalLoadResultStart { .. } |
+ QueryBlockedStart { .. } => true,
+
+ QueryEnd { .. } |
+ GenericActivityEnd { .. } |
+ QueryCacheHit { .. } |
+ QueryCount { .. } |
+ IncrementalLoadResultEnd { .. } |
+ QueryBlockedEnd { .. } => false,
}
+ }
+}
- impl<T> Categories<T> {
- fn get(&self, category: ProfileCategory) -> &T {
- match category {
- $(ProfileCategory::$name => &self.$name),*
- }
- }
+pub struct SelfProfiler {
+ events: HashMap<ThreadId, Vec<ProfilerEvent>>,
+}
- fn set(&mut self, category: ProfileCategory, value: T) {
- match category {
- $(ProfileCategory::$name => self.$name = value),*
- }
- }
+struct CategoryResultData {
+ query_times: BTreeMap<&'static str, u64>,
+ query_cache_stats: BTreeMap<&'static str, (u64, u64)>, //(hits, total)
+}
+
+impl CategoryResultData {
+ fn new() -> CategoryResultData {
+ CategoryResultData {
+ query_times: BTreeMap::new(),
+ query_cache_stats: BTreeMap::new(),
}
+ }
- struct CategoryData {
- times: Categories<u64>,
- query_counts: Categories<(u64, u64)>,
+ fn total_time(&self) -> u64 {
+ self.query_times.iter().map(|(_, time)| time).sum()
+ }
+
+ fn total_cache_data(&self) -> (u64, u64) {
+ let (mut hits, mut total) = (0, 0);
+
+ for (_, (h, t)) in &self.query_cache_stats {
+ hits += h;
+ total += t;
}
- impl CategoryData {
- fn new() -> CategoryData {
- CategoryData {
- times: Categories::new(),
- query_counts: Categories::new(),
- }
- }
+ (hits, total)
+ }
+}
- fn print(&self, lock: &mut StderrLock<'_>) {
- writeln!(lock, "| Phase | Time (ms) \
- | Time (%) | Queries | Hits (%)")
- .unwrap();
- writeln!(lock, "| ---------------- | -------------- \
- | -------- | -------------- | --------")
- .unwrap();
-
- let total_time = ($(self.times.$name + )* 0) as f32;
-
- $(
- let (hits, computed) = self.query_counts.$name;
- let total = hits + computed;
- let (hits, total) = if total > 0 {
- (format!("{:.2}",
- (((hits as f32) / (total as f32)) * 100.0)), total.to_string())
- } else {
- (String::new(), String::new())
- };
+impl Default for CategoryResultData {
+ fn default() -> CategoryResultData {
+ CategoryResultData::new()
+ }
+}
- writeln!(
- lock,
- "| {0: <16} | {1: <14} | {2: <8.2} | {3: <14} | {4: <8}",
- stringify!($name),
- self.times.$name / 1_000_000,
- ((self.times.$name as f32) / total_time) * 100.0,
- total,
- hits,
- ).unwrap();
- )*
- }
+struct CalculatedResults {
+ categories: BTreeMap<ProfileCategory, CategoryResultData>,
+ crate_name: Option<String>,
+ optimization_level: OptLevel,
+ incremental: bool,
+ verbose: bool,
+}
- fn json(&self) -> String {
- let mut json = String::from("[");
-
- $(
- let (hits, computed) = self.query_counts.$name;
- let total = hits + computed;
-
- //normalize hits to 0%
- let hit_percent =
- if total > 0 {
- ((hits as f32) / (total as f32)) * 100.0
- } else {
- 0.0
- };
-
- json.push_str(&format!(
- "{{ \"category\": \"{}\", \"time_ms\": {},\
- \"query_count\": {}, \"query_hits\": {} }},",
- stringify!($name),
- self.times.$name / 1_000_000,
- total,
- format!("{:.2}", hit_percent)
- ));
- )*
+impl CalculatedResults {
+ fn new() -> CalculatedResults {
+ CalculatedResults {
+ categories: BTreeMap::new(),
+ crate_name: None,
+ optimization_level: OptLevel::No,
+ incremental: false,
+ verbose: false,
+ }
+ }
- //remove the trailing ',' character
- json.pop();
+ fn consolidate(mut cr1: CalculatedResults, cr2: CalculatedResults) -> CalculatedResults {
+ for (category, data) in cr2.categories {
+ let cr1_data = cr1.categories.entry(category).or_default();
- json.push(']');
+ for (query, time) in data.query_times {
+ *cr1_data.query_times.entry(query).or_default() += time;
+ }
- json
+ for (query, (hits, total)) in data.query_cache_stats {
+ let (h, t) = cr1_data.query_cache_stats.entry(query).or_insert((0, 0));
+ *h += hits;
+ *t += total;
}
}
+
+ cr1
+ }
+
+ fn total_time(&self) -> u64 {
+ self.categories.iter().map(|(_, data)| data.total_time()).sum()
+ }
+
+ fn with_options(mut self, opts: &Options) -> CalculatedResults {
+ self.crate_name = opts.crate_name.clone();
+ self.optimization_level = opts.optimize;
+ self.incremental = opts.incremental.is_some();
+ self.verbose = opts.debugging_opts.verbose;
+
+ self
}
}
-define_categories! {
- Parsing,
- Expansion,
- TypeChecking,
- BorrowChecking,
- Codegen,
- Linking,
- Other,
+fn time_between_ns(start: Instant, end: Instant) -> u64 {
+ if start < end {
+ let time = end - start;
+ (time.as_secs() * 1_000_000_000) + (time.subsec_nanos() as u64)
+ } else {
+ debug!("time_between_ns: ignorning instance of end < start");
+ 0
+ }
}
-pub struct SelfProfiler {
- timer_stack: Vec<ProfileCategory>,
- data: CategoryData,
- current_timer: Instant,
+fn calculate_percent(numerator: u64, denominator: u64) -> f32 {
+ if denominator > 0 {
+ ((numerator as f32) / (denominator as f32)) * 100.0
+ } else {
+ 0.0
+ }
}
impl SelfProfiler {
pub fn new() -> SelfProfiler {
let mut profiler = SelfProfiler {
- timer_stack: Vec::new(),
- data: CategoryData::new(),
- current_timer: Instant::now(),
+ events: HashMap::new(),
};
profiler.start_activity(ProfileCategory::Other);
profiler
}
+ #[inline]
pub fn start_activity(&mut self, category: ProfileCategory) {
- match self.timer_stack.last().cloned() {
- None => {
- self.current_timer = Instant::now();
- },
- Some(current_category) if current_category == category => {
- //since the current category is the same as the new activity's category,
- //we don't need to do anything with the timer, we just need to push it on the stack
- }
- Some(current_category) => {
- let elapsed = self.stop_timer();
+ self.record(ProfilerEvent::GenericActivityStart {
+ category,
+ time: Instant::now(),
+ })
+ }
- //record the current category's time
- let new_time = self.data.times.get(current_category) + elapsed;
- self.data.times.set(current_category, new_time);
- }
- }
+ #[inline]
+ pub fn end_activity(&mut self, category: ProfileCategory) {
+ self.record(ProfilerEvent::GenericActivityEnd {
+ category,
+ time: Instant::now(),
+ })
+ }
- //push the new category
- self.timer_stack.push(category);
+ #[inline]
+ pub fn record_computed_queries(
+ &mut self,
+ query_name: &'static str,
+ category: ProfileCategory,
+ count: usize)
+ {
+ self.record(ProfilerEvent::QueryCount {
+ query_name,
+ category,
+ count,
+ })
}
- pub fn record_computed_queries(&mut self, category: ProfileCategory, count: usize) {
- let (hits, computed) = *self.data.query_counts.get(category);
- self.data.query_counts.set(category, (hits, computed + count as u64));
+ #[inline]
+ pub fn record_query_hit(&mut self, query_name: &'static str, category: ProfileCategory) {
+ self.record(ProfilerEvent::QueryCacheHit {
+ query_name,
+ category,
+ })
}
- pub fn record_query_hit(&mut self, category: ProfileCategory) {
- let (hits, computed) = *self.data.query_counts.get(category);
- self.data.query_counts.set(category, (hits + 1, computed));
+ #[inline]
+ pub fn start_query(&mut self, query_name: &'static str, category: ProfileCategory) {
+ self.record(ProfilerEvent::QueryStart {
+ query_name,
+ category,
+ time: Instant::now(),
+ });
}
- pub fn end_activity(&mut self, category: ProfileCategory) {
- match self.timer_stack.pop() {
- None => bug!("end_activity() was called but there was no running activity"),
- Some(c) =>
- assert!(
- c == category,
- "end_activity() was called but a different activity was running"),
+ #[inline]
+ pub fn end_query(&mut self, query_name: &'static str, category: ProfileCategory) {
+ self.record(ProfilerEvent::QueryEnd {
+ query_name,
+ category,
+ time: Instant::now(),
+ })
+ }
+
+ #[inline]
+ pub fn incremental_load_result_start(&mut self, query_name: &'static str) {
+ self.record(ProfilerEvent::IncrementalLoadResultStart {
+ query_name,
+ time: Instant::now(),
+ })
+ }
+
+ #[inline]
+ pub fn incremental_load_result_end(&mut self, query_name: &'static str) {
+ self.record(ProfilerEvent::IncrementalLoadResultEnd {
+ query_name,
+ time: Instant::now(),
+ })
+ }
+
+ #[inline]
+ pub fn query_blocked_start(&mut self, query_name: &'static str, category: ProfileCategory) {
+ self.record(ProfilerEvent::QueryBlockedStart {
+ query_name,
+ category,
+ time: Instant::now(),
+ })
+ }
+
+ #[inline]
+ pub fn query_blocked_end(&mut self, query_name: &'static str, category: ProfileCategory) {
+ self.record(ProfilerEvent::QueryBlockedEnd {
+ query_name,
+ category,
+ time: Instant::now(),
+ })
+ }
+
+ #[inline]
+ fn record(&mut self, event: ProfilerEvent) {
+ let thread_id = std::thread::current().id();
+ let events = self.events.entry(thread_id).or_default();
+
+ events.push(event);
+ }
+
+ fn calculate_thread_results(events: &Vec<ProfilerEvent>) -> CalculatedResults {
+ use self::ProfilerEvent::*;
+
+ assert!(
+ events.last().map(|e| !e.is_start_event()).unwrap_or(true),
+ "there was an event running when calculate_reslts() was called"
+ );
+
+ let mut results = CalculatedResults::new();
+
+ //(event, child time to subtract)
+ let mut query_stack = Vec::new();
+
+ for event in events {
+ match event {
+ QueryStart { .. } | GenericActivityStart { .. } => {
+ query_stack.push((event, 0));
+ },
+ QueryEnd { query_name, category, time: end_time } => {
+ let previous_query = query_stack.pop();
+ if let Some((QueryStart {
+ query_name: p_query_name,
+ time: start_time,
+ category: _ }, child_time_to_subtract)) = previous_query {
+ assert_eq!(
+ p_query_name,
+ query_name,
+ "Saw a query end but the previous query wasn't the corresponding start"
+ );
+
+ let time_ns = time_between_ns(*start_time, *end_time);
+ let self_time_ns = time_ns - child_time_to_subtract;
+ let result_data = results.categories.entry(*category).or_default();
+
+ *result_data.query_times.entry(query_name).or_default() += self_time_ns;
+
+ if let Some((_, child_time_to_subtract)) = query_stack.last_mut() {
+ *child_time_to_subtract += time_ns;
+ }
+ } else {
+ bug!("Saw a query end but the previous event wasn't a query start");
+ }
+ }
+ GenericActivityEnd { category, time: end_time } => {
+ let previous_event = query_stack.pop();
+ if let Some((GenericActivityStart {
+ category: previous_category,
+ time: start_time }, child_time_to_subtract)) = previous_event {
+ assert_eq!(
+ previous_category,
+ category,
+ "Saw an end but the previous event wasn't the corresponding start"
+ );
+
+ let time_ns = time_between_ns(*start_time, *end_time);
+ let self_time_ns = time_ns - child_time_to_subtract;
+ let result_data = results.categories.entry(*category).or_default();
+
+ *result_data.query_times
+ .entry("{time spent not running queries}")
+ .or_default() += self_time_ns;
+
+ if let Some((_, child_time_to_subtract)) = query_stack.last_mut() {
+ *child_time_to_subtract += time_ns;
+ }
+ } else {
+ bug!("Saw an activity end but the previous event wasn't an activity start");
+ }
+ },
+ QueryCacheHit { category, query_name } => {
+ let result_data = results.categories.entry(*category).or_default();
+
+ let (hits, total) =
+ result_data.query_cache_stats.entry(query_name).or_insert((0, 0));
+ *hits += 1;
+ *total += 1;
+ },
+ QueryCount { category, query_name, count } => {
+ let result_data = results.categories.entry(*category).or_default();
+
+ let (_, totals) =
+ result_data.query_cache_stats.entry(query_name).or_insert((0, 0));
+ *totals += *count as u64;
+ },
+ //we don't summarize incremental load result events in the simple output mode
+ IncrementalLoadResultStart { .. } | IncrementalLoadResultEnd { .. } => { },
+ //we don't summarize parallel query blocking in the simple output mode
+ QueryBlockedStart { .. } | QueryBlockedEnd { .. } => { },
+ }
}
- //check if the new running timer is in the same category as this one
- //if it is, we don't need to do anything
- if let Some(c) = self.timer_stack.last() {
- if *c == category {
- return;
+ //normalize the times to ms
+ for (_, data) in &mut results.categories {
+ for (_, time) in &mut data.query_times {
+ *time = *time / 1_000_000;
}
}
- //the new timer is different than the previous,
- //so record the elapsed time and start a new timer
- let elapsed = self.stop_timer();
- let new_time = self.data.times.get(category) + elapsed;
- self.data.times.set(category, new_time);
+ results
}
- fn stop_timer(&mut self) -> u64 {
- let elapsed = self.current_timer.elapsed();
-
- self.current_timer = Instant::now();
-
- (elapsed.as_secs() * 1_000_000_000) + (elapsed.subsec_nanos() as u64)
+ fn get_results(&self, opts: &Options) -> CalculatedResults {
+ self.events
+ .iter()
+ .map(|(_, r)| SelfProfiler::calculate_thread_results(r))
+ .fold(CalculatedResults::new(), CalculatedResults::consolidate)
+ .with_options(opts)
}
pub fn print_results(&mut self, opts: &Options) {
self.end_activity(ProfileCategory::Other);
- assert!(
- self.timer_stack.is_empty(),
- "there were timers running when print_results() was called");
+ let results = self.get_results(opts);
+
+ let total_time = results.total_time() as f32;
let out = io::stderr();
let mut lock = out.lock();
- let crate_name =
- opts.crate_name
- .as_ref()
- .map(|n| format!(" for {}", n))
- .unwrap_or_default();
+ let crate_name = results.crate_name.map(|n| format!(" for {}", n)).unwrap_or_default();
writeln!(lock, "Self profiling results{}:", crate_name).unwrap();
writeln!(lock).unwrap();
- self.data.print(&mut lock);
+ writeln!(lock, "| Phase | Time (ms) \
+ | Time (%) | Queries | Hits (%)")
+ .unwrap();
+ writeln!(lock, "| ----------------------------------------- | -------------- \
+ | -------- | -------------- | --------")
+ .unwrap();
+
+ let mut categories: Vec<_> = results.categories.iter().collect();
+ categories.sort_by_cached_key(|(_, d)| d.total_time());
+
+ for (category, data) in categories.iter().rev() {
+ let (category_hits, category_total) = data.total_cache_data();
+ let category_hit_percent = calculate_percent(category_hits, category_total);
+
+ writeln!(
+ lock,
+ "| {0: <41} | {1: >14} | {2: >8.2} | {3: >14} | {4: >8}",
+ format!("{:?}", category),
+ data.total_time(),
+ ((data.total_time() as f32) / total_time) * 100.0,
+ category_total,
+ format!("{:.2}", category_hit_percent),
+ ).unwrap();
+
+ //in verbose mode, show individual query data
+ if results.verbose {
+ //don't show queries that took less than 1ms
+ let mut times: Vec<_> = data.query_times.iter().filter(|(_, t)| **t > 0).collect();
+ times.sort_by(|(_, time1), (_, time2)| time2.cmp(time1));
+
+ for (query, time) in times {
+ let (hits, total) = data.query_cache_stats.get(query).unwrap_or(&(0, 0));
+ let hit_percent = calculate_percent(*hits, *total);
+
+ writeln!(
+ lock,
+ "| - {0: <39} | {1: >14} | {2: >8.2} | {3: >14} | {4: >8}",
+ query,
+ time,
+ ((*time as f32) / total_time) * 100.0,
+ total,
+ format!("{:.2}", hit_percent),
+ ).unwrap();
+ }
+ }
+ }
writeln!(lock).unwrap();
writeln!(lock, "Optimization level: {:?}", opts.optimize).unwrap();
-
- let incremental = if opts.incremental.is_some() { "on" } else { "off" };
- writeln!(lock, "Incremental: {}", incremental).unwrap();
+ writeln!(lock, "Incremental: {}", if results.incremental { "on" } else { "off" }).unwrap();
}
pub fn save_results(&self, opts: &Options) {
- let category_data = self.data.json();
+ let results = self.get_results(opts);
+
let compilation_options =
format!("{{ \"optimization_level\": \"{:?}\", \"incremental\": {} }}",
- opts.optimize,
- if opts.incremental.is_some() { "true" } else { "false" });
+ results.optimization_level,
+ if results.incremental { "true" } else { "false" });
+
+ let mut category_data = String::new();
+
+ for (category, data) in &results.categories {
+ let (hits, total) = data.total_cache_data();
+ let hit_percent = calculate_percent(hits, total);
+
+ category_data.push_str(&format!("{{ \"category\": \"{:?}\", \"time_ms\": {}, \
+ \"query_count\": {}, \"query_hits\": {} }}",
+ category,
+ data.total_time(),
+ total,
+ format!("{:.2}", hit_percent)));
+ }
let json = format!("{{ \"category_data\": {}, \"compilation_options\": {} }}",
category_data,
authors = ["The Rust Project Developers"]
name = "rustc_allocator"
version = "0.0.0"
+edition = "2018"
[lib]
path = "lib.rs"
+use log::debug;
use rustc::middle::allocator::AllocatorKind;
-use rustc_errors;
-use smallvec::SmallVec;
+use smallvec::{smallvec, SmallVec};
use syntax::{
ast::{
self, Arg, Attribute, Crate, Expr, FnHeader, Generics, Ident, Item, ItemKind,
};
use syntax_pos::Span;
-use {AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS};
+use crate::{AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS};
pub fn modify(
sess: &ParseSess,
in_submod: isize,
}
-impl<'a> MutVisitor for ExpandAllocatorDirectives<'a> {
+impl MutVisitor for ExpandAllocatorDirectives<'_> {
fn flat_map_item(&mut self, item: P<Item>) -> SmallVec<[P<Item>; 1]> {
debug!("in submodule {}", self.in_submod);
call_site: item.span, // use the call site of the static
def_site: None,
format: MacroAttribute(Symbol::intern(name)),
- allow_internal_unstable: true,
+ allow_internal_unstable: Some(vec![
+ Symbol::intern("rustc_attrs"),
+ ].into()),
allow_internal_unsafe: false,
local_inner_macros: false,
edition: hygiene::default_edition(),
cx: ExtCtxt<'a>,
}
-impl<'a> AllocFnFactory<'a> {
+impl AllocFnFactory<'_> {
fn allocator_fn(&self, method: &AllocatorMethod) -> P<Item> {
let mut abi_args = Vec::new();
let mut i = 0;
#![feature(nll)]
#![feature(rustc_private)]
-#[macro_use] extern crate log;
-extern crate rustc;
-extern crate rustc_data_structures;
-extern crate rustc_errors;
-extern crate rustc_target;
-extern crate syntax;
-extern crate syntax_pos;
-#[macro_use]
-extern crate smallvec;
+#![deny(rust_2018_idioms)]
pub mod expand;
/// exponent = all 1's, integer bit 0, significand 0 ("pseudoinfinity")
/// exponent = all 1's, integer bit 0, significand nonzero ("pseudoNaN")
/// exponent = 0, integer bit 1 ("pseudodenormal")
- /// exponent!=0 nor all 1's, integer bit 0 ("unnormal")
+ /// exponent != 0 nor all 1's, integer bit 0 ("unnormal")
/// At the moment, the first two are treated as NaNs, the second two as Normal.
fn from_bits(bits: u128) -> IeeeFloat<Self> {
let sign = bits & (1 << (Self::BITS - 1));
}
}
- /// Returns TRUE if, when truncating the current number, with BIT the
+ /// Returns `true` if, when truncating the current number, with `bit` the
/// new LSB, with the given lost fraction and rounding mode, the result
/// would need to be rounded away from zero (i.e., by increasing the
- /// signficand). This routine must work for Category::Zero of both signs, and
- /// Category::Normal numbers.
+ /// signficand). This routine must work for `Category::Zero` of both signs, and
+ /// `Category::Normal` numbers.
fn round_away_from_zero(&self, round: Round, loss: Loss, bit: usize) -> bool {
// NaNs and infinities should not have lost fractions.
assert!(self.is_finite_non_zero() || self.is_zero());
more_significant
}
- /// Return the fraction lost were a bignum truncated losing the least
+ /// Returns the fraction lost were a bignum truncated losing the least
/// significant `bits` bits.
fn through_truncation(limbs: &[Limb], bits: usize) -> Loss {
if bits == 0 {
Ordering::Equal
}
- /// Extract the given bit.
+ /// Extracts the given bit.
pub(super) fn get_bit(limbs: &[Limb], bit: usize) -> bool {
limbs[bit / LIMB_BITS] & (1 << (bit % LIMB_BITS)) != 0
}
- /// Set the given bit.
+ /// Sets the given bit.
pub(super) fn set_bit(limbs: &mut [Limb], bit: usize) {
limbs[bit / LIMB_BITS] |= 1 << (bit % LIMB_BITS);
}
limbs[bit / LIMB_BITS] &= !(1 << (bit % LIMB_BITS));
}
- /// Shift `dst` left `bits` bits, subtract `bits` from its exponent.
+ /// Shifts `dst` left `bits` bits, subtract `bits` from its exponent.
pub(super) fn shift_left(dst: &mut [Limb], exp: &mut ExpInt, bits: usize) {
if bits > 0 {
// Our exponent should not underflow.
}
}
- /// Shift `dst` right `bits` bits noting lost fraction.
+ /// Shifts `dst` right `bits` bits noting lost fraction.
pub(super) fn shift_right(dst: &mut [Limb], exp: &mut ExpInt, bits: usize) -> Loss {
let loss = Loss::through_truncation(dst, bits);
loss
}
- /// Copy the bit vector of width `src_bits` from `src`, starting at bit SRC_LSB,
+ /// Copies the bit vector of width `src_bits` from `src`, starting at bit SRC_LSB,
/// to `dst`, such that the bit SRC_LSB becomes the least significant bit of `dst`.
/// All high bits above `src_bits` in `dst` are zero-filled.
pub(super) fn extract(dst: &mut [Limb], src: &[Limb], src_bits: usize, src_lsb: usize) {
#![forbid(unsafe_code)]
#![deny(rust_2018_idioms)]
+#![feature(nll)]
#![feature(try_from)]
// See librustc_cratesio_shim/Cargo.toml for a comment explaining this.
#[allow(unused_extern_crates)]
fn from_str_r(s: &str, round: Round) -> Result<StatusAnd<Self>, ParseError>;
fn to_bits(self) -> u128;
- /// Convert a floating point number to an integer according to the
+ /// Converts a floating point number to an integer according to the
/// rounding mode. In case of an invalid operation exception,
/// deterministic values are returned, namely zero for NaNs and the
/// minimal or maximal value respectively for underflow or overflow.
///
/// The *is_exact output tells whether the result is exact, in the sense
/// that converting it back to the original floating point type produces
- /// the original value. This is almost equivalent to result==Status::OK,
+ /// the original value. This is almost equivalent to `result == Status::OK`,
/// except for negative zeroes.
fn to_i128_r(self, width: usize, round: Round, is_exact: &mut bool) -> StatusAnd<i128> {
let status;
}
}
- /// IEEE-754R isSignMinus: Returns true if and only if the current value is
+ /// IEEE-754R isSignMinus: Returns whether the current value is
/// negative.
///
/// This applies to zeros and NaNs as well.
fn is_negative(self) -> bool;
- /// IEEE-754R isNormal: Returns true if and only if the current value is normal.
+ /// IEEE-754R isNormal: Returns whether the current value is normal.
///
/// This implies that the current value of the float is not zero, subnormal,
/// infinite, or NaN following the definition of normality from IEEE-754R.
!self.is_denormal() && self.is_finite_non_zero()
}
- /// Returns true if and only if the current value is zero, subnormal, or
+ /// Returns `true` if the current value is zero, subnormal, or
/// normal.
///
/// This means that the value is not infinite or NaN.
!self.is_nan() && !self.is_infinite()
}
- /// Returns true if and only if the float is plus or minus zero.
+ /// Returns `true` if the float is plus or minus zero.
fn is_zero(self) -> bool {
self.category() == Category::Zero
}
- /// IEEE-754R isSubnormal(): Returns true if and only if the float is a
+ /// IEEE-754R isSubnormal(): Returns whether the float is a
/// denormal.
fn is_denormal(self) -> bool;
- /// IEEE-754R isInfinite(): Returns true if and only if the float is infinity.
+ /// IEEE-754R isInfinite(): Returns whether the float is infinity.
fn is_infinite(self) -> bool {
self.category() == Category::Infinity
}
- /// Returns true if and only if the float is a quiet or signaling NaN.
+ /// Returns `true` if the float is a quiet or signaling NaN.
fn is_nan(self) -> bool {
self.category() == Category::NaN
}
- /// Returns true if and only if the float is a signaling NaN.
+ /// Returns `true` if the float is a signaling NaN.
fn is_signaling(self) -> bool;
// Simple Queries
self.is_zero() && self.is_negative()
}
- /// Returns true if and only if the number has the smallest possible non-zero
+ /// Returns `true` if the number has the smallest possible non-zero
/// magnitude in the current semantics.
fn is_smallest(self) -> bool {
Self::SMALLEST.copy_sign(self).bitwise_eq(self)
}
- /// Returns true if and only if the number has the largest possible finite
+ /// Returns `true` if the number has the largest possible finite
/// magnitude in the current semantics.
fn is_largest(self) -> bool {
Self::largest().copy_sign(self).bitwise_eq(self)
}
- /// Returns true if and only if the number is an exact integer.
+ /// Returns `true` if the number is an exact integer.
fn is_integer(self) -> bool {
// This could be made more efficient; I'm going for obviously correct.
if !self.is_finite() {
}
pub trait FloatConvert<T: Float>: Float {
- /// Convert a value of one floating point type to another.
+ /// Converts a value of one floating point type to another.
/// The return value corresponds to the IEEE754 exceptions. *loses_info
/// records whether the transformation lost information, i.e., whether
/// converting the result back to the original type will produce the
- /// original value (this is almost the same as return value==Status::OK,
+ /// original value (this is almost the same as return `value == Status::OK`,
/// but there are edge cases where this is not so).
fn convert_r(self, round: Round, loses_info: &mut bool) -> StatusAnd<T>;
fn convert(self, loses_info: &mut bool) -> StatusAnd<T> {
#![sanitizer_runtime]
+#![feature(nll)]
#![feature(sanitizer_runtime)]
#![feature(staged_api)]
#![no_std]
authors = ["The Rust Project Developers"]
name = "rustc_borrowck"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_borrowck"
log = "0.4"
syntax = { path = "../libsyntax" }
syntax_pos = { path = "../libsyntax_pos" }
-graphviz = { path = "../libgraphviz" }
+# for "clarity", rename the graphviz crate to dot; graphviz within `borrowck`
+# refers to the borrowck-specific graphviz adapter traits.
+dot = { path = "../libgraphviz", package = "graphviz" }
rustc = { path = "../librustc" }
rustc_mir = { path = "../librustc_mir" }
-rustc_errors = { path = "../librustc_errors" }
-rustc_data_structures = { path = "../librustc_data_structures" }
\ No newline at end of file
+errors = { path = "../librustc_errors", package = "rustc_errors" }
+rustc_data_structures = { path = "../librustc_data_structures" }
// 3. assignments do not affect things loaned out as immutable
// 4. moves do not affect things loaned out in any way
-use self::UseError::*;
+use UseError::*;
-use borrowck::*;
-use borrowck::InteriorKind::{InteriorElement, InteriorField};
+use crate::borrowck::*;
+use crate::borrowck::InteriorKind::{InteriorElement, InteriorField};
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::expr_use_visitor::MutateMode;
use rustc::middle::mem_categorization as mc;
use rustc::hir;
use rustc::hir::Node;
use rustc_mir::util::borrowck_errors::{BorrowckErrors, Origin};
+use log::debug;
use std::rc::Rc;
fn matched_pat(&mut self,
_matched_pat: &hir::Pat,
- _cmt: &mc::cmt_,
+ _cmt: &mc::cmt_<'_>,
_mode: euv::MatchMode) { }
fn consume_pat(&mut self,
{
//! Iterates over each loan that has been issued
//! on entrance to `node`, regardless of whether it is
- //! actually *in scope* at that point. Sometimes loans
+ //! actually *in scope* at that point. Sometimes loans
//! are issued for future scopes and thus they may have been
//! *issued* but not yet be in effect.
pub fn report_illegal_mutation(&self,
span: Span,
loan_path: &LoanPath<'tcx>,
- loan: &Loan) {
+ loan: &Loan<'_>) {
self.bccx.cannot_assign_to_borrowed(
span, loan.span, &self.bccx.loan_path_to_string(loan_path), Origin::Ast)
.emit();
//! Computes moves.
-use borrowck::*;
-use borrowck::gather_loans::move_error::MovePlace;
-use borrowck::gather_loans::move_error::{MoveError, MoveErrorCollector};
-use borrowck::move_data::*;
+use crate::borrowck::*;
+use crate::borrowck::gather_loans::move_error::MovePlace;
+use crate::borrowck::gather_loans::move_error::{MoveError, MoveErrorCollector};
+use crate::borrowck::move_data::*;
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization::Categorization;
use syntax_pos::Span;
use rustc::hir::*;
use rustc::hir::Node;
+use log::debug;
struct GatherMoveInfo<'c, 'tcx: 'c> {
id: hir::ItemLocalId,
//! This module implements the check that the lifetime of a borrow
//! does not exceed the lifetime of the value being borrowed.
-use borrowck::*;
+use crate::borrowck::*;
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization::Categorization;
use syntax::ast;
use syntax_pos::Span;
+use log::debug;
type R = Result<(),()>;
impl<'a, 'tcx> GuaranteeLifetimeContext<'a, 'tcx> {
fn check(&self, cmt: &mc::cmt_<'tcx>, discr_scope: Option<ast::NodeId>) -> R {
//! Main routine. Walks down `cmt` until we find the
- //! "guarantor". Reports an error if `self.loan_region` is
+ //! "guarantor". Reports an error if `self.loan_region` is
//! larger than scope of `cmt`.
debug!("guarantee_lifetime.check(cmt={:?}, loan_region={:?})",
cmt,
// their associated scopes. In phase two, checking loans, we will then make
// sure that all of these loans are honored.
-use borrowck::*;
-use borrowck::move_data::MoveData;
+use crate::borrowck::*;
+use crate::borrowck::move_data::MoveData;
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization::Categorization;
use syntax::ast;
use syntax_pos::Span;
use rustc::hir;
+use log::debug;
-use self::restrictions::RestrictionResult;
+use restrictions::RestrictionResult;
mod lifetime;
mod restrictions;
fn decl_without_init(&mut self, id: ast::NodeId, _span: Span) {
let ty = self.bccx
.tables
- .node_id_to_type(self.bccx.tcx.hir().node_to_hir_id(id));
+ .node_type(self.bccx.tcx.hir().node_to_hir_id(id));
gather_moves::gather_decl(self.bccx, &self.move_data, id, ty);
}
}
}
/// Guarantees that `addr_of(cmt)` will be valid for the duration of `static_scope_r`, or
- /// reports an error. This may entail taking out loans, which will be added to the
+ /// reports an error. This may entail taking out loans, which will be added to the
/// `req_loan_map`.
fn guarantee_valid(&mut self,
borrow_id: hir::ItemLocalId,
// }
}
- pub fn mark_loan_path_as_mutated(&self, loan_path: &LoanPath) {
+ pub fn mark_loan_path_as_mutated(&self, loan_path: &LoanPath<'_>) {
//! For mutable loans of content whose mutability derives
//! from a local variable, mark the mutability decl as necessary.
-use borrowck::BorrowckCtxt;
+use crate::borrowck::BorrowckCtxt;
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization::Categorization;
use rustc::middle::mem_categorization::NoteClosureEnv;
use syntax::ast;
use syntax_pos;
use errors::{DiagnosticBuilder, Applicability};
-use borrowck::gather_loans::gather_moves::PatternSource;
+use crate::borrowck::gather_loans::gather_moves::PatternSource;
+use log::debug;
pub struct MoveErrorCollector<'tcx> {
errors: Vec<MoveError<'tcx>>
}
}
-fn note_move_destination(mut err: DiagnosticBuilder,
+fn note_move_destination(mut err: DiagnosticBuilder<'_>,
move_to_span: syntax_pos::Span,
pat_name: ast::Name,
- is_first_note: bool) -> DiagnosticBuilder {
+ is_first_note: bool) -> DiagnosticBuilder<'_> {
if is_first_note {
err.span_label(
move_to_span,
//! Computes the restrictions that result from a borrow.
-use borrowck::*;
+use crate::borrowck::*;
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization::Categorization;
use rustc::ty;
use syntax_pos::Span;
+use log::debug;
-use borrowck::ToInteriorKind;
+use crate::borrowck::ToInteriorKind;
use std::rc::Rc;
#![allow(non_camel_case_types)]
-pub use self::LoanPathKind::*;
-pub use self::LoanPathElem::*;
-pub use self::bckerr_code::*;
-pub use self::AliasableViolationKind::*;
-pub use self::MovedValueUseKind::*;
+pub use LoanPathKind::*;
+pub use LoanPathElem::*;
+pub use bckerr_code::*;
+pub use AliasableViolationKind::*;
+pub use MovedValueUseKind::*;
-use self::InteriorKind::*;
+use InteriorKind::*;
use rustc::hir::HirId;
use rustc::hir::Node;
use syntax::ast;
use syntax_pos::{MultiSpan, Span};
use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
+use log::debug;
use rustc::hir;
-use dataflow::{DataFlowContext, BitwiseOperator, DataFlowOperator, KillFrom};
+use crate::dataflow::{DataFlowContext, BitwiseOperator, DataFlowOperator, KillFrom};
pub mod check_loans;
});
}
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
*providers = Providers {
borrowck,
..*providers
/// gen_scope indicates where loan is introduced. Typically the
/// loan is introduced at the point of the borrow, but in some
/// cases, notably method arguments, the loan may be introduced
- /// only later, once it comes into scope. See also
+ /// only later, once it comes into scope. See also
/// `GatherLoanCtxt::compute_gen_scope`.
gen_scope: region::Scope,
- /// kill_scope indicates when the loan goes out of scope. This is
+ /// kill_scope indicates when the loan goes out of scope. This is
/// either when the lifetime expires or when the local variable
/// which roots the loan-path goes out of scope, whichever happens
/// faster. See also `GatherLoanCtxt::compute_kill_scope`.
}
fn closure_to_block(closure_id: LocalDefId,
- tcx: TyCtxt) -> ast::NodeId {
+ tcx: TyCtxt<'_, '_, '_>) -> ast::NodeId {
let closure_id = tcx.hir().local_def_id_to_node_id(closure_id);
match tcx.hir().get(closure_id) {
Node::Expr(expr) => match expr.node {
hir::ExprKind::Closure(.., body_id, _, _) => {
- body_id.node_id
+ tcx.hir().hir_to_node_id(body_id.hir_id)
}
_ => {
bug!("encountered non-closure id: {}", closure_id)
}
fn note_immutability_blame(&self,
- db: &mut DiagnosticBuilder,
- blame: Option<ImmutabilityBlame>,
+ db: &mut DiagnosticBuilder<'_>,
+ blame: Option<ImmutabilityBlame<'_>>,
error_node_id: ast::NodeId) {
match blame {
None => {}
// binding: either to make the binding mutable (if its type is
// not a mutable reference) or to avoid borrowing altogether
fn note_immutable_local(&self,
- db: &mut DiagnosticBuilder,
+ db: &mut DiagnosticBuilder<'_>,
borrowed_node_id: ast::NodeId,
binding_node_id: ast::NodeId) {
let let_span = self.tcx.hir().span(binding_node_id);
}
}
- fn note_and_explain_mutbl_error(&self, db: &mut DiagnosticBuilder, err: &BckError<'a, 'tcx>,
+ fn note_and_explain_mutbl_error(&self, db: &mut DiagnosticBuilder<'_>, err: &BckError<'a, 'tcx>,
error_span: &Span) {
match err.cmt.note {
mc::NoteClosureEnv(upvar_id) | mc::NoteUpvarRef(upvar_id) => {
}
impl<'tcx> fmt::Debug for InteriorKind {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
InteriorField(mc::FieldIndex(_, info)) => write!(f, "{}", info),
InteriorElement => write!(f, "[]"),
}
impl<'tcx> fmt::Debug for Loan<'tcx> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Loan_{}({:?}, {:?}, {:?}-{:?}, {:?})",
self.index,
self.loan_path,
}
impl<'tcx> fmt::Debug for LoanPath<'tcx> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.kind {
LpVar(id) => {
write!(f, "$({})", ty::tls::with(|tcx| tcx.hir().node_to_string(id)))
}
impl<'tcx> fmt::Display for LoanPath<'tcx> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.kind {
LpVar(id) => {
write!(f, "$({})", ty::tls::with(|tcx| tcx.hir().node_to_user_string(id)))
//! Data structures used for tracking moves. Please see the extensive
//! comments in the section "Moves and initialization" in `README.md`.
-pub use self::MoveKind::*;
+pub use MoveKind::*;
-use dataflow::{DataFlowContext, BitwiseOperator, DataFlowOperator, KillFrom};
+use crate::dataflow::{DataFlowContext, BitwiseOperator, DataFlowOperator, KillFrom};
-use borrowck::*;
+use crate::borrowck::*;
use rustc::cfg;
use rustc::ty::{self, TyCtxt};
use rustc::util::nodemap::FxHashMap;
use std::usize;
use syntax_pos::Span;
use rustc::hir;
+use log::debug;
#[derive(Default)]
pub struct MoveData<'tcx> {
/// Path being moved.
pub path: MovePathIndex,
- /// id of node that is doing the move.
+ /// ID of node that is doing the move.
pub id: hir::ItemLocalId,
/// Kind of move, for error messages.
/// Path being assigned.
pub path: MovePathIndex,
- /// id where assignment occurs
+ /// ID where assignment occurs
pub id: hir::ItemLocalId,
/// span of node where assignment occurs
pub type AssignDataFlow<'a, 'tcx> = DataFlowContext<'a, 'tcx, AssignDataFlowOperator>;
-fn loan_path_is_precise(loan_path: &LoanPath) -> bool {
+fn loan_path_is_precise(loan_path: &LoanPath<'_>) -> bool {
match loan_path.kind {
LpVar(_) | LpUpvar(_) => {
true
}
impl<'a, 'tcx> MoveData<'tcx> {
- /// return true if there are no trackable assignments or moves
- /// in this move data - that means that there is nothing that
+ /// Returns `true` if there are no trackable assignments or moves
+ /// in this move data -- that means that there is nothing that
/// could cause a borrow error.
pub fn is_empty(&self) -> bool {
self.moves.borrow().is_empty() &&
/// killed by scoping. See `README.md` for more details.
fn add_gen_kills(&self,
bccx: &BorrowckCtxt<'a, 'tcx>,
- dfcx_moves: &mut MoveDataFlow,
- dfcx_assign: &mut AssignDataFlow) {
+ dfcx_moves: &mut MoveDataFlow<'_, '_>,
+ dfcx_assign: &mut AssignDataFlow<'_, '_>) {
for (i, the_move) in self.moves.borrow().iter().enumerate() {
dfcx_moves.add_gen(the_move.id, i);
}
path: MovePathIndex,
kill_id: hir::ItemLocalId,
kill_kind: KillFrom,
- dfcx_moves: &mut MoveDataFlow) {
+ dfcx_moves: &mut MoveDataFlow<'_, '_>) {
// We can only perform kills for paths that refer to a unique location,
// since otherwise we may kill a move from one location with an
// assignment referring to another location.
use std::slice;
use syntax::ptr::P;
-use borrowck::BorrowckCtxt;
+use crate::borrowck::BorrowckCtxt;
pub fn check<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, body: &'tcx hir::Body) {
let mut used_mut = bccx.used_mut_nodes.borrow().clone();
use std::mem;
use std::usize;
use syntax::print::pprust::PrintState;
+use log::debug;
use rustc_data_structures::graph::implementation::OUTGOING;
fn initial_value(&self) -> bool;
}
-struct PropagationContext<'a, 'b: 'a, 'tcx: 'b, O: 'a> {
+struct PropagationContext<'a, 'b: 'a, 'tcx: 'b, O> {
dfcx: &'a mut DataFlowContext<'b, 'tcx, O>,
changed: bool
}
}
impl<'a, 'tcx, O:DataFlowOperator> pprust::PpAnn for DataFlowContext<'a, 'tcx, O> {
- fn nested(&self, state: &mut pprust::State, nested: pprust::Nested) -> io::Result<()> {
+ fn nested(&self, state: &mut pprust::State<'_>, nested: pprust::Nested) -> io::Result<()> {
pprust::PpAnn::nested(self.tcx.hir(), state, nested)
}
fn pre(&self,
- ps: &mut pprust::State,
- node: pprust::AnnNode) -> io::Result<()> {
+ ps: &mut pprust::State<'_>,
+ node: pprust::AnnNode<'_>) -> io::Result<()> {
let id = match node {
pprust::AnnNode::Name(_) => return Ok(()),
pprust::AnnNode::Expr(expr) => expr.hir_id.local_id,
return index;
- /// Add mappings from the ast nodes for the formal bindings to
+ /// Adds mappings from the ast nodes for the formal bindings to
/// the entry-node in the graph.
fn add_entries_from_fn_body(index: &mut FxHashMap<hir::ItemLocalId, Vec<CFGIndex>>,
body: &hir::Body,
//! libgraphviz traits, specialized to attaching borrowck analysis
//! data to rendered labels.
-pub use self::Variant::*;
+pub use Variant::*;
pub use rustc::cfg::graphviz::{Node, Edge};
use rustc::cfg::graphviz as cfg_dot;
-use borrowck;
-use borrowck::{BorrowckCtxt, LoanPath};
-use dot;
+use crate::borrowck::{self, BorrowckCtxt, LoanPath};
+use crate::dataflow::{DataFlowOperator, DataFlowContext, EntryOrExit};
+use log::debug;
use rustc::cfg::CFGIndex;
-use dataflow::{DataFlowOperator, DataFlowContext, EntryOrExit};
use std::rc::Rc;
#[derive(Debug, Copy, Clone)]
sets
}
- fn dataflow_for_variant(&self, e: EntryOrExit, n: &Node, v: Variant) -> String {
+ fn dataflow_for_variant(&self, e: EntryOrExit, n: &Node<'_>, v: Variant) -> String {
let cfgidx = n.0;
match v {
Loans => self.dataflow_loans_for(e, cfgidx),
let dfcx = &self.analysis_data.loans;
let loan_index_to_path = |loan_index| {
let all_loans = &self.analysis_data.all_loans;
- let l: &borrowck::Loan = &all_loans[loan_index];
+ let l: &borrowck::Loan<'_> = &all_loans[loan_index];
l.loan_path()
};
self.build_set(e, cfgidx, dfcx, loan_index_to_path)
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
#![allow(non_camel_case_types)]
+#![deny(rust_2018_idioms)]
#![feature(nll)]
#![recursion_limit="256"]
-#[macro_use] extern crate log;
-extern crate syntax;
-extern crate syntax_pos;
-extern crate rustc_errors as errors;
-extern crate rustc_data_structures;
-
-// for "clarity", rename the graphviz crate to dot; graphviz within `borrowck`
-// refers to the borrowck-specific graphviz adapter traits.
-extern crate graphviz as dot;
#[macro_use]
extern crate rustc;
-extern crate rustc_mir;
pub use borrowck::check_crate;
pub use borrowck::build_borrowck_dataflow_data_for_fn;
}
impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
- /// Get the LLVM type for a place of the original Rust type of
+ /// Gets the LLVM type for a place of the original Rust type of
/// this argument/return, i.e., the result of `type_of::type_of`.
fn memory_ty(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type {
self.layout.llvm_type(cx)
}
- /// Store a direct/indirect value described by this ArgType into a
+ /// Stores a direct/indirect value described by this ArgType into a
/// place for the original Rust type of this argument/return.
/// Can be used for both storing formal arguments into Rust variables
/// or results of call/invoke instructions into their destinations.
}
impl<'a> ArchiveBuilder<'a> {
- /// Create a new static archive, ready for modifying the archive specified
+ /// Creates a new static archive, ready for modifying the archive specified
/// by `config`.
pub fn new(config: ArchiveConfig<'a>) -> ArchiveBuilder<'a> {
ArchiveBuilder {
out_filename, check_file_is_writeable};
-/// Perform the linkage portion of the compilation phase. This will generate all
+/// Performs the linkage portion of the compilation phase. This will generate all
/// of the requested outputs for this compilation session.
pub(crate) fn link_binary(sess: &Session,
codegen_results: &CodegenResults,
codegen_results: &CodegenResults) {
// Linker plugins should be specified early in the list of arguments
- cmd.cross_lang_lto();
+ cmd.linker_plugin_lto();
// The default library location, we need this to find the runtime.
// The location of crates will be determined as needed.
Lto::Thin => {
// If we defer LTO to the linker, we haven't run LTO ourselves, so
// any upstream object files have not been copied yet.
- !sess.opts.debugging_opts.cross_lang_lto.enabled()
+ !sess.opts.cg.linker_plugin_lto.enabled()
}
Lto::No |
Lto::ThinLocal => false,
use back::bytecode::{DecodedBytecode, RLIB_BYTECODE_EXTENSION};
use rustc_codegen_ssa::back::symbol_export;
-use rustc_codegen_ssa::back::write::{ModuleConfig, CodegenContext, pre_lto_bitcode_filename};
+use rustc_codegen_ssa::back::write::{ModuleConfig, CodegenContext, FatLTOInput};
use rustc_codegen_ssa::back::lto::{SerializedModule, LtoModuleCodegen, ThinShared, ThinModule};
use rustc_codegen_ssa::traits::*;
use back::write::{self, DiagnosticHandlers, with_llvm_pmb, save_temp_bitcode, to_llvm_opt_settings};
use libc;
use std::ffi::{CStr, CString};
-use std::fs;
use std::ptr;
use std::slice;
use std::sync::Arc;
/// Performs fat LTO by merging all modules into a single one and returning it
/// for further optimization.
pub(crate) fn run_fat(cgcx: &CodegenContext<LlvmCodegenBackend>,
- modules: Vec<ModuleCodegen<ModuleLlvm>>,
+ modules: Vec<FatLTOInput<LlvmCodegenBackend>>,
+ cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
timeline: &mut Timeline)
-> Result<LtoModuleCodegen<LlvmCodegenBackend>, FatalError>
{
let symbol_white_list = symbol_white_list.iter()
.map(|c| c.as_ptr())
.collect::<Vec<_>>();
- fat_lto(cgcx, &diag_handler, modules, upstream_modules, &symbol_white_list, timeline)
+ fat_lto(
+ cgcx,
+ &diag_handler,
+ modules,
+ cached_modules,
+ upstream_modules,
+ &symbol_white_list,
+ timeline,
+ )
}
/// Performs thin LTO by performing necessary global analysis and returning two
let symbol_white_list = symbol_white_list.iter()
.map(|c| c.as_ptr())
.collect::<Vec<_>>();
- if cgcx.opts.debugging_opts.cross_lang_lto.enabled() {
+ if cgcx.opts.cg.linker_plugin_lto.enabled() {
unreachable!("We should never reach this case if the LTO step \
is deferred to the linker");
}
}
pub(crate) fn prepare_thin(
- cgcx: &CodegenContext<LlvmCodegenBackend>,
module: ModuleCodegen<ModuleLlvm>
) -> (String, ThinBuffer) {
let name = module.name.clone();
let buffer = ThinBuffer::new(module.module_llvm.llmod());
-
- // We emit the module after having serialized it into a ThinBuffer
- // because only then it will contain the ThinLTO module summary.
- if let Some(ref incr_comp_session_dir) = cgcx.incr_comp_session_dir {
- if cgcx.config(module.kind).emit_pre_thin_lto_bc {
- let path = incr_comp_session_dir
- .join(pre_lto_bitcode_filename(&name));
-
- fs::write(&path, buffer.data()).unwrap_or_else(|e| {
- panic!("Error writing pre-lto-bitcode file `{}`: {}",
- path.display(),
- e);
- });
- }
- }
-
(name, buffer)
}
fn fat_lto(cgcx: &CodegenContext<LlvmCodegenBackend>,
diag_handler: &Handler,
- mut modules: Vec<ModuleCodegen<ModuleLlvm>>,
+ mut modules: Vec<FatLTOInput<LlvmCodegenBackend>>,
+ cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
symbol_white_list: &[*const libc::c_char],
timeline: &mut Timeline)
// file copy operations in the backend work correctly. The only other kind
// of module here should be an allocator one, and if your crate is smaller
// than the allocator module then the size doesn't really matter anyway.
- let (_, costliest_module) = modules.iter()
+ let costliest_module = modules.iter()
.enumerate()
+ .filter_map(|(i, module)| {
+ match module {
+ FatLTOInput::InMemory(m) => Some((i, m)),
+ FatLTOInput::Serialized { .. } => None,
+ }
+ })
.filter(|&(_, module)| module.kind == ModuleKind::Regular)
.map(|(i, module)| {
let cost = unsafe {
};
(cost, i)
})
- .max()
- .expect("must be codegen'ing at least one module");
- let module = modules.remove(costliest_module);
+ .max();
+
+ // If we found a costliest module, we're good to go. Otherwise all our
+ // inputs were serialized which could happen in the case, for example, that
+ // all our inputs were incrementally reread from the cache and we're just
+ // re-executing the LTO passes. If that's the case deserialize the first
+ // module and create a linker with it.
+ let module: ModuleCodegen<ModuleLlvm> = match costliest_module {
+ Some((_cost, i)) => {
+ match modules.remove(i) {
+ FatLTOInput::InMemory(m) => m,
+ FatLTOInput::Serialized { .. } => unreachable!(),
+ }
+ }
+ None => {
+ let pos = modules.iter().position(|m| {
+ match m {
+ FatLTOInput::InMemory(_) => false,
+ FatLTOInput::Serialized { .. } => true,
+ }
+ }).expect("must have at least one serialized module");
+ let (name, buffer) = match modules.remove(pos) {
+ FatLTOInput::Serialized { name, buffer } => (name, buffer),
+ FatLTOInput::InMemory(_) => unreachable!(),
+ };
+ ModuleCodegen {
+ module_llvm: ModuleLlvm::parse(cgcx, &name, &buffer, diag_handler)?,
+ name,
+ kind: ModuleKind::Regular,
+ }
+ }
+ };
let mut serialized_bitcode = Vec::new();
{
let (llcx, llmod) = {
// way we know of to do that is to serialize them to a string and them parse
// them later. Not great but hey, that's why it's "fat" LTO, right?
serialized_modules.extend(modules.into_iter().map(|module| {
- let buffer = ModuleBuffer::new(module.module_llvm.llmod());
- let llmod_id = CString::new(&module.name[..]).unwrap();
-
- (SerializedModule::Local(buffer), llmod_id)
+ match module {
+ FatLTOInput::InMemory(module) => {
+ let buffer = ModuleBuffer::new(module.module_llvm.llmod());
+ let llmod_id = CString::new(&module.name[..]).unwrap();
+ (SerializedModule::Local(buffer), llmod_id)
+ }
+ FatLTOInput::Serialized { name, buffer } => {
+ let llmod_id = CString::new(name).unwrap();
+ (SerializedModule::Local(buffer), llmod_id)
+ }
+ }
+ }));
+ serialized_modules.extend(cached_modules.into_iter().map(|(buffer, wp)| {
+ (buffer, CString::new(wp.cgu_name.clone()).unwrap())
}));
// For all serialized bitcode files we parse them and link them in as we did
llvm::LLVMRustModuleBufferCreate(m)
})
}
+
+ pub fn parse<'a>(
+ &self,
+ name: &str,
+ cx: &'a llvm::Context,
+ handler: &Handler,
+ ) -> Result<&'a llvm::Module, FatalError> {
+ let name = CString::new(name).unwrap();
+ parse_module(cx, &name, self.data(), handler)
+ }
}
impl ModuleBufferMethods for ModuleBuffer {
// crates but for locally codegened modules we may be able to reuse
// that LLVM Context and Module.
let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);
- let llmod_raw = llvm::LLVMRustParseBitcodeForThinLTO(
+ let llmod_raw = parse_module(
llcx,
- thin_module.data().as_ptr(),
- thin_module.data().len(),
- thin_module.shared.module_names[thin_module.idx].as_ptr(),
- ).ok_or_else(|| {
- let msg = "failed to parse bitcode for thin LTO module";
- write::llvm_err(&diag_handler, msg)
- })? as *const _;
+ &thin_module.shared.module_names[thin_module.idx],
+ thin_module.data(),
+ &diag_handler,
+ )? as *const _;
let module = ModuleCodegen {
module_llvm: ModuleLlvm {
llmod_raw,
self.imports.get(llvm_module_name).map(|v| &v[..]).unwrap_or(&[])
}
- /// Load the ThinLTO import map from ThinLTOData.
+ /// Loads the ThinLTO import map from ThinLTOData.
unsafe fn from_thin_lto_data(data: *const llvm::ThinLTOData) -> ThinLTOImports {
unsafe extern "C" fn imported_module_callback(payload: *mut libc::c_void,
importing_module_name: *const libc::c_char,
c_str.to_str().unwrap_or_else(|e|
bug!("Encountered non-utf8 LLVM module name `{}`: {}", c_str.to_string_lossy(), e))
}
+
+fn parse_module<'a>(
+ cx: &'a llvm::Context,
+ name: &CStr,
+ data: &[u8],
+ diag_handler: &Handler,
+) -> Result<&'a llvm::Module, FatalError> {
+ unsafe {
+ llvm::LLVMRustParseBitcodeForLTO(
+ cx,
+ data.as_ptr(),
+ data.len(),
+ name.as_ptr(),
+ ).ok_or_else(|| {
+ let msg = "failed to parse bitcode for LTO module";
+ write::llvm_err(&diag_handler, msg)
+ })
+ }
+}
let cwd = env::current_dir().unwrap();
let mut lib = fs::canonicalize(&cwd.join(lib)).unwrap_or_else(|_| cwd.join(lib));
- lib.pop();
+ lib.pop(); // strip filename
let mut output = cwd.join(&config.out_filename);
- output.pop();
+ output.pop(); // strip filename
let output = fs::canonicalize(&output).unwrap_or(output);
let relative = path_relative_from(&lib, &output).unwrap_or_else(||
panic!("couldn't create relative path from {:?} to {:?}", output, lib));
}
}
-/// Add or augment the existing `producers` section to encode information about
+/// Adds or augment the existing `producers` section to encode information about
/// the Rust compiler used to produce the wasm file.
pub fn add_producer_section(
path: &Path,
let opt_level = config.opt_level.map(|x| to_llvm_opt_settings(x).0)
.unwrap_or(llvm::CodeGenOptLevel::None);
let prepare_for_thin_lto = cgcx.lto == Lto::Thin || cgcx.lto == Lto::ThinLocal ||
- (cgcx.lto != Lto::Fat && cgcx.opts.debugging_opts.cross_lang_lto.enabled());
+ (cgcx.lto != Lto::Fat && cgcx.opts.cg.linker_plugin_lto.enabled());
with_llvm_pmb(llmod, &config, opt_level, prepare_for_thin_lto, &mut |b| {
llvm::LLVMPassManagerBuilderPopulateFunctionPassManager(b, fpm);
llvm::LLVMPassManagerBuilderPopulateModulePassManager(b, mpm);
//!
//! Hopefully useful general knowledge about codegen:
//!
-//! * There's no way to find out the Ty type of a Value. Doing so
-//! would be "trying to get the eggs out of an omelette" (credit:
-//! pcwalton). You can, instead, find out its llvm::Type by calling val_ty,
-//! but one llvm::Type corresponds to many `Ty`s; for instance, tup(int, int,
-//! int) and rec(x=int, y=int, z=int) will have the same llvm::Type.
+//! * There's no way to find out the `Ty` type of a Value. Doing so
+//! would be "trying to get the eggs out of an omelette" (credit:
+//! pcwalton). You can, instead, find out its `llvm::Type` by calling `val_ty`,
+//! but one `llvm::Type` corresponds to many `Ty`s; for instance, `tup(int, int,
+//! int)` and `rec(x=int, y=int, z=int)` will have the same `llvm::Type`.
use super::ModuleLlvm;
use rustc_codegen_ssa::{ModuleCodegen, ModuleKind};
use llvm;
use metadata;
+use rustc::dep_graph;
use rustc::mir::mono::{Linkage, Visibility, Stats};
use rustc::middle::cstore::{EncodedMetadata};
use rustc::ty::TyCtxt;
let ((stats, module), _) = tcx.dep_graph.with_task(dep_node,
tcx,
cgu_name,
- module_codegen);
+ module_codegen,
+ dep_graph::hash_result);
let time_to_codegen = start_time.elapsed();
// We assume that the cost to run LLVM on a CGU is proportional to
//! Handles codegen of callees as well as other call-related
-//! things. Callees are a superset of normal rust values and sometimes
-//! have different representations. In particular, top-level fn items
+//! things. Callees are a superset of normal rust values and sometimes
+//! have different representations. In particular, top-level fn items
//! and methods are represented as just a fn ptr and not a full
//! closure.
self.use_dll_storage_attrs && !self.tcx.is_foreign_item(def_id) &&
// ThinLTO can't handle this workaround in all cases, so we don't
// emit the attrs. Instead we make them unnecessary by disallowing
- // dynamic linking when cross-language LTO is enabled.
- !self.tcx.sess.opts.debugging_opts.cross_lang_lto.enabled();
+ // dynamic linking when linker plugin based LTO is enabled.
+ !self.tcx.sess.opts.cg.linker_plugin_lto.enabled();
// If this assertion triggers, there's something wrong with commandline
// argument validation.
- debug_assert!(!(self.tcx.sess.opts.debugging_opts.cross_lang_lto.enabled() &&
+ debug_assert!(!(self.tcx.sess.opts.cg.linker_plugin_lto.enabled() &&
self.tcx.sess.target.target.options.is_like_msvc &&
self.tcx.sess.opts.cg.prefer_dynamic));
pub statics_to_rauw: RefCell<Vec<(&'ll Value, &'ll Value)>>,
/// Statics that will be placed in the llvm.used variable
- /// See http://llvm.org/docs/LangRef.html#the-llvm-used-global-variable for details
+ /// See <http://llvm.org/docs/LangRef.html#the-llvm-used-global-variable> for details
pub used_statics: RefCell<Vec<&'ll Value>>,
pub lltypes: RefCell<FxHashMap<(Ty<'tcx>, Option<VariantIdx>), &'ll Type>>,
self.declare_intrinsic(key).unwrap_or_else(|| bug!("unknown intrinsic '{}'", key))
}
+ fn insert_intrinsic(
+ &self, name: &'static str, args: Option<&[&'b llvm::Type]>, ret: &'b llvm::Type
+ ) -> &'b llvm::Value {
+ let fn_ty = if let Some(args) = args {
+ self.type_func(args, ret)
+ } else {
+ self.type_variadic_func(&[], ret)
+ };
+ let f = self.declare_cfn(name, fn_ty);
+ llvm::SetUnnamedAddr(f, false);
+ self.intrinsics.borrow_mut().insert(name, f.clone());
+ f
+ }
+
fn declare_intrinsic(
&self,
key: &str
macro_rules! ifn {
($name:expr, fn() -> $ret:expr) => (
if key == $name {
- let f = self.declare_cfn($name, self.type_func(&[], $ret));
- llvm::SetUnnamedAddr(f, false);
- self.intrinsics.borrow_mut().insert($name, f.clone());
- return Some(f);
+ return Some(self.insert_intrinsic($name, Some(&[]), $ret));
}
);
($name:expr, fn(...) -> $ret:expr) => (
if key == $name {
- let f = self.declare_cfn($name, self.type_variadic_func(&[], $ret));
- llvm::SetUnnamedAddr(f, false);
- self.intrinsics.borrow_mut().insert($name, f.clone());
- return Some(f);
+ return Some(self.insert_intrinsic($name, None, $ret));
}
);
($name:expr, fn($($arg:expr),*) -> $ret:expr) => (
if key == $name {
- let f = self.declare_cfn($name, self.type_func(&[$($arg),*], $ret));
- llvm::SetUnnamedAddr(f, false);
- self.intrinsics.borrow_mut().insert($name, f.clone());
- return Some(f);
+ return Some(self.insert_intrinsic($name, Some(&[$($arg),*]), $ret));
}
);
}
}
impl<'b, 'tcx> CodegenCx<'b, 'tcx> {
- /// Generate a new symbol name with the given prefix. This symbol name must
+ /// Generates a new symbol name with the given prefix. This symbol name must
/// only be used for definitions with `internal` or `private` linkage.
pub fn generate_local_symbol_name(&self, prefix: &str) -> String {
let idx = self.local_gen_sym_counter.get();
use syntax_pos::BytePos;
-/// Produce DIScope DIEs for each MIR Scope which has variables defined in it.
+/// Produces DIScope DIEs for each MIR Scope which has variables defined in it.
/// If debuginfo is disabled, the returned vector is empty.
pub fn create_mir_scopes(
cx: &CodegenCx<'ll, '_>,
//!
//! This algorithm also provides a stable ID for types that are defined in one
//! crate but instantiated from metadata within another crate. We just have to
-//! take care to always map crate and node IDs back to the original crate
+//! take care to always map crate and `NodeId`s back to the original crate
//! context.
//!
//! As a side-effect these unique type IDs also help to solve a problem arising
//! with different concrete substitutions for `'a`, and thus there will be N
//! `Ty` instances for the type `Struct<'a>` even though it is not generic
//! otherwise. Unfortunately this means that we cannot use `ty::type_id()` as
-//! cheap identifier for type metadata---we have done this in the past, but it
+//! cheap identifier for type metadata -- we have done this in the past, but it
//! led to unnecessary metadata duplication in the best case and LLVM
//! assertions in the worst. However, the unique type ID as described above
//! *can* be used as identifier. Since it is comparatively expensive to
}
}
-/// Create any deferred debug metadata nodes
+/// Creates any deferred debug metadata nodes
pub fn finalize(cx: &CodegenCx) {
if cx.dbg_cx.is_none() {
return;
};
}
-/// Return syntax_pos::Loc corresponding to the beginning of the span
+/// Returns syntax_pos::Loc corresponding to the beginning of the span
pub fn span_start(cx: &CodegenCx, span: Span) -> syntax_pos::Loc {
cx.sess().source_map().lookup_char_pos(span.lo())
}
#![feature(nll)]
#![feature(range_contains)]
#![feature(rustc_diagnostic_macros)]
-#![feature(slice_sort_by_cached_key)]
#![feature(optin_builtin_traits)]
#![feature(concat_idents)]
#![feature(link_args)]
extern crate memmap;
use rustc_codegen_ssa::traits::*;
-use rustc_codegen_ssa::back::write::{CodegenContext, ModuleConfig};
+use rustc_codegen_ssa::back::write::{CodegenContext, ModuleConfig, FatLTOInput};
use rustc_codegen_ssa::back::lto::{SerializedModule, LtoModuleCodegen, ThinModule};
use rustc_codegen_ssa::CompiledModule;
use errors::{FatalError, Handler};
}
fn run_fat_lto(
cgcx: &CodegenContext<Self>,
- modules: Vec<ModuleCodegen<Self::Module>>,
+ modules: Vec<FatLTOInput<Self>>,
+ cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
timeline: &mut Timeline
) -> Result<LtoModuleCodegen<Self>, FatalError> {
- back::lto::run_fat(cgcx, modules, timeline)
+ back::lto::run_fat(cgcx, modules, cached_modules, timeline)
}
fn run_thin_lto(
cgcx: &CodegenContext<Self>,
back::write::codegen(cgcx, diag_handler, module, config, timeline)
}
fn prepare_thin(
- cgcx: &CodegenContext<Self>,
module: ModuleCodegen<Self::Module>
) -> (String, Self::ThinBuffer) {
- back::lto::prepare_thin(cgcx, module)
+ back::lto::prepare_thin(module)
+ }
+ fn serialize_module(
+ module: ModuleCodegen<Self::Module>
+ ) -> (String, Self::ModuleBuffer) {
+ (module.name, back::lto::ModuleBuffer::new(module.module_llvm.llmod()))
}
fn run_lto_pass_manager(
cgcx: &CodegenContext<Self>,
}
}
+ fn parse(
+ cgcx: &CodegenContext<LlvmCodegenBackend>,
+ name: &str,
+ buffer: &back::lto::ModuleBuffer,
+ handler: &Handler,
+ ) -> Result<Self, FatalError> {
+ unsafe {
+ let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);
+ let llmod_raw = buffer.parse(name, llcx, handler)?;
+ let tm = match (cgcx.tm_factory.0)() {
+ Ok(m) => m,
+ Err(e) => {
+ handler.struct_err(&e).emit();
+ return Err(FatalError)
+ }
+ };
+
+ Ok(ModuleLlvm {
+ llmod_raw,
+ llcx,
+ tm,
+ })
+ }
+ }
+
fn llmod(&self) -> &llvm::Module {
unsafe {
&*self.llmod_raw
pub fn LLVMGetSections(ObjFile: &'a ObjectFile) -> &'a mut SectionIterator<'a>;
/// Destroys a section iterator.
pub fn LLVMDisposeSectionIterator(SI: &'a mut SectionIterator<'a>);
- /// Returns true if the section iterator is at the end of the section
+ /// Returns `true` if the section iterator is at the end of the section
/// list:
pub fn LLVMIsSectionIteratorAtEnd(ObjFile: &'a ObjectFile, SI: &SectionIterator<'a>) -> Bool;
/// Moves the section iterator to point to the next section.
CallbackPayload: *mut c_void,
);
pub fn LLVMRustFreeThinLTOData(Data: &'static mut ThinLTOData);
- pub fn LLVMRustParseBitcodeForThinLTO(
+ pub fn LLVMRustParseBitcodeForLTO(
Context: &Context,
Data: *const u8,
len: usize,
}
}
- /// Get the LLVM type corresponding to a Rust type, i.e., `rustc::ty::Ty`.
+ /// Gets the LLVM type corresponding to a Rust type, i.e., `rustc::ty::Ty`.
/// The pointee type of the pointer in `PlaceRef` is always this type.
/// For sized types, it is also the right LLVM type for an `alloca`
/// containing a value of that type, and most immediates (except `bool`).
authors = ["The Rust Project Developers"]
name = "rustc_codegen_ssa"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_codegen_ssa"
use rustc::hir::def_id::CrateNum;
use super::command::Command;
-use CrateInfo;
+use crate::CrateInfo;
use cc::windows_registry;
use std::fs;
use rustc::middle::dependency_format::Linkage;
use rustc::session::Session;
use rustc::session::config::{self, CrateType, OptLevel, DebugInfo,
- CrossLangLto, Lto};
+ LinkerPluginLto, Lto};
use rustc::ty::TyCtxt;
use rustc_target::spec::{LinkerFlavor, LldFlavor};
use serialize::{json, Encoder};
}
}
-/// Linker abstraction used by back::link to build up the command to invoke a
+/// Linker abstraction used by `back::link` to build up the command to invoke a
/// linker.
///
/// This trait is the total list of requirements needed by `back::link` and
fn subsystem(&mut self, subsystem: &str);
fn group_start(&mut self);
fn group_end(&mut self);
- fn cross_lang_lto(&mut self);
+ fn linker_plugin_lto(&mut self);
// Should have been finalize(self), but we don't support self-by-value on trait objects (yet?).
fn finalize(&mut self) -> Command;
}
impl<'a> GccLinker<'a> {
/// Argument that must be passed *directly* to the linker
///
- /// These arguments need to be prepended with '-Wl,' when a gcc-style linker is used
+ /// These arguments need to be prepended with `-Wl`, when a GCC-style linker is used.
fn linker_arg<S>(&mut self, arg: S) -> &mut Self
where S: AsRef<OsStr>
{
}
}
- fn push_cross_lang_lto_args(&mut self, plugin_path: Option<&OsStr>) {
+ fn push_linker_plugin_lto_args(&mut self, plugin_path: Option<&OsStr>) {
if let Some(plugin_path) = plugin_path {
let mut arg = OsString::from("-plugin=");
arg.push(plugin_path);
}
}
- fn cross_lang_lto(&mut self) {
- match self.sess.opts.debugging_opts.cross_lang_lto {
- CrossLangLto::Disabled => {
+ fn linker_plugin_lto(&mut self) {
+ match self.sess.opts.cg.linker_plugin_lto {
+ LinkerPluginLto::Disabled => {
// Nothing to do
}
- CrossLangLto::LinkerPluginAuto => {
- self.push_cross_lang_lto_args(None);
+ LinkerPluginLto::LinkerPluginAuto => {
+ self.push_linker_plugin_lto_args(None);
}
- CrossLangLto::LinkerPlugin(ref path) => {
- self.push_cross_lang_lto_args(Some(path.as_os_str()));
+ LinkerPluginLto::LinkerPlugin(ref path) => {
+ self.push_linker_plugin_lto_args(Some(path.as_os_str()));
}
}
}
fn group_start(&mut self) {}
fn group_end(&mut self) {}
- fn cross_lang_lto(&mut self) {
+ fn linker_plugin_lto(&mut self) {
// Do nothing
}
}
fn group_start(&mut self) {}
fn group_end(&mut self) {}
- fn cross_lang_lto(&mut self) {
+ fn linker_plugin_lto(&mut self) {
// Do nothing
}
}
fn group_start(&mut self) {}
fn group_end(&mut self) {}
- fn cross_lang_lto(&mut self) {
+ fn linker_plugin_lto(&mut self) {
// Do nothing for now
}
}
fn group_end(&mut self) {
}
- fn cross_lang_lto(&mut self) {
+ fn linker_plugin_lto(&mut self) {
}
}
use super::write::CodegenContext;
-use traits::*;
-use ModuleCodegen;
+use crate::traits::*;
+use crate::ModuleCodegen;
use rustc::util::time_graph::Timeline;
use rustc_errors::FatalError;
-use {ModuleCodegen, ModuleKind, CachedModuleCodegen, CompiledModule, CrateInfo, CodegenResults,
- RLIB_BYTECODE_EXTENSION};
+use crate::{ModuleCodegen, ModuleKind, CachedModuleCodegen, CompiledModule, CrateInfo,
+ CodegenResults, RLIB_BYTECODE_EXTENSION};
use super::linker::LinkerInfo;
use super::lto::{self, SerializedModule};
use super::link::{self, remove, get_linker};
use super::command::Command;
use super::symbol_export::ExportedSymbols;
-use memmap;
+use crate::traits::*;
use rustc_incremental::{copy_cgu_workproducts_to_incr_comp_cache_dir,
in_incr_comp_dir, in_incr_comp_dir_sess};
use rustc::dep_graph::{WorkProduct, WorkProductId, WorkProductFileKind};
use rustc::session::Session;
use rustc::util::nodemap::FxHashMap;
use rustc::util::time_graph::{self, TimeGraph, Timeline};
-use traits::*;
use rustc::hir::def_id::{CrateNum, LOCAL_CRATE};
use rustc::ty::TyCtxt;
use rustc::util::common::{time_depth, set_time_depth, print_time_passes_entry};
use std::time::Instant;
use std::thread;
-const PRE_THIN_LTO_BC_EXT: &str = "pre-thin-lto.bc";
+const PRE_LTO_BC_EXT: &str = "pre-lto.bc";
/// Module-specific configuration for `optimize_and_codegen`.
pub struct ModuleConfig {
pub pgo_use: String,
// Flags indicating which outputs to produce.
- pub emit_pre_thin_lto_bc: bool,
+ pub emit_pre_lto_bc: bool,
pub emit_no_opt_bc: bool,
pub emit_bc: bool,
pub emit_bc_compressed: bool,
pgo_use: String::new(),
emit_no_opt_bc: false,
- emit_pre_thin_lto_bc: false,
+ emit_pre_lto_bc: false,
emit_bc: false,
emit_bc_compressed: false,
emit_lto_bc: false,
self.time_passes = sess.time_passes();
self.inline_threshold = sess.opts.cg.inline_threshold;
self.obj_is_bitcode = sess.target.target.options.obj_is_bitcode ||
- sess.opts.debugging_opts.cross_lang_lto.enabled();
+ sess.opts.cg.linker_plugin_lto.enabled();
let embed_bitcode = sess.target.target.options.embed_bitcode ||
sess.opts.debugging_opts.embed_bitcode;
if embed_bitcode {
fn generate_lto_work<B: ExtraBackendMethods>(
cgcx: &CodegenContext<B>,
- needs_fat_lto: Vec<ModuleCodegen<B::Module>>,
+ needs_fat_lto: Vec<FatLTOInput<B>>,
needs_thin_lto: Vec<(String, B::ThinBuffer)>,
import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>
) -> Vec<(WorkItem<B>, u64)> {
let (lto_modules, copy_jobs) = if !needs_fat_lto.is_empty() {
assert!(needs_thin_lto.is_empty());
- assert!(import_only_modules.is_empty());
- let lto_module = B::run_fat_lto(cgcx, needs_fat_lto, &mut timeline)
- .unwrap_or_else(|e| e.raise());
+ let lto_module = B::run_fat_lto(
+ cgcx,
+ needs_fat_lto,
+ import_only_modules,
+ &mut timeline,
+ )
+ .unwrap_or_else(|e| e.raise());
(vec![lto_module], vec![])
} else {
assert!(needs_fat_lto.is_empty());
sess.opts.output_types.contains_key(&OutputType::Exe)
}
-fn need_pre_thin_lto_bitcode_for_incr_comp(sess: &Session) -> bool {
+fn need_pre_lto_bitcode_for_incr_comp(sess: &Session) -> bool {
if sess.opts.incremental.is_none() {
return false
}
match sess.lto() {
- Lto::Fat |
Lto::No => false,
+ Lto::Fat |
Lto::Thin |
Lto::ThinLocal => true,
}
// Save all versions of the bytecode if we're saving our temporaries.
if sess.opts.cg.save_temps {
modules_config.emit_no_opt_bc = true;
- modules_config.emit_pre_thin_lto_bc = true;
+ modules_config.emit_pre_lto_bc = true;
modules_config.emit_bc = true;
modules_config.emit_lto_bc = true;
metadata_config.emit_bc = true;
allocator_config.emit_bc_compressed = true;
}
- modules_config.emit_pre_thin_lto_bc =
- need_pre_thin_lto_bitcode_for_incr_comp(sess);
+ modules_config.emit_pre_lto_bc =
+ need_pre_lto_bitcode_for_incr_comp(sess);
modules_config.no_integrated_as = tcx.sess.opts.cg.no_integrated_as ||
tcx.sess.target.target.options.no_integrated_as;
/// Copy the post-LTO artifacts from the incremental cache to the output
/// directory.
CopyPostLtoArtifacts(CachedModuleCodegen),
- /// Perform (Thin)LTO on the given module.
+ /// Performs (Thin)LTO on the given module.
LTO(lto::LtoModuleCodegen<B>),
}
enum WorkItemResult<B: WriteBackendMethods> {
Compiled(CompiledModule),
- NeedsFatLTO(ModuleCodegen<B::Module>),
+ NeedsFatLTO(FatLTOInput<B>),
NeedsThinLTO(String, B::ThinBuffer),
}
+pub enum FatLTOInput<B: WriteBackendMethods> {
+ Serialized {
+ name: String,
+ buffer: B::ModuleBuffer,
+ },
+ InMemory(ModuleCodegen<B::Module>),
+}
+
fn execute_work_item<B: ExtraBackendMethods>(
cgcx: &CodegenContext<B>,
work_item: WorkItem<B>,
// If the linker does LTO, we don't have to do it. Note that we
// keep doing full LTO, if it is requested, as not to break the
// assumption that the output will be a single module.
- let linker_does_lto = cgcx.opts.debugging_opts.cross_lang_lto.enabled();
+ let linker_does_lto = cgcx.opts.cg.linker_plugin_lto.enabled();
// When we're automatically doing ThinLTO for multi-codegen-unit
// builds we don't actually want to LTO the allocator modules if
}
};
+ // If we're doing some form of incremental LTO then we need to be sure to
+ // save our module to disk first.
+ let bitcode = if cgcx.config(module.kind).emit_pre_lto_bc {
+ let filename = pre_lto_bitcode_filename(&module.name);
+ cgcx.incr_comp_session_dir.as_ref().map(|path| path.join(&filename))
+ } else {
+ None
+ };
+
Ok(match lto_type {
ComputedLtoType::No => {
let module = unsafe {
WorkItemResult::Compiled(module)
}
ComputedLtoType::Thin => {
- let (name, thin_buffer) = B::prepare_thin(cgcx, module);
+ let (name, thin_buffer) = B::prepare_thin(module);
+ if let Some(path) = bitcode {
+ fs::write(&path, thin_buffer.data()).unwrap_or_else(|e| {
+ panic!("Error writing pre-lto-bitcode file `{}`: {}",
+ path.display(),
+ e);
+ });
+ }
WorkItemResult::NeedsThinLTO(name, thin_buffer)
}
- ComputedLtoType::Fat => WorkItemResult::NeedsFatLTO(module),
+ ComputedLtoType::Fat => {
+ match bitcode {
+ Some(path) => {
+ let (name, buffer) = B::serialize_module(module);
+ fs::write(&path, buffer.data()).unwrap_or_else(|e| {
+ panic!("Error writing pre-lto-bitcode file `{}`: {}",
+ path.display(),
+ e);
+ });
+ WorkItemResult::NeedsFatLTO(FatLTOInput::Serialized { name, buffer })
+ }
+ None => WorkItemResult::NeedsFatLTO(FatLTOInput::InMemory(module)),
+ }
+ }
})
}
pub enum Message<B: WriteBackendMethods> {
Token(io::Result<Acquired>),
NeedsFatLTO {
- result: ModuleCodegen<B::Module>,
+ result: FatLTOInput<B>,
worker_id: usize,
},
NeedsThinLTO {
drop(self.coordinator_send.send(Box::new(Message::CodegenComplete::<B>)));
}
- /// Consume this context indicating that codegen was entirely aborted, and
+ /// Consumes this context indicating that codegen was entirely aborted, and
/// we need to exit as quickly as possible.
///
/// This method blocks the current thread until all worker threads have
}
pub fn pre_lto_bitcode_filename(module_name: &str) -> String {
- format!("{}.{}", module_name, PRE_THIN_LTO_BC_EXT)
+ format!("{}.{}", module_name, PRE_LTO_BC_EXT)
}
fn msvc_imps_needed(tcx: TyCtxt) -> bool {
// This should never be true (because it's not supported). If it is true,
// something is wrong with commandline arg validation.
- assert!(!(tcx.sess.opts.debugging_opts.cross_lang_lto.enabled() &&
+ assert!(!(tcx.sess.opts.cg.linker_plugin_lto.enabled() &&
tcx.sess.target.target.options.is_like_msvc &&
tcx.sess.opts.cg.prefer_dynamic));
tcx.sess.crate_types.borrow().iter().any(|ct| *ct == config::CrateType::Rlib) &&
// ThinLTO can't handle this workaround in all cases, so we don't
// emit the `__imp_` symbols. Instead we make them unnecessary by disallowing
- // dynamic linking when cross-language LTO is enabled.
- !tcx.sess.opts.debugging_opts.cross_lang_lto.enabled()
+ // dynamic linking when linker plugin LTO is enabled.
+ !tcx.sess.opts.cg.linker_plugin_lto.enabled()
}
//!
//! Hopefully useful general knowledge about codegen:
//!
-//! * There's no way to find out the Ty type of a Value. Doing so
-//! would be "trying to get the eggs out of an omelette" (credit:
-//! pcwalton). You can, instead, find out its llvm::Type by calling val_ty,
-//! but one llvm::Type corresponds to many `Ty`s; for instance, tup(int, int,
-//! int) and rec(x=int, y=int, z=int) will have the same llvm::Type.
+//! * There's no way to find out the `Ty` type of a Value. Doing so
+//! would be "trying to get the eggs out of an omelette" (credit:
+//! pcwalton). You can, instead, find out its `llvm::Type` by calling `val_ty`,
+//! but one `llvm::Type` corresponds to many `Ty`s; for instance, `tup(int, int,
+//! int)` and `rec(x=int, y=int, z=int)` will have the same `llvm::Type`.
-use {ModuleCodegen, ModuleKind, CachedModuleCodegen};
+use crate::{ModuleCodegen, ModuleKind, CachedModuleCodegen};
use rustc::dep_graph::cgu_reuse_tracker::CguReuse;
use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
use rustc::util::profiling::ProfileCategory;
use rustc::session::config::{self, EntryFnType, Lto};
use rustc::session::Session;
-use mir::place::PlaceRef;
-use back::write::{OngoingCodegen, start_async_codegen, submit_pre_lto_module_to_llvm,
- submit_post_lto_module_to_llvm};
-use {MemFlags, CrateInfo};
-use callee;
use rustc_mir::monomorphize::item::DefPathBasedNames;
-use common::{RealPredicate, TypeKind, IntPredicate};
-use meth;
-use mir;
use rustc::util::time_graph;
use rustc_mir::monomorphize::Instance;
use rustc_mir::monomorphize::partitioning::{CodegenUnit, CodegenUnitExt};
-use mono_item::MonoItem;
use rustc::util::nodemap::FxHashMap;
use rustc_data_structures::indexed_vec::Idx;
use rustc_data_structures::sync::Lrc;
use rustc_codegen_utils::{symbol_names_test, check_for_rustc_errors_attr};
use rustc::ty::layout::{FAT_PTR_ADDR, FAT_PTR_EXTRA};
+use crate::mir::place::PlaceRef;
+use crate::back::write::{OngoingCodegen, start_async_codegen, submit_pre_lto_module_to_llvm,
+ submit_post_lto_module_to_llvm};
+use crate::{MemFlags, CrateInfo};
+use crate::callee;
+use crate::common::{RealPredicate, TypeKind, IntPredicate};
+use crate::meth;
+use crate::mir;
+use crate::mono_item::MonoItem;
-use traits::*;
+use crate::traits::*;
use std::any::Any;
use std::cmp;
use syntax::attr;
use rustc::hir;
-use mir::operand::OperandValue;
+use crate::mir::operand::OperandValue;
use std::marker::PhantomData;
bx.sext(cmp, ret_ty)
}
-/// Retrieve the information we are losing (making dynamic) in an unsizing
+/// Retrieves the information we are losing (making dynamic) in an unsizing
/// adjustment.
///
/// The `old_info` argument is a bit funny. It is intended for use
}
}
-/// Returns whether this session's target will use SEH-based unwinding.
+/// Returns `true` if this session's target will use SEH-based unwinding.
///
/// This is only true for MSVC targets, and even then the 64-bit MSVC target
/// currently uses SEH-ish unwinding with DWARF info tables to the side (same as
mir::codegen_mir::<Bx>(cx, lldecl, &mir, instance, sig);
}
-/// Create the `main` function which will initialize the rust runtime and call
+/// Creates the `main` function which will initialize the rust runtime and call
/// users main function.
pub fn maybe_create_entry_wrapper<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
cx: &'a Bx::CodegenCx
-use traits::*;
+use crate::traits::*;
use rustc::ty;
use rustc::ty::subst::Substs;
use rustc::hir::def_id::DefId;
use rustc::hir::def_id::DefId;
use rustc::middle::lang_items::LangItem;
-use base;
-use traits::*;
+use crate::base;
+use crate::traits::*;
use rustc::hir;
-use traits::BuilderMethods;
+use crate::traits::BuilderMethods;
pub fn type_needs_drop<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> bool {
ty.needs_drop(tcx, ty::ParamEnv::reveal_all())
mod temp_stable_hash_impls {
use rustc_data_structures::stable_hasher::{StableHasherResult, StableHasher,
HashStable};
- use ModuleCodegen;
+ use crate::ModuleCodegen;
impl<HCX, M> HashStable<HCX> for ModuleCodegen<M> {
fn hash_stable<W: StableHasherResult>(&self,
//
// Code relating to drop glue.
-use std;
-
-use common::IntPredicate;
-use meth;
use rustc::ty::{self, Ty};
-use traits::*;
+use crate::common::IntPredicate;
+use crate::meth;
+use crate::traits::*;
pub fn size_and_align_of_dst<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
bx: &mut Bx,
#![feature(libc)]
#![feature(rustc_diagnostic_macros)]
#![feature(in_band_lifetimes)]
-#![feature(slice_sort_by_cached_key)]
#![feature(nll)]
#![allow(unused_attributes)]
#![allow(dead_code)]
+#![deny(rust_2018_idioms)]
+#![allow(explicit_outlives_requirements)]
+#![allow(elided_lifetimes_in_paths)]
#![recursion_limit="256"]
//! The backend-agnostic functions of this crate use functions defined in various traits that
//! have to be implemented by each backends.
-#[macro_use] extern crate bitflags;
#[macro_use] extern crate log;
-extern crate rustc_apfloat;
-#[macro_use] extern crate rustc;
-extern crate rustc_target;
-extern crate rustc_mir;
+#[macro_use] extern crate rustc;
#[macro_use] extern crate syntax;
-extern crate syntax_pos;
-extern crate rustc_incremental;
-extern crate rustc_codegen_utils;
-extern crate rustc_data_structures;
-extern crate rustc_allocator;
-extern crate rustc_fs_util;
-extern crate serialize;
-extern crate rustc_errors;
-extern crate rustc_demangle;
-extern crate cc;
-extern crate libc;
-extern crate jobserver;
-extern crate memmap;
-extern crate num_cpus;
use std::path::PathBuf;
use rustc::dep_graph::WorkProduct;
pub struct ModuleCodegen<M> {
/// The name of the module. When the crate may be saved between
/// compilations, incremental compilation requires that name be
- /// unique amongst **all** crates. Therefore, it should contain
+ /// unique amongst **all** crates. Therefore, it should contain
/// something unique to this crate (e.g., a module path) as well
/// as the crate name and disambiguator.
/// We currently generate these names via CodegenUnit::build_cgu_name().
Allocator,
}
-bitflags! {
+bitflags::bitflags! {
pub struct MemFlags: u8 {
const VOLATILE = 1 << 0;
const NONTEMPORAL = 1 << 1;
}
}
-/// Misc info we load from metadata to persist beyond the tcx
+/// Misc info we load from metadata to persist beyond the tcx.
pub struct CrateInfo {
pub panic_runtime: Option<CrateNum>,
pub compiler_builtins: Option<CrateNum>,
use rustc_target::abi::call::FnType;
-use callee;
use rustc_mir::monomorphize;
-use traits::*;
+use crate::callee;
+use crate::traits::*;
use rustc::ty::{self, Ty};
use rustc::ty;
use rustc::ty::layout::{LayoutOf, HasTyCtxt};
use super::FunctionCx;
-use traits::*;
+use crate::traits::*;
pub fn non_ssa_locals<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
fx: &FunctionCx<'a, 'tcx, Bx>
use rustc::mir::interpret::EvalErrorKind;
use rustc_target::abi::call::{ArgType, FnType, PassMode};
use rustc_target::spec::abi::Abi;
-use base;
-use MemFlags;
-use common::{self, IntPredicate};
-use meth;
use rustc_mir::monomorphize;
+use crate::base;
+use crate::MemFlags;
+use crate::common::{self, IntPredicate};
+use crate::meth;
-use traits::*;
+use crate::traits::*;
use syntax::symbol::Symbol;
use syntax_pos::Pos;
}
}
- /// Return the landingpad wrapper around the given basic block
+ /// Returns the landing-pad wrapper around the given basic block.
///
/// No-op in MSVC SEH scheme.
fn landing_pad_to(
use rustc::ty::{self, Ty};
use rustc::ty::layout;
use syntax::source_map::Span;
-use traits::*;
+use crate::traits::*;
use super::FunctionCx;
use rustc::mir::{self, Mir};
use rustc::ty::subst::Substs;
use rustc::session::config::DebugInfo;
-use base;
-use debuginfo::{self, VariableAccess, VariableKind, FunctionDebugContext};
use rustc_mir::monomorphize::Instance;
use rustc_target::abi::call::{FnType, PassMode};
-use traits::*;
+use crate::base;
+use crate::debuginfo::{self, VariableAccess, VariableKind, FunctionDebugContext};
+use crate::traits::*;
use syntax_pos::{DUMMY_SP, NO_EXPANSION, BytePos, Span};
use syntax::symbol::keywords;
}).unzip()
}
-/// Produce, for each argument, a `Value` pointing at the
+/// Produces, for each argument, a `Value` pointing at the
/// argument's value. As arguments are places, these are always
/// indirect.
fn arg_local_refs<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
use rustc::ty;
use rustc::ty::layout::{self, Align, LayoutOf, TyLayout};
-use base;
-use MemFlags;
-use glue;
+use crate::base;
+use crate::MemFlags;
+use crate::glue;
-use traits::*;
+use crate::traits::*;
use std::fmt;
use rustc::ty::layout::{self, Align, TyLayout, LayoutOf, VariantIdx, HasTyCtxt};
use rustc::mir;
use rustc::mir::tcx::PlaceTy;
-use MemFlags;
-use common::IntPredicate;
-use glue;
+use crate::MemFlags;
+use crate::common::IntPredicate;
+use crate::glue;
-use traits::*;
+use crate::traits::*;
use super::{FunctionCx, LocalRef};
use super::operand::OperandValue;
#[derive(Copy, Clone, Debug)]
pub struct PlaceRef<'tcx, V> {
- /// Pointer to the contents of the place
+ /// Pointer to the contents of the place.
pub llval: V,
- /// This place's extra data if it is unsized, or null
+ /// This place's extra data if it is unsized, or null.
pub llextra: Option<V>,
- /// Monomorphized type of this place, including variant information
+ /// Monomorphized type of this place, including variant information.
pub layout: TyLayout<'tcx>,
- /// What alignment we know for this place
+ /// What alignment we know for this place.
pub align: Align,
}
}
}
- /// Set the discriminant for a new value of the given case of the given
+ /// Sets the discriminant for a new value of the given case of the given
/// representation.
pub fn codegen_set_discr<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
&self,
use rustc_apfloat::{ieee, Float, Status, Round};
use std::{u128, i128};
-use base;
-use MemFlags;
-use callee;
-use common::{self, RealPredicate, IntPredicate};
+use crate::base;
+use crate::MemFlags;
+use crate::callee;
+use crate::common::{self, RealPredicate, IntPredicate};
use rustc_mir::monomorphize;
-use traits::*;
+use crate::traits::*;
use super::{FunctionCx, LocalRef};
use super::operand::{OperandRef, OperandValue};
use rustc::mir;
-use traits::BuilderMethods;
+use crate::traits::BuilderMethods;
use super::FunctionCx;
use super::LocalRef;
use super::OperandValue;
-use traits::*;
+use crate::traits::*;
impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
pub fn codegen_statement(
-use base;
use rustc::hir;
use rustc::hir::def::Def;
use rustc::mir::mono::{Linkage, Visibility};
use rustc::ty::layout::HasTyCtxt;
use std::fmt;
-use traits::*;
+use crate::base;
+use crate::traits::*;
pub use rustc::mir::mono::MonoItem;
use super::BackendTypes;
-use mir::place::PlaceRef;
+use crate::mir::place::PlaceRef;
use rustc::hir::{GlobalAsm, InlineAsm};
pub trait AsmBuilderMethods<'tcx>: BackendTypes {
use super::intrinsic::IntrinsicCallMethods;
use super::type_::ArgTypeMethods;
use super::{HasCodegen, StaticBuilderMethods};
-use common::{AtomicOrdering, AtomicRmwBinOp, IntPredicate, RealPredicate, SynchronizationScope};
-use mir::operand::OperandRef;
-use mir::place::PlaceRef;
+use crate::common::{AtomicOrdering, AtomicRmwBinOp, IntPredicate, RealPredicate,
+ SynchronizationScope};
+use crate::mir::operand::OperandRef;
+use crate::mir::place::PlaceRef;
+use crate::MemFlags;
use rustc::ty::Ty;
use rustc::ty::layout::{Align, Size};
use std::ffi::CStr;
-use MemFlags;
use std::borrow::Cow;
use std::ops::Range;
use super::BackendTypes;
-use mir::place::PlaceRef;
+use crate::mir::place::PlaceRef;
use rustc::mir::interpret::Allocation;
use rustc::mir::interpret::Scalar;
use rustc::ty::layout;
use super::BackendTypes;
-use debuginfo::{FunctionDebugContext, MirDebugScope, VariableAccess, VariableKind};
+use crate::debuginfo::{FunctionDebugContext, MirDebugScope, VariableAccess, VariableKind};
use rustc::hir::def_id::CrateNum;
use rustc::mir;
use rustc::ty::{self, Ty};
/// Declare a global with an intention to define it.
///
/// Use this function when you intend to define a global. This function will
- /// return None if the name already has a definition associated with it. In that
+ /// return `None` if the name already has a definition associated with it. In that
/// case an error should be reported to the user, because it usually happens due
/// to user’s fault (e.g., misuse of #[no_mangle] or #[export_name] attributes).
fn define_global(&self, name: &str, ty: Self::Type) -> Option<Self::Value>;
/// can happen with #[no_mangle] or #[export_name], for example.
fn define_internal_fn(&self, name: &str, fn_sig: ty::PolyFnSig<'tcx>) -> Self::Value;
- /// Get declared value by name.
+ /// Gets declared value by name.
fn get_declared_value(&self, name: &str) -> Option<Self::Value>;
- /// Get defined or externally defined (AvailableExternally linkage) value by
+ /// Gets defined or externally defined (AvailableExternally linkage) value by
/// name.
fn get_defined_value(&self, name: &str) -> Option<Self::Value>;
}
use super::BackendTypes;
-use mir::operand::OperandRef;
+use crate::mir::operand::OperandRef;
use rustc::ty::Ty;
use rustc_target::abi::call::FnType;
use syntax_pos::Span;
use super::misc::MiscMethods;
use super::Backend;
use super::HasCodegen;
-use common::{self, TypeKind};
-use mir::place::PlaceRef;
+use crate::common::{self, TypeKind};
+use crate::mir::place::PlaceRef;
use rustc::ty::layout::{self, Align, Size, TyLayout};
use rustc::ty::{self, Ty};
use rustc::util::nodemap::FxHashMap;
fn type_ptr_to(&self, ty: Self::Type) -> Self::Type;
fn element_type(&self, ty: Self::Type) -> Self::Type;
- /// Return the number of elements in `self` if it is a LLVM vector type.
+ /// Returns the number of elements in `self` if it is a LLVM vector type.
fn vector_length(&self, ty: Self::Type) -> usize;
fn func_params_types(&self, ty: Self::Type) -> Vec<Self::Type>;
fn float_width(&self, ty: Self::Type) -> usize;
- /// Retrieve the bit width of the integer type `self`.
+ /// Retrieves the bit width of the integer type `self`.
fn int_width(&self, ty: Self::Type) -> u64;
fn val_ty(&self, v: Self::Value) -> Self::Type;
-use back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
-use back::write::{CodegenContext, ModuleConfig};
-use {CompiledModule, ModuleCodegen};
+use crate::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
+use crate::back::write::{CodegenContext, ModuleConfig, FatLTOInput};
+use crate::{CompiledModule, ModuleCodegen};
use rustc::dep_graph::WorkProduct;
use rustc::util::time_graph::Timeline;
/// for further optimization.
fn run_fat_lto(
cgcx: &CodegenContext<Self>,
- modules: Vec<ModuleCodegen<Self::Module>>,
+ modules: Vec<FatLTOInput<Self>>,
+ cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
timeline: &mut Timeline,
) -> Result<LtoModuleCodegen<Self>, FatalError>;
/// Performs thin LTO by performing necessary global analysis and returning two
timeline: &mut Timeline,
) -> Result<CompiledModule, FatalError>;
fn prepare_thin(
- cgcx: &CodegenContext<Self>,
module: ModuleCodegen<Self::Module>
) -> (String, Self::ThinBuffer);
+ fn serialize_module(
+ module: ModuleCodegen<Self::Module>
+ ) -> (String, Self::ModuleBuffer);
fn run_lto_pass_manager(
cgcx: &CodegenContext<Self>,
llmod: &ModuleCodegen<Self::Module>,
authors = ["The Rust Project Developers"]
name = "rustc_codegen_utils"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_codegen_utils"
use rustc::middle::cstore::MetadataLoader;
use rustc::dep_graph::DepGraph;
use rustc_target::spec::Target;
-use link::out_filename;
+use crate::link::out_filename;
pub use rustc_data_structures::sync::MetadataRef;
fn diagnostics(&self) -> &[(&'static str, &'static str)] { &[] }
fn metadata_loader(&self) -> Box<dyn MetadataLoader + Sync>;
- fn provide(&self, _providers: &mut Providers);
- fn provide_extern(&self, _providers: &mut Providers);
+ fn provide(&self, _providers: &mut Providers<'_>);
+ fn provide_extern(&self, _providers: &mut Providers<'_>);
fn codegen_crate<'a, 'tcx>(
&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
box NoLlvmMetadataLoader
}
- fn provide(&self, providers: &mut Providers) {
- ::symbol_names::provide(providers);
+ fn provide(&self, providers: &mut Providers<'_>) {
+ crate::symbol_names::provide(providers);
providers.target_features_whitelist = |_tcx, _cnum| {
Default::default() // Just a dummy
providers.is_reachable_non_generic = |_tcx, _defid| true;
providers.exported_symbols = |_tcx, _crate| Arc::new(Vec::new());
}
- fn provide_extern(&self, providers: &mut Providers) {
+ fn provide_extern(&self, providers: &mut Providers<'_>) {
providers.is_reachable_non_generic = |_tcx, _defid| true;
}
) -> Box<dyn Any> {
use rustc_mir::monomorphize::item::MonoItem;
- ::check_for_rustc_errors_attr(tcx);
- ::symbol_names_test::report_symbol_names(tcx);
- ::rustc_incremental::assert_dep_graph(tcx);
- ::rustc_incremental::assert_module_sources::assert_module_sources(tcx);
+ crate::check_for_rustc_errors_attr(tcx);
+ crate::symbol_names_test::report_symbol_names(tcx);
+ rustc_incremental::assert_dep_graph(tcx);
+ rustc_incremental::assert_module_sources::assert_module_sources(tcx);
// FIXME: Fix this
- // ::rustc::middle::dependency_format::calculate(tcx);
+ // rustc::middle::dependency_format::calculate(tcx);
let _ = tcx.link_args(LOCAL_CRATE);
let _ = tcx.native_libraries(LOCAL_CRATE);
let (_, cgus) = tcx.collect_and_partition_mono_items(LOCAL_CRATE);
#![recursion_limit="256"]
-extern crate flate2;
-#[macro_use]
-extern crate log;
+#![deny(rust_2018_idioms)]
#[macro_use]
extern crate rustc;
-extern crate rustc_target;
-extern crate rustc_metadata;
-extern crate rustc_mir;
-extern crate rustc_incremental;
-extern crate syntax;
-extern crate syntax_pos;
#[macro_use] extern crate rustc_data_structures;
use rustc::ty::TyCtxt;
/// error in codegen. This is used to write compile-fail tests
/// that actually test that compilation succeeds without
/// reporting an error.
-pub fn check_for_rustc_errors_attr(tcx: TyCtxt) {
+pub fn check_for_rustc_errors_attr(tcx: TyCtxt<'_, '_, '_>) {
if let Some((def_id, _)) = tcx.entry_fn(LOCAL_CRATE) {
if tcx.has_attr(def_id, "rustc_error") {
tcx.sess.span_fatal(tcx.def_span(def_id), "compilation successful");
attrs: &[ast::Attribute],
input: &Input) -> String {
let validate = |s: String, span: Option<Span>| {
- ::rustc_metadata::validate_crate_name(sess, &s, span);
+ rustc_metadata::validate_crate_name(sess, &s, span);
s
};
use syntax_pos::symbol::Symbol;
+use log::debug;
+
use std::fmt::Write;
use std::mem::discriminant;
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
*providers = Providers {
def_symbol_name,
symbol_name,
authors = ["The Rust Project Developers"]
name = "rustc_cratesio_shim"
version = "0.0.0"
+edition = "2018"
[lib]
crate-type = ["dylib"]
+#![deny(rust_2018_idioms)]
+
// See Cargo.toml for a comment explaining this crate.
#![allow(unused_extern_crates)]
authors = ["The Rust Project Developers"]
name = "rustc_data_structures"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_data_structures"
graphviz = { path = "../libgraphviz" }
cfg-if = "0.1.2"
stable_deref_trait = "1.0.0"
-rustc-rayon = "0.1.1"
-rustc-rayon-core = "0.1.1"
+rayon = { version = "0.1.1", package = "rustc-rayon" }
+rayon-core = { version = "0.1.1", package = "rustc-rayon-core" }
rustc-hash = "1.0.1"
smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
-/// Convert unsigned integers into a string representation with some base.
+/// Converts unsigned integers into a string representation with some base.
/// Bases up to and including 36 can be used for case-insensitive things.
use std::str;
-use indexed_vec::{Idx, IndexVec};
+use crate::indexed_vec::{Idx, IndexVec};
use smallvec::SmallVec;
use std::fmt;
use std::iter;
}
impl<T: Idx> BitSet<T> {
- /// Create a new, empty bitset with a given `domain_size`.
+ /// Creates a new, empty bitset with a given `domain_size`.
#[inline]
pub fn new_empty(domain_size: usize) -> BitSet<T> {
let num_words = num_words(domain_size);
}
}
- /// Create a new, filled bitset with a given `domain_size`.
+ /// Creates a new, filled bitset with a given `domain_size`.
#[inline]
pub fn new_filled(domain_size: usize) -> BitSet<T> {
let num_words = num_words(domain_size);
result
}
- /// Get the domain size.
+ /// Gets the domain size.
pub fn domain_size(&self) -> usize {
self.domain_size
}
self.words.iter().map(|e| e.count_ones() as usize).sum()
}
- /// True if `self` contains `elem`.
+ /// Returns `true` if `self` contains `elem`.
#[inline]
pub fn contains(&self, elem: T) -> bool {
assert!(elem.index() < self.domain_size);
self.words.iter().all(|a| *a == 0)
}
- /// Insert `elem`. Returns true if the set has changed.
+ /// Insert `elem`. Returns whether the set has changed.
#[inline]
pub fn insert(&mut self, elem: T) -> bool {
assert!(elem.index() < self.domain_size);
self.clear_excess_bits();
}
- /// Returns true if the set has changed.
+ /// Returns `true` if the set has changed.
#[inline]
pub fn remove(&mut self, elem: T) -> bool {
assert!(elem.index() < self.domain_size);
new_word != word
}
- /// Set `self = self | other` and return true if `self` changed
+ /// Sets `self = self | other` and returns `true` if `self` changed
/// (i.e., if new bits were added).
pub fn union(&mut self, other: &impl UnionIntoBitSet<T>) -> bool {
other.union_into(self)
}
- /// Set `self = self - other` and return true if `self` changed.
+ /// Sets `self = self - other` and returns `true` if `self` changed.
/// (i.e., if any bits were removed).
pub fn subtract(&mut self, other: &impl SubtractFromBitSet<T>) -> bool {
other.subtract_from(self)
}
- /// Set `self = self & other` and return true if `self` changed.
+ /// Sets `self = self & other` and return `true` if `self` changed.
/// (i.e., if any bits were removed).
pub fn intersect(&mut self, other: &BitSet<T>) -> bool {
assert_eq!(self.domain_size, other.domain_size);
bitwise(&mut self.words, &other.words, |a, b| { a & b })
}
- /// Get a slice of the underlying words.
+ /// Gets a slice of the underlying words.
pub fn words(&self) -> &[Word] {
&self.words
}
}
impl<T: Idx> fmt::Debug for BitSet<T> {
- fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
w.debug_list()
.entries(self.iter())
.finish()
dense
}
- fn iter(&self) -> slice::Iter<T> {
+ fn iter(&self) -> slice::Iter<'_, T> {
self.elems.iter()
}
}
}
}
- pub fn iter(&self) -> HybridIter<T> {
+ pub fn iter(&self) -> HybridIter<'_, T> {
match self {
HybridBitSet::Sparse(sparse) => HybridIter::Sparse(sparse.iter()),
HybridBitSet::Dense(dense) => HybridIter::Dense(dense.iter()),
GrowableBitSet { bit_set: BitSet::new_empty(bits) }
}
- /// Returns true if the set has changed.
+ /// Returns `true` if the set has changed.
#[inline]
pub fn insert(&mut self, elem: T) -> bool {
self.ensure(elem.index() + 1);
}
impl<R: Idx, C: Idx> BitMatrix<R, C> {
- /// Create a new `rows x columns` matrix, initially empty.
+ /// Creates a new `rows x columns` matrix, initially empty.
pub fn new(num_rows: usize, num_columns: usize) -> BitMatrix<R, C> {
// For every element, we need one bit for every other
// element. Round up to an even number of words.
/// Sets the cell at `(row, column)` to true. Put another way, insert
/// `column` to the bitset for `row`.
///
- /// Returns true if this changed the matrix, and false otherwise.
+ /// Returns `true` if this changed the matrix.
pub fn insert(&mut self, row: R, column: C) -> bool {
assert!(row.index() < self.num_rows && column.index() < self.num_columns);
let (start, _) = self.range(row);
(self.words[start + word_index] & mask) != 0
}
- /// Returns those indices that are true in rows `a` and `b`. This
+ /// Returns those indices that are true in rows `a` and `b`. This
/// is an O(n) operation where `n` is the number of elements
/// (somewhat independent from the actual size of the
/// intersection, in particular).
result
}
- /// Add the bits from row `read` to the bits from row `write`,
- /// return true if anything changed.
+ /// Adds the bits from row `read` to the bits from row `write`, and
+ /// returns `true` if anything changed.
///
/// This is used when computing transitive reachability because if
/// you have an edge `write -> read`, because in that case
}
impl<R: Idx, C: Idx> SparseBitMatrix<R, C> {
- /// Create a new empty sparse bit matrix with no rows or columns.
+ /// Creates a new empty sparse bit matrix with no rows or columns.
pub fn new(num_columns: usize) -> Self {
Self {
num_columns,
/// Sets the cell at `(row, column)` to true. Put another way, insert
/// `column` to the bitset for `row`.
///
- /// Returns true if this changed the matrix, and false otherwise.
+ /// Returns `true` if this changed the matrix.
pub fn insert(&mut self, row: R, column: C) -> bool {
self.ensure_row(row).insert(column)
}
self.row(row).map_or(false, |r| r.contains(column))
}
- /// Add the bits from row `read` to the bits from row `write`,
- /// return true if anything changed.
+ /// Adds the bits from row `read` to the bits from row `write`, and
+ /// returns `true` if anything changed.
///
/// This is used when computing transitive reachability because if
/// you have an edge `write -> read`, because in that case
+use crate::stable_hasher;
use std::mem;
-use stable_hasher;
use serialize;
use serialize::opaque::{EncodeResult, Encoder, Decoder};
}
impl ::std::fmt::Display for Fingerprint {
- fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+ fn fmt(&self, formatter: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(formatter, "{:x}-{:x}", self.0, self.1)
}
}
if #[cfg(unix)] {
use std::ffi::{CString, OsStr};
use std::os::unix::prelude::*;
- use libc;
#[cfg(any(target_os = "linux", target_os = "android"))]
mod os {
- use libc;
-
#[repr(C)]
pub struct flock {
pub l_type: libc::c_short,
#[cfg(target_os = "freebsd")]
mod os {
- use libc;
-
#[repr(C)]
pub struct flock {
pub l_start: libc::off_t,
target_os = "netbsd",
target_os = "openbsd"))]
mod os {
- use libc;
-
#[repr(C)]
pub struct flock {
pub l_start: libc::off_t,
#[cfg(target_os = "haiku")]
mod os {
- use libc;
-
#[repr(C)]
pub struct flock {
pub l_type: libc::c_short,
#[cfg(any(target_os = "macos", target_os = "ios"))]
mod os {
- use libc;
-
#[repr(C)]
pub struct flock {
pub l_start: libc::off_t,
#[cfg(target_os = "solaris")]
mod os {
- use libc;
-
#[repr(C)]
pub struct flock {
pub l_type: libc::c_short,
self.immediate_dominators[node].unwrap()
}
- pub fn dominators(&self, node: Node) -> Iter<Node> {
+ pub fn dominators(&self, node: Node) -> Iter<'_, Node> {
assert!(self.is_reachable(node), "node {:?} is not reachable", node);
Iter {
dominators: self,
}
}
-pub struct Iter<'dom, Node: Idx + 'dom> {
+pub struct Iter<'dom, Node: Idx> {
dominators: &'dom Dominators<Node>,
node: Option<Node>,
}
}
impl<Node: Idx> fmt::Debug for DominatorTree<Node> {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(
&DominatorTreeNode {
tree: self,
}
impl<'tree, Node: Idx> fmt::Debug for DominatorTreeNode<'tree, Node> {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
let subtrees: Vec<_> = self.tree
.children(self.node)
.iter()
//! stored. The edges are stored in a central array, but they are also
//! threaded onto two linked lists for each node, one for incoming edges
//! and one for outgoing edges. Note that every edge is a member of some
-//! incoming list and some outgoing list. Basically you can load the
+//! incoming list and some outgoing list. Basically you can load the
//! first index of the linked list from the node data structures (the
//! field `first_edge`) and then, for each edge, load the next index from
//! the field `next_edge`). Each of those fields is an array that should
//! be indexed by the direction (see the type `Direction`).
-use bit_set::BitSet;
+use crate::bit_set::BitSet;
+use crate::snapshot_vec::{SnapshotVec, SnapshotVecDelegate};
use std::fmt::Debug;
use std::usize;
-use snapshot_vec::{SnapshotVec, SnapshotVecDelegate};
#[cfg(test)]
mod tests;
pub const INCOMING: Direction = Direction { repr: 1 };
impl NodeIndex {
- /// Returns unique id (unique with respect to the graph holding associated node).
+ /// Returns unique ID (unique with respect to the graph holding associated node).
pub fn node_id(self) -> usize {
self.0
}
.all(|(edge_idx, edge)| f(edge_idx, edge))
}
- pub fn outgoing_edges(&self, source: NodeIndex) -> AdjacentEdges<N, E> {
+ pub fn outgoing_edges(&self, source: NodeIndex) -> AdjacentEdges<'_, N, E> {
self.adjacent_edges(source, OUTGOING)
}
- pub fn incoming_edges(&self, source: NodeIndex) -> AdjacentEdges<N, E> {
+ pub fn incoming_edges(&self, source: NodeIndex) -> AdjacentEdges<'_, N, E> {
self.adjacent_edges(source, INCOMING)
}
- pub fn adjacent_edges(&self, source: NodeIndex, direction: Direction) -> AdjacentEdges<N, E> {
+ pub fn adjacent_edges(
+ &self,
+ source: NodeIndex,
+ direction: Direction
+ ) -> AdjacentEdges<'_, N, E> {
let first_edge = self.node(source).first_edge[direction.repr];
AdjacentEdges {
graph: self,
// # Iterators
-pub struct AdjacentEdges<'g, N, E>
-where
- N: 'g,
- E: 'g,
-{
+pub struct AdjacentEdges<'g, N, E> {
graph: &'g Graph<N, E>,
direction: Direction,
next: EdgeIndex,
}
}
-pub struct DepthFirstTraversal<'g, N, E>
-where
- N: 'g,
- E: 'g,
-{
+pub struct DepthFirstTraversal<'g, N, E> {
graph: &'g Graph<N, E>,
stack: Vec<NodeIndex>,
visited: BitSet<usize>,
-use graph::implementation::*;
+use crate::graph::implementation::*;
use std::fmt::Debug;
type TestGraph = Graph<&'static str, &'static str>;
//! node in the graph. This uses Tarjan's algorithm that completes in
//! O(n) time.
-use fx::FxHashSet;
-use graph::{DirectedGraph, WithNumNodes, WithSuccessors};
-use indexed_vec::{Idx, IndexVec};
+use crate::fx::FxHashSet;
+use crate::graph::{DirectedGraph, WithNumNodes, WithSuccessors};
+use crate::indexed_vec::{Idx, IndexVec};
use std::ops::Range;
mod test;
}
}
-struct SccsConstruction<'c, G: DirectedGraph + WithNumNodes + WithSuccessors + 'c, S: Idx> {
+struct SccsConstruction<'c, G: DirectedGraph + WithNumNodes + WithSuccessors, S: Idx> {
graph: &'c G,
/// The state of each node; used during walk to record the stack
}
}
- /// Visit a node during the DFS. We first examine its current
+ /// Visits a node during the DFS. We first examine its current
/// state -- if it is not yet visited (`NotVisited`), we can push
/// it onto the stack and start walking its successors.
///
#![cfg(test)]
-use graph::test::TestGraph;
+use crate::graph::test::TestGraph;
use super::*;
#[test]
-use fx::FxHashMap;
+use crate::fx::FxHashMap;
use std::cmp::max;
use std::slice;
use std::iter;
/// Represents some newtyped `usize` wrapper.
///
-/// (purpose: avoid mixing indexes for different bitvector domains.)
+/// Purpose: avoid mixing indexes for different bitvector domains.
pub trait Idx: Copy + 'static + Ord + Debug + Hash {
fn new(idx: usize) -> Self;
unsafe { $type { private: value } }
}
- /// Extract value of this index as an integer.
+ /// Extracts the value of this index as an integer.
#[inline]
$v fn index(self) -> usize {
self.as_usize()
}
- /// Extract value of this index as a usize.
+ /// Extracts the value of this index as a `u32`.
#[inline]
$v fn as_u32(self) -> u32 {
self.private
}
- /// Extract value of this index as a u32.
+ /// Extracts the value of this index as a `usize`.
#[inline]
$v fn as_usize(self) -> usize {
self.as_u32() as usize
@type [$type:ident]
@debug_format [$debug_format:tt]) => (
impl ::std::fmt::Debug for $type {
- fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+ fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(fmt, $debug_format, self.as_u32())
}
}
}
impl<I: Idx, T: fmt::Debug> fmt::Debug for IndexVec<I, T> {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&self.raw, fmt)
}
}
}
#[inline]
- pub fn iter(&self) -> slice::Iter<T> {
+ pub fn iter(&self) -> slice::Iter<'_, T> {
self.raw.iter()
}
}
#[inline]
- pub fn iter_mut(&mut self) -> slice::IterMut<T> {
+ pub fn iter_mut(&mut self) -> slice::IterMut<'_, T> {
self.raw.iter_mut()
}
self.raw.get_mut(index.index())
}
- /// Return mutable references to two distinct elements, a and b. Panics if a == b.
+ /// Returns mutable references to two distinct elements, a and b. Panics if a == b.
#[inline]
pub fn pick2_mut(&mut self, a: I, b: I) -> (&mut T, &mut T) {
let (ai, bi) = (a.index(), b.index());
#![cfg_attr(unix, feature(libc))]
#![cfg_attr(test, feature(test))]
-extern crate core;
-extern crate ena;
+#![deny(rust_2018_idioms)]
+
#[macro_use]
extern crate log;
+#[allow(unused_extern_crates)]
extern crate serialize as rustc_serialize; // used by deriving
#[cfg(unix)]
extern crate libc;
-extern crate parking_lot;
#[macro_use]
extern crate cfg_if;
-extern crate stable_deref_trait;
-extern crate rustc_rayon as rayon;
-extern crate rustc_rayon_core as rayon_core;
-extern crate rustc_hash;
-extern crate serialize;
-extern crate graphviz;
-extern crate smallvec;
// See librustc_cratesio_shim/Cargo.toml for a comment explaining this.
#[allow(unused_extern_crates)]
/// A simple static assertion macro. The first argument should be a unique
/// ALL_CAPS identifier that describes the condition.
#[macro_export]
-#[allow_internal_unstable]
+#[cfg_attr(stage0, allow_internal_unstable)]
+#[cfg_attr(not(stage0), allow_internal_unstable(type_ascription))]
macro_rules! static_assert {
($name:ident: $test:expr) => {
// Use the bool to access an array such that if the bool is false, the access
+use crate::obligation_forest::{ForestObligation, ObligationForest};
use graphviz as dot;
-use obligation_forest::{ForestObligation, ObligationForest};
use std::env::var_os;
use std::fs::File;
use std::path::Path;
use std::sync::atomic::Ordering;
impl<O: ForestObligation> ObligationForest<O> {
- /// Create a graphviz representation of the obligation forest. Given a directory this will
- /// create files with name of the format `<counter>_<description>.gv`. The counter is
+ /// Creates a graphviz representation of the obligation forest. Given a directory this will
+ /// create files with name of the format `<counter>_<description>.gv`. The counter is
/// global and is maintained internally.
///
/// Calling this will do nothing unless the environment variable
type Node = usize;
type Edge = (usize, usize);
- fn graph_id(&self) -> dot::Id {
+ fn graph_id(&self) -> dot::Id<'_> {
dot::Id::new("trait_obligation_forest").unwrap()
}
- fn node_id(&self, index: &Self::Node) -> dot::Id {
+ fn node_id(&self, index: &Self::Node) -> dot::Id<'_> {
dot::Id::new(format!("obligation_{}", index)).unwrap()
}
- fn node_label(&self, index: &Self::Node) -> dot::LabelText {
+ fn node_label(&self, index: &Self::Node) -> dot::LabelText<'_> {
let node = &self.nodes[*index];
let label = format!("{:?} ({:?})", node.obligation.as_predicate(), node.state.get());
dot::LabelText::LabelStr(label.into())
}
- fn edge_label(&self, (_index_source, _index_target): &Self::Edge) -> dot::LabelText {
+ fn edge_label(&self, (_index_source, _index_target): &Self::Edge) -> dot::LabelText<'_> {
dot::LabelText::LabelStr("".into())
}
}
type Node = usize;
type Edge = (usize, usize);
- fn nodes(&self) -> dot::Nodes<Self::Node> {
+ fn nodes(&self) -> dot::Nodes<'_, Self::Node> {
(0..self.nodes.len()).collect()
}
- fn edges(&self) -> dot::Edges<Self::Edge> {
+ fn edges(&self) -> dot::Edges<'_, Self::Edge> {
(0..self.nodes.len())
.flat_map(|i| {
let node = &self.nodes[i];
//! #### Snapshots
//!
//! The `ObligationForest` supports a limited form of snapshots; see
-//! `start_snapshot`; `commit_snapshot`; and `rollback_snapshot`. In
+//! `start_snapshot`, `commit_snapshot`, and `rollback_snapshot`. In
//! particular, you can use a snapshot to roll back new root
//! obligations. However, it is an error to attempt to
//! `process_obligations` during a snapshot.
//! ### Implementation details
//!
//! For the most part, comments specific to the implementation are in the
-//! code. This file only contains a very high-level overview. Basically,
+//! code. This file only contains a very high-level overview. Basically,
//! the forest is stored in a vector. Each element of the vector is a node
//! in some tree. Each node in the vector has the index of an (optional)
//! parent and (for convenience) its root (which may be itself). It also
//! processing step, we compress the vector to remove completed and error
//! nodes, which aren't needed anymore.
-use fx::{FxHashMap, FxHashSet};
+use crate::fx::{FxHashMap, FxHashSet};
use std::cell::Cell;
use std::collections::hash_map::Entry;
obligation_tree_id_generator: ObligationTreeIdGenerator,
- /// Per tree error cache. This is used to deduplicate errors,
+ /// Per tree error cache. This is used to deduplicate errors,
/// which is necessary to avoid trait resolution overflow in
/// some cases.
///
}
}
- /// Return the total number of nodes in the forest that have not
+ /// Returns the total number of nodes in the forest that have not
/// yet been fully resolved.
pub fn len(&self) -> usize {
self.nodes.len()
}
- /// Registers an obligation
+ /// Registers an obligation.
///
/// This CAN be done in a snapshot
pub fn register_obligation(&mut self, obligation: O) {
}
}
- /// Convert all remaining obligations to the given error.
+ /// Converts all remaining obligations to the given error.
///
/// This cannot be done during a snapshot.
pub fn to_errors<E: Clone>(&mut self, error: E) -> Vec<Error<O, E>> {
.insert(node.obligation.as_predicate().clone());
}
- /// Perform a pass through the obligation list. This must
+ /// Performs a pass through the obligation list. This must
/// be called in a loop until `outcome.stalled` is false.
///
- /// This CANNOT be unrolled (presently, at least).
+ /// This _cannot_ be unrolled (presently, at least).
pub fn process_obligations<P>(&mut self, processor: &mut P, do_completed: DoCompleted)
-> Outcome<O, P::Error>
where P: ObligationProcessor<Obligation=O>
}
}
- /// Mark all NodeState::Success nodes as NodeState::Done and
+ /// Mark all `NodeState::Success` nodes as `NodeState::Done` and
/// report all cycles between them. This should be called
/// after `mark_as_waiting` marks all nodes with pending
/// subobligations as NodeState::Waiting.
}
}
- /// Marks all nodes that depend on a pending node as NodeState::Waiting.
+ /// Marks all nodes that depend on a pending node as `NodeState::Waiting`.
fn mark_as_waiting(&self) {
for node in &self.nodes {
if node.state.get() == NodeState::Waiting {
// I need a Clone closure
#[derive(Clone)]
-struct GetObligation<'a, O: 'a>(&'a [Node<O>]);
+struct GetObligation<'a, O>(&'a [Node<O>]);
impl<'a, 'b, O> FnOnce<(&'b usize,)> for GetObligation<'a, O> {
type Output = &'a O;
pub unsafe trait IntoErased<'a> {
/// Owner with the dereference type substituted to `Erased`.
type Erased;
- /// Perform the type erasure.
+ /// Performs the type erasure.
fn into_erased(self) -> Self::Erased;
}
pub unsafe trait IntoErasedSend<'a> {
/// Owner with the dereference type substituted to `Erased + Send`.
type Erased: Send;
- /// Perform the type erasure.
+ /// Performs the type erasure.
fn into_erased_send(self) -> Self::Erased;
}
pub unsafe trait IntoErasedSendSync<'a> {
/// Owner with the dereference type substituted to `Erased + Send + Sync`.
type Erased: Send + Sync;
- /// Perform the type erasure.
+ /// Performs the type erasure.
fn into_erased_send_sync(self) -> Self::Erased;
}
impl<O, H> OwningHandle<O, H>
where O: StableAddress, O::Target: ToHandle<Handle = H>, H: Deref,
{
- /// Create a new `OwningHandle` for a type that implements `ToHandle`. For types
+ /// Creates a new `OwningHandle` for a type that implements `ToHandle`. For types
/// that don't implement `ToHandle`, callers may invoke `new_with_fn`, which accepts
/// a callback to perform the conversion.
pub fn new(o: O) -> Self {
impl<O, H> OwningHandle<O, H>
where O: StableAddress, O::Target: ToHandleMut<HandleMut = H>, H: DerefMut,
{
- /// Create a new mutable `OwningHandle` for a type that implements `ToHandleMut`.
+ /// Creates a new mutable `OwningHandle` for a type that implements `ToHandleMut`.
pub fn new_mut(o: O) -> Self {
OwningHandle::new_with_fn(o, |x| unsafe { O::Target::to_handle_mut(x) })
}
impl<O, H> OwningHandle<O, H>
where O: StableAddress, H: Deref,
{
- /// Create a new OwningHandle. The provided callback will be invoked with
+ /// Creates a new OwningHandle. The provided callback will be invoked with
/// a pointer to the object owned by `o`, and the returned value is stored
/// as the object to which this `OwningHandle` will forward `Deref` and
/// `DerefMut`.
}
}
- /// Create a new OwningHandle. The provided callback will be invoked with
+ /// Creates a new OwningHandle. The provided callback will be invoked with
/// a pointer to the object owned by `o`, and the returned value is stored
/// as the object to which this `OwningHandle` will forward `Deref` and
/// `DerefMut`.
where O: Debug,
T: Debug,
{
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f,
"OwningRef {{ owner: {:?}, reference: {:?} }}",
self.owner(),
where O: Debug,
T: Debug,
{
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f,
"OwningRefMut {{ owner: {:?}, reference: {:?} }}",
self.owner(),
where O: Sync, for<'a> (&'a mut T): Sync {}
impl Debug for dyn Erased {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "<Erased>",)
}
}
/// A wrapper around reference that compares and hashes like a pointer.
/// Can be used as a key in sets/maps indexed by pointers to avoid `unsafe`.
#[derive(Debug)]
-pub struct PtrKey<'a, T: 'a>(pub &'a T);
+pub struct PtrKey<'a, T>(pub &'a T);
impl<'a, T> Clone for PtrKey<'a, T> {
fn clone(&self) -> Self { *self }
});
}
-/// Load an integer of the desired type from a byte stream, in LE order. Uses
+/// Loads an integer of the desired type from a byte stream, in LE order. Uses
/// `copy_nonoverlapping` to let the compiler generate the most efficient way
/// to load it from a possibly unaligned address.
///
});
}
-/// Load an u64 using up to 7 bytes of a byte slice.
+/// Loads an u64 using up to 7 bytes of a byte slice.
///
/// Unsafe because: unchecked indexing at start..start+len
#[inline]
-use fx::FxHashMap;
+use crate::fx::FxHashMap;
use std::hash::Hash;
use std::ops;
use std::mem;
/// Iterate over elements, sorted by key
#[inline]
- pub fn iter(&self) -> ::std::slice::Iter<(K, V)> {
+ pub fn iter(&self) -> ::std::slice::Iter<'_, (K, V)> {
self.data.iter()
}
use std::hash::{Hash, Hasher, BuildHasher};
use std::marker::PhantomData;
use std::mem;
-use sip128::SipHasher128;
+use crate::sip128::SipHasher128;
+use crate::indexed_vec;
+use crate::bit_set;
/// When hashing something that ends up affecting properties like symbol names,
/// we want these symbol names to be calculated independently of other factors
}
impl<W: StableHasherResult> ::std::fmt::Debug for StableHasher<W> {
- fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(f, "{:?}", self.state)
}
}
}
}
-impl<I: ::indexed_vec::Idx, T, CTX> HashStable<CTX> for ::indexed_vec::IndexVec<I, T>
+impl<I: indexed_vec::Idx, T, CTX> HashStable<CTX> for indexed_vec::IndexVec<I, T>
where T: HashStable<CTX>,
{
fn hash_stable<W: StableHasherResult>(&self,
}
-impl<I: ::indexed_vec::Idx, CTX> HashStable<CTX> for ::bit_set::BitSet<I>
+impl<I: indexed_vec::Idx, CTX> HashStable<CTX> for bit_set::BitSet<I>
{
fn hash_stable<W: StableHasherResult>(&self,
ctx: &mut CTX,
use std::hash::{Hash, Hasher};
use serialize::{Encodable, Decodable, Encoder, Decoder};
-use stable_hasher;
+use crate::stable_hasher;
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct Svh {
}
impl Svh {
- /// Create a new `Svh` given the hash. If you actually want to
+ /// Creates a new `Svh` given the hash. If you actually want to
/// compute the SVH from some HIR, you want the `calculate_svh`
/// function found in `librustc_incremental`.
pub fn new(hash: u64) -> Svh {
}
impl fmt::Display for Svh {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.pad(&self.to_string())
}
}
use std::hash::{Hash, BuildHasher};
use std::marker::PhantomData;
use std::ops::{Deref, DerefMut};
-use owning_ref::{Erased, OwningRef};
+use crate::owning_ref::{Erased, OwningRef};
pub fn serial_join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
where A: FnOnce() -> RA,
}
#[inline(always)]
- pub fn lock(&self) -> LockGuard<T> {
+ pub fn lock(&self) -> LockGuard<'_, T> {
self.0.lock()
}
#[inline(always)]
- pub fn lock_mut(&self) -> LockGuard<T> {
+ pub fn lock_mut(&self) -> LockGuard<'_, T> {
self.lock()
}
}
#[cfg(parallel_compiler)]
#[inline(always)]
- pub fn try_lock(&self) -> Option<LockGuard<T>> {
+ pub fn try_lock(&self) -> Option<LockGuard<'_, T>> {
self.0.try_lock()
}
#[cfg(not(parallel_compiler))]
#[inline(always)]
- pub fn try_lock(&self) -> Option<LockGuard<T>> {
+ pub fn try_lock(&self) -> Option<LockGuard<'_, T>> {
self.0.try_borrow_mut().ok()
}
#[cfg(parallel_compiler)]
#[inline(always)]
- pub fn lock(&self) -> LockGuard<T> {
+ pub fn lock(&self) -> LockGuard<'_, T> {
if ERROR_CHECKING {
self.0.try_lock().expect("lock was already held")
} else {
#[cfg(not(parallel_compiler))]
#[inline(always)]
- pub fn lock(&self) -> LockGuard<T> {
+ pub fn lock(&self) -> LockGuard<'_, T> {
self.0.borrow_mut()
}
}
#[inline(always)]
- pub fn borrow(&self) -> LockGuard<T> {
+ pub fn borrow(&self) -> LockGuard<'_, T> {
self.lock()
}
#[inline(always)]
- pub fn borrow_mut(&self) -> LockGuard<T> {
+ pub fn borrow_mut(&self) -> LockGuard<'_, T> {
self.lock()
}
}
#[cfg(not(parallel_compiler))]
#[inline(always)]
- pub fn read(&self) -> ReadGuard<T> {
+ pub fn read(&self) -> ReadGuard<'_, T> {
self.0.borrow()
}
#[cfg(parallel_compiler)]
#[inline(always)]
- pub fn read(&self) -> ReadGuard<T> {
+ pub fn read(&self) -> ReadGuard<'_, T> {
if ERROR_CHECKING {
self.0.try_read().expect("lock was already held")
} else {
#[cfg(not(parallel_compiler))]
#[inline(always)]
- pub fn try_write(&self) -> Result<WriteGuard<T>, ()> {
+ pub fn try_write(&self) -> Result<WriteGuard<'_, T>, ()> {
self.0.try_borrow_mut().map_err(|_| ())
}
#[cfg(parallel_compiler)]
#[inline(always)]
- pub fn try_write(&self) -> Result<WriteGuard<T>, ()> {
+ pub fn try_write(&self) -> Result<WriteGuard<'_, T>, ()> {
self.0.try_write().ok_or(())
}
#[cfg(not(parallel_compiler))]
#[inline(always)]
- pub fn write(&self) -> WriteGuard<T> {
+ pub fn write(&self) -> WriteGuard<'_, T> {
self.0.borrow_mut()
}
#[cfg(parallel_compiler)]
#[inline(always)]
- pub fn write(&self) -> WriteGuard<T> {
+ pub fn write(&self) -> WriteGuard<'_, T> {
if ERROR_CHECKING {
self.0.try_write().expect("lock was already held")
} else {
}
#[inline(always)]
- pub fn borrow(&self) -> ReadGuard<T> {
+ pub fn borrow(&self) -> ReadGuard<'_, T> {
self.read()
}
#[inline(always)]
- pub fn borrow_mut(&self) -> WriteGuard<T> {
+ pub fn borrow_mut(&self) -> WriteGuard<'_, T> {
self.write()
}
}
mod test {
use super::*;
extern crate test;
- use self::test::Bencher;
+ use test::Bencher;
#[test]
fn test_contains_and_insert() {
-use bit_set::BitMatrix;
-use fx::FxHashMap;
-use sync::Lock;
+use crate::bit_set::BitMatrix;
+use crate::fx::FxHashMap;
+use crate::stable_hasher::{HashStable, StableHasher, StableHasherResult};
+use crate::sync::Lock;
use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
-use stable_hasher::{HashStable, StableHasher, StableHasherResult};
use std::fmt::Debug;
use std::hash::Hash;
use std::mem;
}
/// Applies the (partial) function to each edge and returns a new
- /// relation. If `f` returns `None` for any end-point, returns
+ /// relation. If `f` returns `None` for any end-point, returns
/// `None`.
pub fn maybe_map<F, U>(&self, mut f: F) -> Option<TransitiveRelation<U>>
where F: FnMut(&T) -> Option<U>,
}
}
- /// Check whether `a < target` (transitively)
+ /// Checks whether `a < target` (transitively)
pub fn contains(&self, a: &T, b: &T) -> bool {
match (self.index(a), self.index(b)) {
(Some(a), Some(b)) => self.with_closure(|closure| closure.contains(a.0, b.0)),
/// Thinking of `x R y` as an edge `x -> y` in a graph, this
/// returns all things reachable from `a`.
///
- /// Really this probably ought to be `impl Iterator<Item=&T>`, but
+ /// Really this probably ought to be `impl Iterator<Item = &T>`, but
/// I'm too lazy to make that work, and -- given the caching
/// strategy -- it'd be a touch tricky anyhow.
pub fn reachable_from(&self, a: &T) -> Vec<&T> {
/// the query is `postdom_upper_bound(a, b)`:
///
/// ```text
- /// // returns Some(x), which is also LUB
+ /// // Returns Some(x), which is also LUB.
/// a -> a1 -> x
/// ^
/// |
/// b -> b1 ---+
///
- /// // returns Some(x), which is not LUB (there is none)
- /// // diagonal edges run left-to-right
+ /// // Returns `Some(x)`, which is not LUB (there is none)
+ /// // diagonal edges run left-to-right.
/// a -> a1 -> x
/// \/ ^
/// /\ |
/// b -> b1 ---+
///
- /// // returns None
+ /// // Returns `None`.
/// a -> a1
/// b -> b1
/// ```
-use indexed_vec::{Idx, IndexVec};
+use crate::indexed_vec::{Idx, IndexVec};
pub fn iter<Ls>(
first: Option<Ls::LinkIndex>,
-use bit_set::BitSet;
-use indexed_vec::Idx;
+use crate::bit_set::BitSet;
+use crate::indexed_vec::Idx;
use std::collections::VecDeque;
/// A work queue is a handy data structure for tracking work left to
}
impl<T: Idx> WorkQueue<T> {
- /// Create a new work queue with all the elements from (0..len).
+ /// Creates a new work queue with all the elements from (0..len).
#[inline]
pub fn with_all(len: usize) -> Self {
WorkQueue {
}
}
- /// Create a new work queue that starts empty, where elements range from (0..len).
+ /// Creates a new work queue that starts empty, where elements range from (0..len).
#[inline]
pub fn with_none(len: usize) -> Self {
WorkQueue {
}
}
- /// True if nothing is enqueued.
+ /// Returns `true` if nothing is enqueued.
#[inline]
pub fn is_empty(&self) -> bool {
self.deque.is_empty()
(control.after_analysis.callback)(&mut state);
});
+ // Plugins like clippy and rust-semverver stop the analysis early,
+ // but want to still return an error if errors during the analysis
+ // happened:
+ tcx.sess.compile_status()?;
+
if control.after_analysis.stop == Compilation::Stop {
return result.and_then(|_| Err(CompileIncomplete::Stopped));
}
pub hir_forest: hir_map::Forest,
}
-/// Run the "early phases" of the compiler: initial `cfg` processing,
+/// Runs the "early phases" of the compiler: initial `cfg` processing,
/// loading compiler plugins (including those from `addl_plugins`),
/// syntax expansion, secondary `cfg` expansion, synthesis of a test
/// harness if one is to be provided, injection of a dependency on the
cstore::provide_extern(providers);
}
-/// Run the resolution, typechecking, region checking and other
+/// Runs the resolution, typec-hecking, region checking and other
/// miscellaneous analysis passes on the crate. Return various
/// structures carrying the results of the analysis.
pub fn phase_3_run_analysis_passes<'tcx, F, R>(
)
}
-/// Run the codegen backend, after which the AST and analysis can
+/// Runs the codegen backend, after which the AST and analysis can
/// be discarded.
pub fn phase_4_codegen<'a, 'tcx>(
codegen_backend: &dyn CodegenBackend,
#![cfg_attr(unix, feature(libc))]
#![feature(nll)]
#![feature(rustc_diagnostic_macros)]
-#![feature(slice_sort_by_cached_key)]
#![feature(set_stdio)]
#![feature(no_debug)]
#![feature(integer_atomics)]
use rustc::session::Session;
use rustc_codegen_utils::codegen_backend::CodegenBackend;
- /// Add `target_feature = "..."` cfgs for a variety of platform
+ /// Adds `target_feature = "..."` cfgs for a variety of platform
/// specific features (SSE, NEON etc.).
///
/// This is performed by checking whether a whitelisted set of
early_error(sopts.error_format, "no input filename given");
}
1 => panic!("make_input should have provided valid inputs"),
- _ => early_error(sopts.error_format, "multiple input filenames provided"),
+ _ =>
+ early_error(
+ sopts.error_format,
+ &format!(
+ "multiple input filenames provided (first two filenames are `{}` and `{}`)",
+ matches.free[0],
+ matches.free[1],
+ ),
+ )
}
}
/// Process command line options. Emits messages as appropriate. If compilation
/// should continue, returns a getopts::Matches object parsed from args,
-/// otherwise returns None.
+/// otherwise returns `None`.
///
/// The compiler's handling of options is a little complicated as it ties into
/// our stability story, and it's even *more* complicated by historical
in_named_rustc_thread("rustc".to_string(), f)
}
-/// Get a list of extra command-line flags provided by the user, as strings.
+/// Gets a list of extra command-line flags provided by the user, as strings.
///
/// This function is used during ICEs to show more information useful for
/// debugging, since some ICEs only happens with non-default compiler flags
}
}
-/// Run a procedure which will detect panics in the compiler and print nicer
+/// Runs a procedure which will detect panics in the compiler and print nicer
/// error messages rather than just failing the test.
///
/// The diagnostic emitter yielded to the procedure should be used for reporting
-//! # Standalone Tests for the Inference Module
+//! Standalone tests for the inference module.
use driver;
use errors;
})
}
-/// Test substituting a bound region into a function, which introduces another level of binding.
-/// This requires adjusting the Debruijn index.
+/// Tests substituting a bound region into a function, which introduces another level of binding.
+/// This requires adjusting the De Bruijn index.
#[test]
fn subst_ty_renumber_some_bounds() {
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
})
}
-/// Test that we correctly compute whether a type has escaping regions or not.
+/// Tests that we correctly compute whether a type has escaping regions or not.
#[test]
fn escaping() {
test_env(EMPTY_SOURCE_STR, errors(&[]), |mut env| {
})
}
-/// Test applying a substitution where the value being substituted for an early-bound region is a
+/// Tests applying a substitution where the value being substituted for an early-bound region is a
/// late-bound region.
#[test]
fn subst_region_renumber_region() {
use crate::CodeSuggestion;
+use crate::SuggestionStyle;
use crate::SubstitutionPart;
use crate::Substitution;
use crate::Applicability;
self.level == Level::Cancelled
}
- /// Add a span/label to be included in the resulting snippet.
+ /// Adds a span/label to be included in the resulting snippet.
/// This is pushed onto the `MultiSpan` that was created when the
/// diagnostic was first built. If you don't call this function at
/// all, and you just supplied a `Span` to create the diagnostic,
.collect(),
}],
msg: msg.to_owned(),
- show_code_when_inline: true,
+ style: SuggestionStyle::ShowCode,
+ applicability,
+ });
+ self
+ }
+
+ /// Prints out a message with for a multipart suggestion without showing the suggested code.
+ ///
+ /// This is intended to be used for suggestions that are obvious in what the changes need to
+ /// be from the message, showing the span label inline would be visually unpleasant
+ /// (marginally overlapping spans or multiline spans) and showing the snippet window wouldn't
+ /// improve understandability.
+ pub fn tool_only_multipart_suggestion(
+ &mut self,
+ msg: &str,
+ suggestion: Vec<(Span, String)>,
+ applicability: Applicability,
+ ) -> &mut Self {
+ self.suggestions.push(CodeSuggestion {
+ substitutions: vec![Substitution {
+ parts: suggestion
+ .into_iter()
+ .map(|(span, snippet)| SubstitutionPart { snippet, span })
+ .collect(),
+ }],
+ msg: msg.to_owned(),
+ style: SuggestionStyle::CompletelyHidden,
applicability,
});
self
}],
}],
msg: msg.to_owned(),
- show_code_when_inline: true,
+ style: SuggestionStyle::ShowCode,
applicability,
});
self
}],
}).collect(),
msg: msg.to_owned(),
- show_code_when_inline: true,
+ style: SuggestionStyle::ShowCode,
applicability,
});
self
}],
}],
msg: msg.to_owned(),
- show_code_when_inline: false,
+ style: SuggestionStyle::HideCodeInline,
+ applicability,
+ });
+ self
+ }
+
+ /// Prints out a message with for a suggestion without showing the suggested code.
+ ///
+ /// This is intended to be used for suggestions that are obvious in what the changes need to
+ /// be from the message, showing the span label inline would be visually unpleasant
+ /// (marginally overlapping spans or multiline spans) and showing the snippet window wouldn't
+ /// improve understandability.
+ pub fn span_suggestion_hidden(
+ &mut self, sp: Span, msg: &str, suggestion: String, applicability: Applicability
+ ) -> &mut Self {
+ self.suggestions.push(CodeSuggestion {
+ substitutions: vec![Substitution {
+ parts: vec![SubstitutionPart {
+ snippet: suggestion,
+ span: sp,
+ }],
+ }],
+ msg: msg.to_owned(),
+ style: SuggestionStyle::HideCodeInline,
+ applicability,
+ });
+ self
+ }
+
+ /// Adds a suggestion to the json output, but otherwise remains silent/undisplayed in the cli.
+ ///
+ /// This is intended to be used for suggestions that are *very* obvious in what the changes
+ /// need to be from the message, but we still want other tools to be able to apply them.
+ pub fn tool_only_span_suggestion(
+ &mut self, sp: Span, msg: &str, suggestion: String, applicability: Applicability
+ ) -> &mut Self {
+ self.suggestions.push(CodeSuggestion {
+ substitutions: vec![Substitution {
+ parts: vec![SubstitutionPart {
+ snippet: suggestion,
+ span: sp,
+ }],
+ }],
+ msg: msg.to_owned(),
+ style: SuggestionStyle::CompletelyHidden,
applicability: applicability,
});
self
/// In general, the `DiagnosticBuilder` uses deref to allow access to
/// the fields and methods of the embedded `diagnostic` in a
-/// transparent way. *However,* many of the methods are intended to
+/// transparent way. *However,* many of the methods are intended to
/// be used in a chained way, and hence ought to return `self`. In
/// that case, we can't just naively forward to the method on the
/// `diagnostic`, because the return type would be a `&Diagnostic`
self.cancel();
}
- /// Add a span/label to be included in the resulting snippet.
+ /// Adds a span/label to be included in the resulting snippet.
/// This is pushed onto the `MultiSpan` that was created when the
/// diagnostic was first built. If you don't call this function at
/// all, and you just supplied a `Span` to create the diagnostic,
self
}
+ pub fn tool_only_multipart_suggestion(
+ &mut self,
+ msg: &str,
+ suggestion: Vec<(Span, String)>,
+ applicability: Applicability,
+ ) -> &mut Self {
+ if !self.allow_suggestions {
+ return self
+ }
+ self.diagnostic.tool_only_multipart_suggestion(
+ msg,
+ suggestion,
+ applicability,
+ );
+ self
+ }
+
+
pub fn span_suggestion(
&mut self,
sp: Span,
);
self
}
+
+ pub fn span_suggestion_hidden(
+ &mut self,
+ sp: Span,
+ msg: &str,
+ suggestion: String,
+ applicability: Applicability,
+ ) -> &mut Self {
+ if !self.allow_suggestions {
+ return self
+ }
+ self.diagnostic.span_suggestion_hidden(
+ sp,
+ msg,
+ suggestion,
+ applicability,
+ );
+ self
+ }
+
+ pub fn tool_only_span_suggestion(
+ &mut self,
+ sp: Span,
+ msg: &str,
+ suggestion: String,
+ applicability: Applicability,
+ ) -> &mut Self {
+ if !self.allow_suggestions {
+ return self
+ }
+ self.diagnostic.tool_only_span_suggestion(
+ sp,
+ msg,
+ suggestion,
+ applicability,
+ );
+ self
+ }
+
forward!(pub fn set_span<S: Into<MultiSpan>>(&mut self, sp: S) -> &mut Self);
forward!(pub fn code(&mut self, s: DiagnosticId) -> &mut Self);
use syntax_pos::{SourceFile, Span, MultiSpan};
-use crate::{Level, CodeSuggestion, DiagnosticBuilder, SubDiagnostic, SourceMapperDyn, DiagnosticId};
+use crate::{
+ Level, CodeSuggestion, DiagnosticBuilder, SubDiagnostic,
+ SuggestionStyle, SourceMapperDyn, DiagnosticId,
+};
use crate::snippet::{Annotation, AnnotationType, Line, MultilineAnnotation, StyledString, Style};
use crate::styled_buffer::StyledBuffer;
/// Emit a structured diagnostic.
fn emit(&mut self, db: &DiagnosticBuilder<'_>);
- /// Check if should show explanations about "rustc --explain"
+ /// Checks if should show explanations about "rustc --explain"
fn should_show_explain(&self) -> bool {
true
}
// don't display long messages as labels
sugg.msg.split_whitespace().count() < 10 &&
// don't display multiline suggestions as labels
- !sugg.substitutions[0].parts[0].snippet.contains('\n') {
+ !sugg.substitutions[0].parts[0].snippet.contains('\n') &&
+ // when this style is set we want the suggestion to be a message, not inline
+ sugg.style != SuggestionStyle::HideCodeAlways &&
+ // trivial suggestion for tooling's sake, never shown
+ sugg.style != SuggestionStyle::CompletelyHidden
+ {
let substitution = &sugg.substitutions[0].parts[0].snippet.trim();
- let msg = if substitution.len() == 0 || !sugg.show_code_when_inline {
+ let msg = if substitution.len() == 0 || sugg.style.hide_inline() {
// This substitution is only removal or we explicitly don't want to show the
// code inline, don't show it
format!("help: {}", sugg.msg)
// | | something about `foo`
// | something about `fn foo()`
annotations_position.sort_by(|a, b| {
- // Decreasing order
- a.1.len().cmp(&b.1.len()).reverse()
+ // Decreasing order. When `a` and `b` are the same length, prefer `Primary`.
+ (a.1.len(), !a.1.is_primary).cmp(&(b.1.len(), !b.1.is_primary)).reverse()
});
// Write the underlines.
}
}
- /// Add a left margin to every line but the first, given a padding length and the label being
+ /// Adds a left margin to every line but the first, given a padding length and the label being
/// displayed, keeping the provided highlighting.
fn msg_to_buffer(&self,
buffer: &mut StyledBuffer,
// `max_line_num_len`
let padding = " ".repeat(padding + label.len() + 5);
- /// Return whether `style`, or the override if present and the style is `NoStyle`.
+ /// Returns `true` if `style`, or the override if present and the style is `NoStyle`.
fn style_or_override(style: Style, override_style: Option<Style>) -> Style {
if let Some(o) = override_style {
if style == Style::NoStyle {
}
}
- fn emit_message_default(&mut self,
- msp: &MultiSpan,
- msg: &[(String, Style)],
- code: &Option<DiagnosticId>,
- level: &Level,
- max_line_num_len: usize,
- is_secondary: bool)
- -> io::Result<()> {
+ fn emit_message_default(
+ &mut self,
+ msp: &MultiSpan,
+ msg: &[(String, Style)],
+ code: &Option<DiagnosticId>,
+ level: &Level,
+ max_line_num_len: usize,
+ is_secondary: bool,
+ ) -> io::Result<()> {
let mut buffer = StyledBuffer::new();
let header_style = if is_secondary {
Style::HeaderMsg
}
- fn emit_suggestion_default(&mut self,
- suggestion: &CodeSuggestion,
- level: &Level,
- max_line_num_len: usize)
- -> io::Result<()> {
+ fn emit_suggestion_default(
+ &mut self,
+ suggestion: &CodeSuggestion,
+ level: &Level,
+ max_line_num_len: usize,
+ ) -> io::Result<()> {
if let Some(ref sm) = self.sm {
let mut buffer = StyledBuffer::new();
buffer.append(0, &level_str, Style::Level(level.clone()));
buffer.append(0, ": ", Style::HeaderMsg);
}
- self.msg_to_buffer(&mut buffer,
- &[(suggestion.msg.to_owned(), Style::NoStyle)],
- max_line_num_len,
- "suggestion",
- Some(Style::HeaderMsg));
+ self.msg_to_buffer(
+ &mut buffer,
+ &[(suggestion.msg.to_owned(), Style::NoStyle)],
+ max_line_num_len,
+ "suggestion",
+ Some(Style::HeaderMsg),
+ );
// Render the replacements for each suggestion
let suggestions = suggestion.splice_lines(&**sm);
if !self.short_message {
for child in children {
let span = child.render_span.as_ref().unwrap_or(&child.span);
- match self.emit_message_default(&span,
- &child.styled_message(),
- &None,
- &child.level,
- max_line_num_len,
- true) {
+ match self.emit_message_default(
+ &span,
+ &child.styled_message(),
+ &None,
+ &child.level,
+ max_line_num_len,
+ true,
+ ) {
Err(e) => panic!("failed to emit error: {}", e),
_ => ()
}
}
for sugg in suggestions {
- match self.emit_suggestion_default(sugg,
- &Level::Help,
- max_line_num_len) {
- Err(e) => panic!("failed to emit error: {}", e),
- _ => ()
+ if sugg.style == SuggestionStyle::CompletelyHidden {
+ // do not display this suggestion, it is meant only for tools
+ } else if sugg.style == SuggestionStyle::HideCodeAlways {
+ match self.emit_message_default(
+ &MultiSpan::new(),
+ &[(sugg.msg.to_owned(), Style::HeaderMsg)],
+ &None,
+ &Level::Help,
+ max_line_num_len,
+ true,
+ ) {
+ Err(e) => panic!("failed to emit error: {}", e),
+ _ => ()
+ }
+ } else {
+ match self.emit_suggestion_default(
+ sugg,
+ &Level::Help,
+ max_line_num_len,
+ ) {
+ Err(e) => panic!("failed to emit error: {}", e),
+ _ => ()
+ }
}
}
}
#![allow(unused_attributes)]
#![feature(range_contains)]
#![cfg_attr(unix, feature(libc))]
+#![feature(nll)]
#![feature(optin_builtin_traits)]
#![deny(rust_2018_idioms)]
Unspecified,
}
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, RustcEncodable, RustcDecodable)]
+pub enum SuggestionStyle {
+ /// Hide the suggested code when displaying this suggestion inline.
+ HideCodeInline,
+ /// Always hide the suggested code but display the message.
+ HideCodeAlways,
+ /// Do not display this suggestion in the cli output, it is only meant for tools.
+ CompletelyHidden,
+ /// Always show the suggested code.
+ /// This will *not* show the code if the suggestion is inline *and* the suggested code is
+ /// empty.
+ ShowCode,
+}
+
+impl SuggestionStyle {
+ fn hide_inline(&self) -> bool {
+ match *self {
+ SuggestionStyle::ShowCode => false,
+ _ => true,
+ }
+ }
+}
+
#[derive(Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)]
pub struct CodeSuggestion {
/// Each substitute can have multiple variants due to multiple
/// ```
pub substitutions: Vec<Substitution>,
pub msg: String,
- pub show_code_when_inline: bool,
+ /// Visual representation of this suggestion.
+ pub style: SuggestionStyle,
/// Whether or not the suggestion is approximate
///
/// Sometimes we may show suggestions with placeholders,
/// Resets the diagnostic error count as well as the cached emitted diagnostics.
///
- /// NOTE: DO NOT call this function from rustc. It is only meant to be called from external
+ /// NOTE: *do not* call this function from rustc. It is only meant to be called from external
/// tools that want to reuse a `Parser` cleaning the previously emitted diagnostics as well as
/// the overall count of emitted error diagnostics.
pub fn reset_err_count(&self) {
Copy,
}
-/// Copy `p` into `q`, preferring to use hard-linking if possible. If
+/// Copies `p` into `q`, preferring to use hard-linking if possible. If
/// `q` already exists, it is removed first.
/// The result indicates which of the two operations has been performed.
pub fn link_or_copy<P: AsRef<Path>, Q: AsRef<Path>>(p: P, q: Q) -> io::Result<LinkOrCopy> {
authors = ["The Rust Project Developers"]
name = "rustc_incremental"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_incremental"
//! In this code, we report errors on each `rustc_if_this_changed`
//! annotation. If a path exists in all cases, then we would report
//! "all path(s) exist". Otherwise, we report: "no path to `foo`" for
-//! each case where no path exists. `compile-fail` tests can then be
+//! each case where no path exists. `compile-fail` tests can then be
//! used to check when paths exist or do not.
//!
//! The full form of the `rustc_if_this_changed` annotation is
}
}
-fn dump_graph(tcx: TyCtxt) {
+fn dump_graph(tcx: TyCtxt<'_, '_, '_>) {
let path: String = env::var("RUST_DEP_GRAPH").unwrap_or_else(|_| "dep_graph".to_string());
let query = tcx.dep_graph.query();
impl<'a, 'tcx, 'q> dot::GraphWalk<'a> for GraphvizDepGraph<'q> {
type Node = &'q DepNode;
type Edge = (&'q DepNode, &'q DepNode);
- fn nodes(&self) -> dot::Nodes<&'q DepNode> {
+ fn nodes(&self) -> dot::Nodes<'_, &'q DepNode> {
let nodes: Vec<_> = self.0.iter().cloned().collect();
nodes.into()
}
- fn edges(&self) -> dot::Edges<(&'q DepNode, &'q DepNode)> {
+ fn edges(&self) -> dot::Edges<'_, (&'q DepNode, &'q DepNode)> {
self.1[..].into()
}
fn source(&self, edge: &(&'q DepNode, &'q DepNode)) -> &'q DepNode {
impl<'a, 'tcx, 'q> dot::Labeller<'a> for GraphvizDepGraph<'q> {
type Node = &'q DepNode;
type Edge = (&'q DepNode, &'q DepNode);
- fn graph_id(&self) -> dot::Id {
+ fn graph_id(&self) -> dot::Id<'_> {
dot::Id::new("DependencyGraph").unwrap()
}
- fn node_id(&self, n: &&'q DepNode) -> dot::Id {
+ fn node_id(&self, n: &&'q DepNode) -> dot::Id<'_> {
let s: String =
format!("{:?}", n).chars()
.map(|c| if c == '_' || c.is_alphanumeric() { c } else { '_' })
debug!("n={:?} s={:?}", n, s);
dot::Id::new(s).unwrap()
}
- fn node_label(&self, n: &&'q DepNode) -> dot::LabelText {
+ fn node_label(&self, n: &&'q DepNode) -> dot::LabelText<'_> {
dot::LabelText::label(format!("{:?}", n))
}
}
#![recursion_limit="256"]
-extern crate graphviz;
+#![deny(rust_2018_idioms)]
+
#[macro_use] extern crate rustc;
-extern crate rustc_data_structures;
-extern crate serialize as rustc_serialize;
-extern crate rand;
-extern crate rustc_fs_util;
+#[allow(unused_extern_crates)]
+extern crate serialize as rustc_serialize; // used by deriving
#[macro_use] extern crate log;
-extern crate syntax;
-extern crate syntax_pos;
mod assert_dep_graph;
pub mod assert_module_sources;
//!
//! - `#[rustc_clean(cfg="rev2", except="TypeckTables")]` if we are
//! in `#[cfg(rev2)]`, then the fingerprints associated with
-//! `DepNode::TypeckTables(X)` must be DIFFERENT (`X` is the def-id of the
+//! `DepNode::TypeckTables(X)` must be DIFFERENT (`X` is the `DefId` of the
//! current node).
//! - `#[rustc_clean(cfg="rev2")]` same as above, except that the
//! fingerprints must be the SAME (along with all other fingerprints).
//!
//! Errors are reported if we are in the suitable configuration but
//! the required condition is not met.
-//!
use std::iter::FromIterator;
use std::vec::Vec;
label_strs::ImplTraitRef,
];
-/// DepNodes for MirValidated/Optimized, which is relevant in "executable"
+/// DepNodes for MirBuilt/Optimized, which is relevant in "executable"
/// code, i.e., functions+methods
const BASE_MIR: &[&str] = &[
label_strs::MirOptimized,
- label_strs::MirValidated,
+ label_strs::MirBuilt,
];
/// Struct, Enum and Union DepNodes
label_strs::TypeOfItem,
];
-/// Trait Definition DepNodes
+/// Trait definition `DepNode`s.
const BASE_TRAIT_DEF: &[&str] = &[
label_strs::AssociatedItemDefIds,
label_strs::GenericsOfItem,
label_strs::TraitImpls,
];
-/// extra DepNodes for methods (+fn)
+/// Extra `DepNode`s for functions and methods.
const EXTRA_ASSOCIATED: &[&str] = &[
label_strs::AssociatedItems,
];
EXTRA_TRAIT,
];
-/// Function DepNode
+/// Function `DepNode`s.
const LABELS_FN: &[&[&str]] = &[
BASE_HIR,
BASE_MIR,
BASE_FN,
];
-/// Method DepNodes
+/// Method `DepNode`s.
const LABELS_FN_IN_IMPL: &[&[&str]] = &[
BASE_HIR,
BASE_MIR,
EXTRA_ASSOCIATED,
];
-/// Trait-Method DepNodes
+/// Trait method `DepNode`s.
const LABELS_FN_IN_TRAIT: &[&[&str]] = &[
BASE_HIR,
BASE_MIR,
EXTRA_TRAIT,
];
-/// For generic cases like inline-assembly/mod/etc
+/// For generic cases like inline-assembly, modules, etc.
const LABELS_HIR_ONLY: &[&[&str]] = &[
BASE_HIR,
];
-/// Impl DepNodes
+/// Impl `DepNode`s.
const LABELS_IMPL: &[&[&str]] = &[
BASE_HIR,
BASE_IMPL,
];
-/// Abstract Data Type (Struct, Enum, Unions) DepNodes
+/// Abstract data type (struct, enum, union) `DepNode`s.
const LABELS_ADT: &[&[&str]] = &[
BASE_HIR,
BASE_STRUCT,
];
-/// Trait Definition DepNodes
+/// Trait definition `DepNode`s.
#[allow(dead_code)]
const LABELS_TRAIT: &[&[&str]] = &[
BASE_HIR,
Some(assertion)
}
- /// Get the "auto" assertion on pre-validated attr, along with the `except` labels
+ /// Gets the "auto" assertion on pre-validated attr, along with the `except` labels.
fn assertion_auto(&mut self, item_id: ast::NodeId, attr: &Attribute, is_clean: bool)
-> Assertion
{
///
/// Also make sure that the `label` and `except` fields do not
/// both exist.
-fn check_config(tcx: TyCtxt, attr: &Attribute) -> bool {
+fn check_config(tcx: TyCtxt<'_, '_, '_>, attr: &Attribute) -> bool {
debug!("check_config(attr={:?})", attr);
let config = &tcx.sess.parse_sess.config;
debug!("check_config: config={:?}", config);
}
}
-fn expect_associated_value(tcx: TyCtxt, item: &NestedMetaItem) -> ast::Name {
+fn expect_associated_value(tcx: TyCtxt<'_, '_, '_>, item: &NestedMetaItem) -> ast::Name {
if let Some(value) = item.value_str() {
value
} else {
use rustc::session::config::nightly_options;
use rustc_serialize::opaque::Encoder;
-/// The first few bytes of files generated by incremental compilation
+/// The first few bytes of files generated by incremental compilation.
const FILE_MAGIC: &[u8] = b"RSIC";
-/// Change this if the header format changes
+/// Change this if the header format changes.
const HEADER_FORMAT_VERSION: u16 = 0;
/// A version string that hopefully is always different for compiler versions
/// with different encodings of incremental compilation artifacts. Contains
-/// the git commit hash.
+/// the Git commit hash.
const RUSTC_VERSION: Option<&str> = option_env!("CFG_VERSION");
pub fn write_file_header(stream: &mut Encoder) {
Ok(files_linked > 0 || files_copied == 0)
}
-/// Generate unique directory path of the form:
+/// Generates unique directory path of the form:
/// {crate_dir}/s-{timestamp}-{random-number}-working
fn generate_session_dir_path(crate_dir: &Path) -> PathBuf {
let timestamp = timestamp_to_string(SystemTime::now());
}
}
-/// Find the most recent published session directory that is not in the
+/// Finds the most recent published session directory that is not in the
/// ignore-list.
fn find_source_directory(crate_dir: &Path,
source_directories_already_tried: &FxHashSet<PathBuf>)
use rustc_serialize::Decodable as RustcDecodable;
use rustc_serialize::opaque::Decoder;
use std::path::Path;
-use std;
use super::data::*;
use super::fs::*;
mod work_product;
mod file_format;
-pub use self::fs::finalize_session_directory;
-pub use self::fs::garbage_collect_session_directories;
-pub use self::fs::in_incr_comp_dir;
-pub use self::fs::in_incr_comp_dir_sess;
-pub use self::fs::prepare_session_directory;
-pub use self::load::dep_graph_tcx_init;
-pub use self::load::load_dep_graph;
-pub use self::load::load_query_result_cache;
-pub use self::load::LoadResult;
-pub use self::save::save_dep_graph;
-pub use self::save::save_work_product_index;
-pub use self::work_product::copy_cgu_workproducts_to_incr_comp_cache_dir;
-pub use self::work_product::delete_workproduct_files;
+pub use fs::finalize_session_directory;
+pub use fs::garbage_collect_session_directories;
+pub use fs::in_incr_comp_dir;
+pub use fs::in_incr_comp_dir_sess;
+pub use fs::prepare_session_directory;
+pub use load::dep_graph_tcx_init;
+pub use load::load_dep_graph;
+pub use load::load_query_result_cache;
+pub use load::LoadResult;
+pub use save::save_dep_graph;
+pub use save::save_work_product_index;
+pub use work_product::copy_cgu_workproducts_to_incr_comp_cache_dir;
+pub use work_product::delete_workproduct_files;
}
}
-fn encode_dep_graph(tcx: TyCtxt,
+fn encode_dep_graph(tcx: TyCtxt<'_, '_, '_>,
encoder: &mut Encoder) {
// First encode the commandline arguments hash
tcx.sess.opts.dep_tracking_hash().encode(encoder).unwrap();
serialized_products.encode(encoder).unwrap();
}
-fn encode_query_cache(tcx: TyCtxt,
+fn encode_query_cache(tcx: TyCtxt<'_, '_, '_>,
encoder: &mut Encoder) {
time(tcx.sess, "serialize query result cache", || {
tcx.serialize_query_result_cache(encoder).unwrap();
//! This module contains files for saving intermediate work-products.
-use persist::fs::*;
+use crate::persist::fs::*;
use rustc::dep_graph::{WorkProduct, WorkProductId, WorkProductFileKind};
use rustc::session::Session;
use rustc_fs_util::link_or_copy;
authors = ["The Rust Project Developers"]
name = "rustc_lint"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_lint"
path = "lib.rs"
crate-type = ["dylib"]
-test = false
[dependencies]
log = "0.4"
//! `LintPass` (also, note that such lints will need to be defined in
//! `rustc::lint::builtin`, not here).
//!
-//! If you define a new `LintPass`, you will also need to add it to the
-//! `add_builtin!` or `add_builtin_with_new!` invocation in `lib.rs`.
-//! Use the former for unit-like structs and the latter for structs with
-//! a `pub fn new()`.
+//! If you define a new `EarlyLintPass`, you will also need to add it to the
+//! `add_early_builtin!` or `add_early_builtin_with_new!` invocation in
+//! `lib.rs`. Use the former for unit-like structs and the latter for structs
+//! with a `pub fn new()`.
+//!
+//! If you define a new `LateLintPass`, you will also need to add it to the
+//! `late_lint_methods!` invocation in `lib.rs`.
use rustc::hir::def::Def;
use rustc::hir::def_id::{DefId, LOCAL_CRATE};
use rustc::ty::{self, Ty};
+use rustc::{lint, util};
use hir::Node;
use util::nodemap::NodeSet;
use lint::{LateContext, LintContext, LintArray};
use syntax::errors::{Applicability, DiagnosticBuilder};
use syntax::print::pprust::expr_to_string;
use syntax::visit::FnKind;
+use syntax::struct_span_err;
use rustc::hir::{self, GenericParamKind, PatKind};
-use nonstandard_style::{MethodLateContext, method_context};
+use crate::nonstandard_style::{MethodLateContext, method_context};
+
+use log::debug;
// hardwired lints from librustc
pub use lint::builtin::*;
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for WhileTrue {
- fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
+ fn check_expr(&mut self, cx: &LateContext<'_, '_>, e: &hir::Expr) {
if let hir::ExprKind::While(ref cond, ..) = e.node {
if let hir::ExprKind::Lit(ref lit) = cond.node {
if let ast::LitKind::Bool(true) = lit.node {
pub struct BoxPointers;
impl BoxPointers {
- fn check_heap_type<'a, 'tcx>(&self, cx: &LateContext, span: Span, ty: Ty) {
+ fn check_heap_type<'a, 'tcx>(&self, cx: &LateContext<'_, '_>, span: Span, ty: Ty<'_>) {
for leaf_ty in ty.walk() {
if leaf_ty.is_box() {
let m = format!("type uses owned (Box type) pointers: {}", ty);
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxPointers {
- fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
match it.node {
hir::ItemKind::Fn(..) |
hir::ItemKind::Ty(..) |
}
}
- fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
- let ty = cx.tables.node_id_to_type(e.hir_id);
+ fn check_expr(&mut self, cx: &LateContext<'_, '_>, e: &hir::Expr) {
+ let ty = cx.tables.node_type(e.hir_id);
self.check_heap_type(cx, e.span, ty);
}
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonShorthandFieldPatterns {
- fn check_pat(&mut self, cx: &LateContext, pat: &hir::Pat) {
+ fn check_pat(&mut self, cx: &LateContext<'_, '_>, pat: &hir::Pat) {
if let PatKind::Struct(ref qpath, ref field_pats, _) = pat.node {
let variant = cx.tables.pat_ty(pat).ty_adt_def()
.expect("struct pattern type is not an ADT")
}
impl UnsafeCode {
- fn report_unsafe(&self, cx: &EarlyContext, span: Span, desc: &'static str) {
+ fn report_unsafe(&self, cx: &EarlyContext<'_>, span: Span, desc: &'static str) {
// This comes from a macro that has #[allow_internal_unsafe].
if span.allows_unsafe() {
return;
}
impl EarlyLintPass for UnsafeCode {
- fn check_attribute(&mut self, cx: &EarlyContext, attr: &ast::Attribute) {
+ fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &ast::Attribute) {
if attr.check_name("allow_internal_unsafe") {
self.report_unsafe(cx, attr.span, "`allow_internal_unsafe` allows defining \
macros using unsafe without triggering \
}
}
- fn check_expr(&mut self, cx: &EarlyContext, e: &ast::Expr) {
+ fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
if let ast::ExprKind::Block(ref blk, _) = e.node {
// Don't warn about generated blocks, that'll just pollute the output.
if blk.rules == ast::BlockCheckMode::Unsafe(ast::UserProvided) {
}
}
- fn check_item(&mut self, cx: &EarlyContext, it: &ast::Item) {
+ fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) {
match it.node {
ast::ItemKind::Trait(_, ast::Unsafety::Unsafe, ..) => {
self.report_unsafe(cx, it.span, "declaration of an `unsafe` trait")
}
fn check_fn(&mut self,
- cx: &EarlyContext,
- fk: FnKind,
+ cx: &EarlyContext<'_>,
+ fk: FnKind<'_>,
_: &ast::FnDecl,
span: Span,
_: ast::NodeId) {
}
}
- fn check_trait_item(&mut self, cx: &EarlyContext, item: &ast::TraitItem) {
+ fn check_trait_item(&mut self, cx: &EarlyContext<'_>, item: &ast::TraitItem) {
if let ast::TraitItemKind::Method(ref sig, None) = item.node {
if sig.header.unsafety == ast::Unsafety::Unsafe {
self.report_unsafe(cx, item.span, "declaration of an `unsafe` method")
}
pub struct MissingDoc {
- /// Stack of whether #[doc(hidden)] is set
- /// at each level which has lint attributes.
+ /// Stack of whether `#[doc(hidden)]` is set at each level which has lint attributes.
doc_hidden_stack: Vec<bool>,
/// Private traits or trait items that leaked through. Don't check their methods.
}
fn check_missing_docs_attrs(&self,
- cx: &LateContext,
+ cx: &LateContext<'_, '_>,
id: Option<ast::NodeId>,
attrs: &[ast::Attribute],
sp: Span,
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
- fn enter_lint_attrs(&mut self, _: &LateContext, attrs: &[ast::Attribute]) {
+ fn enter_lint_attrs(&mut self, _: &LateContext<'_, '_>, attrs: &[ast::Attribute]) {
let doc_hidden = self.doc_hidden() ||
attrs.iter().any(|attr| {
attr.check_name("doc") &&
self.doc_hidden_stack.push(doc_hidden);
}
- fn exit_lint_attrs(&mut self, _: &LateContext, _attrs: &[ast::Attribute]) {
+ fn exit_lint_attrs(&mut self, _: &LateContext<'_, '_>, _attrs: &[ast::Attribute]) {
self.doc_hidden_stack.pop().expect("empty doc_hidden_stack");
}
- fn check_crate(&mut self, cx: &LateContext, krate: &hir::Crate) {
+ fn check_crate(&mut self, cx: &LateContext<'_, '_>, krate: &hir::Crate) {
self.check_missing_docs_attrs(cx, None, &krate.attrs, krate.span, "crate");
for macro_def in &krate.exported_macros {
}
}
- fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
let desc = match it.node {
hir::ItemKind::Fn(..) => "a function",
hir::ItemKind::Mod(..) => "a module",
self.check_missing_docs_attrs(cx, Some(it.id), &it.attrs, it.span, desc);
}
- fn check_trait_item(&mut self, cx: &LateContext, trait_item: &hir::TraitItem) {
+ fn check_trait_item(&mut self, cx: &LateContext<'_, '_>, trait_item: &hir::TraitItem) {
if self.private_traits.contains(&trait_item.id) {
return;
}
desc);
}
- fn check_impl_item(&mut self, cx: &LateContext, impl_item: &hir::ImplItem) {
+ fn check_impl_item(&mut self, cx: &LateContext<'_, '_>, impl_item: &hir::ImplItem) {
// If the method is an impl for a trait, don't doc.
if method_context(cx, impl_item.id) == MethodLateContext::TraitImpl {
return;
desc);
}
- fn check_struct_field(&mut self, cx: &LateContext, sf: &hir::StructField) {
+ fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, sf: &hir::StructField) {
if !sf.is_positional() {
self.check_missing_docs_attrs(cx,
Some(sf.id),
}
}
- fn check_variant(&mut self, cx: &LateContext, v: &hir::Variant, _: &hir::Generics) {
+ fn check_variant(&mut self, cx: &LateContext<'_, '_>, v: &hir::Variant, _: &hir::Generics) {
self.check_missing_docs_attrs(cx,
Some(v.node.data.id()),
&v.node.attrs,
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingCopyImplementations {
- fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item) {
if !cx.access_levels.is_reachable(item.id) {
return;
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDebugImplementations {
- fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item) {
if !cx.access_levels.is_reachable(item.id) {
return;
}
"detects anonymous parameters"
}
-/// Checks for use of anonymous parameters (RFC 1685)
-#[derive(Clone)]
+/// Checks for use of anonymous parameters (RFC 1685).
+#[derive(Copy, Clone)]
pub struct AnonymousParameters;
impl LintPass for AnonymousParameters {
}
impl EarlyLintPass for AnonymousParameters {
- fn check_trait_item(&mut self, cx: &EarlyContext, it: &ast::TraitItem) {
+ fn check_trait_item(&mut self, cx: &EarlyContext<'_>, it: &ast::TraitItem) {
match it.node {
ast::TraitItemKind::Method(ref sig, _) => {
for arg in sig.decl.inputs.iter() {
}
}
-/// Checks for use of attributes which have been deprecated.
+/// Check for use of attributes which have been deprecated.
#[derive(Clone)]
pub struct DeprecatedAttr {
// This is not free to compute, so we want to keep it around, rather than
}
impl EarlyLintPass for DeprecatedAttr {
- fn check_attribute(&mut self, cx: &EarlyContext, attr: &ast::Attribute) {
+ fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &ast::Attribute) {
for &&(n, _, _, ref g) in &self.depr_attrs {
if attr.name() == n {
if let &AttributeGate::Gated(Stability::Deprecated(link, suggestion),
}
impl EarlyLintPass for UnusedDocComment {
- fn check_local(&mut self, cx: &EarlyContext, decl: &ast::Local) {
+ fn check_local(&mut self, cx: &EarlyContext<'_>, decl: &ast::Local) {
self.warn_if_doc(decl.attrs.iter(), cx);
}
- fn check_arm(&mut self, cx: &EarlyContext, arm: &ast::Arm) {
+ fn check_arm(&mut self, cx: &EarlyContext<'_>, arm: &ast::Arm) {
self.warn_if_doc(arm.attrs.iter(), cx);
}
- fn check_expr(&mut self, cx: &EarlyContext, expr: &ast::Expr) {
+ fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
self.warn_if_doc(expr.attrs.iter(), cx);
}
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PluginAsLibrary {
- fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
if cx.tcx.plugin_registrar_fn(LOCAL_CRATE).is_some() {
// We're compiling a plugin; it's fine to link other plugins.
return;
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidNoMangleItems {
- fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
match it.node {
hir::ItemKind::Fn(.., ref generics, _) => {
if let Some(no_mangle_attr) = attr::find_by_name(&it.attrs, "no_mangle") {
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MutableTransmutes {
- fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) {
+ fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &hir::Expr) {
use rustc_target::spec::abi::Abi::RustIntrinsic;
let msg = "mutating transmuted &mut T from &T may cause undefined behavior, \
if !def_id_is_transmute(cx, did) {
return None;
}
- let sig = cx.tables.node_id_to_type(expr.hir_id).fn_sig(cx.tcx);
+ let sig = cx.tables.node_type(expr.hir_id).fn_sig(cx.tcx);
let from = sig.inputs().skip_binder()[0];
let to = *sig.output().skip_binder();
return Some((&from.sty, &to.sty));
None
}
- fn def_id_is_transmute(cx: &LateContext, def_id: DefId) -> bool {
+ fn def_id_is_transmute(cx: &LateContext<'_, '_>, def_id: DefId) -> bool {
cx.tcx.fn_sig(def_id).abi() == RustIntrinsic &&
cx.tcx.item_name(def_id) == "transmute"
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnstableFeatures {
- fn check_attribute(&mut self, ctx: &LateContext, attr: &ast::Attribute) {
+ fn check_attribute(&mut self, ctx: &LateContext<'_, '_>, attr: &ast::Attribute) {
if attr.check_name("feature") {
if let Some(items) = attr.meta_item_list() {
for item in items {
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnionsWithDropFields {
- fn check_item(&mut self, ctx: &LateContext, item: &hir::Item) {
+ fn check_item(&mut self, ctx: &LateContext<'_, '_>, item: &hir::Item) {
if let hir::ItemKind::Union(ref vdata, _) = item.node {
for field in vdata.fields() {
let field_ty = ctx.tcx.type_of(ctx.tcx.hir().local_def_id(field.id));
}
}
-/// Lint for items marked `pub` that aren't reachable from other crates
+/// Lint for items marked `pub` that aren't reachable from other crates.
+#[derive(Copy, Clone)]
pub struct UnreachablePub;
declare_lint! {
}
impl UnreachablePub {
- fn perform_lint(&self, cx: &LateContext, what: &str, id: ast::NodeId,
+ fn perform_lint(&self, cx: &LateContext<'_, '_>, what: &str, id: ast::NodeId,
vis: &hir::Visibility, span: Span, exportable: bool) {
let mut applicability = Applicability::MachineApplicable;
match vis.node {
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnreachablePub {
- fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item) {
self.perform_lint(cx, "item", item.id, &item.vis, item.span, true);
}
- fn check_foreign_item(&mut self, cx: &LateContext, foreign_item: &hir::ForeignItem) {
+ fn check_foreign_item(&mut self, cx: &LateContext<'_, '_>, foreign_item: &hir::ForeignItem) {
self.perform_lint(cx, "item", foreign_item.id, &foreign_item.vis,
foreign_item.span, true);
}
- fn check_struct_field(&mut self, cx: &LateContext, field: &hir::StructField) {
+ fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, field: &hir::StructField) {
self.perform_lint(cx, "field", field.id, &field.vis, field.span, false);
}
- fn check_impl_item(&mut self, cx: &LateContext, impl_item: &hir::ImplItem) {
+ fn check_impl_item(&mut self, cx: &LateContext<'_, '_>, impl_item: &hir::ImplItem) {
self.perform_lint(cx, "item", impl_item.id, &impl_item.vis, impl_item.span, false);
}
}
-/// Lint for trait and lifetime bounds in type aliases being mostly ignored:
+/// Lint for trait and lifetime bounds in type aliases being mostly ignored.
/// They are relevant when using associated types, but otherwise neither checked
/// at definition site nor enforced at use site.
}
}
- fn suggest_changing_assoc_types(ty: &hir::Ty, err: &mut DiagnosticBuilder) {
+ fn suggest_changing_assoc_types(ty: &hir::Ty, err: &mut DiagnosticBuilder<'_>) {
// Access to associates types should use `<T as Bound>::Assoc`, which does not need a
// bound. Let's see if this type does that.
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeAliasBounds {
- fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item) {
let (ty, type_alias_generics) = match item.node {
hir::ItemKind::Ty(ref ty, ref generics) => (&*ty, generics),
_ => return,
lint_array!()
}
}
-fn check_const(cx: &LateContext, body_id: hir::BodyId) {
+fn check_const(cx: &LateContext<'_, '_>, body_id: hir::BodyId) {
let def_id = cx.tcx.hir().body_owner_def_id(body_id);
let is_static = cx.tcx.is_static(def_id).is_some();
let param_env = if is_static {
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedBrokenConst {
- fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
match it.node {
hir::ItemKind::Const(_, body_id) => {
check_const(cx, body_id);
}
impl EarlyLintPass for EllipsisInclusiveRangePatterns {
- fn check_pat(&mut self, cx: &EarlyContext, pat: &ast::Pat, visit_subpats: &mut bool) {
+ fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &ast::Pat, visit_subpats: &mut bool) {
use self::ast::{PatKind, RangeEnd, RangeSyntax::DotDotDot};
/// If `pat` is a `...` pattern, return the start and end of the range, as well as the span
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnameableTestItems {
- fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
if self.items_nameable {
if let hir::ItemKind::Mod(..) = it.node {}
else {
}
}
- fn check_item_post(&mut self, _cx: &LateContext, it: &hir::Item) {
+ fn check_item_post(&mut self, _cx: &LateContext<'_, '_>, it: &hir::Item) {
if !self.items_nameable && self.boundary == it.id {
self.items_nameable = true;
}
"detects edition keywords being used as an identifier"
}
-/// Checks for uses of edition keywords used as an identifier
-#[derive(Clone)]
+/// Check for uses of edition keywords used as an identifier.
+#[derive(Copy, Clone)]
pub struct KeywordIdents;
impl LintPass for KeywordIdents {
}
impl KeywordIdents {
- fn check_tokens(&mut self, cx: &EarlyContext, tokens: TokenStream) {
+ fn check_tokens(&mut self, cx: &EarlyContext<'_>, tokens: TokenStream) {
for tt in tokens.into_trees() {
match tt {
TokenTree::Token(span, tok) => match tok.ident() {
}
impl EarlyLintPass for KeywordIdents {
- fn check_mac_def(&mut self, cx: &EarlyContext, mac_def: &ast::MacroDef, _id: ast::NodeId) {
+ fn check_mac_def(&mut self, cx: &EarlyContext<'_>, mac_def: &ast::MacroDef, _id: ast::NodeId) {
self.check_tokens(cx, mac_def.stream());
}
- fn check_mac(&mut self, cx: &EarlyContext, mac: &ast::Mac) {
+ fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &ast::Mac) {
self.check_tokens(cx, mac.node.tts.clone().into());
}
- fn check_ident(&mut self, cx: &EarlyContext, ident: ast::Ident) {
+ fn check_ident(&mut self, cx: &EarlyContext<'_>, ident: ast::Ident) {
let ident_str = &ident.as_str()[..];
let cur_edition = cx.sess.edition();
let is_raw_ident = |ident: ast::Ident| {
impl ExplicitOutlivesRequirements {
fn collect_outlives_bound_spans(
&self,
- cx: &LateContext,
+ cx: &LateContext<'_, '_>,
item_def_id: DefId,
param_name: &str,
bounds: &hir::GenericBounds,
+use syntax::{register_diagnostic, register_diagnostics};
+
register_diagnostics! {
E0721, // `await` keyword
}
#![recursion_limit="256"]
-#[macro_use]
-extern crate syntax;
+#![deny(rust_2018_idioms)]
+
#[macro_use]
extern crate rustc;
-#[macro_use]
-extern crate log;
-extern crate rustc_target;
-extern crate syntax_pos;
-extern crate rustc_data_structures;
mod diagnostics;
mod nonstandard_style;
parser::ILL_FORMED_ATTRIBUTE_INPUT,
};
use rustc::session;
-use rustc::util;
use rustc::hir;
use syntax::ast;
reference: "issue #57644 <https://github.com/rust-lang/rust/issues/57644>",
edition: None,
},
+ FutureIncompatibleInfo {
+ id: LintId::of(DUPLICATE_MATCHER_BINDING_NAME),
+ reference: "issue #57593 <https://github.com/rust-lang/rust/issues/57593>",
+ edition: None,
+ },
]);
// Register renamed and removed lints.
use rustc::hir::{self, GenericParamKind, PatKind};
use rustc::hir::def::Def;
use rustc::hir::intravisit::FnKind;
+use rustc::lint;
use rustc::ty;
use rustc_target::spec::abi::Abi;
use lint::{EarlyContext, LateContext, LintContext, LintArray};
PlainImpl,
}
-pub fn method_context(cx: &LateContext, id: ast::NodeId) -> MethodLateContext {
+pub fn method_context(cx: &LateContext<'_, '_>, id: ast::NodeId) -> MethodLateContext {
let def_id = cx.tcx.hir().local_def_id(id);
let item = cx.tcx.associated_item(def_id);
match item.container {
"types, variants, traits and type parameters should have camel case names"
}
-#[derive(Copy, Clone)]
-pub struct NonCamelCaseTypes;
+fn char_has_case(c: char) -> bool {
+ c.is_lowercase() || c.is_uppercase()
+}
-impl NonCamelCaseTypes {
- fn check_case(&self, cx: &EarlyContext, sort: &str, ident: &Ident) {
- fn char_has_case(c: char) -> bool {
- c.is_lowercase() || c.is_uppercase()
- }
+fn is_camel_case(name: &str) -> bool {
+ let name = name.trim_matches('_');
+ if name.is_empty() {
+ return true;
+ }
- fn is_camel_case(name: &str) -> bool {
- let name = name.trim_matches('_');
- if name.is_empty() {
- return true;
+ // start with a non-lowercase letter rather than non-uppercase
+ // ones (some scripts don't have a concept of upper/lowercase)
+ !name.chars().next().unwrap().is_lowercase()
+ && !name.contains("__")
+ && !name.chars().collect::<Vec<_>>().windows(2).any(|pair| {
+ // contains a capitalisable character followed by, or preceded by, an underscore
+ char_has_case(pair[0]) && pair[1] == '_' || char_has_case(pair[1]) && pair[0] == '_'
+ })
+}
+
+fn to_camel_case(s: &str) -> String {
+ s.trim_matches('_')
+ .split('_')
+ .filter(|component| !component.is_empty())
+ .map(|component| {
+ let mut camel_cased_component = String::new();
+
+ let mut new_word = true;
+ let mut prev_is_lower_case = true;
+
+ for c in component.chars() {
+ // Preserve the case if an uppercase letter follows a lowercase letter, so that
+ // `camelCase` is converted to `CamelCase`.
+ if prev_is_lower_case && c.is_uppercase() {
+ new_word = true;
+ }
+
+ if new_word {
+ camel_cased_component.push_str(&c.to_uppercase().to_string());
+ } else {
+ camel_cased_component.push_str(&c.to_lowercase().to_string());
+ }
+
+ prev_is_lower_case = c.is_lowercase();
+ new_word = false;
}
- // start with a non-lowercase letter rather than non-uppercase
- // ones (some scripts don't have a concept of upper/lowercase)
- !name.is_empty() && !name.chars().next().unwrap().is_lowercase() &&
- !name.contains("__") && !name.chars().collect::<Vec<_>>().windows(2).any(|pair| {
- // contains a capitalisable character followed by, or preceded by, an underscore
- char_has_case(pair[0]) && pair[1] == '_' ||
- char_has_case(pair[1]) && pair[0] == '_'
- })
- }
+ camel_cased_component
+ })
+ .fold(
+ (String::new(), None),
+ |(acc, prev): (String, Option<String>), next| {
+ // separate two components with an underscore if their boundary cannot
+ // be distinguished using a uppercase/lowercase case distinction
+ let join = if let Some(prev) = prev {
+ let l = prev.chars().last().unwrap();
+ let f = next.chars().next().unwrap();
+ !char_has_case(l) && !char_has_case(f)
+ } else {
+ false
+ };
+ (acc + if join { "_" } else { "" } + &next, Some(next))
+ },
+ )
+ .0
+}
- fn to_camel_case(s: &str) -> String {
- s.trim_matches('_')
- .split('_')
- .map(|word| {
- word.chars().enumerate().map(|(i, c)| if i == 0 {
- c.to_uppercase().collect::<String>()
- } else {
- c.to_lowercase().collect()
- })
- .collect::<String>()
- })
- .filter(|x| !x.is_empty())
- .fold((String::new(), None), |(acc, prev): (String, Option<String>), next| {
- // separate two components with an underscore if their boundary cannot
- // be distinguished using a uppercase/lowercase case distinction
- let join = if let Some(prev) = prev {
- let l = prev.chars().last().unwrap();
- let f = next.chars().next().unwrap();
- !char_has_case(l) && !char_has_case(f)
- } else { false };
- (acc + if join { "_" } else { "" } + &next, Some(next))
- }).0
- }
+#[derive(Copy, Clone)]
+pub struct NonCamelCaseTypes;
+impl NonCamelCaseTypes {
+ fn check_case(&self, cx: &EarlyContext<'_>, sort: &str, ident: &Ident) {
let name = &ident.name.as_str();
if !is_camel_case(name) {
- let c = to_camel_case(name);
-
- let msg = format!("{} `{}` should have a camel case name", sort, name);
+ let msg = format!("{} `{}` should have an upper camel case name", sort, name);
cx.struct_span_lint(NON_CAMEL_CASE_TYPES, ident.span, &msg)
.span_suggestion(
ident.span,
- "convert the identifier to camel case",
- c,
+ "convert the identifier to upper camel case",
+ to_camel_case(name),
Applicability::MaybeIncorrect,
)
.emit();
}
impl EarlyLintPass for NonCamelCaseTypes {
- fn check_item(&mut self, cx: &EarlyContext, it: &ast::Item) {
+ fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) {
let has_repr_c = it.attrs
.iter()
- .any(|attr| {
- attr::find_repr_attrs(&cx.sess.parse_sess, attr)
- .iter()
- .any(|r| r == &attr::ReprC)
- });
+ .any(|attr| attr::find_repr_attrs(&cx.sess.parse_sess, attr).contains(&attr::ReprC));
if has_repr_c {
return;
}
}
- fn check_variant(&mut self, cx: &EarlyContext, v: &ast::Variant, _: &ast::Generics) {
+ fn check_variant(&mut self, cx: &EarlyContext<'_>, v: &ast::Variant, _: &ast::Generics) {
self.check_case(cx, "variant", &v.node.ident);
}
- fn check_generic_param(&mut self, cx: &EarlyContext, param: &ast::GenericParam) {
+ fn check_generic_param(&mut self, cx: &EarlyContext<'_>, param: &ast::GenericParam) {
if let ast::GenericParamKind::Type { .. } = param.kind {
self.check_case(cx, "type parameter", ¶m.ident);
}
}
/// Checks if a given identifier is snake case, and reports a diagnostic if not.
- fn check_snake_case(&self, cx: &LateContext, sort: &str, ident: &Ident) {
+ fn check_snake_case(&self, cx: &LateContext<'_, '_>, sort: &str, ident: &Ident) {
fn is_snake_case(ident: &str) -> bool {
if ident.is_empty() {
return true;
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase {
- fn check_crate(&mut self, cx: &LateContext, cr: &hir::Crate) {
+ fn check_crate(&mut self, cx: &LateContext<'_, '_>, cr: &hir::Crate) {
let crate_ident = if let Some(name) = &cx.tcx.sess.opts.crate_name {
Some(Ident::from_str(name))
} else {
}
}
- fn check_generic_param(&mut self, cx: &LateContext, param: &hir::GenericParam) {
+ fn check_generic_param(&mut self, cx: &LateContext<'_, '_>, param: &hir::GenericParam) {
if let GenericParamKind::Lifetime { .. } = param.kind {
self.check_snake_case(cx, "lifetime", ¶m.name.ident());
}
fn check_fn(
&mut self,
- cx: &LateContext,
- fk: FnKind,
+ cx: &LateContext<'_, '_>,
+ fk: FnKind<'_>,
_: &hir::FnDecl,
_: &hir::Body,
_: Span,
}
}
- fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
if let hir::ItemKind::Mod(_) = it.node {
self.check_snake_case(cx, "module", &it.ident);
}
}
- fn check_trait_item(&mut self, cx: &LateContext, item: &hir::TraitItem) {
+ fn check_trait_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::TraitItem) {
if let hir::TraitItemKind::Method(_, hir::TraitMethod::Required(pnames)) = &item.node {
self.check_snake_case(cx, "trait method", &item.ident);
for param_name in pnames {
}
}
- fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) {
+ fn check_pat(&mut self, cx: &LateContext<'_, '_>, p: &hir::Pat) {
if let &PatKind::Binding(_, _, _, ident, _) = &p.node {
self.check_snake_case(cx, "variable", &ident);
}
fn check_struct_def(
&mut self,
- cx: &LateContext,
+ cx: &LateContext<'_, '_>,
s: &hir::VariantData,
_: ast::Name,
_: &hir::Generics,
pub struct NonUpperCaseGlobals;
impl NonUpperCaseGlobals {
- fn check_upper_case(cx: &LateContext, sort: &str, ident: &Ident) {
+ fn check_upper_case(cx: &LateContext<'_, '_>, sort: &str, ident: &Ident) {
let name = &ident.name.as_str();
if name.chars().any(|c| c.is_lowercase()) {
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals {
- fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
match it.node {
hir::ItemKind::Static(..) if !attr::contains_name(&it.attrs, "no_mangle") => {
NonUpperCaseGlobals::check_upper_case(cx, "static variable", &it.ident);
}
}
- fn check_trait_item(&mut self, cx: &LateContext, ti: &hir::TraitItem) {
+ fn check_trait_item(&mut self, cx: &LateContext<'_, '_>, ti: &hir::TraitItem) {
if let hir::TraitItemKind::Const(..) = ti.node {
NonUpperCaseGlobals::check_upper_case(cx, "associated constant", &ti.ident);
}
}
- fn check_impl_item(&mut self, cx: &LateContext, ii: &hir::ImplItem) {
+ fn check_impl_item(&mut self, cx: &LateContext<'_, '_>, ii: &hir::ImplItem) {
if let hir::ImplItemKind::Const(..) = ii.node {
NonUpperCaseGlobals::check_upper_case(cx, "associated constant", &ii.ident);
}
}
- fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) {
+ fn check_pat(&mut self, cx: &LateContext<'_, '_>, p: &hir::Pat) {
// Lint for constants that look like binding identifiers (#7526)
if let PatKind::Path(hir::QPath::Resolved(None, ref path)) = p.node {
if let Def::Const(..) = path.def {
}
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::{is_camel_case, to_camel_case};
+
+ #[test]
+ fn camel_case() {
+ assert!(!is_camel_case("userData"));
+ assert_eq!(to_camel_case("userData"), "UserData");
+
+ assert!(is_camel_case("X86_64"));
+
+ assert!(!is_camel_case("X86__64"));
+ assert_eq!(to_camel_case("X86__64"), "X86_64");
+
+ assert!(!is_camel_case("Abc_123"));
+ assert_eq!(to_camel_case("Abc_123"), "Abc123");
+
+ assert!(!is_camel_case("A1_b2_c3"));
+ assert_eq!(to_camel_case("A1_b2_c3"), "A1B2C3");
+
+ assert!(!is_camel_case("ONE_TWO_THREE"));
+ assert_eq!(to_camel_case("ONE_TWO_THREE"), "OneTwoThree");
+ }
+}
use rustc::ty::subst::Substs;
use rustc::ty::{self, AdtKind, ParamEnv, Ty, TyCtxt};
use rustc::ty::layout::{self, IntegerExt, LayoutOf, VariantIdx};
+use rustc::{lint, util};
use rustc_data_structures::indexed_vec::Idx;
use util::nodemap::FxHashSet;
use lint::{LateContext, LintContext, LintArray};
use rustc::mir::interpret::{sign_extend, truncate};
+use log::debug;
+
declare_lint! {
UNUSED_COMPARISONS,
Warn,
}
}
hir::ExprKind::Lit(ref lit) => {
- match cx.tables.node_id_to_type(e.hir_id).sty {
+ match cx.tables.node_type(e.hir_id).sty {
ty::Int(t) => {
match lit.node {
ast::LitKind::Int(v, ast::LitIntType::Signed(_)) |
}
}
- fn check_limits(cx: &LateContext,
+ fn check_limits(cx: &LateContext<'_, '_>,
binop: hir::BinOp,
l: &hir::Expr,
r: &hir::Expr)
// Normalize the binop so that the literal is always on the RHS in
// the comparison
let norm_binop = if swap { rev_binop(binop) } else { binop };
- match cx.tables.node_id_to_type(expr.hir_id).sty {
+ match cx.tables.node_type(expr.hir_id).sty {
ty::Int(int_ty) => {
let (min, max) = int_ty_range(int_ty);
let lit_val: i128 = match lit.node {
}
}
- fn get_bin_hex_repr(cx: &LateContext, lit: &ast::Lit) -> Option<String> {
+ fn get_bin_hex_repr(cx: &LateContext<'_, '_>, lit: &ast::Lit) -> Option<String> {
let src = cx.sess().source_map().span_to_snippet(lit.span).ok()?;
let firstch = src.chars().next()?;
//
// No suggestion for: `isize`, `usize`.
fn get_type_suggestion<'a>(
- t: &ty::TyKind,
+ t: &ty::TyKind<'_>,
val: u128,
negative: bool,
) -> Option<String> {
}
fn report_bin_hex_error(
- cx: &LateContext,
+ cx: &LateContext<'_, '_>,
expr: &hir::Expr,
- ty: ty::TyKind,
+ ty: ty::TyKind<'_>,
repr_str: String,
val: u128,
negative: bool,
repr_str, val, t, actually, t
));
if let Some(sugg_ty) =
- get_type_suggestion(&cx.tables.node_id_to_type(expr.hir_id).sty, val, negative)
+ get_type_suggestion(&cx.tables.node_type(expr.hir_id).sty, val, negative)
{
if let Some(pos) = repr_str.chars().position(|c| c == 'i' || c == 'u') {
let (sans_suffix, _) = repr_str.split_at(pos);
}
impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
- /// Check if the given type is "ffi-safe" (has a stable, well-defined
+ /// Checks if the given type is "ffi-safe" (has a stable, well-defined
/// representation which can be exported to C code).
fn check_type_for_ffi(&self,
cache: &mut FxHashSet<Ty<'tcx>>,
ty: Ty<'tcx>) -> FfiResult<'tcx> {
- use self::FfiResult::*;
+ use FfiResult::*;
let cx = self.cx.tcx;
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImproperCTypes {
- fn check_foreign_item(&mut self, cx: &LateContext, it: &hir::ForeignItem) {
+ fn check_foreign_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::ForeignItem) {
let mut vis = ImproperCTypesVisitor { cx };
let abi = cx.tcx.hir().get_foreign_abi(it.id);
if abi != Abi::RustIntrinsic && abi != Abi::PlatformIntrinsic {
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VariantSizeDifferences {
- fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
+ fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) {
if let hir::ItemKind::Enum(ref enum_definition, _) = it.node {
let item_def_id = cx.tcx.hir().local_def_id(it.id);
let t = cx.tcx.type_of(item_def_id);
use rustc::hir::def::Def;
use rustc::hir::def_id::DefId;
+use rustc::lint;
use rustc::ty;
use rustc::ty::adjustment;
use lint::{LateContext, EarlyContext, LintContext, LintArray};
use rustc::hir;
+use log::debug;
+
declare_lint! {
pub UNUSED_MUST_USE,
Warn,
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedResults {
- fn check_stmt(&mut self, cx: &LateContext, s: &hir::Stmt) {
+ fn check_stmt(&mut self, cx: &LateContext<'_, '_>, s: &hir::Stmt) {
let expr = match s.node {
hir::StmtKind::Semi(ref expr) => &**expr,
_ => return,
}
fn check_must_use(
- cx: &LateContext,
+ cx: &LateContext<'_, '_>,
def_id: DefId,
sp: Span,
descr_pre_path: &str,
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PathStatements {
- fn check_stmt(&mut self, cx: &LateContext, s: &hir::Stmt) {
+ fn check_stmt(&mut self, cx: &LateContext<'_, '_>, s: &hir::Stmt) {
if let hir::StmtKind::Semi(ref expr) = s.node {
if let hir::ExprKind::Path(_) = expr.node {
cx.span_lint(PATH_STATEMENTS, s.span, "path statement with no effect");
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAttributes {
- fn check_attribute(&mut self, cx: &LateContext, attr: &ast::Attribute) {
+ fn check_attribute(&mut self, cx: &LateContext<'_, '_>, attr: &ast::Attribute) {
debug!("checking attribute: {:?}", attr);
// Note that check_name() marks the attribute as used if it matches.
for &(name, ty, ..) in BUILTIN_ATTRIBUTES {
impl UnusedParens {
fn check_unused_parens_expr(&self,
- cx: &EarlyContext,
+ cx: &EarlyContext<'_>,
value: &ast::Expr,
msg: &str,
followed_by_block: bool) {
}
fn check_unused_parens_pat(&self,
- cx: &EarlyContext,
+ cx: &EarlyContext<'_>,
value: &ast::Pat,
msg: &str) {
if let ast::PatKind::Paren(_) = value.node {
}
}
- fn remove_outer_parens(cx: &EarlyContext, span: Span, pattern: &str, msg: &str) {
+ fn remove_outer_parens(cx: &EarlyContext<'_>, span: Span, pattern: &str, msg: &str) {
let span_msg = format!("unnecessary parentheses around {}", msg);
let mut err = cx.struct_span_lint(UNUSED_PARENS, span, &span_msg);
let mut ate_left_paren = false;
}
impl EarlyLintPass for UnusedParens {
- fn check_expr(&mut self, cx: &EarlyContext, e: &ast::Expr) {
+ fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
use syntax::ast::ExprKind::*;
let (value, msg, followed_by_block) = match e.node {
If(ref cond, ..) => (cond, "`if` condition", true),
self.check_unused_parens_expr(cx, &value, msg, followed_by_block);
}
- fn check_pat(&mut self, cx: &EarlyContext, p: &ast::Pat, _: &mut bool) {
+ fn check_pat(&mut self, cx: &EarlyContext<'_>, p: &ast::Pat, _: &mut bool) {
use ast::PatKind::{Paren, Range};
// The lint visitor will visit each subpattern of `p`. We do not want to lint any range
// pattern no matter where it occurs in the pattern. For something like `&(a..=b)`, there
}
}
- fn check_stmt(&mut self, cx: &EarlyContext, s: &ast::Stmt) {
+ fn check_stmt(&mut self, cx: &EarlyContext<'_>, s: &ast::Stmt) {
if let ast::StmtKind::Local(ref local) = s.node {
if let Some(ref value) = local.init {
self.check_unused_parens_expr(cx, &value, "assigned value", false);
pub struct UnusedImportBraces;
impl UnusedImportBraces {
- fn check_use_tree(&self, cx: &EarlyContext, use_tree: &ast::UseTree, item: &ast::Item) {
+ fn check_use_tree(&self, cx: &EarlyContext<'_>, use_tree: &ast::UseTree, item: &ast::Item) {
if let ast::UseTreeKind::Nested(ref items) = use_tree.kind {
// Recursively check nested UseTrees
for &(ref tree, _) in items {
}
impl EarlyLintPass for UnusedImportBraces {
- fn check_item(&mut self, cx: &EarlyContext, item: &ast::Item) {
+ fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
if let ast::ItemKind::Use(ref use_tree) = item.node {
self.check_use_tree(cx, use_tree, item);
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAllocation {
- fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
+ fn check_expr(&mut self, cx: &LateContext<'_, '_>, e: &hir::Expr) {
match e.node {
hir::ExprKind::Box(_) => {}
_ => return,
#![deny(rust_2018_idioms)]
+#![feature(nll)]
#![feature(static_nobundle)]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
#![sanitizer_runtime]
+#![feature(nll)]
#![feature(sanitizer_runtime)]
#![feature(staged_api)]
#![no_std]
authors = ["The Rust Project Developers"]
name = "rustc_metadata"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_metadata"
memmap = "0.6"
rustc = { path = "../librustc" }
rustc_data_structures = { path = "../librustc_data_structures" }
-rustc_errors = { path = "../librustc_errors" }
+errors = { path = "../librustc_errors", package = "rustc_errors" }
rustc_target = { path = "../librustc_target" }
serialize = { path = "../libserialize" }
stable_deref_trait = "1.0.0"
//! Validates all used crates and extern libraries and loads their metadata
-use cstore::{self, CStore, CrateSource, MetadataBlob};
-use locator::{self, CratePaths};
-use decoder::proc_macro_def_path_table;
-use schema::CrateRoot;
+use crate::cstore::{self, CStore, CrateSource, MetadataBlob};
+use crate::locator::{self, CratePaths};
+use crate::decoder::proc_macro_def_path_table;
+use crate::schema::CrateRoot;
use rustc_data_structures::sync::{Lrc, RwLock, Lock};
use rustc::hir::def_id::CrateNum;
use syntax::ext::base::SyntaxExtension;
use syntax::symbol::Symbol;
use syntax::visit;
+use syntax::{span_err, span_fatal};
use syntax_pos::{Span, DUMMY_SP};
-use log;
+use log::{debug, info, log_enabled};
pub struct Library {
pub dylib: Option<(PathBuf, PathKind)>,
}
}
- fn load(&mut self, locate_ctxt: &mut locator::Context) -> Option<LoadResult> {
+ fn load(&mut self, locate_ctxt: &mut locator::Context<'_>) -> Option<LoadResult> {
let library = locate_ctxt.maybe_load_library_crate()?;
// In the case that we're loading a crate, but not matching
// The map from crate numbers in the crate we're resolving to local crate numbers.
// We map 0 and all other holes in the map to our parent crate. The "additional"
// self-dependencies should be harmless.
- ::std::iter::once(krate).chain(crate_root.crate_deps
+ std::iter::once(krate).chain(crate_root.crate_deps
.decode(metadata)
.map(|dep| {
info!("resolving dep crate {} hash: `{}` extra filename: `{}`", dep.name, dep.hash,
}
}
- /// Load custom derive macros.
+ /// Loads custom derive macros.
///
/// Note that this is intentionally similar to how we load plugins today,
/// but also intentionally separate. Plugins are likely always going to be
fn load_derive_macros(&mut self, root: &CrateRoot, dylib: Option<PathBuf>, span: Span)
-> Vec<(ast::Name, Lrc<SyntaxExtension>)> {
use std::{env, mem};
- use dynamic_lib::DynamicLibrary;
+ use crate::dynamic_lib::DynamicLibrary;
use proc_macro::bridge::client::ProcMacro;
use syntax_ext::deriving::custom::ProcMacroDerive;
use syntax_ext::proc_macro_impl::{AttrProcMacro, BangProcMacro};
ProcMacro::Bang { name, client } => {
(name, SyntaxExtension::ProcMacro {
expander: Box::new(BangProcMacro { client }),
- allow_internal_unstable: false,
+ allow_internal_unstable: None,
edition: root.edition,
})
}
item.ident, orig_name);
let orig_name = match orig_name {
Some(orig_name) => {
- ::validate_crate_name(Some(self.sess), &orig_name.as_str(),
+ crate::validate_crate_name(Some(self.sess), &orig_name.as_str(),
Some(item.span));
orig_name
}
// The crate store - a central repo for information collected about external
// crates and libraries
-use schema;
+use crate::schema;
use rustc::hir::def_id::{CrateNum, DefIndex};
use rustc::hir::map::definitions::DefPathTable;
use rustc::middle::cstore::{DepKind, ExternCrate, MetadataLoader};
pub use rustc::middle::cstore::NativeLibraryKind::*;
pub use rustc::middle::cstore::{CrateSource, LibSource, ForeignModule};
-pub use cstore_impl::{provide, provide_extern};
+pub use crate::cstore_impl::{provide, provide_extern};
// A map from external crate numbers (as decoded from some crate file) to
// local crate numbers (as generated during this session). Each external
/// Original name of the crate.
pub name: Symbol,
- /// Name of the crate as imported. I.e., if imported with
+ /// Name of the crate as imported. I.e., if imported with
/// `extern crate foo as bar;` this will be `bar`.
pub imported_name: Symbol,
pub root: schema::CrateRoot,
- /// For each public item in this crate, we encode a key. When the
+ /// For each public item in this crate, we encode a key. When the
/// crate is loaded, we read all the keys and put them in this
- /// hashmap, which gives the reverse mapping. This allows us to
+ /// hashmap, which gives the reverse mapping. This allows us to
/// quickly retrace a `DefPath`, which is needed for incremental
/// compilation support.
pub def_path_table: Lrc<DefPathTable>,
-use cstore::{self, LoadedMacro};
-use encoder;
-use link_args;
-use native_libs;
-use foreign_modules;
-use schema;
+use crate::cstore::{self, LoadedMacro};
+use crate::encoder;
+use crate::link_args;
+use crate::native_libs;
+use crate::foreign_modules;
+use crate::schema;
use rustc::ty::query::QueryConfig;
use rustc::middle::cstore::{CrateStore, DepKind,
use syntax::source_map;
use syntax::edition::Edition;
use syntax::parse::source_file_to_stream;
+use syntax::parse::parser::emit_unclosed_delims;
use syntax::symbol::Symbol;
use syntax_pos::{Span, NO_EXPANSION, FileName};
use rustc_data_structures::bit_set::BitSet;
index: CRATE_DEF_INDEX
});
let dep_node = def_path_hash
- .to_dep_node(::rustc::dep_graph::DepKind::CrateMetadata);
+ .to_dep_node(rustc::dep_graph::DepKind::CrateMetadata);
// The DepNodeIndex of the DepNode::CrateMetadata should be
// cached somewhere, so that we can use read_index().
$tcx.dep_graph.read(dep_node);
use syntax::ext::base::SyntaxExtension;
use syntax_ext::proc_macro_impl::BangProcMacro;
- let client = ::proc_macro::bridge::client::Client::expand1(::proc_macro::quote);
+ let client = proc_macro::bridge::client::Client::expand1(proc_macro::quote);
let ext = SyntaxExtension::ProcMacro {
expander: Box::new(BangProcMacro { client }),
- allow_internal_unstable: true,
+ allow_internal_unstable: Some(vec![
+ Symbol::intern("proc_macro_def_site"),
+ ].into()),
edition: data.root.edition,
};
return LoadedMacro::ProcMacro(Lrc::new(ext));
let source_file = sess.parse_sess.source_map().new_source_file(source_name, def.body);
let local_span = Span::new(source_file.start_pos, source_file.end_pos, NO_EXPANSION);
- let body = source_file_to_stream(&sess.parse_sess, source_file, None);
+ let (body, errors) = source_file_to_stream(&sess.parse_sess, source_file, None);
+ emit_unclosed_delims(&errors, &sess.diagnostic());
// Mark the attrs as used
let attrs = data.get_item_attrs(id.index, sess);
// Decoding metadata from a single crate's metadata
-use cstore::{self, CrateMetadata, MetadataBlob, NativeLibrary, ForeignModule};
-use schema::*;
+use crate::cstore::{self, CrateMetadata, MetadataBlob, NativeLibrary, ForeignModule};
+use crate::schema::*;
use rustc_data_structures::sync::{Lrc, ReadGuard};
use rustc::hir::map::{DefKey, DefPath, DefPathData, DefPathHash, Definitions};
use syntax::ext::base::{MacroKind, SyntaxExtension};
use syntax::ext::hygiene::Mark;
use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP, NO_EXPANSION};
+use log::debug;
pub struct DecodeContext<'a, 'tcx: 'a> {
opaque: opaque::Decoder<'a>,
}
}
-/// Create the "fake" DefPathTable for a given proc macro crate.
+/// Creates the "fake" DefPathTable for a given proc macro crate.
///
/// The DefPathTable is as follows:
///
fn get_variant(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- item: &Entry,
+ item: &Entry<'_>,
index: DefIndex,
adt_kind: ty::AdtKind)
-> ty::VariantDef
#![allow(non_snake_case)]
+use syntax::{register_diagnostic, register_diagnostics, register_long_diagnostics};
+
register_long_diagnostics! {
E0454: r##"
A link name was given with an empty name. Erroneous code example:
```
See more:
-https://doc.rust-lang.org/book/first-edition/conditional-compilation.html
+https://doc.rust-lang.org/reference/attributes.html#conditional-compilation
"##,
E0458: r##"
}
}
- /// Load a dynamic library into the global namespace (RTLD_GLOBAL on Unix)
+ /// Loads a dynamic library into the global namespace (RTLD_GLOBAL on Unix)
/// and do it now (don't use RTLD_LAZY on Unix).
pub fn open_global_now(filename: &Path) -> Result<DynamicLibrary, String> {
let maybe_library = dl::open_global_now(filename.as_os_str());
#[cfg(test)]
mod tests {
use super::*;
- use libc;
use std::mem;
#[test]
#[cfg(unix)]
mod dl {
- use libc;
use std::ffi::{CStr, OsStr, CString};
use std::os::unix::prelude::*;
use std::ptr;
-use index::Index;
-use index_builder::{FromId, IndexBuilder, Untracked};
-use isolated_encoder::IsolatedEncoder;
-use schema::*;
+use crate::index::Index;
+use crate::index_builder::{FromId, IndexBuilder, Untracked};
+use crate::isolated_encoder::IsolatedEncoder;
+use crate::schema::*;
use rustc::middle::cstore::{LinkagePreference, NativeLibrary,
EncodedMetadata, ForeignModule};
use syntax::source_map::Spanned;
use syntax::symbol::keywords;
use syntax_pos::{self, hygiene, FileName, SourceFile, Span};
+use log::{debug, trace};
use rustc::hir::{self, PatKind};
use rustc::hir::itemlikevisit::ItemLikeVisitor;
let def_id = field.did;
debug!("IsolatedEncoder::encode_field({:?})", def_id);
- let variant_id = tcx.hir().as_local_node_id(variant.did).unwrap();
+ let variant_id = tcx.hir().as_local_hir_id(variant.did).unwrap();
let variant_data = tcx.hir().expect_variant_data(variant_id);
Entry {
let tables = self.tcx.typeck_tables_of(def_id);
let node_id = self.tcx.hir().as_local_node_id(def_id).unwrap();
let hir_id = self.tcx.hir().node_to_hir_id(node_id);
- let kind = match tables.node_id_to_type(hir_id).sty {
+ let kind = match tables.node_type(hir_id).sty {
ty::Generator(def_id, ..) => {
let layout = self.tcx.generator_layout(def_id);
let data = GeneratorData {
// symbol associated with them (they weren't translated) or if they're an FFI
// definition (as that's not defined in this crate).
fn encode_exported_symbols(&mut self,
- exported_symbols: &[(ExportedSymbol, SymbolExportLevel)])
+ exported_symbols: &[(ExportedSymbol<'_>, SymbolExportLevel)])
-> EncodedExportedSymbols {
// The metadata symbol name is special. It should not show up in
// downstream crates.
-use schema::*;
+use crate::schema::*;
use rustc::hir::def_id::{DefId, DefIndex, DefIndexAddressSpace};
use rustc_serialize::opaque::Encoder;
use std::slice;
use std::u32;
+use log::debug;
/// While we are generating the metadata, we also track the position
/// of each DefIndex. It is not required that all definitions appear
}
}
- pub fn record(&mut self, def_id: DefId, entry: Lazy<Entry>) {
+ pub fn record(&mut self, def_id: DefId, entry: Lazy<Entry<'_>>) {
assert!(def_id.is_local());
self.record_index(def_id.index, entry);
}
- pub fn record_index(&mut self, item: DefIndex, entry: Lazy<Entry>) {
+ pub fn record_index(&mut self, item: DefIndex, entry: Lazy<Entry<'_>>) {
assert!(entry.position < (u32::MAX as usize));
let position = entry.position as u32;
let space_index = item.address_space().index();
//!
//! ```
//! <common::data> // big list of item-like things...
-//! <common::data_item> // ...for most def-ids, there is an entry.
+//! <common::data_item> // ...for most `DefId`s, there is an entry.
//! </common::data_item>
//! </common::data>
//! ```
//! give a callback fn, rather than taking a closure: it allows us to
//! easily control precisely what data is given to that fn.
-use encoder::EncodeContext;
-use index::Index;
-use schema::*;
-use isolated_encoder::IsolatedEncoder;
+use crate::encoder::EncodeContext;
+use crate::index::Index;
+use crate::schema::*;
+use crate::isolated_encoder::IsolatedEncoder;
use rustc::hir;
use rustc::hir::def_id::DefId;
}
}
- /// Emit the data for a def-id to the metadata. The function to
+ /// Emit the data for a `DefId` to the metadata. The function to
/// emit the data is `op`, and it will be given `data` as
/// arguments. This `record` function will call `op` to generate
/// the `Entry` (which may point to other encoded information)
}
/// Trait used for data that can be passed from outside a dep-graph
-/// task. The data must either be of some safe type, such as a
+/// task. The data must either be of some safe type, such as a
/// `DefId` index, or implement the `read` method so that it can add
/// a read of whatever dep-graph nodes are appropriate.
pub trait DepGraphRead {
- fn read(&self, tcx: TyCtxt);
+ fn read(&self, tcx: TyCtxt<'_, '_, '_>);
}
impl DepGraphRead for DefId {
- fn read(&self, _tcx: TyCtxt) {}
+ fn read(&self, _tcx: TyCtxt<'_, '_, '_>) {}
}
impl DepGraphRead for ast::NodeId {
- fn read(&self, _tcx: TyCtxt) {}
+ fn read(&self, _tcx: TyCtxt<'_, '_, '_>) {}
}
impl<T> DepGraphRead for Option<T>
where T: DepGraphRead
{
- fn read(&self, tcx: TyCtxt) {
+ fn read(&self, tcx: TyCtxt<'_, '_, '_>) {
match *self {
Some(ref v) => v.read(tcx),
None => (),
impl<T> DepGraphRead for [T]
where T: DepGraphRead
{
- fn read(&self, tcx: TyCtxt) {
+ fn read(&self, tcx: TyCtxt<'_, '_, '_>) {
for i in self {
i.read(tcx);
}
where $($name: DepGraphRead),*
{
#[allow(non_snake_case)]
- fn read(&self, tcx: TyCtxt) {
+ fn read(&self, tcx: TyCtxt<'_, '_, '_>) {
let &($(ref $name),*) = self;
$($name.read(tcx);)*
}
macro_rules! read_hir {
($t:ty) => {
impl<'tcx> DepGraphRead for &'tcx $t {
- fn read(&self, tcx: TyCtxt) {
+ fn read(&self, tcx: TyCtxt<'_, '_, '_>) {
tcx.hir().read(self.id);
}
}
pub struct Untracked<T>(pub T);
impl<T> DepGraphRead for Untracked<T> {
- fn read(&self, _tcx: TyCtxt) {}
+ fn read(&self, _tcx: TyCtxt<'_, '_, '_>) {}
}
/// Newtype that can be used to package up misc data extracted from a
-/// HIR node that doesn't carry its own id. This will allow an
+/// HIR node that doesn't carry its own ID. This will allow an
/// arbitrary `T` to be passed in, but register a read on the given
-/// node-id.
+/// `NodeId`.
pub struct FromId<T>(pub ast::NodeId, pub T);
impl<T> DepGraphRead for FromId<T> {
- fn read(&self, tcx: TyCtxt) {
+ fn read(&self, tcx: TyCtxt<'_, '_, '_>) {
tcx.hir().read(self.0);
}
}
-use encoder::EncodeContext;
-use schema::{Lazy, LazySeq};
+use crate::encoder::EncodeContext;
+use crate::schema::{Lazy, LazySeq};
use rustc::ty::TyCtxt;
use rustc_serialize::Encodable;
#![feature(proc_macro_internals)]
#![feature(proc_macro_quote)]
#![feature(rustc_diagnostic_macros)]
-#![feature(slice_sort_by_cached_key)]
#![feature(crate_visibility_modifier)]
#![feature(specialization)]
#![feature(rustc_private)]
#![recursion_limit="256"]
+#![deny(rust_2018_idioms)]
+
extern crate libc;
-#[macro_use]
-extern crate log;
-extern crate memmap;
-extern crate stable_deref_trait;
-#[macro_use]
-extern crate syntax;
-extern crate syntax_pos;
-extern crate flate2;
+#[allow(unused_extern_crates)]
extern crate serialize as rustc_serialize; // used by deriving
-extern crate rustc_errors as errors;
-extern crate syntax_ext;
extern crate proc_macro;
#[macro_use]
extern crate rustc;
-extern crate rustc_target;
#[macro_use]
extern crate rustc_data_structures;
//!
//! The reason for this is that any of B's types could be composed of C's types,
//! any function in B could return a type from C, etc. To be able to guarantee
-//! that we can always typecheck/translate any function, we have to have
+//! that we can always type-check/translate any function, we have to have
//! complete knowledge of the whole ecosystem, not just our immediate
//! dependencies.
//!
//! no means all of the necessary details. Take a look at the rest of
//! metadata::locator or metadata::creader for all the juicy details!
-use cstore::{MetadataRef, MetadataBlob};
-use creader::Library;
-use schema::{METADATA_HEADER, rustc_version};
+use crate::cstore::{MetadataRef, MetadataBlob};
+use crate::creader::Library;
+use crate::schema::{METADATA_HEADER, rustc_version};
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::svh::Svh;
use errors::DiagnosticBuilder;
use syntax::symbol::Symbol;
+use syntax::struct_span_err;
use syntax_pos::Span;
use rustc_target::spec::{Target, TargetTriple};
use rustc_data_structures::owning_ref::OwningRef;
+use log::{debug, info, warn};
+
pub struct CrateMismatch {
path: PathBuf,
got: String,
}
impl fmt::Display for CrateFlavor {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match *self {
CrateFlavor::Rlib => "rlib",
CrateFlavor::Rmeta => "rmeta",
}
}
- let mut err: Option<DiagnosticBuilder> = None;
+ let mut err: Option<DiagnosticBuilder<'_>> = None;
for (lib, kind) in m {
info!("{} reading metadata from: {}", flavor, lib.display());
let (hash, metadata) =
}
}
-// A diagnostic function for dumping crate metadata to an output stream
+/// A diagnostic function for dumping crate metadata to an output stream.
pub fn list_file_metadata(target: &Target,
path: &Path,
loader: &dyn MetadataLoader,
use syntax::source_map::Span;
use syntax::feature_gate::{self, GateIssue};
use syntax::symbol::Symbol;
+use syntax::{span_err, struct_span_err};
pub fn collect<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec<NativeLibrary> {
let mut collector = Collector {
-use index;
+use crate::index;
use rustc::hir;
use rustc::hir::def::{self, CtorKind};
ImplFinal,
}
-impl_stable_hash_for!(enum ::schema::AssociatedContainer {
+impl_stable_hash_for!(enum crate::schema::AssociatedContainer {
TraitRequired,
TraitWithDefault,
ImplDefault,
authors = ["The Rust Project Developers"]
name = "rustc_mir"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_mir"
[dependencies]
arena = { path = "../libarena" }
-bitflags = "1.0"
either = "1.5.0"
-graphviz = { path = "../libgraphviz" }
+dot = { path = "../libgraphviz", package = "graphviz" }
log = "0.4"
log_settings = "0.1.1"
polonius-engine = "0.6.2"
-use borrow_check::place_ext::PlaceExt;
-use borrow_check::nll::ToRegionVid;
-use dataflow::indexes::BorrowIndex;
-use dataflow::move_paths::MoveData;
+use crate::borrow_check::place_ext::PlaceExt;
+use crate::borrow_check::nll::ToRegionVid;
+use crate::dataflow::indexes::BorrowIndex;
+use crate::dataflow::move_paths::MoveData;
use rustc::mir::traversal;
use rustc::mir::visit::{
PlaceContext, Visitor, NonUseContext, MutatingUseContext, NonMutatingUseContext
crate location_map: FxHashMap<Location, BorrowIndex>,
/// Locations which activate borrows.
- /// NOTE: A given location may activate more than one borrow in the future
+ /// NOTE: a given location may activate more than one borrow in the future
/// when more general two-phase borrow support is introduced, but for now we
- /// only need to store one borrow index
+ /// only need to store one borrow index.
crate activation_map: FxHashMap<Location, Vec<BorrowIndex>>,
- /// Map from local to all the borrows on that local
+ /// Map from local to all the borrows on that local.
crate local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
crate locals_state_at_exit: LocalsStateAtExit,
}
}
-/// Location where a two phase borrow is activated, if a borrow
-/// is in fact a two phase borrow.
+/// Location where a two-phase borrow is activated, if a borrow
+/// is in fact a two-phase borrow.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
crate enum TwoPhaseActivation {
NotTwoPhase,
}
impl<'tcx> fmt::Display for BorrowData<'tcx> {
- fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
let kind = match self.kind {
mir::BorrowKind::Shared => "",
mir::BorrowKind::Shallow => "shallow ",
}
impl<'a, 'gcx, 'tcx> GatherBorrows<'a, 'gcx, 'tcx> {
- /// Returns true if the borrow represented by `kind` is
+ /// Returns `true` if the borrow represented by `kind` is
/// allowed to be split into separate Reservation and
/// Activation phases.
fn allow_two_phase_borrow(&self, kind: mir::BorrowKind) -> bool {
-use borrow_check::nll::explain_borrow::BorrowExplanation;
-use borrow_check::nll::region_infer::{RegionName, RegionNameSource};
-use borrow_check::prefixes::IsPrefixOf;
-use borrow_check::WriteKind;
+use crate::borrow_check::nll::explain_borrow::BorrowExplanation;
+use crate::borrow_check::nll::region_infer::{RegionName, RegionNameSource};
+use crate::borrow_check::prefixes::IsPrefixOf;
+use crate::borrow_check::WriteKind;
use rustc::hir;
use rustc::hir::def_id::DefId;
use rustc::middle::region::ScopeTree;
use super::borrow_set::BorrowData;
use super::{Context, MirBorrowckCtxt};
use super::{InitializationRequiringAction, PrefixSet};
-use dataflow::drop_flag_effects;
-use dataflow::move_paths::indexes::MoveOutIndex;
-use dataflow::move_paths::MovePathIndex;
-use util::borrowck_errors::{BorrowckErrors, Origin};
+use crate::dataflow::drop_flag_effects;
+use crate::dataflow::move_paths::indexes::MoveOutIndex;
+use crate::dataflow::move_paths::MovePathIndex;
+use crate::util::borrowck_errors::{BorrowckErrors, Origin};
#[derive(Debug)]
struct MoveSite {
/// then tell us where the move occurred.
moi: MoveOutIndex,
- /// True if we traversed a back edge while walking from the point
+ /// `true` if we traversed a back edge while walking from the point
/// of error to the move site.
traversed_back_edge: bool
}
format!("`{}` would have to be valid for `{}`...", name, region_name),
);
- if let Some(fn_node_id) = self.infcx.tcx.hir().as_local_node_id(self.mir_def_id) {
+ if let Some(fn_hir_id) = self.infcx.tcx.hir().as_local_hir_id(self.mir_def_id) {
err.span_label(
drop_span,
format!(
"...but `{}` will be dropped here, when the function `{}` returns",
name,
- self.infcx.tcx.hir().name(fn_node_id),
+ self.infcx.tcx.hir().name_by_hir_id(fn_hir_id),
),
);
let escapes_from = if tcx.is_closure(self.mir_def_id) {
let tables = tcx.typeck_tables_of(self.mir_def_id);
let mir_hir_id = tcx.hir().def_index_to_hir_id(self.mir_def_id.index);
- match tables.node_id_to_type(mir_hir_id).sty {
+ match tables.node_type(mir_hir_id).sty {
ty::Closure(..) => "closure",
ty::Generator(..) => "generator",
_ => bug!("Closure body doesn't have a closure or generator type"),
}
/// End-user visible description of the `field`nth field of `base`
- fn describe_field(&self, base: &Place, field: Field) -> String {
+ fn describe_field(&self, base: &Place<'_>, field: Field) -> String {
match *base {
Place::Local(local) => {
let local = &self.mir.local_decls[local];
}
/// End-user visible description of the `field_index`nth field of `ty`
- fn describe_field_from_ty(&self, ty: &ty::Ty, field: Field) -> String {
+ fn describe_field_from_ty(&self, ty: &ty::Ty<'_>, field: Field) -> String {
if ty.is_box() {
// If the type is a box, the field is described from the boxed type
self.describe_field_from_ty(&ty.boxed_ty(), field)
}
}
- /// Check if a place is a thread-local static.
+ /// Checks if a place is a thread-local static.
pub fn is_place_thread_local(&self, place: &Place<'tcx>) -> bool {
if let Place::Static(statik) = place {
let attrs = self.infcx.tcx.get_attrs(statik.def_id);
fn annotate_argument_and_return_for_borrow(
&self,
borrow: &BorrowData<'tcx>,
- ) -> Option<AnnotatedBorrowFnSignature> {
+ ) -> Option<AnnotatedBorrowFnSignature<'_>> {
// Define a fallback for when we can't match a closure.
let fallback = || {
let is_closure = self.infcx.tcx.is_closure(self.mir_def_id);
&self,
did: DefId,
sig: ty::PolyFnSig<'tcx>,
- ) -> Option<AnnotatedBorrowFnSignature> {
+ ) -> Option<AnnotatedBorrowFnSignature<'_>> {
debug!("annotate_fn_sig: did={:?} sig={:?}", did, sig);
let is_closure = self.infcx.tcx.is_closure(did);
let fn_node_id = self.infcx.tcx.hir().as_local_node_id(did)?;
}
}
- /// Return the name of the provided `Ty` (that must be a reference)'s region with a
+ /// Returns the name of the provided `Ty` (that must be a reference)'s region with a
/// synthesized lifetime name where required.
fn get_region_name_for_ty(&self, ty: ty::Ty<'tcx>, counter: usize) -> String {
match ty.sty {
}
// Add a span label to the arguments of the closure, if it exists.
- pub(super) fn args_span_label(self, err: &mut DiagnosticBuilder, message: impl Into<String>) {
+ pub(super) fn args_span_label(
+ self,
+ err: &mut DiagnosticBuilder<'_>,
+ message: impl Into<String>,
+ ) {
if let UseSpans::ClosureUse { args_span, .. } = self {
err.span_label(args_span, message);
}
}
// Add a span label to the use of the captured variable, if it exists.
- pub(super) fn var_span_label(self, err: &mut DiagnosticBuilder, message: impl Into<String>) {
+ pub(super) fn var_span_label(
+ self,
+ err: &mut DiagnosticBuilder<'_>,
+ message: impl Into<String>,
+ ) {
if let UseSpans::ClosureUse { var_span, .. } = self {
err.span_label(var_span, message);
}
}
- /// Return `false` if this place is not used in a closure.
+ /// Returns `false` if this place is not used in a closure.
fn for_closure(&self) -> bool {
match *self {
UseSpans::ClosureUse { is_generator, .. } => !is_generator,
}
}
- /// Return `false` if this place is not used in a generator.
+ /// Returns `false` if this place is not used in a generator.
fn for_generator(&self) -> bool {
match *self {
UseSpans::ClosureUse { is_generator, .. } => is_generator,
/// Helper to retrieve span(s) of given borrow from the current MIR
/// representation
- pub(super) fn retrieve_borrow_spans(&self, borrow: &BorrowData) -> UseSpans {
+ pub(super) fn retrieve_borrow_spans(&self, borrow: &BorrowData<'_>) -> UseSpans {
let span = self.mir.source_info(borrow.reserve_location).span;
self.borrow_spans(span, borrow.reserve_location)
}
use rustc::ty::RegionVid;
use rustc_data_structures::bit_set::BitIter;
-use borrow_check::location::LocationIndex;
+use crate::borrow_check::location::LocationIndex;
use polonius_engine::Output;
-use dataflow::move_paths::indexes::BorrowIndex;
-use dataflow::move_paths::HasMoveData;
-use dataflow::Borrows;
-use dataflow::EverInitializedPlaces;
-use dataflow::{FlowAtLocation, FlowsAtLocation};
-use dataflow::MaybeUninitializedPlaces;
+use crate::dataflow::move_paths::indexes::BorrowIndex;
+use crate::dataflow::move_paths::HasMoveData;
+use crate::dataflow::Borrows;
+use crate::dataflow::EverInitializedPlaces;
+use crate::dataflow::{FlowAtLocation, FlowsAtLocation};
+use crate::dataflow::MaybeUninitializedPlaces;
use either::Either;
use std::fmt;
use std::rc::Rc;
}
}
- crate fn with_outgoing_borrows(&self, op: impl FnOnce(BitIter<BorrowIndex>)) {
+ crate fn with_outgoing_borrows(&self, op: impl FnOnce(BitIter<'_, BorrowIndex>)) {
self.borrows.with_iter_outgoing(op)
}
}
}
impl<'b, 'gcx, 'tcx> fmt::Display for Flows<'b, 'gcx, 'tcx> {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut s = String::new();
s.push_str("borrows in effect: [");
//! This query borrow-checks the MIR to (further) ensure it is not broken.
-use borrow_check::nll::region_infer::RegionInferenceContext;
+use crate::borrow_check::nll::region_infer::RegionInferenceContext;
use rustc::hir;
use rustc::hir::Node;
use rustc::hir::def_id::DefId;
use syntax_pos::Span;
-use dataflow::indexes::{BorrowIndex, InitIndex, MoveOutIndex, MovePathIndex};
-use dataflow::move_paths::{HasMoveData, LookupResult, MoveData, MoveError};
-use dataflow::Borrows;
-use dataflow::DataflowResultsConsumer;
-use dataflow::FlowAtLocation;
-use dataflow::MoveDataParamEnv;
-use dataflow::{do_dataflow, DebugFormatted};
-use dataflow::EverInitializedPlaces;
-use dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces};
-use util::borrowck_errors::{BorrowckErrors, Origin};
+use crate::dataflow::indexes::{BorrowIndex, InitIndex, MoveOutIndex, MovePathIndex};
+use crate::dataflow::move_paths::{HasMoveData, LookupResult, MoveData, MoveError};
+use crate::dataflow::Borrows;
+use crate::dataflow::DataflowResultsConsumer;
+use crate::dataflow::FlowAtLocation;
+use crate::dataflow::MoveDataParamEnv;
+use crate::dataflow::{do_dataflow, DebugFormatted};
+use crate::dataflow::EverInitializedPlaces;
+use crate::dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces};
+use crate::util::borrowck_errors::{BorrowckErrors, Origin};
use self::borrow_set::{BorrowData, BorrowSet};
use self::flows::Flows;
pub(crate) mod nll;
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
*providers = Providers {
mir_borrowck,
..*providers
}
let opt_closure_req = tcx.infer_ctxt().enter(|infcx| {
- let input_mir: &Mir = &input_mir.borrow();
+ let input_mir: &Mir<'_> = &input_mir.borrow();
do_mir_borrowck(&infcx, input_mir, def_id)
});
debug!("mir_borrowck done");
access_place_error_reported: FxHashSet<(Place<'tcx>, Span)>,
/// This field keeps track of when borrow conflict errors are reported
/// for reservations, so that we don't report seemingly duplicate
- /// errors for corresponding activations
- ///
- /// FIXME: Ideally this would be a set of BorrowIndex, not Places,
- /// but it is currently inconvenient to track down the BorrowIndex
- /// at the time we detect and report a reservation error.
+ /// errors for corresponding activations.
+ //
+ // FIXME: ideally this would be a set of `BorrowIndex`, not `Place`s,
+ // but it is currently inconvenient to track down the `BorrowIndex`
+ // at the time we detect and report a reservation error.
reservation_error_reported: FxHashSet<Place<'tcx>>,
/// This field keeps track of move errors that are to be reported for given move indicies.
///
/// If the function we're checking is a closure, then we'll need to report back the list of
/// mutable upvars that have been used. This field keeps track of them.
used_mut_upvars: SmallVec<[Field; 8]>,
- /// Non-lexical region inference context, if NLL is enabled. This
+ /// Non-lexical region inference context, if NLL is enabled. This
/// contains the results from region inference and lets us e.g.
/// find out which CFG points are contained in each borrow region.
nonlexical_regioncx: Rc<RegionInferenceContext<'tcx>>,
/// When checking permissions for a place access, this flag is used to indicate that an immutable
/// local place can be mutated.
-///
-/// FIXME: @nikomatsakis suggested that this flag could be removed with the following modifications:
-/// - Merge `check_access_permissions()` and `check_if_reassignment_to_immutable_state()`
-/// - Split `is_mutable()` into `is_assignable()` (can be directly assigned) and
-/// `is_declared_mutable()`
-/// - Take flow state into consideration in `is_assignable()` for local variables
+//
+// FIXME: @nikomatsakis suggested that this flag could be removed with the following modifications:
+// - Merge `check_access_permissions()` and `check_if_reassignment_to_immutable_state()`.
+// - Split `is_mutable()` into `is_assignable()` (can be directly assigned) and
+// `is_declared_mutable()`.
+// - Take flow state into consideration in `is_assignable()` for local variables.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
enum LocalMutationIsAllowed {
Yes,
/// place is initialized and (b) it is not borrowed in some way that would prevent this
/// access.
///
- /// Returns true if an error is reported, false otherwise.
+ /// Returns `true` if an error is reported.
fn access_place(
&mut self,
context: Context,
}
}
- /// Check the permissions for the given place and read or write kind
+ /// Checks the permissions for the given place and read or write kind
///
- /// Returns true if an error is reported, false otherwise.
+ /// Returns `true` if an error is reported.
fn check_access_permissions(
&mut self,
(place, span): (&Place<'tcx>, Span),
use rustc_errors::{DiagnosticBuilder,Applicability};
use syntax_pos::Span;
-use borrow_check::MirBorrowckCtxt;
-use borrow_check::prefixes::PrefixSet;
-use dataflow::move_paths::{
+use crate::borrow_check::MirBorrowckCtxt;
+use crate::borrow_check::prefixes::PrefixSet;
+use crate::dataflow::move_paths::{
IllegalMoveOrigin, IllegalMoveOriginKind, InitLocation,
LookupResult, MoveError, MovePathIndex,
};
-use util::borrowck_errors::{BorrowckErrors, Origin};
+use crate::util::borrowck_errors::{BorrowckErrors, Origin};
// Often when desugaring a pattern match we may have many individual moves in
// MIR that are all part of one operation from the user's point-of-view. For
}
impl Display for BorrowedContentSource {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
BorrowedContentSource::Arc => write!(f, "an `Arc`"),
BorrowedContentSource::Rc => write!(f, "an `Rc`"),
fn report(&mut self, error: GroupedMoveError<'tcx>) {
let (mut err, err_span) = {
- let (span, original_path, kind): (Span, &Place<'tcx>, &IllegalMoveOriginKind) =
+ let (span, original_path, kind): (Span, &Place<'tcx>, &IllegalMoveOriginKind<'_>) =
match error {
GroupedMoveError::MovesFromPlace {
span,
let upvar_decl = &self.mir.upvar_decls[field.index()];
let upvar_hir_id =
upvar_decl.var_hir_id.assert_crate_local();
- let upvar_node_id =
- self.infcx.tcx.hir().hir_to_node_id(upvar_hir_id);
- let upvar_span = self.infcx.tcx.hir().span(upvar_node_id);
+ let upvar_span = self.infcx.tcx.hir().span_by_hir_id(
+ upvar_hir_id);
diag.span_label(upvar_span, "captured outer variable");
break;
}
use syntax_pos::Span;
use syntax_pos::symbol::keywords;
-use dataflow::move_paths::InitLocation;
-use borrow_check::MirBorrowckCtxt;
-use util::borrowck_errors::{BorrowckErrors, Origin};
-use util::collect_writes::FindAssignments;
-use util::suggest_ref_mut;
+use crate::dataflow::move_paths::InitLocation;
+use crate::borrow_check::MirBorrowckCtxt;
+use crate::util::borrowck_errors::{BorrowckErrors, Origin};
+use crate::util::collect_writes::FindAssignments;
+use crate::util::suggest_ref_mut;
use rustc_errors::Applicability;
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
})
}
-fn is_closure_or_generator(ty: ty::Ty) -> bool {
+fn is_closure_or_generator(ty: ty::Ty<'_>) -> bool {
ty.is_closure() || ty.is_generator()
}
-/// Add a suggestion to a struct definition given a field access to a local.
+/// Adds a suggestion to a struct definition given a field access to a local.
/// This function expects the local to be a reference to a struct in order to produce a suggestion.
///
/// ```text
-use borrow_check::borrow_set::BorrowSet;
-use borrow_check::location::LocationTable;
-use borrow_check::nll::ToRegionVid;
-use borrow_check::nll::facts::AllFacts;
-use borrow_check::nll::region_infer::values::LivenessValues;
+use crate::borrow_check::borrow_set::BorrowSet;
+use crate::borrow_check::location::LocationTable;
+use crate::borrow_check::nll::ToRegionVid;
+use crate::borrow_check::nll::facts::AllFacts;
+use crate::borrow_check::nll::region_infer::values::LivenessValues;
use rustc::infer::InferCtxt;
use rustc::mir::visit::TyContext;
use rustc::mir::visit::Visitor;
-use borrow_check::nll::type_check::Locations;
-use borrow_check::nll::constraints::ConstraintIndex;
-use borrow_check::nll::constraints::{ConstraintSet, OutlivesConstraint};
+use crate::borrow_check::nll::type_check::Locations;
+use crate::borrow_check::nll::constraints::ConstraintIndex;
+use crate::borrow_check::nll::constraints::{ConstraintSet, OutlivesConstraint};
use rustc::mir::ConstraintCategory;
use rustc::ty::RegionVid;
use rustc_data_structures::graph;
}
impl<D: ConstraintGraphDirecton> ConstraintGraph<D> {
- /// Create a "dependency graph" where each region constraint `R1:
+ /// Creates a "dependency graph" where each region constraint `R1:
/// R2` is treated as an edge `R1 -> R2`. We use this graph to
/// construct SCCs for region inference but also for error
/// reporting.
}
impl<'s, D: ConstraintGraphDirecton> RegionGraph<'s, D> {
- /// Create a "dependency graph" where each region constraint `R1:
+ /// Creates a "dependency graph" where each region constraint `R1:
/// R2` is treated as an edge `R1 -> R2`. We use this graph to
/// construct SCCs for region inference but also for error
/// reporting.
use rustc::ty::RegionVid;
use rustc_data_structures::graph::scc::Sccs;
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
-use borrow_check::nll::type_check::Locations;
+use crate::borrow_check::nll::type_check::Locations;
use std::fmt;
use std::ops::Deref;
/// easy to find the constraints affecting a particular region.
///
/// N.B., this graph contains a "frozen" view of the current
- /// constraints. any new constraints added to the `ConstraintSet`
+ /// constraints. Any new constraints added to the `ConstraintSet`
/// after the graph is built will not be present in the graph.
crate fn graph(&self, num_region_vars: usize) -> graph::NormalConstraintGraph {
graph::ConstraintGraph::new(graph::Normal, self, num_region_vars)
graph::ConstraintGraph::new(graph::Reverse, self, num_region_vars)
}
- /// Compute cycles (SCCs) in the graph of regions. In particular,
+ /// Computes cycles (SCCs) in the graph of regions. In particular,
/// find all regions R1, R2 such that R1: R2 and R2: R1 and group
/// them into an SCC, and find the relationships between SCCs.
crate fn compute_sccs(
}
impl fmt::Debug for OutlivesConstraint {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
formatter,
"({:?}: {:?}) due to {:?}",
use std::collections::VecDeque;
use std::rc::Rc;
-use borrow_check::nll::region_infer::{Cause, RegionInferenceContext};
-use borrow_check::nll::ToRegionVid;
+use crate::borrow_check::nll::region_infer::{Cause, RegionInferenceContext};
+use crate::borrow_check::nll::ToRegionVid;
+use crate::util::liveness::{self, DefUse};
use rustc::mir::visit::{MirVisitable, PlaceContext, Visitor};
use rustc::mir::{Local, Location, Mir};
use rustc::ty::{RegionVid, TyCtxt};
use rustc_data_structures::fx::FxHashSet;
-use util::liveness::{self, DefUse};
crate fn find<'tcx>(
mir: &Mir<'tcx>,
-use borrow_check::borrow_set::BorrowData;
-use borrow_check::error_reporting::UseSpans;
-use borrow_check::nll::ConstraintDescription;
-use borrow_check::nll::region_infer::{Cause, RegionName};
-use borrow_check::{Context, MirBorrowckCtxt, WriteKind};
+use crate::borrow_check::borrow_set::BorrowData;
+use crate::borrow_check::error_reporting::UseSpans;
+use crate::borrow_check::nll::ConstraintDescription;
+use crate::borrow_check::nll::region_infer::{Cause, RegionName};
+use crate::borrow_check::{Context, MirBorrowckCtxt, WriteKind};
use rustc::ty::{self, TyCtxt};
use rustc::mir::{
CastKind, ConstraintCategory, FakeReadCause, Local, Location, Mir, Operand,
mod find_use;
-pub(in borrow_check) enum BorrowExplanation {
+pub(in crate::borrow_check) enum BorrowExplanation {
UsedLater(LaterUseKind, Span),
UsedLaterInLoop(LaterUseKind, Span),
UsedLaterWhenDropped {
}
#[derive(Clone, Copy)]
-pub(in borrow_check) enum LaterUseKind {
+pub(in crate::borrow_check) enum LaterUseKind {
TraitCapture,
ClosureCapture,
Call,
}
impl BorrowExplanation {
- pub(in borrow_check) fn is_explained(&self) -> bool {
+ pub(in crate::borrow_check) fn is_explained(&self) -> bool {
match self {
BorrowExplanation::Unexplained => false,
_ => true,
}
}
- pub(in borrow_check) fn add_explanation_to_diagnostic<'cx, 'gcx, 'tcx>(
+ pub(in crate::borrow_check) fn add_explanation_to_diagnostic<'cx, 'gcx, 'tcx>(
&self,
tcx: TyCtxt<'cx, 'gcx, 'tcx>,
mir: &Mir<'tcx>,
/// - second half is the place being accessed
///
/// [d]: https://rust-lang.github.io/rfcs/2094-nll.html#leveraging-intuition-framing-errors-in-terms-of-points
- pub(in borrow_check) fn explain_why_borrow_contains_point(
+ pub(in crate::borrow_check) fn explain_why_borrow_contains_point(
&self,
context: Context,
borrow: &BorrowData<'tcx>,
}
}
- /// Check if a borrow location is within a loop.
+ /// Checks if a borrow location is within a loop.
fn is_borrow_location_in_loop(
&self,
borrow_location: Location,
}
}
- /// Check if a borrowed value was captured by a trait object. We do this by
+ /// Checks if a borrowed value was captured by a trait object. We do this by
/// looking forward in the MIR from the reserve location and checking if we see
/// a unsized cast to a trait object on our data.
fn was_captured_by_trait_object(&self, borrow: &BorrowData<'tcx>) -> bool {
-use borrow_check::location::{LocationIndex, LocationTable};
-use dataflow::indexes::BorrowIndex;
+use crate::borrow_check::location::{LocationIndex, LocationTable};
+use crate::dataflow::indexes::BorrowIndex;
use polonius_engine::AllFacts as PoloniusAllFacts;
use polonius_engine::Atom;
use rustc::ty::{RegionVid, TyCtxt};
crate type AllFacts = PoloniusAllFacts<RegionVid, BorrowIndex, LocationIndex>;
crate trait AllFactsExt {
- /// Returns true if there is a need to gather `AllFacts` given the
+ /// Returns `true` if there is a need to gather `AllFacts` given the
/// current `-Z` flags.
fn enabled(tcx: TyCtxt<'_, '_, '_>) -> bool;
-use borrow_check::borrow_set::BorrowSet;
-use borrow_check::location::LocationTable;
-use borrow_check::{JustWrite, WriteAndRead};
-use borrow_check::{AccessDepth, Deep, Shallow};
-use borrow_check::{ReadOrWrite, Activation, Read, Reservation, Write};
-use borrow_check::{Context, ContextKind};
-use borrow_check::{LocalMutationIsAllowed, MutateMode};
-use borrow_check::ArtificialField;
-use borrow_check::{ReadKind, WriteKind};
-use borrow_check::nll::facts::AllFacts;
-use borrow_check::path_utils::*;
-use dataflow::move_paths::indexes::BorrowIndex;
+use crate::borrow_check::borrow_set::BorrowSet;
+use crate::borrow_check::location::LocationTable;
+use crate::borrow_check::{JustWrite, WriteAndRead};
+use crate::borrow_check::{AccessDepth, Deep, Shallow};
+use crate::borrow_check::{ReadOrWrite, Activation, Read, Reservation, Write};
+use crate::borrow_check::{Context, ContextKind};
+use crate::borrow_check::{LocalMutationIsAllowed, MutateMode};
+use crate::borrow_check::ArtificialField;
+use crate::borrow_check::{ReadKind, WriteKind};
+use crate::borrow_check::nll::facts::AllFacts;
+use crate::borrow_check::path_utils::*;
+use crate::dataflow::move_paths::indexes::BorrowIndex;
use rustc::ty::TyCtxt;
use rustc::mir::visit::Visitor;
use rustc::mir::{BasicBlock, Location, Mir, Place, Rvalue};
borrow_set: &'cx BorrowSet<'tcx>,
}
-/// Visits the whole MIR and generates invalidates() facts
-/// Most of the code implementing this was stolen from borrow_check/mod.rs
+/// Visits the whole MIR and generates `invalidates()` facts.
+/// Most of the code implementing this was stolen from `borrow_check/mod.rs`.
impl<'cx, 'tcx, 'gcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx, 'gcx> {
fn visit_statement(
&mut self,
}
impl<'cg, 'cx, 'tcx, 'gcx> InvalidationGenerator<'cx, 'tcx, 'gcx> {
- /// Simulates mutation of a place
+ /// Simulates mutation of a place.
fn mutate_place(
&mut self,
context: Context,
);
}
- /// Simulates consumption of an operand
+ /// Simulates consumption of an operand.
fn consume_operand(
&mut self,
context: Context,
}
}
- /// Simulates an access to a place
+ /// Simulates an access to a place.
fn access_place(
&mut self,
context: Context,
}
- /// Generate a new invalidates(L, B) fact
+ /// Generates a new `invalidates(L, B)` fact.
fn generate_invalidates(&mut self, b: BorrowIndex, l: Location) {
let lidx = self.location_table.start_index(l);
self.all_facts.invalidates.push((lidx, b));
-use borrow_check::borrow_set::BorrowSet;
-use borrow_check::location::{LocationIndex, LocationTable};
-use borrow_check::nll::facts::AllFactsExt;
-use borrow_check::nll::type_check::{MirTypeckResults, MirTypeckRegionConstraints};
-use borrow_check::nll::type_check::liveness::liveness_map::NllLivenessMap;
-use borrow_check::nll::region_infer::values::RegionValueElements;
-use dataflow::indexes::BorrowIndex;
-use dataflow::move_paths::MoveData;
-use dataflow::FlowAtLocation;
-use dataflow::MaybeInitializedPlaces;
+use crate::borrow_check::borrow_set::BorrowSet;
+use crate::borrow_check::location::{LocationIndex, LocationTable};
+use crate::borrow_check::nll::facts::AllFactsExt;
+use crate::borrow_check::nll::type_check::{MirTypeckResults, MirTypeckRegionConstraints};
+use crate::borrow_check::nll::type_check::liveness::liveness_map::NllLivenessMap;
+use crate::borrow_check::nll::region_infer::values::RegionValueElements;
+use crate::dataflow::indexes::BorrowIndex;
+use crate::dataflow::move_paths::MoveData;
+use crate::dataflow::FlowAtLocation;
+use crate::dataflow::MaybeInitializedPlaces;
+use crate::transform::MirSource;
use rustc::hir::def_id::DefId;
use rustc::infer::InferCtxt;
use rustc::mir::{ClosureOutlivesSubject, ClosureRegionRequirements, Mir};
use std::path::PathBuf;
use std::rc::Rc;
use std::str::FromStr;
-use transform::MirSource;
use self::mir_util::PassWhere;
use polonius_engine::{Algorithm, Output};
-use util as mir_util;
-use util::pretty;
+use crate::util as mir_util;
+use crate::util::pretty;
mod constraint_generation;
pub mod explain_borrow;
/// scraping out the set of universal regions (e.g., region parameters)
/// declared on the function. That set will need to be given to
/// `compute_regions`.
-pub(in borrow_check) fn replace_regions_in_mir<'cx, 'gcx, 'tcx>(
+pub(in crate::borrow_check) fn replace_regions_in_mir<'cx, 'gcx, 'tcx>(
infcx: &InferCtxt<'cx, 'gcx, 'tcx>,
def_id: DefId,
param_env: ty::ParamEnv<'tcx>,
/// Computes the (non-lexical) regions from the input MIR.
///
/// This may result in errors being reported.
-pub(in borrow_check) fn compute_regions<'cx, 'gcx, 'tcx>(
+pub(in crate::borrow_check) fn compute_regions<'cx, 'gcx, 'tcx>(
infcx: &InferCtxt<'cx, 'gcx, 'tcx>,
def_id: DefId,
universal_regions: UniversalRegions<'tcx>,
fn dump_mir_results<'a, 'gcx, 'tcx>(
infcx: &InferCtxt<'a, 'gcx, 'tcx>,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &Mir<'tcx>,
- regioncx: &RegionInferenceContext,
- closure_region_requirements: &Option<ClosureRegionRequirements>,
+ regioncx: &RegionInferenceContext<'_>,
+ closure_region_requirements: &Option<ClosureRegionRequirements<'_>>,
) {
if !mir_util::dump_enabled(infcx.tcx, "nll", source) {
return;
);
// Also dump the inference graph constraints as a graphviz file.
- let _: io::Result<()> = try_block! {
+ let _: io::Result<()> = try {
let mut file =
pretty::create_dump_file(infcx.tcx, "regioncx.all.dot", None, "nll", &0, source)?;
regioncx.dump_graphviz_raw_constraints(&mut file)?;
};
// Also dump the inference graph constraints as a graphviz file.
- let _: io::Result<()> = try_block! {
+ let _: io::Result<()> = try {
let mut file =
pretty::create_dump_file(infcx.tcx, "regioncx.scc.dot", None, "nll", &0, source)?;
regioncx.dump_graphviz_scc_constraints(&mut file)?;
mir: &Mir<'tcx>,
mir_def_id: DefId,
regioncx: &RegionInferenceContext<'tcx>,
- closure_region_requirements: &Option<ClosureRegionRequirements>,
+ closure_region_requirements: &Option<ClosureRegionRequirements<'_>>,
errors_buffer: &mut Vec<Diagnostic>,
) {
let tcx = infcx.tcx;
}
fn for_each_region_constraint(
- closure_region_requirements: &ClosureRegionRequirements,
+ closure_region_requirements: &ClosureRegionRequirements<'_>,
with_msg: &mut dyn FnMut(&str) -> io::Result<()>,
) -> io::Result<()> {
for req in &closure_region_requirements.outlives_requirements {
}
/// Debugging aid: Invokes the `with_msg` callback repeatedly with
- /// our internal region constraints. These are dumped into the
+ /// our internal region constraints. These are dumped into the
/// -Zdump-mir file so that we can figure out why the region
/// inference resulted in the values that it did when debugging.
fn for_each_constraint(
-use borrow_check::nll::constraints::OutlivesConstraint;
-use borrow_check::nll::region_infer::RegionInferenceContext;
-use borrow_check::nll::type_check::Locations;
-use borrow_check::nll::universal_regions::DefiningTy;
-use borrow_check::nll::ConstraintDescription;
+use crate::borrow_check::nll::constraints::OutlivesConstraint;
+use crate::borrow_check::nll::region_infer::RegionInferenceContext;
+use crate::borrow_check::nll::type_check::Locations;
+use crate::borrow_check::nll::universal_regions::DefiningTy;
+use crate::borrow_check::nll::ConstraintDescription;
+use crate::util::borrowck_errors::{BorrowckErrors, Origin};
use rustc::hir::def_id::DefId;
use rustc::infer::error_reporting::nice_region_error::NiceRegionError;
use rustc::infer::InferCtxt;
use syntax::errors::Applicability;
use syntax::symbol::keywords;
use syntax_pos::Span;
-use util::borrowck_errors::{BorrowckErrors, Origin};
mod region_name;
mod var_name;
if let (Some(f), Some(o)) = (self.to_error_region(fr), self.to_error_region(outlived_fr)) {
let tables = infcx.tcx.typeck_tables_of(mir_def_id);
let nice = NiceRegionError::new_from_span(infcx, span, o, f, Some(tables));
- if let Some(_error_reported) = nice.try_report_from_nll() {
+ if let Some(diag) = nice.try_report_from_nll() {
+ diag.buffer(errors_buffer);
return;
}
}
}
/// If `r2` represents a placeholder region, then this returns
- /// true if `r1` cannot name that placeholder in its
- /// value. Otherwise, returns false.
+ /// `true` if `r1` cannot name that placeholder in its
+ /// value; otherwise, returns `false`.
fn cannot_name_placeholder(&self, r1: RegionVid, r2: RegionVid) -> bool {
debug!("cannot_name_value_of(r1={:?}, r2={:?})", r1, r2);
use std::fmt::{self, Display};
-use borrow_check::nll::region_infer::RegionInferenceContext;
-use borrow_check::nll::universal_regions::DefiningTy;
-use borrow_check::nll::ToRegionVid;
+use crate::borrow_check::nll::region_infer::RegionInferenceContext;
+use crate::borrow_check::nll::universal_regions::DefiningTy;
+use crate::borrow_check::nll::ToRegionVid;
use rustc::hir;
use rustc::hir::def_id::DefId;
use rustc::infer::InferCtxt;
use rustc::ty::{self, RegionKind, RegionVid, Ty, TyCtxt};
use rustc::util::ppaux::RegionHighlightMode;
use rustc_errors::DiagnosticBuilder;
-use syntax::ast::{Name, DUMMY_NODE_ID};
+use syntax::ast::Name;
use syntax::symbol::keywords;
use syntax_pos::Span;
use syntax_pos::symbol::InternedString;
}
impl Display for RegionName {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.name)
}
}
value
}
- /// Check for the case where `fr` maps to something that the
+ /// Checks for the case where `fr` maps to something that the
/// *user* has a name for. In that case, we'll be able to map
/// `fr` to a `Region<'tcx>`, and that region will be one of
/// named variants.
}
}
- /// Get a span of a named region to provide context for error messages that
+ /// Gets a span of a named region to provide context for error messages that
/// mention that span, for example:
///
/// ```
name: &InternedString,
) -> Span {
let scope = error_region.free_region_binding_scope(tcx);
- let node = tcx.hir().as_local_node_id(scope).unwrap_or(DUMMY_NODE_ID);
+ let node = tcx.hir().as_local_hir_id(scope).unwrap_or(hir::DUMMY_HIR_ID);
- let span = tcx.sess.source_map().def_span(tcx.hir().span(node));
+ let span = tcx.sess.source_map().def_span(tcx.hir().span_by_hir_id(node));
if let Some(param) = tcx.hir()
.get_generics(scope)
.and_then(|generics| generics.get_named(name))
}
}
- /// Find an argument that contains `fr` and label it with a fully
+ /// Finds an argument that contains `fr` and label it with a fully
/// elaborated type, returning something like `'1`. Result looks
/// like:
///
/// to. For example, we might produce an annotation like this:
///
/// ```
- /// | fn a<T>(items: &[T]) -> Box<dyn Iterator<Item=&T>> {
+ /// | fn a<T>(items: &[T]) -> Box<dyn Iterator<Item = &T>> {
/// | - let's call the lifetime of this reference `'1`
/// ```
///
/// `argument_hir_ty`, a `hir::Ty` (the syntax of the type
/// annotation). We are descending through the types stepwise,
/// looking in to find the region `needle_fr` in the internal
- /// type. Once we find that, we can use the span of the `hir::Ty`
+ /// type. Once we find that, we can use the span of the `hir::Ty`
/// to add the highlight.
///
/// This is a somewhat imperfect process, so long the way we also
None
}
- /// Find a closure upvar that contains `fr` and label it with a
+ /// Finds a closure upvar that contains `fr` and label it with a
/// fully elaborated type, returning something like `'1`. Result
/// looks like:
///
})
}
- /// Check for arguments appearing in the (closure) return type. It
+ /// Checks for arguments appearing in the (closure) return type. It
/// must be a closure since, in a free fn, such an argument would
/// have to either also appear in an argument (if using elision)
/// or be early bound (named, not in argument).
let (return_span, mir_description) = match tcx.hir().get(mir_node_id) {
hir::Node::Expr(hir::Expr {
- node: hir::ExprKind::Closure(_, _, _, span, gen_move),
+ node: hir::ExprKind::Closure(_, return_ty, _, span, gen_move),
..
}) => (
- tcx.sess.source_map().end_point(*span),
+ match return_ty.output {
+ hir::FunctionRetTy::DefaultReturn(_) => tcx.sess.source_map().end_point(*span),
+ hir::FunctionRetTy::Return(_) => return_ty.output.span(),
+ },
if gen_move.is_some() {
" of generator"
} else {
})
}
- /// Create a synthetic region named `'1`, incrementing the
+ /// Creates a synthetic region named `'1`, incrementing the
/// counter.
fn synthesize_region_name(&self, counter: &mut usize) -> InternedString {
let c = *counter;
-use borrow_check::nll::region_infer::RegionInferenceContext;
-use borrow_check::nll::ToRegionVid;
+use crate::borrow_check::nll::region_infer::RegionInferenceContext;
+use crate::borrow_check::nll::ToRegionVid;
use rustc::mir::{Local, Mir};
use rustc::ty::{RegionVid, TyCtxt};
use rustc_data_structures::indexed_vec::Idx;
upvar_index: usize,
) -> (Symbol, Span) {
let upvar_hir_id = mir.upvar_decls[upvar_index].var_hir_id.assert_crate_local();
- let upvar_node_id = tcx.hir().hir_to_node_id(upvar_hir_id);
- debug!("get_upvar_name_and_span_for_region: upvar_node_id={:?}", upvar_node_id);
+ debug!("get_upvar_name_and_span_for_region: upvar_hir_id={:?}", upvar_hir_id);
- let upvar_name = tcx.hir().name(upvar_node_id);
- let upvar_span = tcx.hir().span(upvar_node_id);
+ let upvar_name = tcx.hir().name_by_hir_id(upvar_hir_id);
+ let upvar_span = tcx.hir().span_by_hir_id(upvar_hir_id);
debug!("get_upvar_name_and_span_for_region: upvar_name={:?} upvar_span={:?}",
upvar_name, upvar_span);
//! data to rendered labels.
use super::*;
-use borrow_check::nll::constraints::OutlivesConstraint;
-use dot;
+use crate::borrow_check::nll::constraints::OutlivesConstraint;
use std::borrow::Cow;
use std::io::{self, Write};
use super::universal_regions::UniversalRegions;
-use borrow_check::nll::constraints::graph::NormalConstraintGraph;
-use borrow_check::nll::constraints::{ConstraintSccIndex, ConstraintSet, OutlivesConstraint};
-use borrow_check::nll::region_infer::values::{PlaceholderIndices, RegionElement, ToElementIndex};
-use borrow_check::nll::type_check::free_region_relations::UniversalRegionRelations;
-use borrow_check::nll::type_check::Locations;
+use crate::borrow_check::nll::constraints::graph::NormalConstraintGraph;
+use crate::borrow_check::nll::constraints::{ConstraintSccIndex, ConstraintSet, OutlivesConstraint};
+use crate::borrow_check::nll::region_infer::values::{
+ PlaceholderIndices, RegionElement, ToElementIndex
+};
+use crate::borrow_check::nll::type_check::free_region_relations::UniversalRegionRelations;
+use crate::borrow_check::nll::type_check::Locations;
use rustc::hir::def_id::DefId;
use rustc::infer::canonical::QueryRegionConstraint;
use rustc::infer::region_constraints::{GenericKind, VarInfos, VerifyBound};
ConstraintCategory, Local, Location, Mir,
};
use rustc::ty::{self, RegionVid, Ty, TyCtxt, TypeFoldable};
-use rustc::util::common;
+use rustc::util::common::{self, ErrorReported};
use rustc_data_structures::bit_set::BitSet;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::graph::scc::Sccs;
use super::ToRegionVid;
pub struct RegionInferenceContext<'tcx> {
- /// Contains the definition for every region variable. Region
+ /// Contains the definition for every region variable. Region
/// variables are identified by their index (`RegionVid`). The
/// definition contains information about where the region came
/// from as well as its final inferred value.
}
/// A "type test" corresponds to an outlives constraint between a type
-/// and a lifetime, like `T: 'x` or `<T as Foo>::Bar: 'x`. They are
+/// and a lifetime, like `T: 'x` or `<T as Foo>::Bar: 'x`. They are
/// translated from the `Verify` region constraints in the ordinary
/// inference context.
///
///
/// In some cases, however, there are outlives relationships that are
/// not converted into a region constraint, but rather into one of
-/// these "type tests". The distinction is that a type test does not
+/// these "type tests". The distinction is that a type test does not
/// influence the inference result, but instead just examines the
/// values that we ultimately inferred for each region variable and
-/// checks that they meet certain extra criteria. If not, an error
+/// checks that they meet certain extra criteria. If not, an error
/// can be issued.
///
/// One reason for this is that these type tests typically boil down
/// Initializes the region variables for each universally
/// quantified region (lifetime parameter). The first N variables
/// always correspond to the regions appearing in the function
- /// signature (both named and anonymous) and where clauses. This
+ /// signature (both named and anonymous) and where-clauses. This
/// function iterates over those regions and initializes them with
/// minimum values.
///
self.universal_regions.to_region_vid(r)
}
- /// Add annotations for `#[rustc_regions]`; see `UniversalRegions::annotate`.
+ /// Adds annotations for `#[rustc_regions]`; see `UniversalRegions::annotate`.
crate fn annotate(&self, tcx: TyCtxt<'_, '_, 'tcx>, err: &mut DiagnosticBuilder<'_>) {
self.universal_regions.annotate(tcx, err)
}
- /// Returns true if the region `r` contains the point `p`.
+ /// Returns `true` if the region `r` contains the point `p`.
///
/// Panics if called before `solve()` executes,
crate fn region_contains(&self, r: impl ToRegionVid, p: impl ToElementIndex) -> bool {
self.scc_universes[scc]
}
- /// Perform region inference and report errors if we see any
+ /// Performs region inference and report errors if we see any
/// unsatisfiable constraints. If this is a closure, returns the
/// region requirements to propagate to our creator, if any.
pub(super) fn solve<'gcx>(
);
}
- /// True if all the elements in the value of `scc_b` are nameable
+ /// Returns `true` if all the elements in the value of `scc_b` are nameable
/// in `scc_a`. Used during constraint propagation, and only once
/// the value of `scc_b` has been computed.
fn universe_compatible(&self, scc_b: ConstraintSccIndex, scc_a: ConstraintSccIndex) -> bool {
debug!("try_promote_type_test: ur={:?}", ur);
- let non_local_ub = self.universal_region_relations.non_local_upper_bound(ur);
+ let non_local_ub = self.universal_region_relations.non_local_upper_bounds(&ur);
debug!("try_promote_type_test: non_local_ub={:?}", non_local_ub);
- assert!(self.universal_regions.is_universal_region(non_local_ub));
- assert!(!self.universal_regions.is_local_free_region(non_local_ub));
-
- let requirement = ClosureOutlivesRequirement {
- subject,
- outlived_free_region: non_local_ub,
- blame_span: locations.span(mir),
- category: ConstraintCategory::Boring,
- };
- debug!("try_promote_type_test: pushing {:#?}", requirement);
- propagated_outlives_requirements.push(requirement);
+ // This is slightly too conservative. To show T: '1, given `'2: '1`
+ // and `'3: '1` we only need to prove that T: '2 *or* T: '3, but to
+ // avoid potential non-determinism we approximate this by requiring
+ // T: '1 and T: '2.
+ for &upper_bound in non_local_ub {
+ debug_assert!(self.universal_regions.is_universal_region(upper_bound));
+ debug_assert!(!self.universal_regions.is_local_free_region(upper_bound));
+
+ let requirement = ClosureOutlivesRequirement {
+ subject,
+ outlived_free_region: upper_bound,
+ blame_span: locations.span(mir),
+ category: ConstraintCategory::Boring,
+ };
+ debug!("try_promote_type_test: pushing {:#?}", requirement);
+ propagated_outlives_requirements.push(requirement);
+ }
}
true
}
lub
}
- /// Test if `test` is true when applied to `lower_bound` at
- /// `point`, and returns true or false.
+ /// Tests if `test` is true when applied to `lower_bound` at
+ /// `point`.
fn eval_verify_bound(
&self,
tcx: TyCtxt<'_, '_, 'tcx>,
/// different results. (For example, there might be two regions
/// with the same value that are not in the same SCC).
///
- /// NB. This is not an ideal approach and I would like to revisit
+ /// N.B., this is not an ideal approach and I would like to revisit
/// it. However, it works pretty well in practice. In particular,
/// this is needed to deal with projection outlives bounds like
///
///
/// In particular, this routine winds up being important when
/// there are bounds like `where <T as Foo<'a>>::Item: 'b` in the
- /// environment. In this case, if we can show that `'0 == 'a`,
+ /// environment. In this case, if we can show that `'0 == 'a`,
/// and that `'b: '1`, then we know that the clause is
/// satisfied. In such cases, particularly due to limitations of
/// the trait solver =), we usually wind up with a where-clause like
/// Once regions have been propagated, this method is used to see
/// whether any of the constraints were too strong. In particular,
/// we want to check for a case where a universally quantified
- /// region exceeded its bounds. Consider:
+ /// region exceeded its bounds. Consider:
///
/// fn foo<'a, 'b>(x: &'a u32) -> &'b u32 { x }
///
}
}
- /// Check the final value for the free region `fr` to see if it
+ /// Checks the final value for the free region `fr` to see if it
/// grew too large. In particular, examine what `end(X)` points
/// wound up in `fr`'s final value; for each `end(X)` where `X !=
/// fr`, we want to check that `fr: X`. If not, that's either an
.is_none()
);
+ // Only check all of the relations for the main representative of each
+ // SCC, otherwise just check that we outlive said representative. This
+ // reduces the number of redundant relations propagated out of
+ // closures.
+ // Note that the representative will be a universal region if there is
+ // one in this SCC, so we will always check the representative here.
+ let representative = self.scc_representatives[longer_fr_scc];
+ if representative != longer_fr {
+ self.check_universal_region_relation(
+ longer_fr,
+ representative,
+ infcx,
+ mir,
+ mir_def_id,
+ propagated_outlives_requirements,
+ errors_buffer,
+ );
+ return;
+ }
+
// Find every region `o` such that `fr: o`
// (because `fr` includes `end(o)`).
for shorter_fr in self.scc_values.universal_regions_outlived_by(longer_fr_scc) {
- // If it is known that `fr: o`, carry on.
- if self.universal_region_relations
- .outlives(longer_fr, shorter_fr)
- {
- continue;
+ if let Some(ErrorReported) = self.check_universal_region_relation(
+ longer_fr,
+ shorter_fr,
+ infcx,
+ mir,
+ mir_def_id,
+ propagated_outlives_requirements,
+ errors_buffer,
+ ) {
+ // continuing to iterate just reports more errors than necessary
+ return;
}
+ }
+ }
- debug!(
- "check_universal_region: fr={:?} does not outlive shorter_fr={:?}",
- longer_fr, shorter_fr,
- );
+ fn check_universal_region_relation(
+ &self,
+ longer_fr: RegionVid,
+ shorter_fr: RegionVid,
+ infcx: &InferCtxt<'_, 'gcx, 'tcx>,
+ mir: &Mir<'tcx>,
+ mir_def_id: DefId,
+ propagated_outlives_requirements: &mut Option<&mut Vec<ClosureOutlivesRequirement<'gcx>>>,
+ errors_buffer: &mut Vec<Diagnostic>,
+ ) -> Option<ErrorReported> {
+ // If it is known that `fr: o`, carry on.
+ if self.universal_region_relations
+ .outlives(longer_fr, shorter_fr)
+ {
+ return None;
+ }
- let blame_span_category = self.find_outlives_blame_span(mir, longer_fr, shorter_fr);
-
- if let Some(propagated_outlives_requirements) = propagated_outlives_requirements {
- // Shrink `fr` until we find a non-local region (if we do).
- // We'll call that `fr-` -- it's ever so slightly smaller than `fr`.
- if let Some(fr_minus) = self.universal_region_relations
- .non_local_lower_bound(longer_fr)
- {
- debug!("check_universal_region: fr_minus={:?}", fr_minus);
-
- // Grow `shorter_fr` until we find a non-local
- // region. (We always will.) We'll call that
- // `shorter_fr+` -- it's ever so slightly larger than
- // `fr`.
- let shorter_fr_plus = self.universal_region_relations
- .non_local_upper_bound(shorter_fr);
- debug!(
- "check_universal_region: shorter_fr_plus={:?}",
- shorter_fr_plus
- );
+ debug!(
+ "check_universal_region_relation: fr={:?} does not outlive shorter_fr={:?}",
+ longer_fr, shorter_fr,
+ );
+ if let Some(propagated_outlives_requirements) = propagated_outlives_requirements {
+ // Shrink `longer_fr` until we find a non-local region (if we do).
+ // We'll call it `fr-` -- it's ever so slightly smaller than
+ // `longer_fr`.
+
+ if let Some(fr_minus) = self
+ .universal_region_relations
+ .non_local_lower_bound(longer_fr)
+ {
+ debug!("check_universal_region: fr_minus={:?}", fr_minus);
+
+ let blame_span_category = self.find_outlives_blame_span(mir, longer_fr, shorter_fr);
+
+ // Grow `shorter_fr` until we find some non-local regions. (We
+ // always will.) We'll call them `shorter_fr+` -- they're ever
+ // so slightly larger than `shorter_fr`.
+ let shorter_fr_plus = self.universal_region_relations
+ .non_local_upper_bounds(&shorter_fr);
+ debug!(
+ "check_universal_region: shorter_fr_plus={:?}",
+ shorter_fr_plus
+ );
+ for &&fr in &shorter_fr_plus {
// Push the constraint `fr-: shorter_fr+`
propagated_outlives_requirements.push(ClosureOutlivesRequirement {
subject: ClosureOutlivesSubject::Region(fr_minus),
- outlived_free_region: shorter_fr_plus,
+ outlived_free_region: fr,
blame_span: blame_span_category.1,
category: blame_span_category.0,
});
- continue;
}
+ return None;
}
-
- // If we are not in a context where we can propagate
- // errors, or we could not shrink `fr` to something
- // smaller, then just report an error.
- //
- // Note: in this case, we use the unapproximated regions
- // to report the error. This gives better error messages
- // in some cases.
- self.report_error(mir, infcx, mir_def_id, longer_fr, shorter_fr, errors_buffer);
- return; // continuing to iterate just reports more errors than necessary
}
+
+ // If we are not in a context where we can't propagate errors, or we
+ // could not shrink `fr` to something smaller, then just report an
+ // error.
+ //
+ // Note: in this case, we use the unapproximated regions to report the
+ // error. This gives better error messages in some cases.
+ self.report_error(mir, infcx, mir_def_id, longer_fr, shorter_fr, errors_buffer);
+ Some(ErrorReported)
}
fn check_bound_universal_region<'gcx>(
self.points.rows()
}
- /// Adds the given element to the value for the given region. Returns true if
+ /// Adds the given element to the value for the given region. Returns whether
/// the element is newly added (i.e., was not already present).
crate fn add_element(&mut self, row: N, location: Location) -> bool {
debug!("LivenessValues::add(r={:?}, location={:?})", row, location);
}
/// Adds all the elements in the given bit array into the given
- /// region. Returns true if any of them are newly added.
+ /// region. Returns whether any of them are newly added.
crate fn add_elements(&mut self, row: N, locations: &HybridBitSet<PointIndex>) -> bool {
debug!(
"LivenessValues::add_elements(row={:?}, locations={:?})",
self.points.insert_all_into_row(row);
}
- /// True if the region `r` contains the given element.
+ /// Returns `true` if the region `r` contains the given element.
crate fn contains(&self, row: N, location: Location) -> bool {
let index = self.elements.point_from_location(location);
self.points.contains(row, index)
}
}
- /// Adds the given element to the value for the given region. Returns true if
+ /// Adds the given element to the value for the given region. Returns whether
/// the element is newly added (i.e., was not already present).
crate fn add_element(&mut self, r: N, elem: impl ToElementIndex) -> bool {
debug!("add(r={:?}, elem={:?})", r, elem);
self.points.insert_all_into_row(r);
}
- /// Add all elements in `r_from` to `r_to` (because e.g., `r_to:
+ /// Adds all elements in `r_from` to `r_to` (because e.g., `r_to:
/// r_from`).
crate fn add_region(&mut self, r_to: N, r_from: N) -> bool {
self.points.union_rows(r_from, r_to)
| self.placeholders.union_rows(r_from, r_to)
}
- /// True if the region `r` contains the given element.
+ /// Returns `true` if the region `r` contains the given element.
crate fn contains(&self, r: N, elem: impl ToElementIndex) -> bool {
elem.contained_in_row(self, r)
}
}
}
- /// True if `sup_region` contains all the CFG points that
+ /// Returns `true` if `sup_region` contains all the CFG points that
/// `sub_region` contains. Ignores universal regions.
crate fn contains_points(&self, sup_region: N, sub_region: N) -> bool {
if let Some(sub_row) = self.points.row(sub_region) {
-use borrow_check::nll::constraints::OutlivesConstraint;
-use borrow_check::nll::region_infer::TypeTest;
-use borrow_check::nll::type_check::{Locations, MirTypeckRegionConstraints};
-use borrow_check::nll::universal_regions::UniversalRegions;
-use borrow_check::nll::ToRegionVid;
+use crate::borrow_check::nll::constraints::OutlivesConstraint;
+use crate::borrow_check::nll::region_infer::TypeTest;
+use crate::borrow_check::nll::type_check::{Locations, MirTypeckRegionConstraints};
+use crate::borrow_check::nll::universal_regions::UniversalRegions;
+use crate::borrow_check::nll::ToRegionVid;
use rustc::infer::canonical::QueryRegionConstraint;
use rustc::infer::outlives::env::RegionBoundPairs;
use rustc::infer::outlives::obligations::{TypeOutlives, TypeOutlivesDelegate};
-use borrow_check::nll::type_check::constraint_conversion;
-use borrow_check::nll::type_check::{Locations, MirTypeckRegionConstraints};
-use borrow_check::nll::universal_regions::UniversalRegions;
-use borrow_check::nll::ToRegionVid;
+use crate::borrow_check::nll::type_check::constraint_conversion;
+use crate::borrow_check::nll::type_check::{Locations, MirTypeckRegionConstraints};
+use crate::borrow_check::nll::universal_regions::UniversalRegions;
+use crate::borrow_check::nll::ToRegionVid;
use rustc::infer::canonical::QueryRegionConstraint;
use rustc::infer::outlives::free_region_map::FreeRegionRelations;
use rustc::infer::region_constraints::GenericKind;
universal_regions: Rc<UniversalRegions<'tcx>>,
/// Stores the outlives relations that are known to hold from the
- /// implied bounds, in-scope where clauses, and that sort of
+ /// implied bounds, in-scope where-clauses, and that sort of
/// thing.
outlives: TransitiveRelation<RegionVid>,
/// added via implicit bounds.
///
/// Each region here is guaranteed to be a key in the `indices`
-/// map. We use the "original" regions (i.e., the keys from the
+/// map. We use the "original" regions (i.e., the keys from the
/// map, and not the values) because the code in
/// `process_registered_region_obligations` has some special-cased
/// logic expecting to see (e.g.) `ReStatic`, and if we supplied
/// As part of computing the free region relations, we also have to
/// normalize the input-output types, which we then need later. So we
-/// return those. This vector consists of first the input types and
+/// return those. This vector consists of first the input types and
/// then the output type as the last element.
type NormalizedInputsAndOutput<'tcx> = Vec<Ty<'tcx>>;
/// Finds an "upper bound" for `fr` that is not local. In other
/// words, returns the smallest (*) known region `fr1` that (a)
- /// outlives `fr` and (b) is not local. This cannot fail, because
- /// we will always find `'static` at worst.
+ /// outlives `fr` and (b) is not local.
///
- /// (*) If there are multiple competing choices, we pick the "postdominating"
- /// one. See `TransitiveRelation::postdom_upper_bound` for details.
- crate fn non_local_upper_bound(&self, fr: RegionVid) -> RegionVid {
+ /// (*) If there are multiple competing choices, we return all of them.
+ crate fn non_local_upper_bounds(&'a self, fr: &'a RegionVid) -> Vec<&'a RegionVid> {
debug!("non_local_upper_bound(fr={:?})", fr);
- self.non_local_bound(&self.inverse_outlives, fr)
+ let res = self.non_local_bounds(&self.inverse_outlives, fr);
+ assert!(!res.is_empty(), "can't find an upper bound!?");
+ res
+ }
+
+ /// Returns the "postdominating" bound of the set of
+ /// `non_local_upper_bounds` for the given region.
+ crate fn non_local_upper_bound(&self, fr: RegionVid) -> RegionVid {
+ let upper_bounds = self.non_local_upper_bounds(&fr);
+
+ // In case we find more than one, reduce to one for
+ // convenience. This is to prevent us from generating more
+ // complex constraints, but it will cause spurious errors.
+ let post_dom = self
+ .inverse_outlives
+ .mutual_immediate_postdominator(upper_bounds);
+
+ debug!("non_local_bound: post_dom={:?}", post_dom);
+
+ post_dom
+ .and_then(|&post_dom| {
+ // If the mutual immediate postdom is not local, then
+ // there is no non-local result we can return.
+ if !self.universal_regions.is_local_free_region(post_dom) {
+ Some(post_dom)
+ } else {
+ None
+ }
+ })
.unwrap_or(self.universal_regions.fr_static)
}
+
/// Finds a "lower bound" for `fr` that is not local. In other
/// words, returns the largest (*) known region `fr1` that (a) is
- /// outlived by `fr` and (b) is not local. This cannot fail,
- /// because we will always find `'static` at worst.
+ /// outlived by `fr` and (b) is not local.
///
/// (*) If there are multiple competing choices, we pick the "postdominating"
/// one. See `TransitiveRelation::postdom_upper_bound` for details.
crate fn non_local_lower_bound(&self, fr: RegionVid) -> Option<RegionVid> {
debug!("non_local_lower_bound(fr={:?})", fr);
- self.non_local_bound(&self.outlives, fr)
+ let lower_bounds = self.non_local_bounds(&self.outlives, &fr);
+
+ // In case we find more than one, reduce to one for
+ // convenience. This is to prevent us from generating more
+ // complex constraints, but it will cause spurious errors.
+ let post_dom = self
+ .outlives
+ .mutual_immediate_postdominator(lower_bounds);
+
+ debug!("non_local_bound: post_dom={:?}", post_dom);
+
+ post_dom
+ .and_then(|&post_dom| {
+ // If the mutual immediate postdom is not local, then
+ // there is no non-local result we can return.
+ if !self.universal_regions.is_local_free_region(post_dom) {
+ Some(post_dom)
+ } else {
+ None
+ }
+ })
}
- /// Helper for `non_local_upper_bound` and
- /// `non_local_lower_bound`. Repeatedly invokes `postdom_parent`
- /// until we find something that is not local. Returns None if we
- /// never do so.
- fn non_local_bound(
+ /// Helper for `non_local_upper_bounds` and `non_local_lower_bounds`.
+ /// Repeatedly invokes `postdom_parent` until we find something that is not
+ /// local. Returns `None` if we never do so.
+ fn non_local_bounds<'a>(
&self,
- relation: &TransitiveRelation<RegionVid>,
- fr0: RegionVid,
- ) -> Option<RegionVid> {
+ relation: &'a TransitiveRelation<RegionVid>,
+ fr0: &'a RegionVid,
+ ) -> Vec<&'a RegionVid> {
// This method assumes that `fr0` is one of the universally
// quantified region variables.
- assert!(self.universal_regions.is_universal_region(fr0));
+ assert!(self.universal_regions.is_universal_region(*fr0));
let mut external_parents = vec![];
- let mut queue = vec![&fr0];
+ let mut queue = vec![fr0];
// Keep expanding `fr` into its parents until we reach
// non-local regions.
debug!("non_local_bound: external_parents={:?}", external_parents);
- // In case we find more than one, reduce to one for
- // convenience. This is to prevent us from generating more
- // complex constraints, but it will cause spurious errors.
- let post_dom = relation
- .mutual_immediate_postdominator(external_parents)
- .cloned();
-
- debug!("non_local_bound: post_dom={:?}", post_dom);
-
- post_dom.and_then(|post_dom| {
- // If the mutual immediate postdom is not local, then
- // there is no non-local result we can return.
- if !self.universal_regions.is_local_free_region(post_dom) {
- Some(post_dom)
- } else {
- None
- }
- })
+ external_parents
}
- /// True if fr1 is known to outlive fr2.
+ /// Returns `true` if fr1 is known to outlive fr2.
///
/// This will only ever be true for universally quantified regions.
crate fn outlives(&self, fr1: RegionVid, fr2: RegionVid) -> bool {
//! `RETURN_PLACE` the MIR arguments) are always fully normalized (and
//! contain revealed `impl Trait` values).
-use borrow_check::nll::universal_regions::UniversalRegions;
+use crate::borrow_check::nll::universal_regions::UniversalRegions;
use rustc::infer::LateBoundRegionConversionTime;
use rustc::mir::*;
use rustc::ty::Ty;
//! liveness code so that it only operates over variables with regions in their
//! types, instead of all variables.
-use borrow_check::nll::ToRegionVid;
-use borrow_check::nll::facts::{AllFacts, AllFactsExt};
+use crate::borrow_check::nll::ToRegionVid;
+use crate::borrow_check::nll::facts::{AllFacts, AllFactsExt};
+use crate::util::liveness::LiveVariableMap;
use rustc::mir::{Local, Mir};
use rustc::ty::{RegionVid, TyCtxt};
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
-use util::liveness::LiveVariableMap;
/// Map between Local and LiveVar indices: the purpose of this
/// map is to define the subset of local variables for which we need
}
}
- /// True if there are no local variables that need liveness computation.
+ /// Returns `true` if there are no local variables that need liveness computation.
crate fn is_empty(&self) -> bool {
self.to_local.is_empty()
}
-use borrow_check::nll::region_infer::values::{PointIndex, RegionValueElements};
-use borrow_check::nll::type_check::liveness::liveness_map::{LiveVar, NllLivenessMap};
+use crate::borrow_check::nll::region_infer::values::{PointIndex, RegionValueElements};
+use crate::borrow_check::nll::type_check::liveness::liveness_map::{LiveVar, NllLivenessMap};
+use crate::util::liveness::{categorize, DefUse, LiveVariableMap};
use rustc::mir::visit::{PlaceContext, Visitor};
use rustc::mir::{Local, Location, Mir};
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
use rustc_data_structures::vec_linked_list as vll;
-use util::liveness::{categorize, DefUse, LiveVariableMap};
/// A map that cross references each local with the locations where it
/// is defined (assigned), used, or dropped. Used during liveness
-use borrow_check::location::LocationTable;
-use borrow_check::nll::region_infer::values::RegionValueElements;
-use borrow_check::nll::constraints::ConstraintSet;
-use borrow_check::nll::NllLivenessMap;
-use borrow_check::nll::universal_regions::UniversalRegions;
-use dataflow::move_paths::MoveData;
-use dataflow::MaybeInitializedPlaces;
-use dataflow::FlowAtLocation;
+use crate::borrow_check::location::LocationTable;
+use crate::borrow_check::nll::region_infer::values::RegionValueElements;
+use crate::borrow_check::nll::constraints::ConstraintSet;
+use crate::borrow_check::nll::NllLivenessMap;
+use crate::borrow_check::nll::universal_regions::UniversalRegions;
+use crate::dataflow::move_paths::MoveData;
+use crate::dataflow::MaybeInitializedPlaces;
+use crate::dataflow::FlowAtLocation;
use rustc::mir::Mir;
use rustc::ty::RegionVid;
use rustc_data_structures::fx::FxHashSet;
/// that indicate which types must be live at which point in the CFG.
/// This vector is consumed by `constraint_generation`.
///
-/// NB. This computation requires normalization; therefore, it must be
+/// N.B., this computation requires normalization; therefore, it must be
/// performed before
pub(super) fn generate<'gcx, 'tcx>(
typeck: &mut TypeChecker<'_, 'gcx, 'tcx>,
trace::trace(typeck, mir, elements, flow_inits, move_data, &liveness_map, location_table);
}
-/// Compute all regions that are (currently) known to outlive free
+/// Computes all regions that are (currently) known to outlive free
/// regions. For these regions, we do not need to compute
/// liveness, since the outlives constraints will ensure that they
/// are live over the whole fn body anyhow.
-use borrow_check::location::LocationTable;
-use borrow_check::nll::region_infer::values::{self, PointIndex, RegionValueElements};
-use borrow_check::nll::type_check::liveness::liveness_map::{LiveVar, NllLivenessMap};
-use borrow_check::nll::type_check::liveness::local_use_map::LocalUseMap;
-use borrow_check::nll::type_check::NormalizeLocation;
-use borrow_check::nll::type_check::TypeChecker;
-use dataflow::move_paths::indexes::MovePathIndex;
-use dataflow::move_paths::MoveData;
-use dataflow::{FlowAtLocation, FlowsAtLocation, MaybeInitializedPlaces};
+use crate::borrow_check::location::LocationTable;
+use crate::borrow_check::nll::region_infer::values::{self, PointIndex, RegionValueElements};
+use crate::borrow_check::nll::type_check::liveness::liveness_map::{LiveVar, NllLivenessMap};
+use crate::borrow_check::nll::type_check::liveness::local_use_map::LocalUseMap;
+use crate::borrow_check::nll::type_check::NormalizeLocation;
+use crate::borrow_check::nll::type_check::TypeChecker;
+use crate::dataflow::move_paths::indexes::MovePathIndex;
+use crate::dataflow::move_paths::MoveData;
+use crate::dataflow::{FlowAtLocation, FlowsAtLocation, MaybeInitializedPlaces};
+use crate::util::liveness::LiveVariableMap;
use rustc::infer::canonical::QueryRegionConstraint;
use rustc::mir::{BasicBlock, ConstraintCategory, Local, Location, Mir};
use rustc::traits::query::dropck_outlives::DropckOutlivesResult;
use rustc_data_structures::bit_set::HybridBitSet;
use rustc_data_structures::fx::FxHashMap;
use std::rc::Rc;
-use util::liveness::LiveVariableMap;
/// This is the heart of the liveness computation. For each variable X
/// that requires a liveness computation, it walks over all the uses
}
}
- /// Compute all points where local is "use live" -- meaning its
+ /// Computes all points where local is "use live" -- meaning its
/// current value may be used later (except by a drop). This is
/// done by walking backwards from each use of `live_local` until we
/// find a `def` of local.
}
}
- /// Compute all points where local is "drop live" -- meaning its
+ /// Computes all points where local is "drop live" -- meaning its
/// current value may be dropped later (but not used). This is
/// done by iterating over the drops of `local` where `local` (or
/// some subpart of `local`) is initialized. For each such drop,
}
impl LivenessContext<'_, '_, '_, '_, 'tcx> {
- /// True if the local variable (or some part of it) is initialized in
+ /// Returns `true` if the local variable (or some part of it) is initialized in
/// the terminator of `block`. We need to check this to determine if a
/// DROP of some local variable will have an effect -- note that
/// drops, as they may unwind, are always terminators.
self.flow_inits.has_any_child_of(mpi).is_some()
}
- /// True if the path `mpi` (or some part of it) is initialized at
+ /// Returns `true` if the path `mpi` (or some part of it) is initialized at
/// the exit of `block`.
///
/// **Warning:** Does not account for the result of `Call`
self.flow_inits.has_any_child_of(mpi).is_some()
}
- /// Store the result that all regions in `value` are live for the
+ /// Stores the result that all regions in `value` are live for the
/// points `live_at`.
fn add_use_live_facts_for(
&mut self,
#![allow(unreachable_code)]
-use borrow_check::borrow_set::BorrowSet;
-use borrow_check::location::LocationTable;
-use borrow_check::nll::constraints::{ConstraintSet, OutlivesConstraint};
-use borrow_check::nll::facts::AllFacts;
-use borrow_check::nll::region_infer::values::LivenessValues;
-use borrow_check::nll::region_infer::values::PlaceholderIndex;
-use borrow_check::nll::region_infer::values::PlaceholderIndices;
-use borrow_check::nll::region_infer::values::RegionValueElements;
-use borrow_check::nll::region_infer::{ClosureRegionRequirementsExt, TypeTest};
-use borrow_check::nll::renumber;
-use borrow_check::nll::type_check::free_region_relations::{
+use crate::borrow_check::borrow_set::BorrowSet;
+use crate::borrow_check::location::LocationTable;
+use crate::borrow_check::nll::constraints::{ConstraintSet, OutlivesConstraint};
+use crate::borrow_check::nll::facts::AllFacts;
+use crate::borrow_check::nll::region_infer::values::LivenessValues;
+use crate::borrow_check::nll::region_infer::values::PlaceholderIndex;
+use crate::borrow_check::nll::region_infer::values::PlaceholderIndices;
+use crate::borrow_check::nll::region_infer::values::RegionValueElements;
+use crate::borrow_check::nll::region_infer::{ClosureRegionRequirementsExt, TypeTest};
+use crate::borrow_check::nll::renumber;
+use crate::borrow_check::nll::type_check::free_region_relations::{
CreateResult, UniversalRegionRelations,
};
-use borrow_check::nll::universal_regions::{DefiningTy, UniversalRegions};
-use borrow_check::nll::ToRegionVid;
-use dataflow::move_paths::MoveData;
-use dataflow::FlowAtLocation;
-use dataflow::MaybeInitializedPlaces;
+use crate::borrow_check::nll::universal_regions::{DefiningTy, UniversalRegions};
+use crate::borrow_check::nll::ToRegionVid;
+use crate::dataflow::move_paths::MoveData;
+use crate::dataflow::FlowAtLocation;
+use crate::dataflow::MaybeInitializedPlaces;
+use crate::transform::{MirPass, MirSource};
use either::Either;
use rustc::hir;
use rustc::hir::def_id::DefId;
use std::rc::Rc;
use std::{fmt, iter};
use syntax_pos::{Span, DUMMY_SP};
-use transform::{MirPass, MirSource};
macro_rules! span_mirbug {
($context:expr, $elem:expr, $($message:tt)*) => ({
extra(&mut checker)
}
-fn translate_outlives_facts(cx: &mut BorrowCheckContext) {
+fn translate_outlives_facts(cx: &mut BorrowCheckContext<'_, '_>) {
if let Some(facts) = cx.all_facts {
let location_table = cx.location_table;
facts
}
}
-fn mirbug(tcx: TyCtxt, span: Span, msg: &str) {
+fn mirbug(tcx: TyCtxt<'_, '_, '_>, span: Span, msg: &str) {
// We sometimes see MIR failures (notably predicate failures) due to
// the fact that we check rvalue sized predicates here. So use `delay_span_bug`
// to avoid reporting bugs in those cases.
}
}
- fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) {
+ fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext<'_>, location: Location) {
self.sanitize_place(place, location, context);
}
&mut self,
place: &Place<'tcx>,
location: Location,
- context: PlaceContext,
+ context: PlaceContext<'_>,
) -> PlaceTy<'tcx> {
debug!("sanitize_place: {:?}", place);
let place_ty = match *place {
/// older NLL analysis, we required this only at the entry point
/// to the function. By the nature of the constraints, this wound
/// up propagating to all points reachable from start (because
- /// `'1` -- as a universal region -- is live everywhere). In the
+ /// `'1` -- as a universal region -- is live everywhere). In the
/// newer analysis, though, this doesn't work: `_0` is considered
/// dead at the start (it has no usable value) and hence this type
/// equality is basically a no-op. Then, later on, when we do `_0
}
}
- /// Add the constraints that arise from a borrow expression `&'a P` at the location `L`.
+ /// Adds the constraints that arise from a borrow expression `&'a P` at the location `L`.
///
/// # Parameters
///
pub struct TypeckMir;
impl MirPass for TypeckMir {
- fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, src: MirSource, mir: &mut Mir<'tcx>) {
- let def_id = src.def_id;
+ fn run_pass<'a, 'tcx>(
+ &self,
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ src: MirSource<'tcx>,
+ mir: &mut Mir<'tcx>,
+ ) {
+ let def_id = src.def_id();
debug!("run_pass: {:?}", def_id);
// When NLL is enabled, the borrow checker runs the typeck
-use borrow_check::nll::constraints::OutlivesConstraint;
-use borrow_check::nll::type_check::{BorrowCheckContext, Locations};
+use crate::borrow_check::nll::constraints::OutlivesConstraint;
+use crate::borrow_check::nll::type_check::{BorrowCheckContext, Locations};
use rustc::infer::nll_relate::{TypeRelating, TypeRelatingDelegate, NormalizationStrategy};
use rustc::infer::{InferCtxt, NLLRegionVariableOrigin};
use rustc::mir::ConstraintCategory;
/// - "Invariant" `a == b`
/// - "Contravariant" `a :> b`
///
-/// NB. The type `a` is permitted to have unresolved inference
+/// N.B., the type `a` is permitted to have unresolved inference
/// variables, but not the type `b`.
pub(super) fn relate_types<'tcx>(
infcx: &InferCtxt<'_, '_, 'tcx>,
pub fr_static: RegionVid,
/// A special region vid created to represent the current MIR fn
- /// body. It will outlive the entire CFG but it will not outlive
+ /// body. It will outlive the entire CFG but it will not outlive
/// any other universal regions.
pub fr_fn_body: RegionVid,
/// We create region variables such that they are ordered by their
/// `RegionClassification`. The first block are globals, then
- /// externals, then locals. So things from:
- /// - `FIRST_GLOBAL_INDEX..first_extern_index` are global;
- /// - `first_extern_index..first_local_index` are external; and
+ /// externals, then locals. So, things from:
+ /// - `FIRST_GLOBAL_INDEX..first_extern_index` are global,
+ /// - `first_extern_index..first_local_index` are external,
/// - `first_local_index..num_universals` are local.
first_extern_index: usize,
num_universals: usize,
/// The "defining" type for this function, with all universal
- /// regions instantiated. For a closure or generator, this is the
+ /// regions instantiated. For a closure or generator, this is the
/// closure type, but for a top-level function it's the `FnDef`.
pub defining_ty: DefiningTy<'tcx>,
/// The return type of this function, with all regions replaced by
/// their universal `RegionVid` equivalents.
///
- /// NB. Associated types in this type have not been normalized,
+ /// N.B., associated types in this type have not been normalized,
/// as the name suggests. =)
pub unnormalized_output_ty: Ty<'tcx>,
/// The fully liberated input types of this function, with all
/// regions replaced by their universal `RegionVid` equivalents.
///
- /// NB. Associated types in these types have not been normalized,
+ /// N.B., associated types in these types have not been normalized,
/// as the name suggests. =)
pub unnormalized_input_tys: &'tcx [Ty<'tcx>],
/// `ClosureSubsts::generator_return_ty`.
Generator(DefId, ty::GeneratorSubsts<'tcx>, hir::GeneratorMovability),
- /// The MIR is a fn item with the given def-id and substs. The signature
+ /// The MIR is a fn item with the given `DefId` and substs. The signature
/// of the function can be bound then with the `fn_sig` query.
FnDef(DefId, &'tcx Substs<'tcx>),
/// A **local** lifetime is one about which we know the full set
/// of relevant constraints (that is, relationships to other named
- /// regions). For a closure, this includes any region bound in
- /// the closure's signature. For a fn item, this includes all
+ /// regions). For a closure, this includes any region bound in
+ /// the closure's signature. For a fn item, this includes all
/// regions other than global ones.
///
/// Continuing with the example from `External`, if we were
/// analyzing the closure, then `'x` would be local (and `'a` and
- /// `'b` are external). If we are analyzing the function item
+ /// `'b` are external). If we are analyzing the function item
/// `foo`, then `'a` and `'b` are local (and `'x` is not in
/// scope).
Local,
region_mapping
}
- /// True if `r` is a member of this set of universal regions.
+ /// Returns `true` if `r` is a member of this set of universal regions.
pub fn is_universal_region(&self, r: RegionVid) -> bool {
(FIRST_GLOBAL_INDEX..self.num_universals).contains(&r.index())
}
(FIRST_GLOBAL_INDEX..self.num_universals).map(RegionVid::new)
}
- /// True if `r` is classified as an local region.
+ /// Returns `true` if `r` is classified as an local region.
pub fn is_local_free_region(&self, r: RegionVid) -> bool {
self.region_classification(r) == Some(RegionClassification::Local)
}
self.first_local_index
}
- /// Get an iterator over all the early-bound regions that have names.
+ /// Gets an iterator over all the early-bound regions that have names.
pub fn named_universal_regions<'s>(
&'s self,
) -> impl Iterator<Item = (ty::Region<'tcx>, ty::RegionVid)> + 's {
tcx.type_of(closure_base_def_id)
} else {
let tables = tcx.typeck_tables_of(self.mir_def_id);
- tables.node_id_to_type(self.mir_hir_id)
+ tables.node_type(self.mir_hir_id)
};
debug!("defining_ty (pre-replacement): {:?}", defining_ty);
/// indices vector. Typically, we identify late-bound regions as we process the inputs and
/// outputs of the closure/function. However, sometimes there are late-bound regions which do
/// not appear in the fn parameters but which are nonetheless in scope. The simplest case of
- /// this are unused functions, like fn foo<'a>() { } (see eg., #51351). Despite not being used,
+ /// this are unused functions, like fn foo<'a>() { } (see e.g., #51351). Despite not being used,
/// users can still reference these regions (e.g., let x: &'a u32 = &22;), so we need to create
/// entries for them and store them in the indices map. This code iterates over the complete
/// set of late-bound regions and checks for any that we have not yet seen, adding them to the
}
}
- /// Replace all free regions in `value` with region vids, as
+ /// Replaces all free regions in `value` with region vids, as
/// returned by `to_region_vid`.
pub fn fold_to_region_vids<T>(&self, tcx: TyCtxt<'_, '_, 'tcx>, value: &T) -> T
where
owner: fn_def_id.index,
local_id: *late_bound,
};
- let region_node_id = tcx.hir().hir_to_node_id(hir_id);
- let name = tcx.hir().name(region_node_id).as_interned_str();
- let region_def_id = tcx.hir().local_def_id(region_node_id);
+ let name = tcx.hir().name_by_hir_id(hir_id).as_interned_str();
+ let region_def_id = tcx.hir().local_def_id_from_hir_id(hir_id);
let liberated_region = tcx.mk_region(ty::ReFree(ty::FreeRegion {
scope: fn_def_id,
bound_region: ty::BoundRegion::BrNamed(region_def_id, name),
-use borrow_check::borrow_set::{BorrowSet, BorrowData, TwoPhaseActivation};
-use borrow_check::places_conflict;
-use borrow_check::Context;
-use borrow_check::AccessDepth;
-use dataflow::indexes::BorrowIndex;
+use crate::borrow_check::borrow_set::{BorrowSet, BorrowData, TwoPhaseActivation};
+use crate::borrow_check::places_conflict;
+use crate::borrow_check::Context;
+use crate::borrow_check::AccessDepth;
+use crate::dataflow::indexes::BorrowIndex;
use rustc::mir::{BasicBlock, Location, Mir, Place};
use rustc::mir::{ProjectionElem, BorrowKind};
use rustc::ty::TyCtxt;
use rustc_data_structures::graph::dominators::Dominators;
-/// Returns true if the borrow represented by `kind` is
+/// Returns `true` if the borrow represented by `kind` is
/// allowed to be split into separate Reservation and
/// Activation phases.
pub(super) fn allow_two_phase_borrow<'a, 'tcx, 'gcx: 'tcx>(
use rustc::mir::ProjectionElem;
use rustc::mir::{Local, Mir, Place, Mutability};
use rustc::ty::{self, TyCtxt};
-use borrow_check::borrow_set::LocalsStateAtExit;
+use crate::borrow_check::borrow_set::LocalsStateAtExit;
/// Extension methods for the `Place` type.
crate trait PlaceExt<'tcx> {
- /// Returns true if we can safely ignore borrows of this place.
+ /// Returns `true` if we can safely ignore borrows of this place.
/// This is true whenever there is no action that the user can do
/// to the place `self` that would invalidate the borrow. This is true
/// for borrows of raw pointer dereferents as well as shared references.
-use borrow_check::ArtificialField;
-use borrow_check::Overlap;
-use borrow_check::{Deep, Shallow, AccessDepth};
+use crate::borrow_check::ArtificialField;
+use crate::borrow_check::Overlap;
+use crate::borrow_check::{Deep, Shallow, AccessDepth};
use rustc::hir;
use rustc::mir::{BorrowKind, Mir, Place};
use rustc::mir::{Projection, ProjectionElem};
/// A linked list of places running up the stack; begins with the
/// innermost place and extends to projections (e.g., `a.b` would have
-/// the place `a` with a "next" pointer to `a.b`). Created by
+/// the place `a` with a "next" pointer to `a.b`). Created by
/// `unroll_place`.
///
-/// N.B., this particular impl strategy is not the most obvious. It was
+/// N.B., this particular impl strategy is not the most obvious. It was
/// chosen because it makes a measurable difference to NLL
/// performance, as this code (`borrow_conflicts_with_place`) is somewhat hot.
struct PlaceComponents<'p, 'tcx: 'p> {
use rustc_data_structures::fx::FxHashSet;
-use borrow_check::MirBorrowckCtxt;
+use crate::borrow_check::MirBorrowckCtxt;
impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
/// Walks the MIR adding to the set of `used_mut` locals that will be ignored for the purposes
-use build::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
-use build::ForGuard::OutsideGuard;
-use build::matches::ArmHasGuard;
-use hair::*;
+use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
+use crate::build::ForGuard::OutsideGuard;
+use crate::build::matches::ArmHasGuard;
+use crate::hair::*;
use rustc::mir::*;
use rustc::hir;
use syntax_pos::Span;
//! Routines for manipulating the control-flow graph.
-use build::CFG;
+use crate::build::CFG;
use rustc::mir::*;
impl<'tcx> CFG<'tcx> {
//! See docs in build/expr/mod.rs
-use build::Builder;
-use hair::*;
+use crate::build::Builder;
+use crate::hair::*;
use rustc::mir::*;
use rustc::ty::CanonicalUserTypeAnnotation;
//! See docs in build/expr/mod.rs
-use build::expr::category::Category;
-use build::{BlockAnd, BlockAndExtension, Builder};
-use hair::*;
+use crate::build::expr::category::Category;
+use crate::build::{BlockAnd, BlockAndExtension, Builder};
+use crate::hair::*;
use rustc::middle::region;
use rustc::mir::*;
//! See docs in build/expr/mod.rs
-use build::expr::category::Category;
-use build::ForGuard::{OutsideGuard, RefWithinGuard};
-use build::{BlockAnd, BlockAndExtension, Builder};
-use hair::*;
+use crate::build::expr::category::Category;
+use crate::build::ForGuard::{OutsideGuard, RefWithinGuard};
+use crate::build::{BlockAnd, BlockAndExtension, Builder};
+use crate::hair::*;
use rustc::mir::interpret::EvalErrorKind::BoundsCheck;
use rustc::mir::*;
use rustc::ty::{CanonicalUserTypeAnnotation, Variance};
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::indexed_vec::Idx;
-use build::expr::category::{Category, RvalueFunc};
-use build::{BlockAnd, BlockAndExtension, Builder};
-use hair::*;
+use crate::build::expr::category::{Category, RvalueFunc};
+use crate::build::{BlockAnd, BlockAndExtension, Builder};
+use crate::hair::*;
use rustc::middle::region;
use rustc::mir::interpret::EvalErrorKind;
use rustc::mir::*;
span: expr_span,
ty: this.hir.tcx().types.u32,
user_ty: None,
- literal: this.hir.tcx().intern_lazy_const(ty::LazyConst::Evaluated(
+ literal: this.hir.tcx().mk_lazy_const(ty::LazyConst::Evaluated(
ty::Const::from_bits(
this.hir.tcx(),
0,
//! See docs in build/expr/mod.rs
-use build::{BlockAnd, BlockAndExtension, Builder};
-use hair::*;
+use crate::build::{BlockAnd, BlockAndExtension, Builder};
+use crate::hair::*;
use rustc::middle::region;
use rustc::mir::*;
-use hair::*;
+use crate::hair::*;
#[derive(Debug, PartialEq)]
pub enum Category {
//! See docs in build/expr/mod.rs
-use build::expr::category::{Category, RvalueFunc};
-use build::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
-use hair::*;
+use crate::build::expr::category::{Category, RvalueFunc};
+use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
+use crate::hair::*;
use rustc::mir::*;
use rustc::ty;
-use build::scope::BreakableScope;
-use build::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
-use hair::*;
+use crate::build::scope::BreakableScope;
+use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
+use crate::hair::*;
use rustc::mir::*;
impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
//! wrapped up as expressions (e.g., blocks). To make this ergonomic, we use this
//! latter `EvalInto` trait.
-use build::{BlockAnd, Builder};
-use hair::*;
+use crate::build::{BlockAnd, Builder};
+use crate::hair::*;
use rustc::mir::*;
-pub(in build) trait EvalInto<'tcx> {
+pub(in crate::build) trait EvalInto<'tcx> {
fn eval_into<'a, 'gcx>(self,
builder: &mut Builder<'a, 'gcx, 'tcx>,
destination: &Place<'tcx>,
//! includes the high-level algorithm, the submodules contain the
//! details.
-use build::scope::{CachedBlock, DropKind};
-use build::ForGuard::{self, OutsideGuard, RefWithinGuard, ValWithinGuard};
-use build::{BlockAnd, BlockAndExtension, Builder};
-use build::{GuardFrame, GuardFrameLocal, LocalsForNode};
-use hair::*;
+use crate::build::scope::{CachedBlock, DropKind};
+use crate::build::ForGuard::{self, OutsideGuard, RefWithinGuard, ValWithinGuard};
+use crate::build::{BlockAnd, BlockAndExtension, Builder};
+use crate::build::{GuardFrame, GuardFrameLocal, LocalsForNode};
+use crate::hair::{self, *};
use rustc::mir::*;
use rustc::ty::{self, CanonicalUserTypeAnnotation, Ty};
use rustc::ty::layout::VariantIdx;
},
..
},
- user_ty: pat_ascription_ty,
- variance: _,
- user_ty_span,
+ ascription: hair::pattern::Ascription {
+ user_ty: pat_ascription_ty,
+ variance: _,
+ user_ty_span,
+ },
} => {
let place =
self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard);
}
PatternKind::AscribeUserType {
ref subpattern,
- ref user_ty,
- user_ty_span,
- variance: _,
+ ascription: hair::pattern::Ascription {
+ ref user_ty,
+ user_ty_span,
+ variance: _,
+ },
} => {
// This corresponds to something like
//
///
/// The return value is a list of "otherwise" blocks. These are
/// points in execution where we found that *NONE* of the
- /// candidates apply. In principle, this means that the input
+ /// candidates apply. In principle, this means that the input
/// list was not exhaustive, though at present we sometimes are
/// not smart enough to recognize all exhaustive inputs.
///
}
}
- /// This is the most subtle part of the matching algorithm. At
+ /// This is the most subtle part of the matching algorithm. At
/// this point, the input candidates have been fully simplified,
/// and so we know that all remaining match-pairs require some
/// sort of test. To decide what test to do, we take the highest
/// 4. etc.
///
/// Once we know what sort of test we are going to perform, this
- /// test may also help us with other candidates. So we walk over
+ /// Tests may also help us with other candidates. So we walk over
/// the candidates (from high to low priority) and check. This
/// gives us, for each outcome of the test, a transformed list of
- /// candidates. For example, if we are testing the current
+ /// candidates. For example, if we are testing the current
/// variant of `x.0`, and we have a candidate `{x.0 @ Some(v), x.1
/// @ 22}`, then we would have a resulting candidate of `{(x.0 as
/// Some).0 @ v, x.1 @ 22}`. Note that the first match-pair is now
/// for the case where the guard fails.
///
/// Note: we check earlier that if there is a guard, there cannot
- /// be move bindings. This isn't really important for the
+ /// be move bindings. This isn't really important for the
/// self-consistency of this fn, but the reason for it should be
/// clear: after we've done the assignments, if there were move
/// bindings, further tests would be a use-after-move (which would
//! sort of test: for example, testing which variant an enum is, or
//! testing a value against a constant.
-use build::Builder;
-use build::matches::{Ascription, Binding, MatchPair, Candidate};
-use hair::*;
+use crate::build::Builder;
+use crate::build::matches::{Ascription, Binding, MatchPair, Candidate};
+use crate::hair::{self, *};
use rustc::ty;
use rustc::ty::layout::{Integer, IntegerExt, Size};
use syntax::attr::{SignedInt, UnsignedInt};
match *match_pair.pattern.kind {
PatternKind::AscribeUserType {
ref subpattern,
- variance,
- ref user_ty,
- user_ty_span
+ ascription: hair::pattern::Ascription {
+ variance,
+ ref user_ty,
+ user_ty_span,
+ },
} => {
// Apply the type ascription to the value at `match_pair.place`, which is the
// value being matched, taking the variance field into account.
// identify what tests are needed, perform the tests, and then filter
// the candidates based on the result.
-use build::Builder;
-use build::matches::{Candidate, MatchPair, Test, TestKind};
-use hair::*;
-use hair::pattern::compare_const_vals;
+use crate::build::Builder;
+use crate::build::matches::{Candidate, MatchPair, Test, TestKind};
+use crate::hair::*;
+use crate::hair::pattern::compare_const_vals;
use rustc_data_structures::bit_set::BitSet;
use rustc_data_structures::fx::FxHashMap;
use rustc::ty::{self, Ty};
}
let eq_def_id = self.hir.tcx().lang_items().eq_trait().unwrap();
let (mty, method) = self.hir.trait_method(eq_def_id, "eq", ty, &[ty.into()]);
- let method = self.hir.tcx().intern_lazy_const(ty::LazyConst::Evaluated(method));
+ let method = self.hir.tcx().mk_lazy_const(ty::LazyConst::Evaluated(method));
let re_erased = self.hir.tcx().types.re_erased;
// take the argument by reference
/// appropriate.
///
/// So, for example, if this candidate is `x @ Some(P0)` and the
- /// test is a variant test, then we would add `(x as Option).0 @
+ /// Tests is a variant test, then we would add `(x as Option).0 @
/// P0` to the `resulting_candidates` entry corresponding to the
/// variant `Some`.
///
-use build::Builder;
-use build::matches::MatchPair;
-use hair::*;
+use crate::build::Builder;
+use crate::build::matches::MatchPair;
+use crate::hair::*;
use rustc::mir::*;
use std::u32;
use std::convert::TryInto;
//! Miscellaneous builder routines that are not specific to building any particular
//! kind of thing.
-use build::Builder;
+use crate::build::Builder;
use rustc::ty::{self, Ty};
use syntax_pos::{Span, DUMMY_SP};
impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
- /// Add a new temporary value of type `ty` storing the result of
+ /// Adds a new temporary value of type `ty` storing the result of
/// evaluating `expr`.
///
/// N.B., **No cleanup is scheduled for this temporary.** You should
span,
ty,
user_ty: None,
- literal: self.hir.tcx().intern_lazy_const(ty::LazyConst::Evaluated(literal)),
+ literal: self.hir.tcx().mk_lazy_const(ty::LazyConst::Evaluated(literal)),
};
Operand::Constant(constant)
}
-use build;
-use build::scope::{CachedBlock, DropKind};
-use hair::cx::Cx;
-use hair::{LintLevel, BindingMode, PatternKind};
+use crate::build;
+use crate::build::scope::{CachedBlock, DropKind};
+use crate::hair::cx::Cx;
+use crate::hair::{LintLevel, BindingMode, PatternKind};
+use crate::shim;
+use crate::transform::MirSource;
+use crate::util as mir_util;
use rustc::hir;
use rustc::hir::Node;
use rustc::hir::def_id::DefId;
use rustc::util::nodemap::NodeMap;
use rustc_target::spec::PanicStrategy;
use rustc_data_structures::indexed_vec::{IndexVec, Idx};
-use shim;
use std::mem;
use std::u32;
use rustc_target::spec::abi::Abi;
use syntax::attr::{self, UnwindAttr};
use syntax::symbol::keywords;
use syntax_pos::Span;
-use transform::MirSource;
-use util as mir_util;
use super::lints;
-/// Construct the MIR for a given def-id.
+/// Construct the MIR for a given `DefId`.
pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'tcx> {
let id = tcx.hir().as_local_node_id(def_id).unwrap();
) => {
(*body_id, ty.span)
}
- Node::AnonConst(hir::AnonConst { body, id, .. }) => {
- (*body, tcx.hir().span(*id))
+ Node::AnonConst(hir::AnonConst { body, hir_id, .. }) => {
+ (*body, tcx.hir().span_by_hir_id(*hir_id))
}
_ => span_bug!(tcx.hir().span(id), "can't build MIR for {:?}", def_id),
Some(ArgInfo(liberated_closure_env_ty(tcx, id, body_id), None, None, None))
}
ty::Generator(..) => {
- let gen_ty = tcx.body_tables(body_id).node_id_to_type(fn_hir_id);
+ let gen_ty = tcx.body_tables(body_id).node_type(fn_hir_id);
Some(ArgInfo(gen_ty, None, None, None))
}
_ => None,
let self_arg;
if let Some(ref fn_decl) = tcx.hir().fn_decl(owner_id) {
let ty_hir_id = fn_decl.inputs[index].hir_id;
- let ty_span = tcx.hir().span(tcx.hir().hir_to_node_id(ty_hir_id));
+ let ty_span = tcx.hir().span_by_hir_id(ty_hir_id);
opt_ty_info = Some(ty_span);
self_arg = if index == 0 && fn_decl.implicit_self.has_implicit_self() {
match fn_decl.implicit_self {
};
globalizer.visit_mir(&mut mir);
let mir = unsafe {
- mem::transmute::<Mir, Mir<'tcx>>(mir)
+ mem::transmute::<Mir<'_>, Mir<'tcx>>(mir)
};
mir_util::dump_mir(tcx, None, "mir_map", &0,
})
}
-/// A pass to lift all the types and substitutions in a Mir
+/// A pass to lift all the types and substitutions in a MIR
/// to the global tcx. Sadly, we don't have a "folder" that
-/// can change 'tcx so we have to transmute afterwards.
+/// can change `'tcx` so we have to transmute afterwards.
struct GlobalizeMir<'a, 'gcx: 'a> {
tcx: TyCtxt<'a, 'gcx, 'gcx>,
span: Span
};
globalizer.visit_mir(&mut mir);
let mir = unsafe {
- mem::transmute::<Mir, Mir<'tcx>>(mir)
+ mem::transmute::<Mir<'_>, Mir<'tcx>>(mir)
};
mir_util::dump_mir(tcx, None, "mir_map", &0,
body_id: hir::BodyId)
-> Ty<'tcx> {
let closure_expr_hir_id = tcx.hir().node_to_hir_id(closure_expr_id);
- let closure_ty = tcx.body_tables(body_id).node_id_to_type(closure_expr_hir_id);
+ let closure_ty = tcx.body_tables(body_id).node_type(closure_expr_hir_id);
let (closure_def_id, closure_substs) = match closure_ty.sty {
ty::Closure(closure_def_id, closure_substs) => (closure_def_id, closure_substs),
fn_span: Span,
arg_count: usize,
- /// the current set of scopes, updated as we traverse;
- /// see the `scope` module for more details
+ /// The current set of scopes, updated as we traverse;
+ /// see the `scope` module for more details.
scopes: Vec<scope::Scope<'tcx>>,
- /// the block-context: each time we build the code within an hair::Block,
+ /// The block-context: each time we build the code within an hair::Block,
/// we push a frame here tracking whether we are building a statement or
/// if we are pushing the tail expression of the block. This is used to
/// embed information in generated temps about whether they were created
/// for a block tail expression or not.
///
/// It would be great if we could fold this into `self.scopes`
- /// somehow; but right now I think that is very tightly tied to
+ /// somehow, but right now I think that is very tightly tied to
/// the code generation in ways that we cannot (or should not)
/// start just throwing new entries onto that vector in order to
/// distinguish the context of EXPR1 from the context of EXPR2 in
- /// `{ STMTS; EXPR1 } + EXPR2`
+ /// `{ STMTS; EXPR1 } + EXPR2`.
block_context: BlockContext,
/// The current unsafe block in scope, even if it is hidden by
- /// a PushUnsafeBlock
+ /// a `PushUnsafeBlock`.
unpushed_unsafe: Safety,
- /// The number of `push_unsafe_block` levels in scope
+ /// The number of `push_unsafe_block` levels in scope.
push_unsafe_count: usize,
- /// the current set of breakables; see the `scope` module for more
- /// details
+ /// The current set of breakables; see the `scope` module for more
+ /// details.
breakable_scopes: Vec<scope::BreakableScope<'tcx>>,
- /// the vector of all scopes that we have created thus far;
- /// we track this for debuginfo later
+ /// The vector of all scopes that we have created thus far;
+ /// we track this for debuginfo later.
source_scopes: IndexVec<SourceScope, SourceScopeData>,
source_scope_local_data: IndexVec<SourceScope, SourceScopeLocalData>,
source_scope: SourceScope,
- /// the guard-context: each time we build the guard expression for
+ /// The guard-context: each time we build the guard expression for
/// a match arm, we push onto this stack, and then pop when we
/// finish building it.
guard_context: Vec<GuardFrame>,
- /// Maps node ids of variable bindings to the `Local`s created for them.
+ /// Maps `NodeId`s of variable bindings to the `Local`s created for them.
/// (A match binding can have two locals; the 2nd is for the arm's guard.)
var_indices: NodeMap<LocalsForNode>,
local_decls: IndexVec<Local, LocalDecl<'tcx>>,
upvar_decls: Vec<UpvarDecl>,
unit_temp: Option<Place<'tcx>>,
- /// cached block with the RESUME terminator; this is created
+ /// Cached block with the `RESUME` terminator; this is created
/// when first set of cleanups are built.
cached_resume_block: Option<BasicBlock>,
- /// cached block with the RETURN terminator
+ /// Cached block with the `RETURN` terminator.
cached_return_block: Option<BasicBlock>,
- /// cached block with the UNREACHABLE terminator
+ /// Cached block with the `UNREACHABLE` terminator.
cached_unreachable_block: Option<BasicBlock>,
}
fn push(&mut self, bf: BlockFrame) { self.0.push(bf); }
fn pop(&mut self) -> Option<BlockFrame> { self.0.pop() }
- /// Traverses the frames on the BlockContext, searching for either
+ /// Traverses the frames on the `BlockContext`, searching for either
/// the first block-tail expression frame with no intervening
/// statement frame.
///
#[derive(Debug)]
enum LocalsForNode {
- /// In the usual case, a node-id for an identifier maps to at most
- /// one Local declaration.
+ /// In the usual case, a `NodeId` for an identifier maps to at most
+ /// one `Local` declaration.
One(Local),
/// The exceptional case is identifiers in a match arm's pattern
/// that are referenced in a guard of that match arm. For these,
- /// we can have `2+k` Locals, where `k` is the number of candidate
+ /// we can have `2 + k` Locals, where `k` is the number of candidate
/// patterns (separated by `|`) in the arm.
///
/// * `for_arm_body` is the Local used in the arm body (which is
/// P1(id1) if (... (match E2 { P2(id2) if ... => B2 })) => B1,
/// }
///
- /// here, when building for FIXME
+ /// here, when building for FIXME.
locals: Vec<GuardFrameLocal>,
}
-/// ForGuard indicates whether we are talking about:
+/// `ForGuard` indicates whether we are talking about:
/// 1. the temp for a local binding used solely within guard expressions,
/// 2. the temp that holds reference to (1.), which is actually what the
/// guard expressions see, or
*/
-use build::{BlockAnd, BlockAndExtension, Builder, CFG};
-use hair::LintLevel;
+use crate::build::{BlockAnd, BlockAndExtension, Builder, CFG};
+use crate::hair::LintLevel;
use rustc::middle::region;
use rustc::ty::Ty;
use rustc::hir;
}
impl<'tcx> Scope<'tcx> {
- /// Invalidate all the cached blocks in the scope.
+ /// Invalidates all the cached blocks in the scope.
///
/// Should always be run for all inner scopes when a drop is pushed into some scope enclosing a
/// larger extent of code.
/// Branch out of `block` to `target`, exiting all scopes up to
- /// and including `region_scope`. This will insert whatever drops are
+ /// and including `region_scope`. This will insert whatever drops are
/// needed. See module comment for details.
pub fn exit_scope(&mut self,
span: Span,
next_target.unit()
}
- /// Create an Assert terminator and return the success block.
+ /// Creates an Assert terminator and return the success block.
/// If the boolean condition operand is not the expected value,
/// a runtime panic will be caused with the given message.
pub fn assert(&mut self, block: BasicBlock,
use rustc::mir::interpret::{ConstEvalErr, ErrorHandled};
use rustc::mir;
use rustc::ty::{self, TyCtxt, query::TyCtxtAt};
-use rustc::ty::layout::{self, LayoutOf, TyLayout, VariantIdx};
+use rustc::ty::layout::{self, LayoutOf, VariantIdx};
use rustc::ty::subst::Subst;
use rustc::traits::Reveal;
use rustc_data_structures::fx::FxHashMap;
use syntax::source_map::{Span, DUMMY_SP};
use crate::interpret::{self,
- PlaceTy, MPlaceTy, MemPlace, OpTy, Operand, Immediate, Scalar, RawConst, ConstValue, Pointer,
+ PlaceTy, MPlaceTy, MemPlace, OpTy, ImmTy, Operand, Immediate, Scalar, Pointer,
+ RawConst, ConstValue,
EvalResult, EvalError, EvalErrorKind, GlobalId, EvalContext, StackPopCleanup,
Allocation, AllocId, MemoryKind,
snapshot, RefTracking,
/// `simd_shuffle` and const patterns in match arms.
///
/// The function containing the `match` that is currently being analyzed may have generic bounds
-/// that inform us about the generic bounds of the constant. E.g. using an associated constant
+/// that inform us about the generic bounds of the constant. E.g., using an associated constant
/// of a function's generic parameter will require knowledge about the bounds on the generic
/// parameter. These bounds are passed to `mk_eval_cx` via the `ParamEnv` argument.
pub(crate) fn mk_eval_cx<'a, 'mir, 'tcx>(
let normalized_op = if normalize {
ecx.try_read_immediate(op)?
} else {
- match op.op {
+ match *op {
Operand::Indirect(mplace) => Err(mplace),
Operand::Immediate(val) => Ok(val)
}
Ok(ty::Const { val, ty: op.layout.ty })
}
-pub fn lazy_const_to_op<'tcx>(
- ecx: &CompileTimeEvalContext<'_, '_, 'tcx>,
- cnst: ty::LazyConst<'tcx>,
- ty: ty::Ty<'tcx>,
-) -> EvalResult<'tcx, OpTy<'tcx>> {
- let op = ecx.const_value_to_op(cnst)?;
- Ok(OpTy { op, layout: ecx.layout_of(ty)? })
-}
-
fn eval_body_and_ecx<'a, 'mir, 'tcx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
cid: GlobalId<'tcx>,
}
impl fmt::Display for ConstEvalError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
use self::ConstEvalError::*;
match *self {
NeedsRfc(ref msg) => {
fn ptr_op(
_ecx: &EvalContext<'a, 'mir, 'tcx, Self>,
_bin_op: mir::BinOp,
- _left: Scalar,
- _left_layout: TyLayout<'tcx>,
- _right: Scalar,
- _right_layout: TyLayout<'tcx>,
+ _left: ImmTy<'tcx>,
+ _right: ImmTy<'tcx>,
) -> EvalResult<'tcx, (Scalar, bool)> {
Err(
ConstEvalError::NeedsRfc("pointer arithmetic or comparison".to_string()).into(),
Ok(())
}
- /// Called immediately before a stack frame gets popped
+ /// Called immediately before a stack frame gets popped.
#[inline(always)]
fn stack_pop(
_ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
}
}
-/// Project to a field of a (variant of a) const
+/// Projects to a field of a (variant of a) const.
pub fn const_field<'a, 'tcx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
let ecx = mk_eval_cx(tcx, DUMMY_SP, param_env);
let result = (|| {
// get the operand again
- let op = lazy_const_to_op(&ecx, ty::LazyConst::Evaluated(value), value.ty)?;
+ let op = ecx.lazy_const_to_op(ty::LazyConst::Evaluated(value), value.ty)?;
// downcast
let down = match variant {
None => op,
) -> EvalResult<'tcx, VariantIdx> {
trace!("const_variant_index: {:?}", val);
let ecx = mk_eval_cx(tcx, DUMMY_SP, param_env);
- let op = lazy_const_to_op(&ecx, ty::LazyConst::Evaluated(val), val.ty)?;
+ let op = ecx.lazy_const_to_op(ty::LazyConst::Evaluated(val), val.ty)?;
Ok(ecx.read_discriminant(op)?.1)
}
op,
path,
Some(&mut ref_tracking),
- /* const_mode */ true,
+ true, // const mode
)?;
}
- // Now that we validated, turn this into a proper constant
+ // Now that we validated, turn this into a proper constant.
let def_id = cid.instance.def.def_id();
let normalize = tcx.is_static(def_id).is_none() && cid.promoted.is_none();
op_to_const(&ecx, op, normalize)
use rustc::mir::{BasicBlock, Location};
use rustc_data_structures::bit_set::{BitIter, BitSet, HybridBitSet};
-use dataflow::{BitDenotation, BlockSets, DataflowResults};
-use dataflow::move_paths::{HasMoveData, MovePathIndex};
+use crate::dataflow::{BitDenotation, BlockSets, DataflowResults};
+use crate::dataflow::move_paths::{HasMoveData, MovePathIndex};
use std::iter;
/// effects don't apply to the unwind edge).
fn reset_to_exit_of(&mut self, bb: BasicBlock);
- /// Build gen + kill sets for statement at `loc`.
+ /// Builds gen and kill sets for statement at `loc`.
///
/// Note that invoking this method alone does not change the
/// `curr_state` -- you must invoke `apply_local_effect`
/// afterwards.
fn reconstruct_statement_effect(&mut self, loc: Location);
- /// Build gen + kill sets for terminator for `loc`.
+ /// Builds gen and kill sets for terminator for `loc`.
///
/// Note that invoking this method alone does not change the
/// `curr_state` -- you must invoke `apply_local_effect`
}
/// Returns an iterator over the elements present in the current state.
- pub fn iter_incoming(&self) -> iter::Peekable<BitIter<BD::Idx>> {
+ pub fn iter_incoming(&self) -> iter::Peekable<BitIter<'_, BD::Idx>> {
self.curr_state.iter().peekable()
}
/// Invokes `f` with an iterator over the resulting state.
pub fn with_iter_outgoing<F>(&self, f: F)
where
- F: FnOnce(BitIter<BD::Idx>),
+ F: FnOnce(BitIter<'_, BD::Idx>),
{
let mut curr_state = self.curr_state.clone();
curr_state.union(&self.stmt_gen);
use rustc::mir::{self, Mir, Location};
use rustc::ty::{self, TyCtxt};
-use util::elaborate_drops::DropFlagState;
+use crate::util::elaborate_drops::DropFlagState;
use super::{MoveDataParamEnv};
use super::indexes::MovePathIndex;
/// In both cases, the contents can only be accessed if and only if
/// their parents are initialized. This implies for example that there
/// is no need to maintain separate drop flags to track such state.
-///
-/// FIXME: we have to do something for moving slice patterns.
+//
+// FIXME: we have to do something for moving slice patterns.
fn place_contents_drop_state_cannot_differ<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &Mir<'tcx>,
place: &mir::Place<'tcx>) -> bool {
use syntax::ast::NodeId;
use rustc::mir::{BasicBlock, Mir};
-use dot;
-
use std::fs;
use std::io;
use std::marker::PhantomData;
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct Edge { source: BasicBlock, index: usize }
-fn outgoing(mir: &Mir, bb: BasicBlock) -> Vec<Edge> {
+fn outgoing(mir: &Mir<'_>, bb: BasicBlock) -> Vec<Edge> {
(0..mir[bb].terminator().successors().count())
.map(|index| Edge { source: bb, index: index}).collect()
}
{
type Node = Node;
type Edge = Edge;
- fn graph_id(&self) -> dot::Id {
+ fn graph_id(&self) -> dot::Id<'_> {
dot::Id::new(format!("graph_for_node_{}",
self.mbcx.node_id()))
.unwrap()
}
- fn node_id(&self, n: &Node) -> dot::Id {
+ fn node_id(&self, n: &Node) -> dot::Id<'_> {
dot::Id::new(format!("bb_{}", n.index()))
.unwrap()
}
- fn node_label(&self, n: &Node) -> dot::LabelText {
+ fn node_label(&self, n: &Node) -> dot::LabelText<'_> {
// Node label is something like this:
// +---------+----------------------------------+------------------+------------------+
// | ENTRY | MIR | GEN | KILL |
}
- fn node_shape(&self, _n: &Node) -> Option<dot::LabelText> {
+ fn node_shape(&self, _n: &Node) -> Option<dot::LabelText<'_>> {
Some(dot::LabelText::label("none"))
}
n: &Node,
w: &mut W,
block: BasicBlock,
- mir: &Mir) -> io::Result<()> {
+ mir: &Mir<'_>) -> io::Result<()> {
// Header rows
const HDRS: [&str; 4] = ["ENTRY", "MIR", "BLOCK GENS", "BLOCK KILLS"];
const HDR_FMT: &str = "bgcolor=\"grey\"";
Ok(())
}
- /// Build the verbose row: full MIR data, and detailed gen/kill/entry sets
+ /// Builds the verbose row: full MIR data, and detailed gen/kill/entry sets.
fn node_label_verbose_row<W: io::Write>(&self,
n: &Node,
w: &mut W,
block: BasicBlock,
- mir: &Mir)
+ mir: &Mir<'_>)
-> io::Result<()> {
let i = n.index();
Ok(())
}
- /// Build the summary row: terminator, gen/kill/entry bit sets
+ /// Builds the summary row: terminator, gen/kill/entry bit sets.
fn node_label_final_row<W: io::Write>(&self,
n: &Node,
w: &mut W,
block: BasicBlock,
- mir: &Mir)
+ mir: &Mir<'_>)
-> io::Result<()> {
let i = n.index();
{
type Node = Node;
type Edge = Edge;
- fn nodes(&self) -> dot::Nodes<Node> {
+ fn nodes(&self) -> dot::Nodes<'_, Node> {
self.mbcx.mir()
.basic_blocks()
.indices()
.into()
}
- fn edges(&self) -> dot::Edges<Edge> {
+ fn edges(&self) -> dot::Edges<'_, Edge> {
let mir = self.mbcx.mir();
mir.basic_blocks()
use rustc::mir::*;
use rustc::mir::visit::Visitor;
-use dataflow::BitDenotation;
+use crate::dataflow::BitDenotation;
/// This calculates if any part of a MIR local could have previously been borrowed.
/// This means that once a local has been borrowed, its bit will be set
}
fn statement_effect(&self,
- sets: &mut BlockSets<Local>,
+ sets: &mut BlockSets<'_, Local>,
loc: Location) {
let stmt = &self.mir[loc.block].statements[loc.statement_index];
}
fn terminator_effect(&self,
- sets: &mut BlockSets<Local>,
+ sets: &mut BlockSets<'_, Local>,
loc: Location) {
BorrowedLocalsVisitor {
sets,
-use borrow_check::borrow_set::{BorrowSet, BorrowData};
-use borrow_check::place_ext::PlaceExt;
+use crate::borrow_check::borrow_set::{BorrowSet, BorrowData};
+use crate::borrow_check::place_ext::PlaceExt;
use rustc::mir::{self, Location, Place, Mir};
use rustc::ty::TyCtxt;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
-use dataflow::{BitDenotation, BlockSets, InitialFlow};
-pub use dataflow::indexes::BorrowIndex;
-use borrow_check::nll::region_infer::RegionInferenceContext;
-use borrow_check::nll::ToRegionVid;
-use borrow_check::places_conflict;
+use crate::dataflow::{BitDenotation, BlockSets, InitialFlow};
+pub use crate::dataflow::indexes::BorrowIndex;
+use crate::borrow_check::nll::region_infer::RegionInferenceContext;
+use crate::borrow_check::nll::ToRegionVid;
+use crate::borrow_check::places_conflict;
use std::rc::Rc;
/// Add all borrows to the kill set, if those borrows are out of scope at `location`.
/// That means they went out of a nonlexical scope
fn kill_loans_out_of_scope_at_location(&self,
- sets: &mut BlockSets<BorrowIndex>,
+ sets: &mut BlockSets<'_, BorrowIndex>,
location: Location) {
// NOTE: The state associated with a given `location`
// reflects the dataflow on entry to the statement.
/// Kill any borrows that conflict with `place`.
fn kill_borrows_on_place(
&self,
- sets: &mut BlockSets<BorrowIndex>,
+ sets: &mut BlockSets<'_, BorrowIndex>,
place: &Place<'tcx>
) {
debug!("kill_borrows_on_place: place={:?}", place);
}
fn before_statement_effect(&self,
- sets: &mut BlockSets<BorrowIndex>,
+ sets: &mut BlockSets<'_, BorrowIndex>,
location: Location) {
debug!("Borrows::before_statement_effect sets: {:?} location: {:?}", sets, location);
self.kill_loans_out_of_scope_at_location(sets, location);
}
- fn statement_effect(&self, sets: &mut BlockSets<BorrowIndex>, location: Location) {
+ fn statement_effect(&self, sets: &mut BlockSets<'_, BorrowIndex>, location: Location) {
debug!("Borrows::statement_effect: sets={:?} location={:?}", sets, location);
let block = &self.mir.basic_blocks().get(location.block).unwrap_or_else(|| {
}
fn before_terminator_effect(&self,
- sets: &mut BlockSets<BorrowIndex>,
+ sets: &mut BlockSets<'_, BorrowIndex>,
location: Location) {
debug!("Borrows::before_terminator_effect sets: {:?} location: {:?}", sets, location);
self.kill_loans_out_of_scope_at_location(sets, location);
}
- fn terminator_effect(&self, _: &mut BlockSets<BorrowIndex>, _: Location) {}
+ fn terminator_effect(&self, _: &mut BlockSets<'_, BorrowIndex>, _: Location) {}
fn propagate_call_return(
&self,
use super::MoveDataParamEnv;
-use util::elaborate_drops::DropFlagState;
+use crate::util::elaborate_drops::DropFlagState;
use super::move_paths::{HasMoveData, MoveData, MovePathIndex, InitIndex};
use super::move_paths::{LookupResult, InitKind};
/// initialized upon reaching a particular point in the control flow
/// for a function.
///
-/// FIXME: Note that once flow-analysis is complete, this should be
-/// the set-complement of MaybeUninitializedPlaces; thus we can get rid
-/// of one or the other of these two. I'm inclined to get rid of
-/// MaybeUninitializedPlaces, simply because the sets will tend to be
-/// smaller in this analysis and thus easier for humans to process
-/// when debugging.
-///
/// For example, in code like the following, we have corresponding
/// dataflow information shown in the right-hand comments.
///
impl<'a, 'gcx, 'tcx> MaybeInitializedPlaces<'a, 'gcx, 'tcx> {
- fn update_bits(sets: &mut BlockSets<MovePathIndex>, path: MovePathIndex,
+ fn update_bits(sets: &mut BlockSets<'_, MovePathIndex>, path: MovePathIndex,
state: DropFlagState)
{
match state {
}
impl<'a, 'gcx, 'tcx> MaybeUninitializedPlaces<'a, 'gcx, 'tcx> {
- fn update_bits(sets: &mut BlockSets<MovePathIndex>, path: MovePathIndex,
+ fn update_bits(sets: &mut BlockSets<'_, MovePathIndex>, path: MovePathIndex,
state: DropFlagState)
{
match state {
}
impl<'a, 'gcx, 'tcx> DefinitelyInitializedPlaces<'a, 'gcx, 'tcx> {
- fn update_bits(sets: &mut BlockSets<MovePathIndex>, path: MovePathIndex,
+ fn update_bits(sets: &mut BlockSets<'_, MovePathIndex>, path: MovePathIndex,
state: DropFlagState)
{
match state {
}
fn statement_effect(&self,
- sets: &mut BlockSets<MovePathIndex>,
+ sets: &mut BlockSets<'_, MovePathIndex>,
location: Location)
{
drop_flag_effects_for_location(
}
fn terminator_effect(&self,
- sets: &mut BlockSets<MovePathIndex>,
+ sets: &mut BlockSets<'_, MovePathIndex>,
location: Location)
{
drop_flag_effects_for_location(
}
fn statement_effect(&self,
- sets: &mut BlockSets<MovePathIndex>,
+ sets: &mut BlockSets<'_, MovePathIndex>,
location: Location)
{
drop_flag_effects_for_location(
}
fn terminator_effect(&self,
- sets: &mut BlockSets<MovePathIndex>,
+ sets: &mut BlockSets<'_, MovePathIndex>,
location: Location)
{
drop_flag_effects_for_location(
}
fn statement_effect(&self,
- sets: &mut BlockSets<MovePathIndex>,
+ sets: &mut BlockSets<'_, MovePathIndex>,
location: Location)
{
drop_flag_effects_for_location(
}
fn terminator_effect(&self,
- sets: &mut BlockSets<MovePathIndex>,
+ sets: &mut BlockSets<'_, MovePathIndex>,
location: Location)
{
drop_flag_effects_for_location(
}
fn statement_effect(&self,
- sets: &mut BlockSets<InitIndex>,
+ sets: &mut BlockSets<'_, InitIndex>,
location: Location) {
let (_, mir, move_data) = (self.tcx, self.mir, self.move_data());
let stmt = &mir[location.block].statements[location.statement_index];
}
fn terminator_effect(&self,
- sets: &mut BlockSets<InitIndex>,
+ sets: &mut BlockSets<'_, InitIndex>,
location: Location)
{
let (mir, move_data) = (self.mir, self.move_data());
pub use super::*;
use rustc::mir::*;
-use dataflow::BitDenotation;
+use crate::dataflow::BitDenotation;
#[derive(Copy, Clone)]
pub struct MaybeStorageLive<'a, 'tcx: 'a> {
}
fn statement_effect(&self,
- sets: &mut BlockSets<Local>,
+ sets: &mut BlockSets<'_, Local>,
loc: Location) {
let stmt = &self.mir[loc.block].statements[loc.statement_index];
}
fn terminator_effect(&self,
- _sets: &mut BlockSets<Local>,
+ _sets: &mut BlockSets<'_, Local>,
_loc: Location) {
// Terminators have no effect
}
}
impl fmt::Debug for DebugFormatted {
- fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(w, "{}", self.0)
}
}
impl<E:Idx> AllSets<E> {
pub fn bits_per_block(&self) -> usize { self.bits_per_block }
- pub fn for_block(&mut self, block_idx: usize) -> BlockSets<E> {
+ pub fn for_block(&mut self, block_idx: usize) -> BlockSets<'_, E> {
BlockSets {
on_entry: &mut self.on_entry_sets[block_idx],
gen_set: &mut self.gen_sets[block_idx],
/// the block's start, not necessarily the state immediately prior
/// to the statement/terminator under analysis.
///
- /// In either case, the passed reference is mutable; but this is a
+ /// In either case, the passed reference is mutable, but this is a
/// wart from using the `BlockSets` type in the API; the intention
/// is that the `statement_effect` and `terminator_effect` methods
/// mutate only the gen/kill sets.
- ///
- /// FIXME: We should consider enforcing the intention described in
- /// the previous paragraph by passing the three sets in separate
- /// parameters to encode their distinct mutabilities.
+ //
+ // FIXME: we should consider enforcing the intention described in
+ // the previous paragraph by passing the three sets in separate
+ // parameters to encode their distinct mutabilities.
fn accumulates_intrablock_state() -> bool { false }
/// A name describing the dataflow analysis that this
- /// BitDenotation is supporting. The name should be something
- /// suitable for plugging in as part of a filename e.g., avoid
+ /// `BitDenotation` is supporting. The name should be something
+ /// suitable for plugging in as part of a filename (i.e., avoid
/// space-characters or other things that tend to look bad on a
- /// file system, like slashes or periods. It is also better for
+ /// file system, like slashes or periods). It is also better for
/// the name to be reasonably short, again because it will be
/// plugged into a filename.
fn name() -> &'static str;
/// applied, in that order, before moving for the next
/// statement.
fn before_statement_effect(&self,
- _sets: &mut BlockSets<Self::Idx>,
+ _sets: &mut BlockSets<'_, Self::Idx>,
_location: Location) {}
/// Mutates the block-sets (the flow sets for the given
/// `bb_data` is the sequence of statements identified by `bb` in
/// the MIR.
fn statement_effect(&self,
- sets: &mut BlockSets<Self::Idx>,
+ sets: &mut BlockSets<'_, Self::Idx>,
location: Location);
/// Similar to `terminator_effect`, except it applies
/// applied, in that order, before moving for the next
/// terminator.
fn before_terminator_effect(&self,
- _sets: &mut BlockSets<Self::Idx>,
+ _sets: &mut BlockSets<'_, Self::Idx>,
_location: Location) {}
/// Mutates the block-sets (the flow sets for the given
/// The effects applied here cannot depend on which branch the
/// terminator took.
fn terminator_effect(&self,
- sets: &mut BlockSets<Self::Idx>,
+ sets: &mut BlockSets<'_, Self::Idx>,
location: Location);
/// Mutates the block-sets according to the (flow-dependent)
/// flow-dependent, the current MIR cannot encode them via just
/// GEN and KILL sets attached to the block, and so instead we add
/// this extra machinery to represent the flow-dependent effect.
- ///
- /// FIXME: Right now this is a bit of a wart in the API. It might
- /// be better to represent this as an additional gen- and
- /// kill-sets associated with each edge coming out of the basic
- /// block.
+ //
+ // FIXME: right now this is a bit of a wart in the API. It might
+ // be better to represent this as an additional gen- and
+ // kill-sets associated with each edge coming out of the basic
+ // block.
fn propagate_call_return(
&self,
in_out: &mut BitSet<Self::Idx>,
//! The move-analysis portion of borrowck needs to work in an abstract
-//! domain of lifted Places. Most of the Place variants fall into a
+//! domain of lifted `Place`s. Most of the `Place` variants fall into a
//! one-to-one mapping between the concrete and abstract (e.g., a
-//! field-deref on a local-variable, `x.field`, has the same meaning
-//! in both domains). Indexed-Projections are the exception: `a[x]`
+//! field-deref on a local variable, `x.field`, has the same meaning
+//! in both domains). Indexed projections are the exception: `a[x]`
//! needs to be treated as mapping to the same move path as `a[y]` as
-//! well as `a[13]`, et cetera.
+//! well as `a[13]`, etc.
//!
-//! (In theory the analysis could be extended to work with sets of
+//! (In theory, the analysis could be extended to work with sets of
//! paths, so that `a[0]` and `a[13]` could be kept distinct, while
//! `a[x]` would still overlap them both. But that is not this
//! representation does today.)
}
impl fmt::Debug for $Index {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(fmt, "{}{}", $debug_name, self.index())
}
}
pub use self::indexes::InitIndex;
impl MoveOutIndex {
- pub fn move_path_index(&self, move_data: &MoveData) -> MovePathIndex {
+ pub fn move_path_index(&self, move_data: &MoveData<'_>) -> MovePathIndex {
move_data.moves[*self].path
}
}
}
impl<'tcx> MovePath<'tcx> {
- pub fn parents(&self, move_paths: &IndexVec<MovePathIndex, MovePath>) -> Vec<MovePathIndex> {
+ pub fn parents(
+ &self,
+ move_paths: &IndexVec<MovePathIndex, MovePath<'_>>,
+ ) -> Vec<MovePathIndex> {
let mut parents = Vec::new();
let mut curr_parent = self.parent;
}
impl<'tcx> fmt::Debug for MovePath<'tcx> {
- fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(w, "MovePath {{")?;
if let Some(parent) = self.parent {
write!(w, " parent: {:?},", parent)?;
}
impl<'tcx> fmt::Display for MovePath<'tcx> {
- fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(w, "{:?}", self.place)
}
}
}
impl<T> LocationMap<T> where T: Default + Clone {
- fn new(mir: &Mir) -> Self {
+ fn new(mir: &Mir<'_>) -> Self {
LocationMap {
map: mir.basic_blocks().iter().map(|block| {
vec![T::default(); block.statements.len()+1]
}
impl fmt::Debug for MoveOut {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(fmt, "{:?}@{:?}", self.path, self.source)
}
}
}
impl fmt::Debug for Init {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(fmt, "{:?}@{:?} ({:?})", self.path, self.location, self.kind)
}
}
}
```
-See also https://doc.rust-lang.org/book/first-edition/unsafe.html
+See also https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html
"##,
E0373: r##"
If you wish to learn more about ownership in Rust, start with the chapter in the
Book:
-https://doc.rust-lang.org/book/first-edition/ownership.html
+https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html
"##,
E0383: r##"
Please note that in rust, you can either have many immutable references, or one
mutable reference. Take a look at
-https://doc.rust-lang.org/stable/book/references-and-borrowing.html for more
+https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html for more
information. Example:
```
For more information on the rust ownership system, take a look at
-https://doc.rust-lang.org/stable/book/references-and-borrowing.html.
+https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html.
"##,
E0503: r##"
```
You can find more information about borrowing in the rust-book:
-http://doc.rust-lang.org/stable/book/references-and-borrowing.html
+http://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html
"##,
E0504: r##"
```
You can find more information about borrowing in the rust-book:
-http://doc.rust-lang.org/stable/book/references-and-borrowing.html
+http://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html
"##,
E0506: r##"
```
You can find more information about borrowing in the rust-book:
-http://doc.rust-lang.org/book/first-edition/references-and-borrowing.html
+http://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html
"##,
E0508: r##"
```
"##,
+E0723: r##"
+An feature unstable in `const` contexts was used.
+
+Erroneous code example:
+
+```compile_fail,E0723
+trait T {}
+
+impl T for () {}
+
+const fn foo() -> impl T { // error: `impl Trait` in const fn is unstable
+ ()
+}
+```
+
+To enable this feature on a nightly version of rustc, add the `const_fn`
+feature flag:
+
+```
+#![feature(const_fn)]
+
+trait T {}
+
+impl T for () {}
+
+const fn foo() -> impl T {
+ ()
+}
+```
+"##,
+
}
register_diagnostics! {
-use hair::*;
-use hair::cx::Cx;
-use hair::cx::to_ref::ToRef;
+use crate::hair::{self, *};
+use crate::hair::cx::Cx;
+use crate::hair::cx::to_ref::ToRef;
use rustc::middle::region;
use rustc::hir;
use rustc::ty;
for (index, stmt) in stmts.iter().enumerate() {
let hir_id = stmt.hir_id;
let opt_dxn_ext = cx.region_scope_tree.opt_destruction_scope(hir_id.local_id);
- let stmt_span = StatementSpan(cx.tcx.hir().span(stmt.id));
+ let stmt_span = StatementSpan(cx.tcx.hir().span_by_hir_id(hir_id));
match stmt.node {
hir::StmtKind::Expr(ref expr) |
hir::StmtKind::Semi(ref expr) => {
ty: pattern.ty,
span: pattern.span,
kind: Box::new(PatternKind::AscribeUserType {
- user_ty: PatternTypeProjection::from_user_type(user_ty),
- user_ty_span: ty.span,
+ ascription: hair::pattern::Ascription {
+ user_ty: PatternTypeProjection::from_user_type(user_ty),
+ user_ty_span: ty.span,
+ variance: ty::Variance::Covariant,
+ },
subpattern: pattern,
- variance: ty::Variance::Covariant,
})
};
}
pub fn to_expr_ref<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
block: &'tcx hir::Block)
-> ExprRef<'tcx> {
- let block_ty = cx.tables().node_id_to_type(block.hir_id);
+ let block_ty = cx.tables().node_type(block.hir_id);
let temp_lifetime = cx.region_scope_tree.temporary_scope(block.hir_id.local_id);
let expr = Expr {
ty: block_ty,
-use hair::*;
+use crate::hair::*;
+use crate::hair::cx::Cx;
+use crate::hair::cx::block;
+use crate::hair::cx::to_ref::ToRef;
+use crate::hair::util::UserAnnotatedTyHelpers;
use rustc_data_structures::indexed_vec::Idx;
-use hair::cx::Cx;
-use hair::cx::block;
-use hair::cx::to_ref::ToRef;
-use hair::util::UserAnnotatedTyHelpers;
use rustc::hir::def::{Def, CtorKind};
use rustc::mir::interpret::{GlobalId, ErrorHandled};
use rustc::ty::{self, AdtKind, Ty};
}
} else {
ExprKind::Call {
- ty: cx.tables().node_id_to_type(fun.hir_id),
+ ty: cx.tables().node_type(fun.hir_id),
fun: fun.to_ref(),
args: args.to_ref(),
from_hir_call: true,
}
hir::ExprKind::Lit(ref lit) => ExprKind::Literal {
- literal: cx.tcx.intern_lazy_const(ty::LazyConst::Evaluated(
+ literal: cx.tcx.mk_lazy_const(ty::LazyConst::Evaluated(
cx.const_eval_literal(&lit.node, expr_ty, lit.span, false)
)),
user_ty: None,
} else {
if let hir::ExprKind::Lit(ref lit) = arg.node {
ExprKind::Literal {
- literal: cx.tcx.intern_lazy_const(ty::LazyConst::Evaluated(
+ literal: cx.tcx.mk_lazy_const(ty::LazyConst::Evaluated(
cx.const_eval_literal(&lit.node, expr_ty, lit.span, true)
)),
user_ty: None,
let def = cx.tables().qpath_def(qpath, source.hir_id);
cx
.tables()
- .node_id_to_type(source.hir_id)
+ .node_type(source.hir_id)
.ty_adt_def()
.and_then(|adt_def| {
match def {
ty: var_ty,
span: expr.span,
kind: ExprKind::Literal {
- literal: cx.tcx.intern_lazy_const(literal),
+ literal: cx.tcx.mk_lazy_const(literal),
user_ty: None
},
}.to_ref();
ty,
span,
kind: ExprKind::Literal {
- literal: cx.tcx().intern_lazy_const(ty::LazyConst::Evaluated(
+ literal: cx.tcx().mk_lazy_const(ty::LazyConst::Evaluated(
ty::Const::zero_sized(ty)
)),
user_ty,
let user_ty = user_substs_applied_to_def(cx, expr.hir_id, &def);
debug!("convert_path_expr: user_ty={:?}", user_ty);
ExprKind::Literal {
- literal: cx.tcx.intern_lazy_const(ty::LazyConst::Evaluated(ty::Const::zero_sized(
- cx.tables().node_id_to_type(expr.hir_id),
+ literal: cx.tcx.mk_lazy_const(ty::LazyConst::Evaluated(ty::Const::zero_sized(
+ cx.tables().node_type(expr.hir_id),
))),
user_ty,
}
let user_ty = user_substs_applied_to_def(cx, expr.hir_id, &def);
debug!("convert_path_expr: (const) user_ty={:?}", user_ty);
ExprKind::Literal {
- literal: cx.tcx.intern_lazy_const(ty::LazyConst::Unevaluated(def_id, substs)),
+ literal: cx.tcx.mk_lazy_const(ty::LazyConst::Unevaluated(def_id, substs)),
user_ty,
}
},
let user_provided_types = cx.tables.user_provided_types();
let user_provided_type = user_provided_types.get(expr.hir_id).map(|u_ty| *u_ty);
debug!("convert_path_expr: user_provided_type={:?}", user_provided_type);
- match cx.tables().node_id_to_type(expr.hir_id).sty {
+ match cx.tables().node_type(expr.hir_id).sty {
// A unit struct/variant which is used as a value.
// We return a completely different ExprKind here to account for this special case.
ty::Adt(adt_def, substs) => {
index,
closure_expr_id);
let var_hir_id = cx.tcx.hir().node_to_hir_id(var_id);
- let var_ty = cx.tables().node_id_to_type(var_hir_id);
+ let var_ty = cx.tables().node_type(var_hir_id);
// FIXME free regions in closures are not right
let closure_ty = cx.tables()
- .node_id_to_type(cx.tcx.hir().node_to_hir_id(closure_expr_id));
+ .node_type(cx.tcx.hir().node_to_hir_id(closure_expr_id));
// FIXME we're just hard-coding the idea that the
// signature will be &self or &mut self and hence will
};
let upvar_capture = cx.tables().upvar_capture(upvar_id);
let temp_lifetime = cx.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id);
- let var_ty = cx.tables().node_id_to_type(var_hir_id);
+ let var_ty = cx.tables().node_type(var_hir_id);
let captured_var = Expr {
temp_lifetime,
ty: var_ty,
-//! This module contains the code to convert from the wacky tcx data
-//! structures into the hair. The `builder` is generally ignorant of
-//! the tcx etc, and instead goes through the `Cx` for most of its
-//! work.
-//!
+//! This module contains the fcuntaiontliy to convert from the wacky tcx data
+//! structures into the HAIR. The `builder` is generally ignorant of the tcx,
+//! etc., and instead goes through the `Cx` for most of its work.
-use hair::*;
-use hair::util::UserAnnotatedTyHelpers;
+use crate::hair::*;
+use crate::hair::util::UserAnnotatedTyHelpers;
use rustc_data_structures::indexed_vec::Idx;
use rustc::hir::def_id::{DefId, LOCAL_CRATE};
use syntax::symbol::Symbol;
use rustc::hir;
use rustc_data_structures::sync::Lrc;
-use hair::constant::{lit_to_const, LitToConstError};
+use crate::hair::constant::{lit_to_const, LitToConstError};
#[derive(Clone)]
pub struct Cx<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
/// What kind of body is being compiled.
pub body_owner_kind: hir::BodyOwnerKind,
- /// True if this constant/function needs overflow checks.
+ /// Whether this constant/function needs overflow checks.
check_overflow: bool,
- /// See field with the same name on `Mir`
+ /// See field with the same name on `Mir`.
control_flow_destroyed: Vec<(Span, String)>,
}
}
impl<'a, 'gcx, 'tcx> Cx<'a, 'gcx, 'tcx> {
- /// Normalizes `ast` into the appropriate `mirror` type.
+ /// Normalizes `ast` into the appropriate "mirror" type.
pub fn mirror<M: Mirror<'tcx>>(&mut self, ast: M) -> M::Output {
ast.make_mirror(self)
}
}
pub fn usize_literal(&mut self, value: u64) -> &'tcx ty::LazyConst<'tcx> {
- self.tcx.intern_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_usize(self.tcx, value)))
+ self.tcx.mk_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_usize(self.tcx, value)))
}
pub fn bool_ty(&mut self) -> Ty<'tcx> {
}
pub fn true_literal(&mut self) -> &'tcx ty::LazyConst<'tcx> {
- self.tcx.intern_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bool(self.tcx, true)))
+ self.tcx.mk_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bool(self.tcx, true)))
}
pub fn false_literal(&mut self) -> &'tcx ty::LazyConst<'tcx> {
- self.tcx.intern_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bool(self.tcx, false)))
+ self.tcx.mk_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bool(self.tcx, false)))
}
pub fn const_eval_literal(
}
}
-fn lint_level_for_hir_id(tcx: TyCtxt, mut id: ast::NodeId) -> ast::NodeId {
+fn lint_level_for_hir_id(tcx: TyCtxt<'_, '_, '_>, mut id: ast::NodeId) -> ast::NodeId {
// Right now we insert a `with_ignore` node in the dep graph here to
// ignore the fact that `lint_levels` below depends on the entire crate.
// For now this'll prevent false positives of recompiling too much when
-use hair::*;
+use crate::hair::*;
use rustc::hir;
use syntax::ptr::P;
/// Mirroring is gradual: when you mirror an outer expression like `e1
/// + e2`, the references to the inner expressions `e1` and `e2` are
/// `ExprRef<'tcx>` instances, and they may or may not be eagerly
-/// mirrored. This allows a single AST node from the compiler to
+/// mirrored. This allows a single AST node from the compiler to
/// expand into one or more Hair nodes, which lets the Hair nodes be
/// simpler.
pub trait Mirror<'tcx> {
///
/// The algorithm implemented here is a modified version of the one described in:
/// http://moscova.inria.fr/~maranget/papers/warn/index.html
-/// However, to save future implementors from reading the original paper, I'm going
-/// to summarise the algorithm here to hopefully save time and be a little clearer
+/// However, to save future implementors from reading the original paper, we
+/// summarise the algorithm here to hopefully save time and be a little clearer
/// (without being so rigorous).
///
/// The core of the algorithm revolves about a "usefulness" check. In particular, we
/// + _ + [_, _, ..tail] +
/// ++++++++++++++++++++++++++
impl<'p, 'tcx> fmt::Debug for Matrix<'p, 'tcx> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "\n")?;
let &Matrix(ref m) = self;
/// The module in which the match occurs. This is necessary for
/// checking inhabited-ness of types because whether a type is (visibly)
/// inhabited can depend on whether it was defined in the current module or
- /// not. eg. `struct Foo { _private: ! }` cannot be seen to be empty
+ /// not. E.g., `struct Foo { _private: ! }` cannot be seen to be empty
/// outside it's module and should not be matchable with an empty match
/// statement.
pub module: DefId,
VariantIdx::new(0)
}
&ConstantValue(c) => {
- ::const_eval::const_variant_index(
+ crate::const_eval::const_variant_index(
cx.tcx,
cx.param_env,
c,
}
fn from_pat(tcx: TyCtxt<'_, 'tcx, 'tcx>,
- pat: &Pattern<'tcx>)
+ mut pat: &Pattern<'tcx>)
-> Option<IntRange<'tcx>> {
- Self::from_ctor(tcx, &match pat.kind {
- box PatternKind::Constant { value } => ConstantValue(value),
- box PatternKind::Range(PatternRange { lo, hi, ty, end }) => ConstantRange(
- lo.to_bits(tcx, ty::ParamEnv::empty().and(ty)).unwrap(),
- hi.to_bits(tcx, ty::ParamEnv::empty().and(ty)).unwrap(),
- ty,
- end,
- ),
- _ => return None,
- })
+ let range = loop {
+ match pat.kind {
+ box PatternKind::Constant { value } => break ConstantValue(value),
+ box PatternKind::Range(PatternRange { lo, hi, ty, end }) => break ConstantRange(
+ lo.to_bits(tcx, ty::ParamEnv::empty().and(ty)).unwrap(),
+ hi.to_bits(tcx, ty::ParamEnv::empty().and(ty)).unwrap(),
+ ty,
+ end,
+ ),
+ box PatternKind::AscribeUserType { ref subpattern, .. } => {
+ pat = subpattern;
+ },
+ _ => return None,
+ }
+ };
+ Self::from_ctor(tcx, &range)
}
// The return value of `signed_bias` should be XORed with an endpoint to encode/decode it.
}
}
- /// Convert a `RangeInclusive` to a `ConstantValue` or inclusive `ConstantRange`.
+ /// Converts a `RangeInclusive` to a `ConstantValue` or inclusive `ConstantRange`.
fn range_to_ctor(
tcx: TyCtxt<'_, 'tcx, 'tcx>,
ty: Ty<'tcx>,
}
}
- /// Return a collection of ranges that spans the values covered by `ranges`, subtracted
+ /// Returns a collection of ranges that spans the values covered by `ranges`, subtracted
/// by the values covered by `self`: i.e., `ranges \ self` (in set notation).
fn subtract_from(self,
tcx: TyCtxt<'_, 'tcx, 'tcx>,
}
}
-/// Algorithm from http://moscova.inria.fr/~maranget/papers/warn/index.html
+/// Algorithm from http://moscova.inria.fr/~maranget/papers/warn/index.html.
/// The algorithm from the paper has been modified to correctly handle empty
/// types. The changes are:
/// (0) We don't exit early if the pattern matrix has zero rows. We just
/// continue to recurse over columns.
/// (1) all_constructors will only return constructors that are statically
-/// possible. eg. it will only return Ok for Result<T, !>
+/// possible. E.g., it will only return `Ok` for `Result<T, !>`.
///
/// This finds whether a (row) vector `v` of patterns is 'useful' in relation
/// to a set of such vectors `m` - this is defined as there being a set of
///
/// All the patterns at each column of the `matrix ++ v` matrix must
/// have the same type, except that wildcard (PatternKind::Wild) patterns
-/// with type TyErr are also allowed, even if the "type of the column"
-/// is not TyErr. That is used to represent private fields, as using their
+/// with type `TyErr` are also allowed, even if the "type of the column"
+/// is not `TyErr`. That is used to represent private fields, as using their
/// real type would assert that they are inhabited.
///
/// This is used both for reachability checking (if a pattern isn't useful in
} else {
debug!("is_useful - expanding wildcard");
- let used_ctors: Vec<Constructor> = rows.iter().flat_map(|row| {
+ let used_ctors: Vec<Constructor<'_>> = rows.iter().flat_map(|row| {
pat_constructors(cx, row[0], pcx).unwrap_or(vec![])
}).collect();
debug!("used_ctors = {:#?}", used_ctors);
/// Slice patterns, however, can match slices of different lengths. For instance,
/// `[a, b, ..tail]` can match a slice of length 2, 3, 4 and so on.
///
-/// Returns None in case of a catch-all, which can't be specialized.
+/// Returns `None` in case of a catch-all, which can't be specialized.
fn pat_constructors<'tcx>(cx: &mut MatchCheckCtxt<'_, 'tcx>,
pat: &Pattern<'tcx>,
- pcx: PatternContext)
+ pcx: PatternContext<'_>)
-> Option<Vec<Constructor<'tcx>>>
{
match *pat.kind {
split_ctors
}
-/// Check whether there exists any shared value in either `ctor` or `pat` by intersecting them.
+/// Checks whether there exists any shared value in either `ctor` or `pat` by intersecting them.
fn constructor_intersects_pattern<'p, 'a: 'p, 'tcx: 'a>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
ctor: &Constructor<'tcx>,
// Then, if the match has no arms, check whether the scrutinee
// is uninhabited.
- let pat_ty = self.tables.node_id_to_type(scrut.hir_id);
+ let pat_ty = self.tables.node_type(scrut.hir_id);
let module = self.tcx.hir().get_module_parent(scrut.id);
if inlined_arms.is_empty() {
let scrutinee_is_uninhabited = if self.tcx.features().exhaustive_patterns {
return;
}
- let matrix: Matrix = inlined_arms
+ let matrix: Matrix<'_, '_> = inlined_arms
.iter()
.filter(|&&(_, guard)| guard.is_none())
.flat_map(|arm| &arm.0)
.map(|pat| smallvec![pat.0])
.collect();
- let scrut_ty = self.tables.node_id_to_type(scrut.hir_id);
+ let scrut_ty = self.tables.node_type(scrut.hir_id);
check_exhaustive(cx, scrut_ty, scrut.span, &matrix);
})
}
self.tables);
let pattern = patcx.lower_pattern(pat);
let pattern_ty = pattern.ty;
- let pats: Matrix = vec![smallvec![
+ let pats: Matrix<'_, '_> = vec![smallvec![
expand_pattern(cx, pattern)
]].into_iter().collect();
}
}
-fn check_for_bindings_named_same_as_variants(cx: &MatchVisitor, pat: &Pat) {
+fn check_for_bindings_named_same_as_variants(cx: &MatchVisitor<'_, '_>, pat: &Pat) {
pat.walk(|p| {
if let PatKind::Binding(_, _, _, ident, None) = p.node {
if let Some(&bm) = cx.tables.pat_binding_modes().get(p.hir_id) {
}
// Legality of move bindings checking
-fn check_legality_of_move_bindings(cx: &MatchVisitor,
+fn check_legality_of_move_bindings(cx: &MatchVisitor<'_, '_>,
has_guard: bool,
pats: &[P<Pat>]) {
let mut by_ref_span = None;
if let Some(&bm) = cx.tables.pat_binding_modes().get(p.hir_id) {
match bm {
ty::BindByValue(..) => {
- let pat_ty = cx.tables.node_id_to_type(p.hir_id);
+ let pat_ty = cx.tables.node_type(p.hir_id);
if !pat_ty.is_copy_modulo_regions(cx.tcx, cx.param_env, pat.span) {
check_move(p, sub.as_ref().map(|p| &**p), span_vec);
}
}
}
-/// Ensures that a pattern guard doesn't borrow by mutable reference or
-/// assign.
-///
-/// FIXME: this should be done by borrowck.
-fn check_for_mutation_in_guard(cx: &MatchVisitor, guard: &hir::Guard) {
+/// Ensures that a pattern guard doesn't borrow by mutable reference or assign.
+//
+// FIXME: this should be done by borrowck.
+fn check_for_mutation_in_guard(cx: &MatchVisitor<'_, '_>, guard: &hir::Guard) {
let mut checker = MutationChecker {
cx,
};
}
impl<'a, 'tcx> Delegate<'tcx> for MutationChecker<'a, 'tcx> {
- fn matched_pat(&mut self, _: &Pat, _: &cmt_, _: euv::MatchMode) {}
- fn consume(&mut self, _: ast::NodeId, _: Span, _: &cmt_, _: ConsumeMode) {}
- fn consume_pat(&mut self, _: &Pat, _: &cmt_, _: ConsumeMode) {}
+ fn matched_pat(&mut self, _: &Pat, _: &cmt_<'_>, _: euv::MatchMode) {}
+ fn consume(&mut self, _: ast::NodeId, _: Span, _: &cmt_<'_>, _: ConsumeMode) {}
+ fn consume_pat(&mut self, _: &Pat, _: &cmt_<'_>, _: ConsumeMode) {}
fn borrow(&mut self,
_: ast::NodeId,
span: Span,
- _: &cmt_,
+ _: &cmt_<'_>,
_: ty::Region<'tcx>,
kind:ty:: BorrowKind,
_: LoanCause) {
}
}
fn decl_without_init(&mut self, _: ast::NodeId, _: Span) {}
- fn mutate(&mut self, _: ast::NodeId, span: Span, _: &cmt_, mode: MutateMode) {
+ fn mutate(&mut self, _: ast::NodeId, span: Span, _: &cmt_<'_>, mode: MutateMode) {
match mode {
MutateMode::JustWrite | MutateMode::WriteAndRead => {
struct_span_err!(self.cx.tcx.sess, span, E0302, "cannot assign in a pattern guard")
/// Forbids bindings in `@` patterns. This is necessary for memory safety,
/// because of the way rvalues are handled in the borrow check. (See issue
/// #14587.)
-fn check_legality_of_bindings_in_at_patterns(cx: &MatchVisitor, pat: &Pat) {
+fn check_legality_of_bindings_in_at_patterns(cx: &MatchVisitor<'_, '_>, pat: &Pat) {
AtBindingPatternVisitor { cx: cx, bindings_allowed: true }.visit_pat(pat);
}
-//! Code to validate patterns/matches
+//! Validation of patterns/matches.
mod _match;
mod check_match;
pub use self::check_match::check_crate;
pub(crate) use self::check_match::check_match;
-use const_eval::{const_field, const_variant_index};
+use crate::const_eval::{const_field, const_variant_index};
-use hair::util::UserAnnotatedTyHelpers;
-use hair::constant::*;
+use crate::hair::util::UserAnnotatedTyHelpers;
+use crate::hair::constant::*;
use rustc::mir::{fmt_const_val, Field, BorrowKind, Mutability};
use rustc::mir::{UserTypeProjection};
}
-#[derive(Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PatternTypeProjection<'tcx> {
pub user_ty: CanonicalUserType<'tcx>,
}
}
}
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct Ascription<'tcx> {
+ pub user_ty: PatternTypeProjection<'tcx>,
+ /// Variance to use when relating the type `user_ty` to the **type of the value being
+ /// matched**. Typically, this is `Variance::Covariant`, since the value being matched must
+ /// have a type that is some subtype of the ascribed type.
+ ///
+ /// Note that this variance does not apply for any bindings within subpatterns. The type
+ /// assigned to those bindings must be exactly equal to the `user_ty` given here.
+ ///
+ /// The only place where this field is not `Covariant` is when matching constants, where
+ /// we currently use `Contravariant` -- this is because the constant type just needs to
+ /// be "comparable" to the type of the input value. So, for example:
+ ///
+ /// ```text
+ /// match x { "foo" => .. }
+ /// ```
+ ///
+ /// requires that `&'static str <: T_x`, where `T_x` is the type of `x`. Really, we should
+ /// probably be checking for a `PartialEq` impl instead, but this preserves the behavior
+ /// of the old type-check for now. See #57280 for details.
+ pub variance: ty::Variance,
+ pub user_ty_span: Span,
+}
+
#[derive(Clone, Debug)]
pub enum PatternKind<'tcx> {
Wild,
AscribeUserType {
- user_ty: PatternTypeProjection<'tcx>,
+ ascription: Ascription<'tcx>,
subpattern: Pattern<'tcx>,
- /// Variance to use when relating the type `user_ty` to the **type of the value being
- /// matched**. Typically, this is `Variance::Covariant`, since the value being matched must
- /// have a type that is some subtype of the ascribed type.
- ///
- /// Note that this variance does not apply for any bindings within subpatterns. The type
- /// assigned to those bindings must be exactly equal to the `user_ty` given here.
- ///
- /// The only place where this field is not `Covariant` is when matching constants, where
- /// we currently use `Contravariant` -- this is because the constant type just needs to
- /// be "comparable" to the type of the input value. So, for example:
- ///
- /// ```text
- /// match x { "foo" => .. }
- /// ```
- ///
- /// requires that `&'static str <: T_x`, where `T_x` is the type of `x`. Really, we should
- /// probably be checking for a `PartialEq` impl instead, but this preserves the behavior
- /// of the old type-check for now. See #57280 for details.
- variance: ty::Variance,
- user_ty_span: Span,
},
- /// x, ref x, x @ P, etc
+ /// `x`, `ref x`, `x @ P`, etc.
Binding {
mutability: Mutability,
name: ast::Name,
subpattern: Option<Pattern<'tcx>>,
},
- /// Foo(...) or Foo{...} or Foo, where `Foo` is a variant name from an adt with >1 variants
+ /// `Foo(...)` or `Foo{...}` or `Foo`, where `Foo` is a variant name from an ADT with
+ /// multiple variants.
Variant {
adt_def: &'tcx AdtDef,
substs: &'tcx Substs<'tcx>,
subpatterns: Vec<FieldPattern<'tcx>>,
},
- /// (...), Foo(...), Foo{...}, or Foo, where `Foo` is a variant name from an adt with 1 variant
+ /// `(...)`, `Foo(...)`, `Foo{...}`, or `Foo`, where `Foo` is a variant name from an ADT with
+ /// a single variant.
Leaf {
subpatterns: Vec<FieldPattern<'tcx>>,
},
- /// box P, &P, &mut P, etc
+ /// `box P`, `&P`, `&mut P`, etc.
Deref {
subpattern: Pattern<'tcx>,
},
Range(PatternRange<'tcx>),
- /// matches against a slice, checking the length and extracting elements.
+ /// Matches against a slice, checking the length and extracting elements.
/// irrefutable when there is a slice pattern and both `prefix` and `suffix` are empty.
/// e.g., `&[ref xs..]`.
Slice {
suffix: Vec<Pattern<'tcx>>,
},
- /// fixed match against an array, irrefutable
+ /// Fixed match against an array; irrefutable.
Array {
prefix: Vec<Pattern<'tcx>>,
slice: Option<Pattern<'tcx>>,
},
}
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq)]
pub struct PatternRange<'tcx> {
pub lo: ty::Const<'tcx>,
pub hi: ty::Const<'tcx>,
}
impl<'tcx> fmt::Display for Pattern<'tcx> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self.kind {
PatternKind::Wild => write!(f, "_"),
PatternKind::AscribeUserType { ref subpattern, .. } =>
)
}
+ fn lower_range_expr(
+ &mut self,
+ expr: &'tcx hir::Expr,
+ ) -> (PatternKind<'tcx>, Option<Ascription<'tcx>>) {
+ match self.lower_lit(expr) {
+ PatternKind::AscribeUserType {
+ ascription: lo_ascription,
+ subpattern: Pattern { kind: box kind, .. },
+ } => (kind, Some(lo_ascription)),
+ kind => (kind, None),
+ }
+ }
+
fn lower_pattern_unadjusted(&mut self, pat: &'tcx hir::Pat) -> Pattern<'tcx> {
- let mut ty = self.tables.node_id_to_type(pat.hir_id);
+ let mut ty = self.tables.node_type(pat.hir_id);
let kind = match pat.node {
PatKind::Wild => PatternKind::Wild,
PatKind::Lit(ref value) => self.lower_lit(value),
PatKind::Range(ref lo_expr, ref hi_expr, end) => {
- match (self.lower_lit(lo_expr), self.lower_lit(hi_expr)) {
- (PatternKind::Constant { value: lo },
- PatternKind::Constant { value: hi }) => {
+ let (lo, lo_ascription) = self.lower_range_expr(lo_expr);
+ let (hi, hi_ascription) = self.lower_range_expr(hi_expr);
+
+ let mut kind = match (lo, hi) {
+ (PatternKind::Constant { value: lo }, PatternKind::Constant { value: hi }) => {
use std::cmp::Ordering;
let cmp = compare_const_vals(
self.tcx,
PatternKind::Wild
}
}
+ },
+ ref pats => {
+ self.tcx.sess.delay_span_bug(
+ pat.span,
+ &format!(
+ "found bad range pattern `{:?}` outside of error recovery",
+ pats,
+ ),
+ );
+
+ PatternKind::Wild
+ },
+ };
+
+ // If we are handling a range with associated constants (e.g.
+ // `Foo::<'a>::A..=Foo::B`), we need to put the ascriptions for the associated
+ // constants somewhere. Have them on the range pattern.
+ for ascription in &[lo_ascription, hi_ascription] {
+ if let Some(ascription) = ascription {
+ kind = PatternKind::AscribeUserType {
+ ascription: *ascription,
+ subpattern: Pattern { span: pat.span, ty, kind: Box::new(kind), },
+ };
}
- _ => PatternKind::Wild
}
+
+ kind
}
PatKind::Path(ref qpath) => {
}
PatKind::Binding(_, id, _, ident, ref sub) => {
- let var_ty = self.tables.node_id_to_type(pat.hir_id);
+ let var_ty = self.tables.node_type(pat.hir_id);
if let ty::Error = var_ty.sty {
// Avoid ICE
return Pattern { span: pat.span, ty, kind: Box::new(PatternKind::Wild) };
ty,
kind: Box::new(kind),
},
- user_ty: PatternTypeProjection::from_user_type(user_ty),
- user_ty_span: span,
- variance: ty::Variance::Covariant,
+ ascription: Ascription {
+ user_ty: PatternTypeProjection::from_user_type(user_ty),
+ user_ty_span: span,
+ variance: ty::Variance::Covariant,
+ },
};
}
/// Takes a HIR Path. If the path is a constant, evaluates it and feeds
/// it to `const_to_pat`. Any other path (like enum variants without fields)
- /// is converted to the corresponding pattern via `lower_variant_or_leaf`
+ /// is converted to the corresponding pattern via `lower_variant_or_leaf`.
fn lower_path(&mut self,
qpath: &hir::QPath,
id: hir::HirId,
span: Span)
-> Pattern<'tcx> {
- let ty = self.tables.node_id_to_type(id);
+ let ty = self.tables.node_type(id);
let def = self.tables.qpath_def(qpath, id);
let is_associated_const = match def {
Def::AssociatedConst(_) => true,
kind: Box::new(
PatternKind::AscribeUserType {
subpattern: pattern,
- /// Note that use `Contravariant` here. See the
- /// `variance` field documentation for details.
- variance: ty::Variance::Contravariant,
- user_ty,
- user_ty_span: span,
+ ascription: Ascription {
+ /// Note that use `Contravariant` here. See the
+ /// `variance` field documentation for details.
+ variance: ty::Variance::Contravariant,
+ user_ty,
+ user_ty_span: span,
+ },
}
),
ty: value.ty,
}
/// Converts literals, paths and negation of literals to patterns.
- /// The special case for negation exists to allow things like -128i8
- /// which would overflow if we tried to evaluate 128i8 and then negate
+ /// The special case for negation exists to allow things like `-128_i8`
+ /// which would overflow if we tried to evaluate `128_i8` and then negate
/// afterwards.
fn lower_lit(&mut self, expr: &'tcx hir::Expr) -> PatternKind<'tcx> {
match expr.node {
/// Converts an evaluated constant to a pattern (if possible).
/// This means aggregate values (like structs and enums) are converted
- /// to a pattern that matches the value (as if you'd compare via eq).
+ /// to a pattern that matches the value (as if you'd compared via equality).
fn const_to_pat(
&self,
instance: ty::Instance<'tcx>,
PatternKind::Wild => PatternKind::Wild,
PatternKind::AscribeUserType {
ref subpattern,
- variance,
- ref user_ty,
- user_ty_span,
+ ascription: Ascription {
+ variance,
+ ref user_ty,
+ user_ty_span,
+ },
} => PatternKind::AscribeUserType {
subpattern: subpattern.fold_with(folder),
- user_ty: user_ty.fold_with(folder),
- variance,
- user_ty_span,
+ ascription: Ascription {
+ user_ty: user_ty.fold_with(folder),
+ variance,
+ user_ty_span,
+ },
},
PatternKind::Binding {
mutability,
let user_provided_types = self.tables().user_provided_types();
let mut user_ty = *user_provided_types.get(hir_id)?;
debug!("user_subts_applied_to_ty_of_hir_id: user_ty={:?}", user_ty);
- match &self.tables().node_id_to_type(hir_id).sty {
+ match &self.tables().node_type(hir_id).sty {
ty::Adt(adt_def, ..) => {
if let UserType::TypeOf(ref mut did, _) = &mut user_ty.value {
*did = adt_def.did;
use rustc::mir::CastKind;
use rustc_apfloat::Float;
-use super::{EvalContext, Machine, PlaceTy, OpTy, Immediate};
+use super::{EvalContext, Machine, PlaceTy, OpTy, ImmTy, Immediate};
impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
fn type_is_fat_ptr(&self, ty: Ty<'tcx>) -> bool {
assert_eq!(src.layout.fields.offset(i).bytes(), 0);
assert_eq!(src_field_layout.size, src.layout.size);
// just sawp out the layout
- OpTy { op: src.op, layout: src_field_layout }
+ OpTy::from(ImmTy { imm: src.to_immediate(), layout: src_field_layout })
}
};
if src_field.layout.ty == dst_field.layout.ty {
/// The MIR for the function called on this frame.
pub mir: &'mir mir::Mir<'tcx>,
- /// The def_id and substs of the current function
+ /// The def_id and substs of the current function.
pub instance: ty::Instance<'tcx>,
/// The span of the call site.
////////////////////////////////////////////////////////////////////////////////
// Return place and locals
////////////////////////////////////////////////////////////////////////////////
- /// Work to perform when returning from this function
+ /// Work to perform when returning from this function.
pub return_to_block: StackPopCleanup,
/// The location where the result of the current stack frame should be written to,
/// The index of the currently evaluated statement.
pub stmt: usize,
- /// Extra data for the machine
+ /// Extra data for the machine.
pub extra: Extra,
}
/// we can validate it at that layout.
Goto(Option<mir::BasicBlock>),
/// Just do nohing: Used by Main and for the box_alloc hook in miri.
- /// `cleanup` says whether locals are deallocated. Static computation
+ /// `cleanup` says whether locals are deallocated. Static computation
/// wants them leaked to intern what they need (and just throw away
/// the entire `ecx` when it is done).
None { cleanup: bool },
) -> EvalResult<'tcx, TyLayout<'tcx>> {
match frame.locals[local].layout.get() {
None => {
- let layout = ::interpret::operand::from_known_layout(layout, || {
+ let layout = crate::interpret::operand::from_known_layout(layout, || {
let local_ty = frame.mir.local_decls[local].ty;
let local_ty = self.monomorphize_with_substs(local_ty, frame.instance.substs);
self.layout_of(local_ty)
Ok(Immediate::new_slice(Scalar::Ptr(ptr), s.len() as u64, self))
}
- /// Return the actual dynamic size and alignment of the place at the given type.
+ /// Returns the actual dynamic size and alignment of the place at the given type.
/// Only the "meta" (metadata) part of the place matters.
/// This can fail to provide an answer for extern types.
pub(super) fn size_and_align_of(
//! Intrinsics and other functions that the miri engine executes without
-//! looking at their MIR. Intrinsics/functions supported here are shared by CTFE
+//! looking at their MIR. Intrinsics/functions supported here are shared by CTFE
//! and miri.
use syntax::symbol::Symbol;
use rustc::ty;
-use rustc::ty::layout::{LayoutOf, Primitive};
+use rustc::ty::layout::{LayoutOf, Primitive, Size};
use rustc::mir::BinOp;
use rustc::mir::interpret::{
EvalResult, EvalErrorKind, Scalar,
}
impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
- /// Returns whether emulation happened.
+ /// Returns `true` if emulation happened.
pub fn emulate_intrinsic(
&mut self,
instance: ty::Instance<'tcx>,
self.binop_with_overflow(bin_op, lhs, rhs, dest)?;
}
}
+ "saturating_add" | "saturating_sub" => {
+ let l = self.read_immediate(args[0])?;
+ let r = self.read_immediate(args[1])?;
+ let is_add = intrinsic_name == "saturating_add";
+ let (val, overflowed) = self.binary_op(if is_add {
+ BinOp::Add
+ } else {
+ BinOp::Sub
+ }, l, r)?;
+ let val = if overflowed {
+ let num_bits = l.layout.size.bits();
+ if l.layout.abi.is_signed() {
+ // For signed ints the saturated value depends on the sign of the first
+ // term since the sign of the second term can be inferred from this and
+ // the fact that the operation has overflowed (if either is 0 no
+ // overflow can occur)
+ let first_term: u128 = l.to_scalar()?.to_bits(l.layout.size)?;
+ let first_term_positive = first_term & (1 << (num_bits-1)) == 0;
+ if first_term_positive {
+ // Negative overflow not possible since the positive first term
+ // can only increase an (in range) negative term for addition
+ // or corresponding negated positive term for subtraction
+ Scalar::from_uint((1u128 << (num_bits - 1)) - 1, // max positive
+ Size::from_bits(num_bits))
+ } else {
+ // Positive overflow not possible for similar reason
+ // max negative
+ Scalar::from_uint(1u128 << (num_bits - 1), Size::from_bits(num_bits))
+ }
+ } else { // unsigned
+ if is_add {
+ // max unsigned
+ Scalar::from_uint(u128::max_value() >> (128 - num_bits),
+ Size::from_bits(num_bits))
+ } else { // underflow to 0
+ Scalar::from_uint(0u128, Size::from_bits(num_bits))
+ }
+ }
+ } else {
+ val
+ };
+ self.write_scalar(val, dest)?;
+ }
"unchecked_shl" | "unchecked_shr" => {
let l = self.read_immediate(args[0])?;
let r = self.read_immediate(args[1])?;
"unchecked_shr" => BinOp::Shr,
_ => bug!("Already checked for int ops")
};
- let (val, overflowed) = self.binary_op_imm(bin_op, l, r)?;
+ let (val, overflowed) = self.binary_op(bin_op, l, r)?;
if overflowed {
let layout = self.layout_of(substs.type_at(0))?;
let r_val = r.to_scalar()?.to_bits(layout.size)?;
}
/// "Intercept" a function call because we have something special to do for it.
- /// Returns whether an intercept happened.
+ /// Returns `true` if an intercept happened.
pub fn hook_fn(
&mut self,
instance: ty::Instance<'tcx>,
use rustc::hir::{self, def_id::DefId};
use rustc::mir;
-use rustc::ty::{self, layout::TyLayout, query::TyCtxtAt};
+use rustc::ty::{self, query::TyCtxtAt};
use super::{
Allocation, AllocId, EvalResult, Scalar, AllocationExtra,
- EvalContext, PlaceTy, MPlaceTy, OpTy, Pointer, MemoryKind,
+ EvalContext, PlaceTy, MPlaceTy, OpTy, ImmTy, Pointer, MemoryKind,
};
/// Whether this kind of memory is allowed to leak
/// The functionality needed by memory to manage its allocations
pub trait AllocMap<K: Hash + Eq, V> {
- /// Test if the map contains the given key.
+ /// Tests if the map contains the given key.
/// Deliberately takes `&mut` because that is sufficient, and some implementations
/// can be more efficient then (using `RefCell::get_mut`).
fn contains_key<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> bool
where K: Borrow<Q>;
- /// Insert new entry into the map.
+ /// Inserts a new entry into the map.
fn insert(&mut self, k: K, v: V) -> Option<V>;
- /// Remove entry from the map.
+ /// Removes an entry from the map.
fn remove<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> Option<V>
where K: Borrow<Q>;
- /// Return data based the keys and values in the map.
+ /// Returns data based the keys and values in the map.
fn filter_map_collect<T>(&self, f: impl FnMut(&K, &V) -> Option<T>) -> Vec<T>;
- /// Return a reference to entry `k`. If no such entry exists, call
+ /// Returns a reference to entry `k`. If no such entry exists, call
/// `vacant` and either forward its error, or add its result to the map
/// and return a reference to *that*.
fn get_or<E>(
vacant: impl FnOnce() -> Result<V, E>
) -> Result<&V, E>;
- /// Return a mutable reference to entry `k`. If no such entry exists, call
+ /// Returns a mutable reference to entry `k`. If no such entry exists, call
/// `vacant` and either forward its error, or add its result to the map
/// and return a reference to *that*.
fn get_mut_or<E>(
/// Additional memory kinds a machine wishes to distinguish from the builtin ones
type MemoryKinds: ::std::fmt::Debug + MayLeak + Eq + 'static;
- /// Tag tracked alongside every pointer. This is used to implement "Stacked Borrows"
+ /// Tag tracked alongside every pointer. This is used to implement "Stacked Borrows"
/// <https://www.ralfj.de/blog/2018/08/07/stacked-borrows.html>.
/// The `default()` is used for pointers to consts, statics, vtables and functions.
type PointerTag: ::std::fmt::Debug + Default + Copy + Eq + Hash + 'static;
/// Extra data stored in every call frame.
type FrameExtra;
- /// Extra data stored in memory. A reference to this is available when `AllocExtra`
+ /// Extra data stored in memory. A reference to this is available when `AllocExtra`
/// gets initialized, so you can e.g., have an `Rc` here if there is global state you
/// need access to in the `AllocExtra` hooks.
type MemoryExtra: Default;
///
/// Returns either the mir to use for the call, or `None` if execution should
/// just proceed (which usually means this hook did all the work that the
- /// called function should usually have done). In the latter case, it is
+ /// called function should usually have done). In the latter case, it is
/// this hook's responsibility to call `goto_block(ret)` to advance the instruction pointer!
/// (This is to support functions like `__rust_maybe_catch_panic` that neither find a MIR
/// nor just jump to `ret`, but instead push their own stack frame.)
fn ptr_op(
ecx: &EvalContext<'a, 'mir, 'tcx, Self>,
bin_op: mir::BinOp,
- left: Scalar<Self::PointerTag>,
- left_layout: TyLayout<'tcx>,
- right: Scalar<Self::PointerTag>,
- right_layout: TyLayout<'tcx>,
+ left: ImmTy<'tcx, Self::PointerTag>,
+ right: ImmTy<'tcx, Self::PointerTag>,
) -> EvalResult<'tcx, (Scalar<Self::PointerTag>, bool)>;
/// Heap allocations via the `box` keyword.
dest: PlaceTy<'tcx, Self::PointerTag>,
) -> EvalResult<'tcx>;
- /// Add the tag for a newly allocated pointer.
+ /// Adds the tag for a newly allocated pointer.
fn tag_new_allocation(
ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
ptr: Pointer,
) -> Pointer<Self::PointerTag>;
/// Executed when evaluating the `*` operator: Following a reference.
- /// This has the chance to adjust the tag. It should not change anything else!
+ /// This has the chance to adjust the tag. It should not change anything else!
/// `mutability` can be `None` in case a raw ptr is being dereferenced.
#[inline]
fn tag_dereference(
Ok(place.ptr)
}
- /// Execute a retagging operation
+ /// Executes a retagging operation
#[inline]
fn retag(
_ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
//! Generally, we use `Pointer` to denote memory addresses. However, some operations
//! have a "size"-like parameter, and they take `Scalar` for the address because
//! if the size is 0, then the pointer can also be a (properly aligned, non-NULL)
-//! integer. It is crucial that these operations call `check_align` *before*
+//! integer. It is crucial that these operations call `check_align` *before*
//! short-circuiting the empty case!
use std::collections::VecDeque;
// `Memory` has to depend on the `Machine` because some of its operations
// (e.g., `get`) call a `Machine` hook.
pub struct Memory<'a, 'mir, 'tcx: 'a + 'mir, M: Machine<'a, 'mir, 'tcx>> {
- /// Allocations local to this instance of the miri engine. The kind
+ /// Allocations local to this instance of the miri engine. The kind
/// helps ensure that the same mechanism is used for allocation and
- /// deallocation. When an allocation is not found here, it is a
- /// static and looked up in the `tcx` for read access. Some machines may
+ /// deallocation. When an allocation is not found here, it is a
+ /// static and looked up in the `tcx` for read access. Some machines may
/// have to mutate this map even on a read-only access to a static (because
/// they do pointer provenance tracking and the allocations in `tcx` have
/// the wrong type), so we let the machine override this type.
Ok(())
}
- /// Check that the pointer is aligned AND non-NULL. This supports ZSTs in two ways:
+ /// Checks that the pointer is aligned AND non-NULL. This supports ZSTs in two ways:
/// You can pass a scalar, and a `Pointer` does not have to actually still be allocated.
pub fn check_align(
&self,
}
}
- /// Check if the pointer is "in-bounds". Notice that a pointer pointing at the end
+ /// Checks if the pointer is "in-bounds". Notice that a pointer pointing at the end
/// of an allocation (i.e., at the first *inaccessible* location) *is* considered
/// in-bounds! This follows C's/LLVM's rules.
/// If you want to check bounds before doing a memory access, better first obtain
}
}
-/// Reading and writing
+/// Reading and writing.
impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
pub fn copy(
&mut self,
ConstValue, Pointer, Scalar,
EvalResult, EvalErrorKind,
};
-use super::{EvalContext, Machine, MemPlace, MPlaceTy, MemoryKind};
+use super::{
+ EvalContext, Machine, AllocMap, Allocation, AllocationExtra,
+ MemPlace, MPlaceTy, PlaceTy, Place, MemoryKind,
+};
pub use rustc::mir::interpret::ScalarMaybeUndef;
/// A `Value` represents a single immediate self-contained Rust value.
}
impl<'tcx, Tag> Immediate<Tag> {
+ #[inline]
+ pub fn from_scalar(val: Scalar<Tag>) -> Self {
+ Immediate::Scalar(ScalarMaybeUndef::Scalar(val))
+ }
+
#[inline]
pub fn erase_tag(self) -> Immediate
{
}
}
- /// Convert the immediate into a pointer (or a pointer-sized integer).
+ /// Converts the immediate into a pointer (or a pointer-sized integer).
/// Throws away the second half of a ScalarPair!
#[inline]
pub fn to_scalar_ptr(self) -> EvalResult<'tcx, Scalar<Tag>> {
}
}
- /// Convert the value into its metadata.
+ /// Converts the value into its metadata.
/// Throws away the first half of a ScalarPair!
#[inline]
pub fn to_meta(self) -> EvalResult<'tcx, Option<Scalar<Tag>>> {
// as input for binary and cast operations.
#[derive(Copy, Clone, Debug)]
pub struct ImmTy<'tcx, Tag=()> {
- immediate: Immediate<Tag>,
+ pub imm: Immediate<Tag>,
pub layout: TyLayout<'tcx>,
}
type Target = Immediate<Tag>;
#[inline(always)]
fn deref(&self) -> &Immediate<Tag> {
- &self.immediate
+ &self.imm
}
}
/// An `Operand` is the result of computing a `mir::Operand`. It can be immediate,
-/// or still in memory. The latter is an optimization, to delay reading that chunk of
+/// or still in memory. The latter is an optimization, to delay reading that chunk of
/// memory and to avoid having to store arbitrary-sized data here.
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub enum Operand<Tag=(), Id=AllocId> {
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct OpTy<'tcx, Tag=()> {
- crate op: Operand<Tag>, // ideally we'd make this private, but const_prop needs this
+ op: Operand<Tag>,
pub layout: TyLayout<'tcx>,
}
#[inline(always)]
fn from(val: ImmTy<'tcx, Tag>) -> Self {
OpTy {
- op: Operand::Immediate(val.immediate),
+ op: Operand::Immediate(val.imm),
layout: val.layout
}
}
}
+impl<'tcx, Tag: Copy> ImmTy<'tcx, Tag>
+{
+ #[inline]
+ pub fn from_scalar(val: Scalar<Tag>, layout: TyLayout<'tcx>) -> Self {
+ ImmTy { imm: Immediate::from_scalar(val), layout }
+ }
+
+ #[inline]
+ pub fn to_bits(self) -> EvalResult<'tcx, u128> {
+ self.to_scalar()?.to_bits(self.layout.size)
+ }
+}
+
impl<'tcx, Tag> OpTy<'tcx, Tag>
{
#[inline]
impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
/// Try reading an immediate in memory; this is interesting particularly for ScalarPair.
- /// Return None if the layout does not permit loading this as a value.
+ /// Returns `None` if the layout does not permit loading this as a value.
pub(super) fn try_read_immediate_from_mplace(
&self,
mplace: MPlaceTy<'tcx, M::PointerTag>,
&self,
op: OpTy<'tcx, M::PointerTag>
) -> EvalResult<'tcx, ImmTy<'tcx, M::PointerTag>> {
- if let Ok(immediate) = self.try_read_immediate(op)? {
- Ok(ImmTy { immediate, layout: op.layout })
+ if let Ok(imm) = self.try_read_immediate(op)? {
+ Ok(ImmTy { imm, layout: op.layout })
} else {
bug!("primitive read failed for type: {:?}", op.layout.ty);
}
Ok(OpTy { op, layout })
}
+ /// Every place can be read from, so we can turm them into an operand
+ #[inline(always)]
+ pub fn place_to_op(
+ &self,
+ place: PlaceTy<'tcx, M::PointerTag>
+ ) -> EvalResult<'tcx, OpTy<'tcx, M::PointerTag>> {
+ let op = match *place {
+ Place::Ptr(mplace) => {
+ Operand::Indirect(mplace)
+ }
+ Place::Local { frame, local } =>
+ *self.stack[frame].locals[local].access()?
+ };
+ Ok(OpTy { op, layout: place.layout })
+ }
+
// Evaluate a place with the goal of reading from it. This lets us sometimes
// avoid allocations.
fn eval_place_to_op(
.collect()
}
- // Used when miri runs into a constant, and by CTFE.
- // FIXME: CTFE should use allocations, then we can make this private (embed it into
- // `eval_operand`, ideally).
- pub(crate) fn const_value_to_op(
+ // Used when Miri runs into a constant, and (indirectly through lazy_const_to_op) by CTFE.
+ fn const_value_to_op(
&self,
val: ty::LazyConst<'tcx>,
) -> EvalResult<'tcx, Operand<M::PointerTag>> {
}
}
+
+impl<'a, 'mir, 'tcx, M> EvalContext<'a, 'mir, 'tcx, M>
+where
+ M: Machine<'a, 'mir, 'tcx, PointerTag=()>,
+ // FIXME: Working around https://github.com/rust-lang/rust/issues/24159
+ M::MemoryMap: AllocMap<AllocId, (MemoryKind<M::MemoryKinds>, Allocation<(), M::AllocExtra>)>,
+ M::AllocExtra: AllocationExtra<(), M::MemoryExtra>,
+{
+ // FIXME: CTFE should use allocations, then we can remove this.
+ pub(crate) fn lazy_const_to_op(
+ &self,
+ cnst: ty::LazyConst<'tcx>,
+ ty: ty::Ty<'tcx>,
+ ) -> EvalResult<'tcx, OpTy<'tcx>> {
+ let op = self.const_value_to_op(cnst)?;
+ Ok(OpTy { op, layout: self.layout_of(ty)? })
+ }
+}
right: ImmTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>,
) -> EvalResult<'tcx> {
- let (val, overflowed) = self.binary_op_imm(op, left, right)?;
+ let (val, overflowed) = self.binary_op(op, left, right)?;
let val = Immediate::ScalarPair(val.into(), Scalar::from_bool(overflowed).into());
self.write_immediate(val, dest)
}
right: ImmTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>,
) -> EvalResult<'tcx> {
- let (val, _overflowed) = self.binary_op_imm(op, left, right)?;
+ let (val, _overflowed) = self.binary_op(op, left, right)?;
self.write_scalar(val, dest)
}
}
Ok((val, false))
}
- /// Convenience wrapper that's useful when keeping the layout together with the
- /// immediate value.
+ /// Returns the result of the specified operation and whether it overflowed.
#[inline]
- pub fn binary_op_imm(
+ pub fn binary_op(
&self,
bin_op: mir::BinOp,
left: ImmTy<'tcx, M::PointerTag>,
right: ImmTy<'tcx, M::PointerTag>,
- ) -> EvalResult<'tcx, (Scalar<M::PointerTag>, bool)> {
- self.binary_op(
- bin_op,
- left.to_scalar()?, left.layout,
- right.to_scalar()?, right.layout,
- )
- }
-
- /// Returns the result of the specified operation and whether it overflowed.
- pub fn binary_op(
- &self,
- bin_op: mir::BinOp,
- left: Scalar<M::PointerTag>,
- left_layout: TyLayout<'tcx>,
- right: Scalar<M::PointerTag>,
- right_layout: TyLayout<'tcx>,
) -> EvalResult<'tcx, (Scalar<M::PointerTag>, bool)> {
trace!("Running binary op {:?}: {:?} ({:?}), {:?} ({:?})",
- bin_op, left, left_layout.ty, right, right_layout.ty);
+ bin_op, *left, left.layout.ty, *right, right.layout.ty);
- match left_layout.ty.sty {
+ match left.layout.ty.sty {
ty::Char => {
- assert_eq!(left_layout.ty, right_layout.ty);
- let left = left.to_char()?;
- let right = right.to_char()?;
+ assert_eq!(left.layout.ty, right.layout.ty);
+ let left = left.to_scalar()?.to_char()?;
+ let right = right.to_scalar()?.to_char()?;
self.binary_char_op(bin_op, left, right)
}
ty::Bool => {
- assert_eq!(left_layout.ty, right_layout.ty);
- let left = left.to_bool()?;
- let right = right.to_bool()?;
+ assert_eq!(left.layout.ty, right.layout.ty);
+ let left = left.to_scalar()?.to_bool()?;
+ let right = right.to_scalar()?.to_bool()?;
self.binary_bool_op(bin_op, left, right)
}
ty::Float(fty) => {
- assert_eq!(left_layout.ty, right_layout.ty);
- let left = left.to_bits(left_layout.size)?;
- let right = right.to_bits(right_layout.size)?;
+ assert_eq!(left.layout.ty, right.layout.ty);
+ let left = left.to_bits()?;
+ let right = right.to_bits()?;
self.binary_float_op(bin_op, fty, left, right)
}
_ => {
// Must be integer(-like) types. Don't forget about == on fn pointers.
- assert!(left_layout.ty.is_integral() || left_layout.ty.is_unsafe_ptr() ||
- left_layout.ty.is_fn());
- assert!(right_layout.ty.is_integral() || right_layout.ty.is_unsafe_ptr() ||
- right_layout.ty.is_fn());
+ assert!(left.layout.ty.is_integral() || left.layout.ty.is_unsafe_ptr() ||
+ left.layout.ty.is_fn());
+ assert!(right.layout.ty.is_integral() || right.layout.ty.is_unsafe_ptr() ||
+ right.layout.ty.is_fn());
// Handle operations that support pointer values
- if left.is_ptr() || right.is_ptr() || bin_op == mir::BinOp::Offset {
- return M::ptr_op(self, bin_op, left, left_layout, right, right_layout);
+ if left.to_scalar_ptr()?.is_ptr() ||
+ right.to_scalar_ptr()?.is_ptr() ||
+ bin_op == mir::BinOp::Offset
+ {
+ return M::ptr_op(self, bin_op, left, right);
}
// Everything else only works with "proper" bits
- let left = left.to_bits(left_layout.size).expect("we checked is_ptr");
- let right = right.to_bits(right_layout.size).expect("we checked is_ptr");
- self.binary_int_op(bin_op, left, left_layout, right, right_layout)
+ let l = left.to_bits().expect("we checked is_ptr");
+ let r = right.to_bits().expect("we checked is_ptr");
+ self.binary_int_op(bin_op, l, left.layout, r, right.layout)
}
}
}
pub fn unary_op(
&self,
un_op: mir::UnOp,
- val: Scalar<M::PointerTag>,
- layout: TyLayout<'tcx>,
+ val: ImmTy<'tcx, M::PointerTag>,
) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
use rustc::mir::UnOp::*;
use rustc_apfloat::ieee::{Single, Double};
use rustc_apfloat::Float;
+ let layout = val.layout;
+ let val = val.to_scalar()?;
trace!("Running unary op {:?}: {:?} ({:?})", un_op, val, layout.ty.sty);
match layout.ty.sty {
/// However, it may never be undef.
pub ptr: Scalar<Tag, Id>,
pub align: Align,
- /// Metadata for unsized places. Interpretation is up to the type.
+ /// Metadata for unsized places. Interpretation is up to the type.
/// Must not be present for sized types, but can be missing for unsized types
/// (e.g., `extern type`).
pub meta: Option<Scalar<Tag, Id>>,
}
}
-impl<'tcx, Tag: ::std::fmt::Debug> OpTy<'tcx, Tag> {
+impl<'tcx, Tag: ::std::fmt::Debug + Copy> OpTy<'tcx, Tag> {
#[inline(always)]
pub fn try_as_mplace(self) -> Result<MPlaceTy<'tcx, Tag>, Immediate<Tag>> {
- match self.op {
+ match *self {
Operand::Indirect(mplace) => Ok(MPlaceTy { mplace, layout: self.layout }),
Operand::Immediate(imm) => Err(imm),
}
Deref => self.deref_operand(base.into())?,
Index(local) => {
- let n = *self.frame().locals[local].access()?;
- let n_layout = self.layout_of(self.tcx.types.usize)?;
- let n = self.read_scalar(OpTy { op: n, layout: n_layout })?;
+ let layout = self.layout_of(self.tcx.types.usize)?;
+ let n = self.access_local(self.frame(), local, Some(layout))?;
+ let n = self.read_scalar(n)?;
let n = n.to_bits(self.tcx.data_layout.pointer_size)?;
self.mplace_field(base, u64::try_from(n).unwrap())?
}
})
}
- /// Get the place of a field inside the place, and also the field's type.
+ /// Gets the place of a field inside the place, and also the field's type.
/// Just a convenience function, but used quite a bit.
/// This is the only projection that might have a side-effect: We cannot project
/// into the field of a local `ScalarPair`, we have to first allocate it.
})
}
- /// Project into a place
+ /// Projects into a place.
pub fn place_projection(
&mut self,
base: PlaceTy<'tcx, M::PointerTag>,
})
}
- /// Evaluate statics and promoteds to an `MPlace`. Used to share some code between
+ /// Evaluate statics and promoteds to an `MPlace`. Used to share some code between
/// `eval_place` and `eval_place_to_op`.
pub(super) fn eval_place_to_mplace(
&self,
})
}
- /// Compute a place. You should only use this if you intend to write into this
+ /// Computes a place. You should only use this if you intend to write into this
/// place; for reading, a more efficient alternative is `eval_place_for_read`.
pub fn eval_place(
&mut self,
}
}
- /// Copy the data from an operand to a place. This does not support transmuting!
+ /// Copies the data from an operand to a place. This does not support transmuting!
/// Use `copy_op_transmute` if the layouts could disagree.
#[inline(always)]
pub fn copy_op(
Ok(())
}
- /// Copy the data from an operand to a place. This does not support transmuting!
+ /// Copies the data from an operand to a place. This does not support transmuting!
/// Use `copy_op_transmute` if the layouts could disagree.
/// Also, if you use this you are responsible for validating that things git copied at the
/// right type.
let src = match self.try_read_immediate(src)? {
Ok(src_val) => {
// Yay, we got a value that we can write directly.
+ // FIXME: Add a check to make sure that if `src` is indirect,
+ // it does not overlap with `dest`.
return self.write_immediate_no_validate(src_val, dest);
}
Err(mplace) => mplace,
self.memory.copy(
src_ptr, src_align,
dest_ptr, dest_align,
- dest.layout.size, false
+ dest.layout.size,
+ /*nonoverlapping*/ true,
)?;
Ok(())
}
- /// Copy the data from an operand to a place. The layouts may disagree, but they must
+ /// Copies the data from an operand to a place. The layouts may disagree, but they must
/// have the same size.
pub fn copy_op_transmute(
&mut self,
Ok(())
}
- /// Make sure that a place is in memory, and return where it is.
+ /// Ensures that a place is in memory, and returns where it is.
/// If the place currently refers to a local that doesn't yet have a matching allocation,
/// create such an allocation.
/// This is essentially `force_to_memplace`.
Ok(())
}
- /// Every place can be read from, so we can turm them into an operand
- #[inline(always)]
- pub fn place_to_op(
- &self,
- place: PlaceTy<'tcx, M::PointerTag>
- ) -> EvalResult<'tcx, OpTy<'tcx, M::PointerTag>> {
- let op = match place.place {
- Place::Ptr(mplace) => {
- Operand::Indirect(mplace)
- }
- Place::Local { frame, local } =>
- *self.stack[frame].locals[local].access()?
- };
- Ok(OpTy { op, layout: place.layout })
- }
-
pub fn raw_const_to_mplace(
&self,
raw: RawConst<'tcx>,
use super::eval_context::{LocalState, StackPopCleanup};
use super::{Frame, Memory, Operand, MemPlace, Place, Immediate, ScalarMaybeUndef, LocalValue};
-use const_eval::CompileTimeInterpreter;
+use crate::const_eval::CompileTimeInterpreter;
#[derive(Default)]
pub(crate) struct InfiniteLoopDetector<'a, 'mir, 'tcx: 'a + 'mir> {
Undef,
});
-impl_stable_hash_for!(struct ::interpret::MemPlace {
+impl_stable_hash_for!(struct crate::interpret::MemPlace {
ptr,
align,
meta,
align -> *align, // just copy alignment verbatim
});
-impl_stable_hash_for!(enum ::interpret::Place {
+impl_stable_hash_for!(enum crate::interpret::Place {
Ptr(mem_place),
Local { frame, local },
});
}
}
-impl_stable_hash_for!(enum ::interpret::Immediate {
+impl_stable_hash_for!(enum crate::interpret::Immediate {
Scalar(x),
ScalarPair(x, y),
});
ScalarPair(s, t),
});
-impl_stable_hash_for!(enum ::interpret::Operand {
+impl_stable_hash_for!(enum crate::interpret::Operand {
Immediate(x),
Indirect(x),
});
Indirect(m),
});
-impl_stable_hash_for!(enum ::interpret::LocalValue {
+impl_stable_hash_for!(enum crate::interpret::LocalValue {
Dead,
Live(x),
});
}
}
-impl_stable_hash_for!(enum ::interpret::eval_context::StackPopCleanup {
+impl_stable_hash_for!(enum crate::interpret::eval_context::StackPopCleanup {
Goto(block),
None { cleanup },
});
Ok(())
}
- /// Returns true as long as there are more things to do.
+ /// Returns `true` as long as there are more things to do.
///
/// This is used by [priroda](https://github.com/oli-obk/priroda)
pub fn step(&mut self) -> EvalResult<'tcx, bool> {
UnaryOp(un_op, ref operand) => {
// The operand always has the same type as the result.
let val = self.read_immediate(self.eval_operand(operand, Some(dest.layout))?)?;
- let val = self.unary_op(un_op, val.to_scalar()?, dest.layout)?;
+ let val = self.unary_op(un_op, val)?;
self.write_scalar(val, dest)?;
}
use rustc::mir::interpret::{EvalResult, PointerArithmetic, EvalErrorKind, Scalar};
use super::{
- EvalContext, Machine, Immediate, OpTy, PlaceTy, MPlaceTy, Operand, StackPopCleanup
+ EvalContext, Machine, Immediate, OpTy, ImmTy, PlaceTy, MPlaceTy, StackPopCleanup
};
impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
// Compare using binary_op, to also support pointer values
let const_int = Scalar::from_uint(const_int, discr.layout.size);
let (res, _) = self.binary_op(mir::BinOp::Eq,
- discr.to_scalar()?, discr.layout,
- const_int, discr.layout,
+ discr,
+ ImmTy::from_scalar(const_int, discr.layout),
)?;
if res.to_bool()? {
target_block = targets[index];
let ty = place.layout.ty;
trace!("TerminatorKind::drop: {:?}, type {}", location, ty);
- let instance = ::monomorphize::resolve_drop_in_place(*self.tcx, ty);
+ let instance = crate::monomorphize::resolve_drop_in_place(*self.tcx, ty);
self.drop_in_place(
place,
instance,
// last incoming argument. These two iterators do not have the same type,
// so to keep the code paths uniform we accept an allocation
// (for RustCall ABI only).
- let caller_args : Cow<[OpTy<'tcx, M::PointerTag>]> =
+ let caller_args : Cow<'_, [OpTy<'tcx, M::PointerTag>]> =
if caller_abi == Abi::RustCall && !args.is_empty() {
// Untuple
let (&untuple_arg, args) = args.split_last().unwrap();
.chain((0..untuple_arg.layout.fields.count()).into_iter()
.map(|i| self.operand_field(untuple_arg, i as u64))
)
- .collect::<EvalResult<Vec<OpTy<'tcx, M::PointerTag>>>>()?)
+ .collect::<EvalResult<'_, Vec<OpTy<'tcx, M::PointerTag>>>>()?)
} else {
// Plain arg passing
Cow::from(args)
let mut args = args.to_vec();
let pointee = args[0].layout.ty.builtin_deref(true).unwrap().ty;
let fake_fat_ptr_ty = self.tcx.mk_mut_ptr(pointee);
- args[0].layout = self.layout_of(fake_fat_ptr_ty)?.field(self, 0)?;
- args[0].op = Operand::Immediate(Immediate::Scalar(ptr.ptr.into())); // strip vtable
+ args[0] = OpTy::from(ImmTy { // strip vtable
+ layout: self.layout_of(fake_fat_ptr_ty)?.field(self, 0)?,
+ imm: Immediate::Scalar(ptr.ptr.into())
+ });
trace!("Patched self operand to {:#?}", args[0]);
// recurse with concrete function
self.eval_fn_call(instance, span, caller_abi, &args, dest, ret)
_ => (instance, place),
};
- let arg = OpTy {
- op: Operand::Immediate(place.to_ref()),
+ let arg = ImmTy {
+ imm: place.to_ref(),
layout: self.layout_of(self.tcx.mk_mut_ptr(place.layout.ty))?,
};
instance,
span,
Abi::Rust,
- &[arg],
+ &[arg.into()],
Some(dest.into()),
Some(target),
)
let (ty, poly_trait_ref) = self.tcx.erase_regions(&(ty, poly_trait_ref));
if let Some(&vtable) = self.vtables.get(&(ty, poly_trait_ref)) {
+ // This means we guarantee that there are no duplicate vtables, we will
+ // always use the same vtable for the same (Type, Trait) combination.
+ // That's not what happens in rustc, but emulating per-crate deduplication
+ // does not sound like it actually makes anything any better.
return Ok(Pointer::from(vtable).with_default_tag());
}
).with_default_tag();
let tcx = &*self.tcx;
- let drop = ::monomorphize::resolve_drop_in_place(*tcx, ty);
+ let drop = crate::monomorphize::resolve_drop_in_place(*tcx, ty);
let drop = self.memory.create_fn_alloc(drop).with_default_tag();
// no need to do any alignment checks on the memory accesses below, because we know the
// allocation is correctly aligned as we created it above. Also we're only offsetting by
Ok(vtable)
}
- /// Return the drop fn instance as well as the actual dynamic type
+ /// Returns the drop fn instance as well as the actual dynamic type
pub fn read_drop_type_from_vtable(
&self,
vtable: Pointer<M::PointerTag>,
}
impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
- /// This function checks the data at `op`. `op` is assumed to cover valid memory if it
+ /// This function checks the data at `op`. `op` is assumed to cover valid memory if it
/// is an indirect operand.
/// It will error if the bits at the destination do not match the ones described by the layout.
///
// that's just more convenient to work with (avoids repeating all the `Machine` bounds).
pub trait Value<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>>: Copy
{
- /// Get this value's layout.
+ /// Gets this value's layout.
fn layout(&self) -> TyLayout<'tcx>;
- /// Make this into an `OpTy`.
+ /// Makes this into an `OpTy`.
fn to_op(
self,
ecx: &EvalContext<'a, 'mir, 'tcx, M>,
) -> EvalResult<'tcx, OpTy<'tcx, M::PointerTag>>;
- /// Create this from an `MPlaceTy`.
- fn from_mem_place(MPlaceTy<'tcx, M::PointerTag>) -> Self;
+ /// Creates this from an `MPlaceTy`.
+ fn from_mem_place(mplace: MPlaceTy<'tcx, M::PointerTag>) -> Self;
- /// Project to the given enum variant.
+ /// Projects to the given enum variant.
fn project_downcast(
self,
ecx: &EvalContext<'a, 'mir, 'tcx, M>,
variant: VariantIdx,
) -> EvalResult<'tcx, Self>;
- /// Project to the n-th field.
+ /// Projects to the n-th field.
fn project_field(
self,
ecx: &EvalContext<'a, 'mir, 'tcx, M>,
}
macro_rules! make_value_visitor {
- ($visitor_trait_name:ident, $($mutability:ident)*) => {
+ ($visitor_trait_name:ident, $($mutability:ident)?) => {
// How to traverse a value and what to do when we are at the leaves.
pub trait $visitor_trait_name<'a, 'mir, 'tcx: 'mir+'a, M: Machine<'a, 'mir, 'tcx>>: Sized {
type V: Value<'a, 'mir, 'tcx, M>;
/// The visitor must have an `EvalContext` in it.
- fn ecx(&$($mutability)* self)
- -> &$($mutability)* EvalContext<'a, 'mir, 'tcx, M>;
+ fn ecx(&$($mutability)? self)
+ -> &$($mutability)? EvalContext<'a, 'mir, 'tcx, M>;
// Recursive actions, ready to be overloaded.
- /// Visit the given value, dispatching as appropriate to more specialized visitors.
+ /// Visits the given value, dispatching as appropriate to more specialized visitors.
#[inline(always)]
fn visit_value(&mut self, v: Self::V) -> EvalResult<'tcx>
{
self.walk_value(v)
}
- /// Visit the given value as a union. No automatic recursion can happen here.
+ /// Visits the given value as a union. No automatic recursion can happen here.
#[inline(always)]
fn visit_union(&mut self, _v: Self::V) -> EvalResult<'tcx>
{
Ok(())
}
- /// Visit this vale as an aggregate, you are even getting an iterator yielding
+ /// Visits this vale as an aggregate, you are even getting an iterator yielding
/// all the fields (still in an `EvalResult`, you have to do error handling yourself).
/// Recurses into the fields.
#[inline(always)]
self.visit_value(new_val)
}
- /// Called for recursing into the field of a generator. These are not known to be
+ /// Called for recursing into the field of a generator. These are not known to be
/// initialized, so we treat them like unions.
#[inline(always)]
fn visit_generator_field(
fn visit_scalar(&mut self, _v: Self::V, _layout: &layout::Scalar) -> EvalResult<'tcx>
{ Ok(()) }
- /// Called whenever we reach a value of primitive type. There can be no recursion
- /// below such a value. This is the leaf function.
+ /// Called whenever we reach a value of primitive type. There can be no recursion
+ /// below such a value. This is the leaf function.
/// We do *not* provide an `ImmTy` here because some implementations might want
/// to write to the place this primitive lives in.
#[inline(always)]
#![feature(nll)]
#![feature(in_band_lifetimes)]
#![feature(slice_patterns)]
-#![feature(slice_sort_by_cached_key)]
#![feature(box_patterns)]
#![feature(box_syntax)]
#![feature(crate_visibility_modifier)]
#![feature(slice_concat_ext)]
#![feature(try_from)]
#![feature(reverse_bits)]
+#![feature(try_blocks)]
#![recursion_limit="256"]
-extern crate arena;
+#![deny(rust_2018_idioms)]
+#![allow(explicit_outlives_requirements)]
-#[macro_use]
-extern crate bitflags;
#[macro_use] extern crate log;
-extern crate either;
-extern crate graphviz as dot;
-extern crate polonius_engine;
#[macro_use]
extern crate rustc;
#[macro_use] extern crate rustc_data_structures;
-extern crate serialize as rustc_serialize;
-extern crate rustc_errors;
+#[allow(unused_extern_crates)]
+extern crate serialize as rustc_serialize; // used by deriving
#[macro_use]
extern crate syntax;
-extern crate syntax_pos;
-extern crate rustc_target;
-extern crate log_settings;
-extern crate rustc_apfloat;
-extern crate byteorder;
-extern crate core;
-extern crate smallvec;
-
-// Once we can use edition 2018 in the compiler,
-// replace this with real try blocks.
-macro_rules! try_block {
- ($($inside:tt)*) => (
- (||{ ::std::ops::Try::from_ok({ $($inside)* }) })()
- )
-}
mod diagnostics;
pub use hair::pattern::check_crate as matchck_crate;
use rustc::ty::query::Providers;
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
borrow_check::provide(providers);
shim::provide(providers);
transform::provide(providers);
}
fn check_fn_for_unconditional_recursion(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- fn_kind: FnKind,
+ fn_kind: FnKind<'_>,
mir: &Mir<'tcx>,
def_id: DefId) {
if let FnKind::Closure(_) = fn_kind {
use rustc::mir::mono::MonoItem;
use rustc::mir::interpret::{Scalar, GlobalId, AllocKind, ErrorHandled};
-use monomorphize::{self, Instance};
+use crate::monomorphize::{self, Instance};
use rustc::util::nodemap::{FxHashSet, FxHashMap, DefIdMap};
use rustc::util::common::time;
-use monomorphize::item::{MonoItemExt, DefPathBasedNames, InstantiationMode};
+use crate::monomorphize::item::{MonoItemExt, DefPathBasedNames, InstantiationMode};
use rustc_data_structures::bit_set::GrowableBitSet;
use rustc_data_structures::sync::{MTRef, MTLock, ParallelIterator, par_iter};
if recursion_depth > *tcx.sess.recursion_limit.get() {
let error = format!("reached the recursion limit while instantiating `{}`",
instance);
- if let Some(node_id) = tcx.hir().as_local_node_id(def_id) {
- tcx.sess.span_fatal(tcx.hir().span(node_id), &error);
+ if let Some(hir_id) = tcx.hir().as_local_hir_id(def_id) {
+ tcx.sess.span_fatal(tcx.hir().span_by_hir_id(hir_id), &error);
} else {
tcx.sess.fatal(&error);
}
let instance_name = instance.to_string();
let msg = format!("reached the type-length limit while instantiating `{:.64}...`",
instance_name);
- let mut diag = if let Some(node_id) = tcx.hir().as_local_node_id(instance.def_id()) {
- tcx.sess.struct_span_fatal(tcx.hir().span(node_id), &msg)
+ let mut diag = if let Some(hir_id) = tcx.hir().as_local_hir_id(instance.def_id()) {
+ tcx.sess.struct_span_fatal(tcx.hir().span_by_hir_id(hir_id), &msg)
} else {
tcx.sess.struct_fatal(&msg)
};
-use monomorphize::Instance;
+use crate::monomorphize::Instance;
use rustc::hir;
use rustc::hir::def_id::{DefId, LOCAL_CRATE};
use rustc::session::config::OptLevel;
codegen_fn_attrs.linkage
}
- /// Returns whether this instance is instantiable - whether it has no unsatisfied
+ /// Returns `true` if this instance is instantiable - whether it has no unsatisfied
/// predicates.
///
/// In order to codegen an item, all of its predicates must hold, because
use rustc::util::nodemap::{DefIdSet, FxHashMap, FxHashSet};
use rustc::mir::mono::MonoItem;
-use monomorphize::collector::InliningMap;
-use monomorphize::collector::{self, MonoItemCollectionMode};
-use monomorphize::item::{MonoItemExt, InstantiationMode};
+use crate::monomorphize::collector::InliningMap;
+use crate::monomorphize::collector::{self, MonoItemCollectionMode};
+use crate::monomorphize::item::{MonoItemExt, InstantiationMode};
pub use rustc::mir::mono::CodegenUnit;
pub enum PartitioningStrategy {
- /// Generate one codegen unit per source-level module.
+ /// Generates one codegen unit per source-level module.
PerModule,
/// Partition the whole crate into a fixed number of codegen units.
WorkProductId::from_cgu_name(&self.name().as_str())
}
- fn work_product(&self, tcx: TyCtxt) -> WorkProduct {
+ fn work_product(&self, tcx: TyCtxt<'_, '_, '_>) -> WorkProduct {
let work_product_id = self.work_product_id();
tcx.dep_graph
.previous_work_product(&work_product_id)
}
// Anything we can't find a proper codegen unit for goes into this.
-fn fallback_cgu_name(name_builder: &mut CodegenUnitNameBuilder) -> InternedString {
+fn fallback_cgu_name(name_builder: &mut CodegenUnitNameBuilder<'_, '_, '_>) -> InternedString {
name_builder.build_cgu_name(LOCAL_CRATE, &["fallback"], Some("cgu"))
}
}
}
-fn default_visibility(tcx: TyCtxt, id: DefId, is_generic: bool) -> Visibility {
+fn default_visibility(tcx: TyCtxt<'_, '_, '_>, id: DefId, is_generic: bool) -> Visibility {
if !tcx.sess.target.target.options.default_hidden_visibility {
return Visibility::Default
}
type CguNameCache = FxHashMap<(DefId, bool), InternedString>;
-fn compute_codegen_unit_name(tcx: TyCtxt,
- name_builder: &mut CodegenUnitNameBuilder,
+fn compute_codegen_unit_name(tcx: TyCtxt<'_, '_, '_>,
+ name_builder: &mut CodegenUnitNameBuilder<'_, '_, '_>,
def_id: DefId,
volatile: bool,
cache: &mut CguNameCache)
}).clone()
}
-fn numbered_codegen_unit_name(name_builder: &mut CodegenUnitNameBuilder,
+fn numbered_codegen_unit_name(name_builder: &mut CodegenUnitNameBuilder<'_, '_, '_>,
index: usize)
-> InternedString {
name_builder.build_cgu_name_no_mangle(LOCAL_CRATE, &["cgu"], Some(index))
tcx.sess.abort_if_errors();
- ::monomorphize::assert_symbols_are_distinct(tcx, items.iter());
+ crate::monomorphize::assert_symbols_are_distinct(tcx, items.iter());
let strategy = if tcx.sess.opts.incremental.is_some() {
PartitioningStrategy::PerModule
(Arc::new(mono_items), Arc::new(codegen_units))
}
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
providers.collect_and_partition_mono_items =
collect_and_partition_mono_items;
use std::fmt;
use std::iter;
-use transform::{add_moves_for_packed_drops, add_call_guards};
-use transform::{remove_noop_landing_pads, no_landing_pads, simplify};
-use util::elaborate_drops::{self, DropElaborator, DropStyle, DropFlagMode};
-use util::patch::MirPatch;
-
-pub fn provide(providers: &mut Providers) {
+use crate::transform::{
+ add_moves_for_packed_drops, add_call_guards,
+ remove_noop_landing_pads, no_landing_pads, simplify, run_passes
+};
+use crate::util::elaborate_drops::{self, DropElaborator, DropStyle, DropFlagMode};
+use crate::util::patch::MirPatch;
+
+pub fn provide(providers: &mut Providers<'_>) {
providers.mir_shims = make_shim;
}
}
};
debug!("make_shim({:?}) = untransformed {:?}", instance, result);
- add_moves_for_packed_drops::add_moves_for_packed_drops(
- tcx, &mut result, instance.def_id());
- no_landing_pads::no_landing_pads(tcx, &mut result);
- remove_noop_landing_pads::remove_noop_landing_pads(tcx, &mut result);
- simplify::simplify_cfg(&mut result);
- add_call_guards::CriticalCallEdges.add_call_guards(&mut result);
+
+ run_passes(tcx, &mut result, instance, MirPhase::Const, &[
+ &add_moves_for_packed_drops::AddMovesForPackedDrops,
+ &no_landing_pads::NoLandingPads,
+ &remove_noop_landing_pads::RemoveNoopLandingPads,
+ &simplify::SimplifyCfg::new("make_shim"),
+ &add_call_guards::CriticalCallEdges,
+ ]);
+
debug!("make_shim({:?}) = {:?}", instance, result);
tcx.alloc_mir(result)
Direct(DefId),
}
-fn temp_decl(mutability: Mutability, ty: Ty, span: Span) -> LocalDecl {
+fn temp_decl(mutability: Mutability, ty: Ty<'_>, span: Span) -> LocalDecl<'_> {
let source_info = SourceInfo { scope: OUTERMOST_SOURCE_SCOPE, span };
LocalDecl {
mutability,
}
impl<'a, 'tcx> fmt::Debug for DropShimElaborator<'a, 'tcx> {
- fn fmt(&self, _f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
Ok(())
}
}
}
}
-/// Build a `Clone::clone` shim for `self_ty`. Here, `def_id` is `Clone::clone`.
+/// Builds a `Clone::clone` shim for `self_ty`. Here, `def_id` is `Clone::clone`.
fn build_clone_shim<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId,
self_ty: Ty<'tcx>)
span: self.span,
ty: func_ty,
user_ty: None,
- literal: tcx.intern_lazy_const(ty::LazyConst::Evaluated(
+ literal: tcx.mk_lazy_const(ty::LazyConst::Evaluated(
ty::Const::zero_sized(func_ty),
)),
});
span: self.span,
ty: self.tcx.types.usize,
user_ty: None,
- literal: self.tcx.intern_lazy_const(ty::LazyConst::Evaluated(
+ literal: self.tcx.mk_lazy_const(ty::LazyConst::Evaluated(
ty::Const::from_usize(self.tcx, value),
)),
}
}
}
-/// Build a "call" shim for `def_id`. The shim calls the
+/// Builds a "call" shim for `def_id`. The shim calls the
/// function specified by `call_kind`, first adjusting its first
/// argument according to `rcvr_adjustment`.
///
span,
ty,
user_ty: None,
- literal: tcx.intern_lazy_const(ty::LazyConst::Evaluated(
+ literal: tcx.mk_lazy_const(ty::LazyConst::Evaluated(
ty::Const::zero_sized(ty)
)),
}),
use rustc::ty::TyCtxt;
use rustc::mir::*;
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
#[derive(PartialEq)]
pub enum AddCallGuards {
impl MirPass for AddCallGuards {
fn run_pass<'a, 'tcx>(&self,
_tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _src: MirSource,
+ _src: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
self.add_call_guards(mir);
}
}
impl AddCallGuards {
- pub fn add_call_guards(&self, mir: &mut Mir) {
+ pub fn add_call_guards(&self, mir: &mut Mir<'_>) {
let pred_count: IndexVec<_, _> =
mir.predecessors().iter().map(|ps| ps.len()).collect();
use rustc::mir::*;
use rustc::ty::TyCtxt;
-use transform::{MirPass, MirSource};
-use util::patch::MirPatch;
-use util;
+use crate::transform::{MirPass, MirSource};
+use crate::util::patch::MirPatch;
+use crate::util;
// This pass moves values being dropped that are within a packed
// struct to a separate local before dropping them, to ensure that
impl MirPass for AddMovesForPackedDrops {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- src: MirSource,
+ src: MirSource<'tcx>,
mir: &mut Mir<'tcx>)
{
debug!("add_moves_for_packed_drops({:?} @ {:?})", src, mir.span);
- add_moves_for_packed_drops(tcx, mir, src.def_id);
+ add_moves_for_packed_drops(tcx, mir, src.def_id());
}
}
use rustc::ty::{self, Ty, TyCtxt};
use rustc::mir::*;
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
pub struct AddRetag;
impl MirPass for AddRetag {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _src: MirSource,
+ _src: MirSource<'tcx>,
mir: &mut Mir<'tcx>)
{
if !tcx.sess.opts.debugging_opts.mir_emit_retag {
use std::ops::Bound;
-use util;
+use crate::util;
pub struct UnsafetyChecker<'a, 'tcx: 'a> {
mir: &'a Mir<'tcx>,
source_info: SourceInfo,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
- /// mark an `unsafe` block as used, so we don't lint it
+ /// Mark an `unsafe` block as used, so we don't lint it.
used_unsafe: FxHashSet<ast::NodeId>,
inherited_blocks: Vec<(ast::NodeId, bool)>,
}
}
}
-pub(crate) fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers<'_>) {
*providers = Providers {
unsafety_check_result,
unsafe_derive_on_repr_packed,
&message);
}
-/// Return the NodeId for an enclosing scope that is also `unsafe`
-fn is_enclosed(tcx: TyCtxt,
+/// Returns the `NodeId` for an enclosing scope that is also `unsafe`.
+fn is_enclosed(tcx: TyCtxt<'_, '_, '_>,
used_unsafe: &FxHashSet<ast::NodeId>,
id: ast::NodeId) -> Option<(String, ast::NodeId)> {
let parent_id = tcx.hir().get_parent_node(id);
}
}
-fn report_unused_unsafe(tcx: TyCtxt, used_unsafe: &FxHashSet<ast::NodeId>, id: ast::NodeId) {
+fn report_unused_unsafe(tcx: TyCtxt<'_, '_, '_>,
+ used_unsafe: &FxHashSet<ast::NodeId>,
+ id: ast::NodeId) {
let span = tcx.sess.source_map().def_span(tcx.hir().span(id));
let msg = "unnecessary `unsafe` block";
let mut db = tcx.struct_span_lint_node(UNUSED_UNSAFE, id, span, msg);
use rustc::mir::{Statement, StatementKind};
use rustc::mir::visit::MutVisitor;
use rustc::ty::TyCtxt;
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
pub struct CleanAscribeUserType;
impl MirPass for CleanAscribeUserType {
fn run_pass<'a, 'tcx>(&self,
_tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _source: MirSource,
+ _source: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
let mut delete = DeleteAscribeUserType;
delete.visit_mir(mir);
impl MirPass for CleanFakeReadsAndBorrows {
fn run_pass<'a, 'tcx>(&self,
_tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _source: MirSource,
+ _source: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
let mut delete_reads = DeleteAndRecordFakeReads::default();
delete_reads.visit_mir(mir);
HasTyCtxt, TargetDataLayout, HasDataLayout,
};
-use interpret::{self, EvalContext, ScalarMaybeUndef, Immediate, OpTy, MemoryKind};
-use const_eval::{
+use crate::interpret::{EvalContext, ScalarMaybeUndef, Immediate, OpTy, ImmTy, MemoryKind};
+use crate::const_eval::{
CompileTimeInterpreter, error_to_const_error, eval_promoted, mk_eval_cx,
- lazy_const_to_op,
};
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
pub struct ConstProp;
impl MirPass for ConstProp {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
// will be evaluated by miri and produce its errors there
if source.promoted.is_some() {
}
use rustc::hir::map::blocks::FnLikeNode;
- let node_id = tcx.hir().as_local_node_id(source.def_id)
+ let node_id = tcx.hir().as_local_node_id(source.def_id())
.expect("Non-local call to local provider is_const_fn");
let is_fn_like = FnLikeNode::from_node(tcx.hir().get(node_id)).is_some();
- let is_assoc_const = match tcx.describe_def(source.def_id) {
+ let is_assoc_const = match tcx.describe_def(source.def_id()) {
Some(Def::AssociatedConst(_)) => true,
_ => false,
};
// Only run const prop on functions, methods, closures and associated constants
if !is_fn_like && !is_assoc_const {
// skip anon_const/statics/consts because they'll be evaluated by miri anyway
- trace!("ConstProp skipped for {:?}", source.def_id);
+ trace!("ConstProp skipped for {:?}", source.def_id());
return
}
- trace!("ConstProp starting for {:?}", source.def_id);
+ trace!("ConstProp starting for {:?}", source.def_id());
// FIXME(oli-obk, eddyb) Optimize locals (or even local paths) to hold
// constants, instead of just checking for const-folding succeeding.
let mut optimization_finder = ConstPropagator::new(mir, tcx, source);
optimization_finder.visit_mir(mir);
- trace!("ConstProp done for {:?}", source.def_id);
+ trace!("ConstProp done for {:?}", source.def_id());
}
}
ecx: EvalContext<'a, 'mir, 'tcx, CompileTimeInterpreter<'a, 'mir, 'tcx>>,
mir: &'mir Mir<'tcx>,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- source: MirSource,
+ source: MirSource<'tcx>,
places: IndexVec<Local, Option<Const<'tcx>>>,
can_const_prop: IndexVec<Local, bool>,
param_env: ParamEnv<'tcx>,
fn new(
mir: &'mir Mir<'tcx>,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- source: MirSource,
+ source: MirSource<'tcx>,
) -> ConstPropagator<'a, 'mir, 'tcx> {
- let param_env = tcx.param_env(source.def_id);
- let ecx = mk_eval_cx(tcx, tcx.def_span(source.def_id), param_env);
+ let param_env = tcx.param_env(source.def_id());
+ let ecx = mk_eval_cx(tcx, tcx.def_span(source.def_id()), param_env);
ConstPropagator {
ecx,
mir,
source_info: SourceInfo,
) -> Option<Const<'tcx>> {
self.ecx.tcx.span = source_info.span;
- match lazy_const_to_op(&self.ecx, *c.literal, c.ty) {
+ match self.ecx.lazy_const_to_op(*c.literal, c.ty) {
Ok(op) => {
Some((op, c.span))
},
_ => None,
},
Place::Promoted(ref promoted) => {
- let generics = self.tcx.generics_of(self.source.def_id);
+ let generics = self.tcx.generics_of(self.source.def_id());
if generics.requires_monomorphization(self.tcx) {
// FIXME: can't handle code with generics
return None;
}
- let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
- let instance = Instance::new(self.source.def_id, substs);
+ let substs = Substs::identity_for_item(self.tcx, self.source.def_id());
+ let instance = Instance::new(self.source.def_id(), substs);
let cid = GlobalId {
instance,
promoted: Some(promoted.0),
Rvalue::Len(_) => None,
Rvalue::NullaryOp(NullOp::SizeOf, ty) => {
type_size_of(self.tcx, self.param_env, ty).and_then(|n| Some((
- OpTy {
- op: interpret::Operand::Immediate(Immediate::Scalar(
+ ImmTy {
+ imm: Immediate::Scalar(
Scalar::Bits {
bits: n as u128,
size: self.tcx.data_layout.pointer_size.bytes() as u8,
}.into()
- )),
+ ),
layout: self.tcx.layout_of(self.param_env.and(self.tcx.types.usize)).ok()?,
- },
+ }.into(),
span,
)))
}
Rvalue::UnaryOp(op, ref arg) => {
- let def_id = if self.tcx.is_closure(self.source.def_id) {
- self.tcx.closure_base_def_id(self.source.def_id)
+ let def_id = if self.tcx.is_closure(self.source.def_id()) {
+ self.tcx.closure_base_def_id(self.source.def_id())
} else {
- self.source.def_id
+ self.source.def_id()
};
let generics = self.tcx.generics_of(def_id);
if generics.requires_monomorphization(self.tcx) {
let (arg, _) = self.eval_operand(arg, source_info)?;
let val = self.use_ecx(source_info, |this| {
- let prim = this.ecx.read_scalar(arg)?.not_undef()?;
+ let prim = this.ecx.read_immediate(arg)?;
match op {
UnOp::Neg => {
// Need to do overflow check here: For actual CTFE, MIR
// generation emits code that does this before calling the op.
- let size = arg.layout.size;
- if prim.to_bits(size)? == (1 << (size.bits() - 1)) {
+ if prim.to_bits()? == (1 << (prim.layout.size.bits() - 1)) {
return err!(OverflowNeg);
}
}
}
}
// Now run the actual operation.
- this.ecx.unary_op(op, prim, arg.layout)
+ this.ecx.unary_op(op, prim)
})?;
- let res = OpTy {
- op: interpret::Operand::Immediate(Immediate::Scalar(val.into())),
+ let res = ImmTy {
+ imm: Immediate::Scalar(val.into()),
layout: place_layout,
};
- Some((res, span))
+ Some((res.into(), span))
}
Rvalue::CheckedBinaryOp(op, ref left, ref right) |
Rvalue::BinaryOp(op, ref left, ref right) => {
trace!("rvalue binop {:?} for {:?} and {:?}", op, left, right);
let right = self.eval_operand(right, source_info)?;
- let def_id = if self.tcx.is_closure(self.source.def_id) {
- self.tcx.closure_base_def_id(self.source.def_id)
+ let def_id = if self.tcx.is_closure(self.source.def_id()) {
+ self.tcx.closure_base_def_id(self.source.def_id())
} else {
- self.source.def_id
+ self.source.def_id()
};
let generics = self.tcx.generics_of(def_id);
if generics.requires_monomorphization(self.tcx) {
})?;
trace!("const evaluating {:?} for {:?} and {:?}", op, left, right);
let (val, overflow) = self.use_ecx(source_info, |this| {
- this.ecx.binary_op_imm(op, l, r)
+ this.ecx.binary_op(op, l, r)
})?;
let val = if let Rvalue::CheckedBinaryOp(..) = *rvalue {
Immediate::ScalarPair(
}
Immediate::Scalar(val.into())
};
- let res = OpTy {
- op: interpret::Operand::Immediate(val),
+ let res = ImmTy {
+ imm: val,
layout: place_layout,
};
- Some((res, span))
+ Some((res.into(), span))
},
}
}
impl CanConstProp {
/// returns true if `local` can be propagated
- fn check(mir: &Mir) -> IndexVec<Local, bool> {
+ fn check(mir: &Mir<'_>) -> IndexVec<Local, bool> {
let mut cpv = CanConstProp {
can_const_prop: IndexVec::from_elem(true, &mir.local_decls),
found_assignment: IndexVec::from_elem(false, &mir.local_decls),
let node_id = self
.tcx
.hir()
- .as_local_node_id(self.source.def_id)
+ .as_local_node_id(self.source.def_id())
.expect("some part of a failing const eval must be local");
use rustc::mir::interpret::EvalErrorKind::*;
let msg = match msg {
use rustc::mir::{Constant, Local, LocalKind, Location, Place, Mir, Operand, Rvalue, StatementKind};
use rustc::mir::visit::MutVisitor;
use rustc::ty::TyCtxt;
-use transform::{MirPass, MirSource};
-use util::def_use::DefUseAnalysis;
+use crate::transform::{MirPass, MirSource};
+use crate::util::def_use::DefUseAnalysis;
pub struct CopyPropagation;
impl MirPass for CopyPropagation {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _source: MirSource,
+ _source: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
// We only run when the MIR optimization level is > 1.
// This avoids a slow pass, and messing up debug info.
}
impl<'tcx> Action<'tcx> {
- fn local_copy(mir: &Mir<'tcx>, def_use_analysis: &DefUseAnalysis, src_place: &Place<'tcx>)
+ fn local_copy(mir: &Mir<'tcx>, def_use_analysis: &DefUseAnalysis<'_>, src_place: &Place<'tcx>)
-> Option<Action<'tcx>> {
// The source must be a local.
let src_local = if let Place::Local(local) = *src_place {
use rustc::ty::TyCtxt;
use rustc::mir::*;
use rustc_data_structures::indexed_vec::Idx;
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
pub struct Deaggregator;
impl MirPass for Deaggregator {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _source: MirSource,
+ _source: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
let (basic_blocks, local_decls) = mir.basic_blocks_and_local_decls_mut();
let local_decls = &*local_decls;
use rustc::mir::Mir;
use rustc::session::config::{OutputFilenames, OutputType};
use rustc::ty::TyCtxt;
-use transform::{MirPass, MirSource};
-use util as mir_util;
+use crate::transform::{MirPass, MirSource};
+use crate::util as mir_util;
pub struct Marker(pub &'static str);
fn run_pass<'a, 'tcx>(&self,
_tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _source: MirSource,
+ _source: MirSource<'tcx>,
_mir: &mut Mir<'tcx>)
{
}
}
impl fmt::Display for Disambiguator {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
let title = if self.is_after { "after" } else { "before" };
write!(formatter, "{}", title)
}
pub fn on_mir_pass<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
pass_num: &dyn fmt::Display,
pass_name: &str,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &Mir<'tcx>,
is_after: bool) {
if mir_util::dump_enabled(tcx, pass_name, source) {
-use dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex, LookupResult};
-use dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces};
-use dataflow::{DataflowResults};
-use dataflow::{on_all_children_bits, on_all_drop_children_bits};
-use dataflow::{drop_flag_effects_for_location, on_lookup_result_bits};
-use dataflow::MoveDataParamEnv;
-use dataflow::{self, do_dataflow, DebugFormatted};
+use crate::dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex, LookupResult};
+use crate::dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces};
+use crate::dataflow::{DataflowResults};
+use crate::dataflow::{on_all_children_bits, on_all_drop_children_bits};
+use crate::dataflow::{drop_flag_effects_for_location, on_lookup_result_bits};
+use crate::dataflow::MoveDataParamEnv;
+use crate::dataflow::{self, do_dataflow, DebugFormatted};
+use crate::transform::{MirPass, MirSource};
+use crate::util::patch::MirPatch;
+use crate::util::elaborate_drops::{DropFlagState, Unwind, elaborate_drop};
+use crate::util::elaborate_drops::{DropElaborator, DropStyle, DropFlagMode};
use rustc::ty::{self, TyCtxt};
use rustc::ty::layout::VariantIdx;
use rustc::mir::*;
use std::fmt;
use syntax::ast;
use syntax_pos::Span;
-use transform::{MirPass, MirSource};
-use util::patch::MirPatch;
-use util::elaborate_drops::{DropFlagState, Unwind, elaborate_drop};
-use util::elaborate_drops::{DropElaborator, DropStyle, DropFlagMode};
pub struct ElaborateDrops;
impl MirPass for ElaborateDrops {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- src: MirSource,
+ src: MirSource<'tcx>,
mir: &mut Mir<'tcx>)
{
debug!("elaborate_drops({:?} @ {:?})", src, mir.span);
- let id = tcx.hir().as_local_node_id(src.def_id).unwrap();
- let param_env = tcx.param_env(src.def_id).with_reveal_all();
+ let id = tcx.hir().as_local_node_id(src.def_id()).unwrap();
+ let param_env = tcx.param_env(src.def_id()).with_reveal_all();
let move_data = match MoveData::gather_moves(mir, tcx) {
Ok(move_data) => move_data,
Err((move_data, _move_errors)) => {
}
}
-/// Return the set of basic blocks whose unwind edges are known
+/// Returns the set of basic blocks whose unwind edges are known
/// to not be reachable, because they are `drop` terminators
/// that can't drop anything.
fn find_dead_unwinds<'a, 'tcx>(
}
impl<'a, 'b, 'tcx> fmt::Debug for Elaborator<'a, 'b, 'tcx> {
- fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
Ok(())
}
}
span,
ty: self.tcx.types.bool,
user_ty: None,
- literal: self.tcx.intern_lazy_const(ty::LazyConst::Evaluated(
+ literal: self.tcx.mk_lazy_const(ty::LazyConst::Evaluated(
ty::Const::from_bool(self.tcx, val),
)),
})))
//! This pass erases all early-bound regions from the types occurring in the MIR.
//! We want to do this once just before codegen, so codegen does not have to take
//! care erasing regions all over the place.
-//! NOTE: We do NOT erase regions of statements that are relevant for
-//! "types-as-contracts"-validation, namely, AcquireValid, ReleaseValid
+//! N.B., we do _not_ erase regions of statements that are relevant for
+//! "types-as-contracts"-validation, namely, `AcquireValid` and `ReleaseValid`.
use rustc::ty::subst::Substs;
use rustc::ty::{self, Ty, TyCtxt};
use rustc::mir::*;
use rustc::mir::visit::{MutVisitor, TyContext};
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
struct EraseRegionsVisitor<'a, 'tcx: 'a> {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
impl MirPass for EraseRegions {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _: MirSource,
+ _: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
EraseRegionsVisitor::new(tcx).visit_mir(mir);
}
use rustc::ty::{self, TyCtxt, AdtDef, Ty};
use rustc::ty::layout::VariantIdx;
use rustc::ty::subst::Substs;
-use util::dump_mir;
-use util::liveness::{self, IdentityMap};
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::indexed_vec::Idx;
use rustc_data_structures::bit_set::BitSet;
use std::borrow::Cow;
use std::iter::once;
use std::mem;
-use transform::{MirPass, MirSource};
-use transform::simplify;
-use transform::no_landing_pads::no_landing_pads;
-use dataflow::{do_dataflow, DebugFormatted, state_for_location};
-use dataflow::{MaybeStorageLive, HaveBeenBorrowedLocals};
+use crate::transform::{MirPass, MirSource};
+use crate::transform::simplify;
+use crate::transform::no_landing_pads::no_landing_pads;
+use crate::dataflow::{do_dataflow, DebugFormatted, state_for_location};
+use crate::dataflow::{MaybeStorageLive, HaveBeenBorrowedLocals};
+use crate::util::dump_mir;
+use crate::util::liveness::{self, IdentityMap};
pub struct StateTransform;
span: source_info.span,
ty: self.tcx.types.u32,
user_ty: None,
- literal: self.tcx.intern_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bits(
+ literal: self.tcx.mk_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bits(
self.tcx,
state_disc.into(),
ty::ParamEnv::empty().and(self.tcx.types.u32)
fn locals_live_across_suspend_points(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
mir: &Mir<'tcx>,
- source: MirSource,
+ source: MirSource<'tcx>,
movable: bool,
) -> (
liveness::LiveVarSet<Local>,
FxHashMap<BasicBlock, liveness::LiveVarSet<Local>>,
) {
let dead_unwinds = BitSet::new_empty(mir.basic_blocks().len());
- let node_id = tcx.hir().as_local_node_id(source.def_id).unwrap();
+ let node_id = tcx.hir().as_local_node_id(source.def_id()).unwrap();
// Calculate when MIR locals have live storage. This gives us an upper bound of their
// lifetimes.
}
fn compute_layout<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- source: MirSource,
+ source: MirSource<'tcx>,
upvars: Vec<Ty<'tcx>>,
interior: Ty<'tcx>,
movable: bool,
fn elaborate_generator_drops<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId,
mir: &mut Mir<'tcx>) {
- use util::elaborate_drops::{elaborate_drop, Unwind};
- use util::patch::MirPatch;
- use shim::DropShimElaborator;
+ use crate::util::elaborate_drops::{elaborate_drop, Unwind};
+ use crate::util::patch::MirPatch;
+ use crate::shim::DropShimElaborator;
// Note that `elaborate_drops` only drops the upvars of a generator, and
// this is ok because `open_drop` can only be reached within that own
tcx: TyCtxt<'a, 'tcx, 'tcx>,
transform: &TransformVisitor<'a, 'tcx>,
def_id: DefId,
- source: MirSource,
+ source: MirSource<'tcx>,
gen_ty: Ty<'tcx>,
mir: &Mir<'tcx>,
drop_clean: BasicBlock) -> Mir<'tcx> {
span: mir.span,
ty: tcx.types.bool,
user_ty: None,
- literal: tcx.intern_lazy_const(ty::LazyConst::Evaluated(
+ literal: tcx.mk_lazy_const(ty::LazyConst::Evaluated(
ty::Const::from_bool(tcx, false),
)),
}),
tcx: TyCtxt<'a, 'tcx, 'tcx>,
transform: TransformVisitor<'a, 'tcx>,
def_id: DefId,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
// Poison the generator when it unwinds
for block in mir.basic_blocks_mut() {
impl MirPass for StateTransform {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
let yield_ty = if let Some(yield_ty) = mir.yield_ty {
yield_ty
assert!(mir.generator_drop.is_none());
- let def_id = source.def_id;
+ let def_id = source.def_id();
// The first argument is the generator type passed by value
let gen_ty = mir.local_decls.raw[1].ty;
use std::collections::VecDeque;
use std::iter;
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
use super::simplify::{remove_dead_blocks, CfgSimplifier};
-use syntax::{attr};
+use syntax::attr;
use rustc_target::spec::abi::Abi;
const DEFAULT_THRESHOLD: usize = 50;
impl MirPass for Inline {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
if tcx.sess.opts.debugging_opts.mir_opt_level >= 2 {
Inliner { tcx, source }.run_pass(mir);
struct Inliner<'a, 'tcx: 'a> {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- source: MirSource,
+ source: MirSource<'tcx>,
}
impl<'a, 'tcx> Inliner<'a, 'tcx> {
let mut callsites = VecDeque::new();
- let param_env = self.tcx.param_env(self.source.def_id);
+ let param_env = self.tcx.param_env(self.source.def_id());
// Only do inlining into fn bodies.
- let id = self.tcx.hir().as_local_node_id(self.source.def_id).unwrap();
+ let id = self.tcx.hir().as_local_node_id(self.source.def_id()).unwrap();
if self.tcx.hir().body_owner_kind(id).is_fn_or_closure() && self.source.promoted.is_none() {
for (bb, bb_data) in caller_mir.basic_blocks().iter_enumerated() {
if let Some(callsite) = self.get_valid_function_call(bb,
// FIXME: Give a bonus to functions with only a single caller
- let param_env = tcx.param_env(self.source.def_id);
+ let param_env = tcx.param_env(self.source.def_id());
let mut first_block = true;
let mut cost = 0;
// Place could result in two different locations if `f`
// writes to `i`. To prevent this we need to create a temporary
// borrow of the place and pass the destination as `*temp` instead.
- fn dest_needs_borrow(place: &Place) -> bool {
+ fn dest_needs_borrow(place: &Place<'_>) -> bool {
match *place {
Place::Projection(ref p) => {
match p.elem {
use rustc::util::nodemap::{FxHashMap, FxHashSet};
use rustc_data_structures::indexed_vec::Idx;
use std::mem;
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
pub struct InstCombine;
impl MirPass for InstCombine {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _: MirSource,
+ _: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
// We only run when optimizing MIR (at any level).
if tcx.sess.opts.debugging_opts.mir_opt_level == 0 {
use rustc::mir::*;
use rustc::ty::{List, Ty, TyCtxt, TyKind};
use rustc_data_structures::indexed_vec::{Idx};
-use transform::{MirPass, MirSource};
-use syntax;
+use crate::transform::{MirPass, MirSource};
pub struct Lower128Bit;
impl MirPass for Lower128Bit {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _src: MirSource,
+ _src: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
let debugging_override = tcx.sess.opts.debugging_opts.lower_128bit_ops;
let target_default = tcx.sess.host.options.i128_lowering;
}
}
-fn sign_of_128bit(ty: Ty) -> Option<bool> {
+fn sign_of_128bit(ty: Ty<'_>) -> Option<bool> {
match ty.sty {
TyKind::Int(syntax::ast::IntTy::I128) => Some(true),
TyKind::Uint(syntax::ast::UintTy::U128) => Some(false),
-use borrow_check::nll::type_check;
-use build;
+use crate::borrow_check::nll::type_check;
+use crate::build;
use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
use rustc::mir::{Mir, MirPhase, Promoted};
-use rustc::ty::TyCtxt;
+use rustc::ty::{TyCtxt, InstanceDef};
use rustc::ty::query::Providers;
use rustc::ty::steal::Steal;
use rustc::hir;
pub mod lower_128bit;
pub mod uniform_array_move_out;
-pub(crate) fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers<'_>) {
self::qualify_consts::provide(providers);
self::check_unsafety::provide(providers);
*providers = Providers {
tcx.mir_keys(def_id.krate).contains(&def_id)
}
-/// Finds the full set of def-ids within the current crate that have
+/// Finds the full set of `DefId`s within the current crate that have
/// MIR associated with them.
fn mir_keys<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, krate: CrateNum)
-> Lrc<DefIdSet> {
/// Where a specific Mir comes from.
#[derive(Debug, Copy, Clone)]
-pub struct MirSource {
- pub def_id: DefId,
+pub struct MirSource<'tcx> {
+ pub instance: InstanceDef<'tcx>,
/// If `Some`, this is a promoted rvalue within the parent function.
pub promoted: Option<Promoted>,
}
-impl MirSource {
+impl<'tcx> MirSource<'tcx> {
pub fn item(def_id: DefId) -> Self {
MirSource {
- def_id,
+ instance: InstanceDef::Item(def_id),
promoted: None
}
}
+
+ #[inline]
+ pub fn def_id(&self) -> DefId {
+ self.instance.def_id()
+ }
}
/// Generates a default name for the pass based on the name of the
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &mut Mir<'tcx>);
}
pub fn run_passes(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
mir: &mut Mir<'tcx>,
- def_id: DefId,
+ instance: InstanceDef<'tcx>,
mir_phase: MirPhase,
passes: &[&dyn MirPass],
) {
}
let source = MirSource {
- def_id,
+ instance,
promoted,
};
let mut index = 0;
let _ = tcx.unsafety_check_result(def_id);
let mut mir = tcx.mir_built(def_id).steal();
- run_passes(tcx, &mut mir, def_id, MirPhase::Const, &[
+ run_passes(tcx, &mut mir, InstanceDef::Item(def_id), MirPhase::Const, &[
// What we need to do constant evaluation.
&simplify::SimplifyCfg::new("initial"),
&type_check::TypeckMir,
}
let mut mir = tcx.mir_const(def_id).steal();
- run_passes(tcx, &mut mir, def_id, MirPhase::Validated, &[
+ run_passes(tcx, &mut mir, InstanceDef::Item(def_id), MirPhase::Validated, &[
// What we need to run borrowck etc.
&qualify_consts::QualifyAndPromoteConstants,
&simplify::SimplifyCfg::new("qualify-consts"),
}
let mut mir = tcx.mir_validated(def_id).steal();
- run_passes(tcx, &mut mir, def_id, MirPhase::Optimized, &[
+ run_passes(tcx, &mut mir, InstanceDef::Item(def_id), MirPhase::Optimized, &[
// Remove all things not needed by analysis
&no_landing_pads::NoLandingPads,
&simplify_branches::SimplifyBranches::new("initial"),
use rustc::ty::TyCtxt;
use rustc::mir::*;
use rustc::mir::visit::MutVisitor;
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
pub struct NoLandingPads;
impl MirPass for NoLandingPads {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _: MirSource,
+ _: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
no_landing_pads(tcx, mir)
}
}
}
-pub fn collect_temps(mir: &Mir, rpo: &mut ReversePostorder) -> IndexVec<Local, TempState> {
+pub fn collect_temps(mir: &Mir<'_>,
+ rpo: &mut ReversePostorder<'_, '_>) -> IndexVec<Local, TempState> {
let mut collector = TempCollector {
temps: IndexVec::from_elem(TempState::Undefined, &mir.local_decls),
span: mir.span,
});
}
- /// Copy the initialization of this temp to the
+ /// Copies the initialization of this temp to the
/// promoted MIR, recursing through temps.
fn promote_temp(&mut self, temp: Local) -> Local {
let old_keep_original = self.keep_original;
use rustc::middle::lang_items;
use rustc::session::config::nightly_options;
use syntax::ast::LitKind;
-use syntax::feature_gate::{UnstableFeatures, emit_feature_err, GateIssue};
+use syntax::feature_gate::{emit_feature_err, GateIssue};
use syntax_pos::{Span, DUMMY_SP};
use std::fmt;
+use std::ops::{Deref, Index, IndexMut};
use std::usize;
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
use super::promote_consts::{self, Candidate, TempState};
-bitflags! {
- // Borrows of temporaries can be promoted only if
- // they have none of these qualifications, with
- // the exception of `STATIC_REF` (in statics only).
- struct Qualif: u8 {
- // Constant containing interior mutability (UnsafeCell).
- const MUTABLE_INTERIOR = 1 << 0;
-
- // Constant containing an ADT that implements Drop.
- const NEEDS_DROP = 1 << 1;
-
- // Function argument.
- const FN_ARGUMENT = 1 << 2;
-
- // Not constant at all - non-`const fn` calls, asm!,
- // pointer comparisons, ptr-to-int casts, etc.
- const NOT_CONST = 1 << 3;
-
- // Refers to temporaries which cannot be promoted as
- // promote_consts decided they weren't simple enough.
- const NOT_PROMOTABLE = 1 << 4;
-
- // Const items can only have MUTABLE_INTERIOR
- // and NOT_PROMOTABLE without producing an error.
- const CONST_ERROR = !Qualif::MUTABLE_INTERIOR.bits &
- !Qualif::NOT_PROMOTABLE.bits;
- }
-}
-
-impl<'a, 'tcx> Qualif {
- /// Remove flags which are impossible for the given type.
- fn restrict(&mut self, ty: Ty<'tcx>,
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- param_env: ty::ParamEnv<'tcx>) {
- if ty.is_freeze(tcx, param_env, DUMMY_SP) {
- *self = *self - Qualif::MUTABLE_INTERIOR;
- }
- if !ty.needs_drop(tcx, param_env) {
- *self = *self - Qualif::NEEDS_DROP;
- }
- }
-}
-
/// What kind of item we are in.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
enum Mode {
}
impl fmt::Display for Mode {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Mode::Const => write!(f, "constant"),
Mode::Static | Mode::StaticMut => write!(f, "static"),
}
}
-struct Qualifier<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
+const QUALIF_COUNT: usize = 4;
+
+// FIXME(eddyb) once we can use const generics, replace this array with
+// something like `IndexVec` but for fixed-size arrays (`IndexArray`?).
+#[derive(Copy, Clone, Default)]
+struct PerQualif<T>([T; QUALIF_COUNT]);
+
+impl<T: Clone> PerQualif<T> {
+ fn new(x: T) -> Self {
+ PerQualif([x.clone(), x.clone(), x.clone(), x])
+ }
+}
+
+impl<T> PerQualif<T> {
+ fn as_mut(&mut self) -> PerQualif<&mut T> {
+ let [x0, x1, x2, x3] = &mut self.0;
+ PerQualif([x0, x1, x2, x3])
+ }
+
+ fn zip<U>(self, other: PerQualif<U>) -> PerQualif<(T, U)> {
+ let [x0, x1, x2, x3] = self.0;
+ let [y0, y1, y2, y3] = other.0;
+ PerQualif([(x0, y0), (x1, y1), (x2, y2), (x3, y3)])
+ }
+}
+
+impl PerQualif<bool> {
+ fn encode_to_bits(self) -> u8 {
+ self.0.iter().enumerate().fold(0, |bits, (i, &qualif)| {
+ bits | ((qualif as u8) << i)
+ })
+ }
+
+ fn decode_from_bits(bits: u8) -> Self {
+ let mut qualifs = Self::default();
+ for (i, qualif) in qualifs.0.iter_mut().enumerate() {
+ *qualif = (bits & (1 << i)) != 0;
+ }
+ qualifs
+ }
+}
+
+impl<Q: Qualif, T> Index<Q> for PerQualif<T> {
+ type Output = T;
+
+ fn index(&self, _: Q) -> &T {
+ &self.0[Q::IDX]
+ }
+}
+
+impl<Q: Qualif, T> IndexMut<Q> for PerQualif<T> {
+ fn index_mut(&mut self, _: Q) -> &mut T {
+ &mut self.0[Q::IDX]
+ }
+}
+
+struct ConstCx<'a, 'tcx> {
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ param_env: ty::ParamEnv<'tcx>,
mode: Mode,
+ mir: &'a Mir<'tcx>,
+
+ per_local: PerQualif<BitSet<Local>>,
+}
+
+impl<'a, 'tcx> ConstCx<'a, 'tcx> {
+ fn is_const_panic_fn(&self, def_id: DefId) -> bool {
+ Some(def_id) == self.tcx.lang_items().panic_fn() ||
+ Some(def_id) == self.tcx.lang_items().begin_panic_fn()
+ }
+}
+
+#[derive(Copy, Clone, Debug)]
+enum ValueSource<'a, 'tcx> {
+ Rvalue(&'a Rvalue<'tcx>),
+ Call {
+ callee: &'a Operand<'tcx>,
+ args: &'a [Operand<'tcx>],
+ return_ty: Ty<'tcx>,
+ },
+}
+
+trait Qualif {
+ const IDX: usize;
+
+ /// Return the qualification that is (conservatively) correct for any value
+ /// of the type, or `None` if the qualification is not value/type-based.
+ fn in_any_value_of_ty(_cx: &ConstCx<'_, 'tcx>, _ty: Ty<'tcx>) -> Option<bool> {
+ None
+ }
+
+ /// Return a mask for the qualification, given a type. This is `false` iff
+ /// no value of that type can have the qualification.
+ fn mask_for_ty(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool {
+ Self::in_any_value_of_ty(cx, ty).unwrap_or(true)
+ }
+
+ fn in_local(cx: &ConstCx<'_, '_>, local: Local) -> bool {
+ cx.per_local.0[Self::IDX].contains(local)
+ }
+
+ fn in_static(_cx: &ConstCx<'_, 'tcx>, _static: &Static<'tcx>) -> bool {
+ // FIXME(eddyb) should we do anything here for value properties?
+ false
+ }
+
+ fn in_projection_structurally(
+ cx: &ConstCx<'_, 'tcx>,
+ proj: &PlaceProjection<'tcx>,
+ ) -> bool {
+ let base_qualif = Self::in_place(cx, &proj.base);
+ let qualif = base_qualif && Self::mask_for_ty(
+ cx,
+ proj.base.ty(cx.mir, cx.tcx)
+ .projection_ty(cx.tcx, &proj.elem)
+ .to_ty(cx.tcx),
+ );
+ match proj.elem {
+ ProjectionElem::Deref |
+ ProjectionElem::Subslice { .. } |
+ ProjectionElem::Field(..) |
+ ProjectionElem::ConstantIndex { .. } |
+ ProjectionElem::Downcast(..) => qualif,
+
+ ProjectionElem::Index(local) => qualif || Self::in_local(cx, local),
+ }
+ }
+
+ fn in_projection(cx: &ConstCx<'_, 'tcx>, proj: &PlaceProjection<'tcx>) -> bool {
+ Self::in_projection_structurally(cx, proj)
+ }
+
+ fn in_place(cx: &ConstCx<'_, 'tcx>, place: &Place<'tcx>) -> bool {
+ match *place {
+ Place::Local(local) => Self::in_local(cx, local),
+ Place::Promoted(_) => bug!("qualifying already promoted MIR"),
+ Place::Static(ref static_) => Self::in_static(cx, static_),
+ Place::Projection(ref proj) => Self::in_projection(cx, proj),
+ }
+ }
+
+ fn in_operand(cx: &ConstCx<'_, 'tcx>, operand: &Operand<'tcx>) -> bool {
+ match *operand {
+ Operand::Copy(ref place) |
+ Operand::Move(ref place) => Self::in_place(cx, place),
+
+ Operand::Constant(ref constant) => {
+ if let ty::LazyConst::Unevaluated(def_id, _) = constant.literal {
+ // Don't peek inside trait associated constants.
+ if cx.tcx.trait_of_item(*def_id).is_some() {
+ Self::in_any_value_of_ty(cx, constant.ty).unwrap_or(false)
+ } else {
+ let (bits, _) = cx.tcx.at(constant.span).mir_const_qualif(*def_id);
+
+ let qualif = PerQualif::decode_from_bits(bits).0[Self::IDX];
+
+ // Just in case the type is more specific than
+ // the definition, e.g., impl associated const
+ // with type parameters, take it into account.
+ qualif && Self::mask_for_ty(cx, constant.ty)
+ }
+ } else {
+ false
+ }
+ }
+ }
+ }
+
+ fn in_rvalue_structurally(cx: &ConstCx<'_, 'tcx>, rvalue: &Rvalue<'tcx>) -> bool {
+ match *rvalue {
+ Rvalue::NullaryOp(..) => false,
+
+ Rvalue::Discriminant(ref place) |
+ Rvalue::Len(ref place) => Self::in_place(cx, place),
+
+ Rvalue::Use(ref operand) |
+ Rvalue::Repeat(ref operand, _) |
+ Rvalue::UnaryOp(_, ref operand) |
+ Rvalue::Cast(_, ref operand, _) => Self::in_operand(cx, operand),
+
+ Rvalue::BinaryOp(_, ref lhs, ref rhs) |
+ Rvalue::CheckedBinaryOp(_, ref lhs, ref rhs) => {
+ Self::in_operand(cx, lhs) || Self::in_operand(cx, rhs)
+ }
+
+ Rvalue::Ref(_, _, ref place) => {
+ // Special-case reborrows to be more like a copy of the reference.
+ if let Place::Projection(ref proj) = *place {
+ if let ProjectionElem::Deref = proj.elem {
+ let base_ty = proj.base.ty(cx.mir, cx.tcx).to_ty(cx.tcx);
+ if let ty::Ref(..) = base_ty.sty {
+ return Self::in_place(cx, &proj.base);
+ }
+ }
+ }
+
+ Self::in_place(cx, place)
+ }
+
+ Rvalue::Aggregate(_, ref operands) => {
+ operands.iter().any(|o| Self::in_operand(cx, o))
+ }
+ }
+ }
+
+ fn in_rvalue(cx: &ConstCx<'_, 'tcx>, rvalue: &Rvalue<'tcx>) -> bool {
+ Self::in_rvalue_structurally(cx, rvalue)
+ }
+
+ fn in_call(
+ cx: &ConstCx<'_, 'tcx>,
+ _callee: &Operand<'tcx>,
+ _args: &[Operand<'tcx>],
+ return_ty: Ty<'tcx>,
+ ) -> bool {
+ // Be conservative about the returned value of a const fn.
+ Self::in_any_value_of_ty(cx, return_ty).unwrap_or(false)
+ }
+
+ fn in_value(cx: &ConstCx<'_, 'tcx>, source: ValueSource<'_, 'tcx>) -> bool {
+ match source {
+ ValueSource::Rvalue(rvalue) => Self::in_rvalue(cx, rvalue),
+ ValueSource::Call { callee, args, return_ty } => {
+ Self::in_call(cx, callee, args, return_ty)
+ }
+ }
+ }
+}
+
+// Constant containing interior mutability (UnsafeCell).
+struct HasMutInterior;
+
+impl Qualif for HasMutInterior {
+ const IDX: usize = 0;
+
+ fn in_any_value_of_ty(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> Option<bool> {
+ Some(!ty.is_freeze(cx.tcx, cx.param_env, DUMMY_SP))
+ }
+
+ fn in_rvalue(cx: &ConstCx<'_, 'tcx>, rvalue: &Rvalue<'tcx>) -> bool {
+ match *rvalue {
+ // Returning `true` for `Rvalue::Ref` indicates the borrow isn't
+ // allowed in constants (and the `Checker` will error), and/or it
+ // won't be promoted, due to `&mut ...` or interior mutability.
+ Rvalue::Ref(_, kind, ref place) => {
+ let ty = place.ty(cx.mir, cx.tcx).to_ty(cx.tcx);
+
+ if let BorrowKind::Mut { .. } = kind {
+ // In theory, any zero-sized value could be borrowed
+ // mutably without consequences. However, only &mut []
+ // is allowed right now, and only in functions.
+ if cx.mode == Mode::StaticMut {
+ // Inside a `static mut`, &mut [...] is also allowed.
+ match ty.sty {
+ ty::Array(..) | ty::Slice(_) => {}
+ _ => return true,
+ }
+ } else if let ty::Array(_, len) = ty.sty {
+ // FIXME(eddyb) the `cx.mode == Mode::Fn` condition
+ // seems unnecessary, given that this is merely a ZST.
+ if !(len.unwrap_usize(cx.tcx) == 0 && cx.mode == Mode::Fn) {
+ return true;
+ }
+ } else {
+ return true;
+ }
+ }
+ }
+
+ Rvalue::Aggregate(ref kind, _) => {
+ if let AggregateKind::Adt(def, ..) = **kind {
+ if Some(def.did) == cx.tcx.lang_items().unsafe_cell_type() {
+ let ty = rvalue.ty(cx.mir, cx.tcx);
+ assert_eq!(Self::in_any_value_of_ty(cx, ty), Some(true));
+ return true;
+ }
+ }
+ }
+
+ _ => {}
+ }
+
+ Self::in_rvalue_structurally(cx, rvalue)
+ }
+}
+
+// Constant containing an ADT that implements Drop.
+struct NeedsDrop;
+
+impl Qualif for NeedsDrop {
+ const IDX: usize = 1;
+
+ fn in_any_value_of_ty(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> Option<bool> {
+ Some(ty.needs_drop(cx.tcx, cx.param_env))
+ }
+
+ fn in_rvalue(cx: &ConstCx<'_, 'tcx>, rvalue: &Rvalue<'tcx>) -> bool {
+ if let Rvalue::Aggregate(ref kind, _) = *rvalue {
+ if let AggregateKind::Adt(def, ..) = **kind {
+ if def.has_dtor(cx.tcx) {
+ return true;
+ }
+ }
+ }
+
+ Self::in_rvalue_structurally(cx, rvalue)
+ }
+}
+
+// Not constant at all - non-`const fn` calls, asm!,
+// pointer comparisons, ptr-to-int casts, etc.
+struct IsNotConst;
+
+impl Qualif for IsNotConst {
+ const IDX: usize = 2;
+
+ fn in_static(cx: &ConstCx<'_, 'tcx>, static_: &Static<'tcx>) -> bool {
+ // Only allow statics (not consts) to refer to other statics.
+ let allowed = cx.mode == Mode::Static || cx.mode == Mode::StaticMut;
+
+ !allowed ||
+ cx.tcx.get_attrs(static_.def_id).iter().any(|attr| attr.check_name("thread_local"))
+ }
+
+ fn in_projection(cx: &ConstCx<'_, 'tcx>, proj: &PlaceProjection<'tcx>) -> bool {
+ match proj.elem {
+ ProjectionElem::Deref |
+ ProjectionElem::Downcast(..) => return true,
+
+ ProjectionElem::ConstantIndex {..} |
+ ProjectionElem::Subslice {..} |
+ ProjectionElem::Index(_) => {}
+
+ ProjectionElem::Field(..) => {
+ if cx.mode == Mode::Fn {
+ let base_ty = proj.base.ty(cx.mir, cx.tcx).to_ty(cx.tcx);
+ if let Some(def) = base_ty.ty_adt_def() {
+ if def.is_union() {
+ return true;
+ }
+ }
+ }
+ }
+ }
+
+ Self::in_projection_structurally(cx, proj)
+ }
+
+ fn in_rvalue(cx: &ConstCx<'_, 'tcx>, rvalue: &Rvalue<'tcx>) -> bool {
+ match *rvalue {
+ Rvalue::Cast(CastKind::Misc, ref operand, cast_ty) if cx.mode == Mode::Fn => {
+ let operand_ty = operand.ty(cx.mir, cx.tcx);
+ let cast_in = CastTy::from_ty(operand_ty).expect("bad input type for cast");
+ let cast_out = CastTy::from_ty(cast_ty).expect("bad output type for cast");
+ match (cast_in, cast_out) {
+ (CastTy::Ptr(_), CastTy::Int(_)) |
+ (CastTy::FnPtr, CastTy::Int(_)) => {
+ // in normal functions, mark such casts as not promotable
+ return true;
+ }
+ _ => {}
+ }
+ }
+
+ Rvalue::BinaryOp(op, ref lhs, _) if cx.mode == Mode::Fn => {
+ if let ty::RawPtr(_) | ty::FnPtr(..) = lhs.ty(cx.mir, cx.tcx).sty {
+ assert!(op == BinOp::Eq || op == BinOp::Ne ||
+ op == BinOp::Le || op == BinOp::Lt ||
+ op == BinOp::Ge || op == BinOp::Gt ||
+ op == BinOp::Offset);
+
+ // raw pointer operations are not allowed inside promoteds
+ return true;
+ }
+ }
+
+ Rvalue::NullaryOp(NullOp::Box, _) => return true,
+
+ _ => {}
+ }
+
+ Self::in_rvalue_structurally(cx, rvalue)
+ }
+
+ fn in_call(
+ cx: &ConstCx<'_, 'tcx>,
+ callee: &Operand<'tcx>,
+ args: &[Operand<'tcx>],
+ _return_ty: Ty<'tcx>,
+ ) -> bool {
+ let fn_ty = callee.ty(cx.mir, cx.tcx);
+ match fn_ty.sty {
+ ty::FnDef(def_id, _) => {
+ match cx.tcx.fn_sig(def_id).abi() {
+ Abi::RustIntrinsic |
+ Abi::PlatformIntrinsic => {
+ assert!(!cx.tcx.is_const_fn(def_id));
+ match &cx.tcx.item_name(def_id).as_str()[..] {
+ | "size_of"
+ | "min_align_of"
+ | "needs_drop"
+ | "type_id"
+ | "bswap"
+ | "bitreverse"
+ | "ctpop"
+ | "cttz"
+ | "cttz_nonzero"
+ | "ctlz"
+ | "ctlz_nonzero"
+ | "overflowing_add"
+ | "overflowing_sub"
+ | "overflowing_mul"
+ | "unchecked_shl"
+ | "unchecked_shr"
+ | "rotate_left"
+ | "rotate_right"
+ | "add_with_overflow"
+ | "sub_with_overflow"
+ | "mul_with_overflow"
+ | "saturating_add"
+ | "saturating_sub"
+ | "transmute"
+ => return true,
+
+ _ => {}
+ }
+ }
+ _ => {
+ let is_const_fn =
+ cx.tcx.is_const_fn(def_id) ||
+ cx.tcx.is_unstable_const_fn(def_id).is_some() ||
+ cx.is_const_panic_fn(def_id);
+ if !is_const_fn {
+ return true;
+ }
+ }
+ }
+ }
+ _ => return true,
+ }
+
+ Self::in_operand(cx, callee) || args.iter().any(|arg| Self::in_operand(cx, arg))
+ }
+}
+
+// Refers to temporaries which cannot be promoted as
+// promote_consts decided they weren't simple enough.
+struct IsNotPromotable;
+
+impl Qualif for IsNotPromotable {
+ const IDX: usize = 3;
+
+ fn in_call(
+ cx: &ConstCx<'_, 'tcx>,
+ callee: &Operand<'tcx>,
+ _args: &[Operand<'tcx>],
+ _return_ty: Ty<'tcx>,
+ ) -> bool {
+ if cx.mode == Mode::Fn {
+ if let ty::FnDef(def_id, _) = callee.ty(cx.mir, cx.tcx).sty {
+ // Never promote runtime `const fn` calls of
+ // functions without `#[rustc_promotable]`.
+ if !cx.tcx.is_promotable_const_fn(def_id) {
+ return true;
+ }
+ }
+ }
+
+ // FIXME(eddyb) do we need "not promotable" in anything
+ // other than `Mode::Fn` by any chance?
+
+ false
+ }
+}
+
+// Ensure the `IDX` values are sequential (`0..QUALIF_COUNT`).
+macro_rules! static_assert_seq_qualifs {
+ ($i:expr => $first:ident $(, $rest:ident)*) => {
+ static_assert!(SEQ_QUALIFS: {
+ static_assert_seq_qualifs!($i + 1 => $($rest),*);
+
+ $first::IDX == $i
+ });
+ };
+ ($i:expr =>) => {
+ static_assert!(SEQ_QUALIFS: QUALIF_COUNT == $i);
+ };
+}
+static_assert_seq_qualifs!(0 => HasMutInterior, NeedsDrop, IsNotConst, IsNotPromotable);
+
+impl ConstCx<'_, 'tcx> {
+ fn qualifs_in_any_value_of_ty(&self, ty: Ty<'tcx>) -> PerQualif<bool> {
+ let mut qualifs = PerQualif::default();
+ qualifs[HasMutInterior] = HasMutInterior::in_any_value_of_ty(self, ty).unwrap_or(false);
+ qualifs[NeedsDrop] = NeedsDrop::in_any_value_of_ty(self, ty).unwrap_or(false);
+ qualifs[IsNotConst] = IsNotConst::in_any_value_of_ty(self, ty).unwrap_or(false);
+ qualifs[IsNotPromotable] = IsNotPromotable::in_any_value_of_ty(self, ty).unwrap_or(false);
+ qualifs
+ }
+
+ fn qualifs_in_local(&self, local: Local) -> PerQualif<bool> {
+ let mut qualifs = PerQualif::default();
+ qualifs[HasMutInterior] = HasMutInterior::in_local(self, local);
+ qualifs[NeedsDrop] = NeedsDrop::in_local(self, local);
+ qualifs[IsNotConst] = IsNotConst::in_local(self, local);
+ qualifs[IsNotPromotable] = IsNotPromotable::in_local(self, local);
+ qualifs
+ }
+
+ fn qualifs_in_value(&self, source: ValueSource<'_, 'tcx>) -> PerQualif<bool> {
+ let mut qualifs = PerQualif::default();
+ qualifs[HasMutInterior] = HasMutInterior::in_value(self, source);
+ qualifs[NeedsDrop] = NeedsDrop::in_value(self, source);
+ qualifs[IsNotConst] = IsNotConst::in_value(self, source);
+ qualifs[IsNotPromotable] = IsNotPromotable::in_value(self, source);
+ qualifs
+ }
+}
+
+struct Checker<'a, 'tcx> {
+ cx: ConstCx<'a, 'tcx>,
+
span: Span,
def_id: DefId,
- mir: &'a Mir<'tcx>,
rpo: ReversePostorder<'a, 'tcx>,
- tcx: TyCtxt<'a, 'gcx, 'tcx>,
- param_env: ty::ParamEnv<'tcx>,
- local_qualif: IndexVec<Local, Option<Qualif>>,
- qualif: Qualif,
+
temp_promotion_state: IndexVec<Local, TempState>,
- promotion_candidates: Vec<Candidate>
+ promotion_candidates: Vec<Candidate>,
}
macro_rules! unleash_miri {
}}
}
-impl<'a, 'tcx> Qualifier<'a, 'tcx, 'tcx> {
+impl Deref for Checker<'a, 'tcx> {
+ type Target = ConstCx<'a, 'tcx>;
+
+ fn deref(&self) -> &Self::Target {
+ &self.cx
+ }
+}
+
+impl<'a, 'tcx> Checker<'a, 'tcx> {
fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId,
mir: &'a Mir<'tcx>,
mode: Mode)
- -> Qualifier<'a, 'tcx, 'tcx> {
+ -> Self {
assert!(def_id.is_local());
let mut rpo = traversal::reverse_postorder(mir);
let temps = promote_consts::collect_temps(mir, &mut rpo);
let param_env = tcx.param_env(def_id);
- let mut local_qualif = IndexVec::from_elem(None, &mir.local_decls);
- for arg in mir.args_iter() {
- let mut qualif = Qualif::NEEDS_DROP;
- qualif.restrict(mir.local_decls[arg].ty, tcx, param_env);
- local_qualif[arg] = Some(qualif);
+ let mut cx = ConstCx {
+ tcx,
+ param_env,
+ mode,
+ mir,
+ per_local: PerQualif::new(BitSet::new_empty(mir.local_decls.len())),
+ };
+
+ for (local, decl) in mir.local_decls.iter_enumerated() {
+ match mir.local_kind(local) {
+ LocalKind::Arg => {
+ let qualifs = cx.qualifs_in_any_value_of_ty(decl.ty);
+ for (per_local, qualif) in &mut cx.per_local.as_mut().zip(qualifs).0 {
+ if *qualif {
+ per_local.insert(local);
+ }
+ }
+ cx.per_local[IsNotPromotable].insert(local);
+ }
+
+ LocalKind::Var if mode == Mode::Fn => {
+ cx.per_local[IsNotConst].insert(local);
+ }
+
+ LocalKind::Temp if !temps[local].is_promotable() => {
+ cx.per_local[IsNotPromotable].insert(local);
+ }
+
+ _ => {}
+ }
}
- Qualifier {
- mode,
+ Checker {
+ cx,
span: mir.span,
def_id,
- mir,
rpo,
- tcx,
- param_env,
- local_qualif,
- qualif: Qualif::empty(),
temp_promotion_state: temps,
promotion_candidates: vec![]
}
// slightly pointless (even with feature-gating).
fn not_const(&mut self) {
unleash_miri!(self);
- self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
let mut err = struct_span_err!(
self.tcx.sess,
}
}
- /// Add the given qualification to self.qualif.
- fn add(&mut self, qualif: Qualif) {
- self.qualif = self.qualif | qualif;
- }
+ /// Assigns an rvalue/call qualification to the given destination.
+ fn assign(&mut self, dest: &Place<'tcx>, source: ValueSource<'_, 'tcx>, location: Location) {
+ trace!("assign: {:?} <- {:?}", dest, source);
- /// Add the given type's qualification to self.qualif.
- fn add_type(&mut self, ty: Ty<'tcx>) {
- self.add(Qualif::MUTABLE_INTERIOR | Qualif::NEEDS_DROP);
- self.qualif.restrict(ty, self.tcx, self.param_env);
- }
+ let mut qualifs = self.qualifs_in_value(source);
- /// Within the provided closure, self.qualif will start
- /// out empty, and its value after the closure returns will
- /// be combined with the value before the call to nest.
- fn nest<F: FnOnce(&mut Self)>(&mut self, f: F) {
- let original = self.qualif;
- self.qualif = Qualif::empty();
- f(self);
- self.add(original);
- }
-
- /// Assign the current qualification to the given destination.
- fn assign(&mut self, dest: &Place<'tcx>, location: Location) {
- trace!("assign: {:?}", dest);
- let qualif = self.qualif;
- let span = self.span;
- let store = |slot: &mut Option<Qualif>| {
- if slot.is_some() {
- span_bug!(span, "multiple assignments to {:?}", dest);
- }
- *slot = Some(qualif);
- };
+ if let ValueSource::Rvalue(&Rvalue::Ref(_, kind, ref place)) = source {
+ // Getting `true` from `HasMutInterior::in_rvalue` means
+ // the borrowed place is disallowed from being borrowed,
+ // due to either a mutable borrow (with some exceptions),
+ // or an shared borrow of a value with interior mutability.
+ // Then `HasMutInterior` is replaced with `IsNotConst`,
+ // to avoid duplicate errors (e.g. from reborrowing).
+ if qualifs[HasMutInterior] {
+ qualifs[HasMutInterior] = false;
+ qualifs[IsNotConst] = true;
- // Only handle promotable temps in non-const functions.
- if self.mode == Mode::Fn {
- if let Place::Local(index) = *dest {
- if self.mir.local_kind(index) == LocalKind::Temp
- && self.temp_promotion_state[index].is_promotable() {
- debug!("store to promotable temp {:?} ({:?})", index, qualif);
- store(&mut self.local_qualif[index]);
+ if self.mode != Mode::Fn {
+ if let BorrowKind::Mut { .. } = kind {
+ let mut err = struct_span_err!(self.tcx.sess, self.span, E0017,
+ "references in {}s may only refer \
+ to immutable values", self.mode);
+ err.span_label(self.span, format!("{}s require immutable values",
+ self.mode));
+ if self.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note("References in statics and constants may only refer to \
+ immutable values.\n\n\
+ Statics are shared everywhere, and if they refer to \
+ mutable data one might violate memory safety since \
+ holding multiple mutable references to shared data is \
+ not allowed.\n\n\
+ If you really want global mutable state, try using \
+ static mut or a global UnsafeCell.");
+ }
+ err.emit();
+ } else {
+ span_err!(self.tcx.sess, self.span, E0492,
+ "cannot borrow a constant which may contain \
+ interior mutability, create a static instead");
+ }
+ }
+ } else {
+ // We might have a candidate for promotion.
+ let candidate = Candidate::Ref(location);
+ // We can only promote interior borrows of promotable temps.
+ let mut place = place;
+ while let Place::Projection(ref proj) = *place {
+ if proj.elem == ProjectionElem::Deref {
+ break;
+ }
+ place = &proj.base;
+ }
+ debug!("qualify_consts: promotion candidate: place={:?}", place);
+ if let Place::Local(local) = *place {
+ if self.mir.local_kind(local) == LocalKind::Temp {
+ debug!("qualify_consts: promotion candidate: local={:?}", local);
+ // The borrowed place doesn't have `HasMutInterior`
+ // (from `in_rvalue`), so we can safely ignore
+ // `HasMutInterior` from the local's qualifications.
+ // This allows borrowing fields which don't have
+ // `HasMutInterior`, from a type that does, e.g.:
+ // `let _: &'static _ = &(Cell::new(1), 2).1;`
+ let mut local_qualifs = self.qualifs_in_local(local);
+ local_qualifs[HasMutInterior] = false;
+ if !local_qualifs.0.iter().any(|&qualif| qualif) {
+ debug!("qualify_consts: promotion candidate: {:?}", candidate);
+ self.promotion_candidates.push(candidate);
+ }
+ }
}
}
- return;
}
let mut dest = dest;
}
}
};
- debug!("store to var {:?}", index);
- match &mut self.local_qualif[index] {
- // this is overly restrictive, because even full assignments do not clear the qualif
- // While we could special case full assignments, this would be inconsistent with
- // aggregates where we overwrite all fields via assignments, which would not get
- // that feature.
- Some(ref mut qualif) => *qualif = *qualif | self.qualif,
- // insert new qualification
- qualif @ None => *qualif = Some(self.qualif),
+
+ let kind = self.mir.local_kind(index);
+ debug!("store to {:?} {:?}", kind, index);
+
+ // Only handle promotable temps in non-const functions.
+ if self.mode == Mode::Fn {
+ if kind != LocalKind::Temp ||
+ !self.temp_promotion_state[index].is_promotable() {
+ return;
+ }
+ }
+
+ // this is overly restrictive, because even full assignments do not clear the qualif
+ // While we could special case full assignments, this would be inconsistent with
+ // aggregates where we overwrite all fields via assignments, which would not get
+ // that feature.
+ for (per_local, qualif) in &mut self.cx.per_local.as_mut().zip(qualifs).0 {
+ if *qualif {
+ per_local.insert(index);
+ }
+ }
+
+ // Ensure the `IsNotPromotable` qualification is preserved.
+ // NOTE(eddyb) this is actually unnecessary right now, as
+ // we never replace the local's qualif, but we might in
+ // the future, and so it serves to catch changes that unset
+ // important bits (in which case, asserting `contains` could
+ // be replaced with calling `insert` to re-set the bit).
+ if kind == LocalKind::Temp {
+ if !self.temp_promotion_state[index].is_promotable() {
+ assert!(self.cx.per_local[IsNotPromotable].contains(index));
+ }
}
}
- /// Qualify a whole const, static initializer or const fn.
- fn qualify_const(&mut self) -> (Qualif, Lrc<BitSet<Local>>) {
- debug!("qualifying {} {:?}", self.mode, self.def_id);
+ /// Check a whole const, static initializer or const fn.
+ fn check_const(&mut self) -> (u8, Lrc<BitSet<Local>>) {
+ debug!("const-checking {} {:?}", self.mode, self.def_id);
let mir = self.mir;
}
}
- self.qualif = self.local_qualif[RETURN_PLACE].unwrap_or(Qualif::NOT_CONST);
-
- // Account for errors in consts by using the
- // conservative type qualification instead.
- if self.qualif.intersects(Qualif::CONST_ERROR) {
- self.qualif = Qualif::empty();
- let return_ty = mir.return_ty();
- self.add_type(return_ty);
- }
-
// Collect all the temps we need to promote.
let mut promoted_temps = BitSet::new_empty(self.temp_promotion_state.len());
}
}
- (self.qualif, Lrc::new(promoted_temps))
- }
-
- fn is_const_panic_fn(&self, def_id: DefId) -> bool {
- Some(def_id) == self.tcx.lang_items().panic_fn() ||
- Some(def_id) == self.tcx.lang_items().begin_panic_fn()
- }
-}
-
-/// Accumulates an Rvalue or Call's effects in self.qualif.
-/// For functions (constant or not), it also records
-/// candidates for promotion in promotion_candidates.
-impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> {
- fn visit_local(&mut self,
- &local: &Local,
- _: PlaceContext<'tcx>,
- _: Location) {
- debug!("visit_local: local={:?}", local);
- let kind = self.mir.local_kind(local);
- match kind {
- LocalKind::ReturnPointer => {
- self.not_const();
- }
- LocalKind::Var if self.mode == Mode::Fn => {
- self.add(Qualif::NOT_CONST);
- }
- LocalKind::Var |
- LocalKind::Arg |
- LocalKind::Temp => {
- if let LocalKind::Arg = kind {
- self.add(Qualif::FN_ARGUMENT);
- }
+ let promoted_temps = Lrc::new(promoted_temps);
- if !self.temp_promotion_state[local].is_promotable() {
- debug!("visit_local: (not promotable) local={:?}", local);
- self.add(Qualif::NOT_PROMOTABLE);
- }
+ let mut qualifs = self.qualifs_in_local(RETURN_PLACE);
- if let Some(qualif) = self.local_qualif[local] {
- self.add(qualif);
- } else {
- self.not_const();
- }
- }
+ // Account for errors in consts by using the
+ // conservative type qualification instead.
+ if qualifs[IsNotConst] {
+ qualifs = self.qualifs_in_any_value_of_ty(mir.return_ty());
}
+
+ (qualifs.encode_to_bits(), promoted_temps)
}
+}
+/// Checks MIR for const-correctness, using `ConstCx`
+/// for value qualifications, and accumulates writes of
+/// rvalue/call results to locals, in `local_qualif`.
+/// For functions (constant or not), it also records
+/// candidates for promotion in `promotion_candidates`.
+impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
fn visit_place(&mut self,
place: &Place<'tcx>,
context: PlaceContext<'tcx>,
location: Location) {
debug!("visit_place: place={:?} context={:?} location={:?}", place, context, location);
+ self.super_place(place, context, location);
match *place {
- Place::Local(ref local) => self.visit_local(local, context, location),
- Place::Promoted(_) => bug!("promoting already promoted MIR"),
+ Place::Local(_) |
+ Place::Promoted(_) => {}
Place::Static(ref global) => {
if self.tcx
.get_attrs(global.def_id)
"thread-local statics cannot be \
accessed at compile-time");
}
- self.add(Qualif::NOT_CONST);
return;
}
return;
}
unleash_miri!(self);
- self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
let mut err = struct_span_err!(self.tcx.sess, self.span, E0013,
}
}
Place::Projection(ref proj) => {
- self.nest(|this| {
- this.super_place(place, context, location);
- match proj.elem {
- ProjectionElem::Deref => {
- if context.is_mutating_use() {
- // `not_const` errors out in const contexts
- this.not_const()
- } else {
- // just make sure this doesn't get promoted
- this.add(Qualif::NOT_CONST);
- }
- let base_ty = proj.base.ty(this.mir, this.tcx).to_ty(this.tcx);
- match this.mode {
- Mode::Fn => {},
- _ => {
- if let ty::RawPtr(_) = base_ty.sty {
- if !this.tcx.features().const_raw_ptr_deref {
- emit_feature_err(
- &this.tcx.sess.parse_sess, "const_raw_ptr_deref",
- this.span, GateIssue::Language,
- &format!(
- "dereferencing raw pointers in {}s is unstable",
- this.mode,
- ),
- );
- }
+ match proj.elem {
+ ProjectionElem::Deref => {
+ if context.is_mutating_use() {
+ // `not_const` errors out in const contexts
+ self.not_const()
+ }
+ let base_ty = proj.base.ty(self.mir, self.tcx).to_ty(self.tcx);
+ match self.mode {
+ Mode::Fn => {},
+ _ => {
+ if let ty::RawPtr(_) = base_ty.sty {
+ if !self.tcx.features().const_raw_ptr_deref {
+ emit_feature_err(
+ &self.tcx.sess.parse_sess, "const_raw_ptr_deref",
+ self.span, GateIssue::Language,
+ &format!(
+ "dereferencing raw pointers in {}s is unstable",
+ self.mode,
+ ),
+ );
}
}
}
}
+ }
- ProjectionElem::ConstantIndex {..} |
- ProjectionElem::Subslice {..} |
- ProjectionElem::Field(..) |
- ProjectionElem::Index(_) => {
- let base_ty = proj.base.ty(this.mir, this.tcx).to_ty(this.tcx);
- if let Some(def) = base_ty.ty_adt_def() {
- if def.is_union() {
- match this.mode {
- Mode::Fn => this.not_const(),
- Mode::ConstFn => {
- if !this.tcx.features().const_fn_union {
- emit_feature_err(
- &this.tcx.sess.parse_sess, "const_fn_union",
- this.span, GateIssue::Language,
- "unions in const fn are unstable",
- );
- }
- },
-
- | Mode::Static
- | Mode::StaticMut
- | Mode::Const
- => {},
- }
+ ProjectionElem::ConstantIndex {..} |
+ ProjectionElem::Subslice {..} |
+ ProjectionElem::Field(..) |
+ ProjectionElem::Index(_) => {
+ let base_ty = proj.base.ty(self.mir, self.tcx).to_ty(self.tcx);
+ if let Some(def) = base_ty.ty_adt_def() {
+ if def.is_union() {
+ match self.mode {
+ Mode::ConstFn => {
+ if !self.tcx.features().const_fn_union {
+ emit_feature_err(
+ &self.tcx.sess.parse_sess, "const_fn_union",
+ self.span, GateIssue::Language,
+ "unions in const fn are unstable",
+ );
+ }
+ },
+
+ | Mode::Fn
+ | Mode::Static
+ | Mode::StaticMut
+ | Mode::Const
+ => {},
}
}
-
- let ty = place.ty(this.mir, this.tcx).to_ty(this.tcx);
- this.qualif.restrict(ty, this.tcx, this.param_env);
}
+ }
- ProjectionElem::Downcast(..) => {
- this.not_const()
- }
+ ProjectionElem::Downcast(..) => {
+ self.not_const()
}
- });
+ }
}
}
}
self.super_operand(operand, location);
match *operand {
- Operand::Copy(_) |
- Operand::Move(_) => {
+ Operand::Move(ref place) => {
// Mark the consumed locals to indicate later drops are noops.
- if let Operand::Move(Place::Local(local)) = *operand {
- self.local_qualif[local] = self.local_qualif[local].map(|q|
- q - Qualif::NEEDS_DROP
- );
- }
- }
- Operand::Constant(ref constant) => {
- if let ty::LazyConst::Unevaluated(def_id, _) = constant.literal {
- // Don't peek inside trait associated constants.
- if self.tcx.trait_of_item(*def_id).is_some() {
- self.add_type(constant.ty);
- } else {
- let (bits, _) = self.tcx.at(constant.span).mir_const_qualif(*def_id);
-
- let qualif = Qualif::from_bits(bits).expect("invalid mir_const_qualif");
- self.add(qualif);
-
- // Just in case the type is more specific than
- // the definition, e.g., impl associated const
- // with type parameters, take it into account.
- self.qualif.restrict(constant.ty, self.tcx, self.param_env);
- }
+ if let Place::Local(local) = *place {
+ self.cx.per_local[NeedsDrop].remove(local);
}
}
+ Operand::Copy(_) |
+ Operand::Constant(_) => {}
}
}
fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
debug!("visit_rvalue: rvalue={:?} location={:?}", rvalue, location);
- // Recurse through operands and places.
+
+ // Check nested operands and places.
if let Rvalue::Ref(region, kind, ref place) = *rvalue {
+ // Special-case reborrows.
let mut is_reborrow = false;
if let Place::Projection(ref proj) = *place {
if let ProjectionElem::Deref = proj.elem {
if is_reborrow {
let ctx = match kind {
- BorrowKind::Shared =>
- PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow(region)),
- BorrowKind::Shallow =>
- PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow(region)),
- BorrowKind::Unique =>
- PlaceContext::NonMutatingUse(NonMutatingUseContext::UniqueBorrow(region)),
- BorrowKind::Mut { .. } =>
- PlaceContext::MutatingUse(MutatingUseContext::Borrow(region)),
+ BorrowKind::Shared => PlaceContext::NonMutatingUse(
+ NonMutatingUseContext::SharedBorrow(region),
+ ),
+ BorrowKind::Shallow => PlaceContext::NonMutatingUse(
+ NonMutatingUseContext::ShallowBorrow(region),
+ ),
+ BorrowKind::Unique => PlaceContext::NonMutatingUse(
+ NonMutatingUseContext::UniqueBorrow(region),
+ ),
+ BorrowKind::Mut { .. } => PlaceContext::MutatingUse(
+ MutatingUseContext::Borrow(region),
+ ),
};
self.super_place(place, ctx, location);
} else {
Rvalue::Cast(CastKind::ClosureFnPointer, ..) |
Rvalue::Cast(CastKind::Unsize, ..) |
Rvalue::Discriminant(..) |
- Rvalue::Len(_) => {}
-
- Rvalue::Ref(_, kind, ref place) => {
- let ty = place.ty(self.mir, self.tcx).to_ty(self.tcx);
-
- // Default to forbidding the borrow and/or its promotion,
- // due to the potential for direct or interior mutability,
- // and only proceed by setting `forbidden_mut` to `false`.
- let mut forbidden_mut = true;
-
- if let BorrowKind::Mut { .. } = kind {
- // In theory, any zero-sized value could be borrowed
- // mutably without consequences. However, only &mut []
- // is allowed right now, and only in functions.
- if self.mode == Mode::StaticMut {
- // Inside a `static mut`, &mut [...] is also allowed.
- match ty.sty {
- ty::Array(..) | ty::Slice(_) => forbidden_mut = false,
- _ => {}
- }
- } else if let ty::Array(_, len) = ty.sty {
- // FIXME(eddyb) the `self.mode == Mode::Fn` condition
- // seems unnecessary, given that this is merely a ZST.
- if len.unwrap_usize(self.tcx) == 0 && self.mode == Mode::Fn {
- forbidden_mut = false;
- }
- }
-
- if forbidden_mut {
- unleash_miri!(self);
- self.add(Qualif::NOT_CONST);
- if self.mode != Mode::Fn {
- let mut err = struct_span_err!(self.tcx.sess, self.span, E0017,
- "references in {}s may only refer \
- to immutable values", self.mode);
- err.span_label(self.span, format!("{}s require immutable values",
- self.mode));
- if self.tcx.sess.teach(&err.get_code().unwrap()) {
- err.note("References in statics and constants may only refer to \
- immutable values.\n\n\
- Statics are shared everywhere, and if they refer to \
- mutable data one might violate memory safety since \
- holding multiple mutable references to shared data is \
- not allowed.\n\n\
- If you really want global mutable state, try using \
- static mut or a global UnsafeCell.");
- }
- err.emit();
- }
- }
- } else {
- // Constants cannot be borrowed if they contain interior mutability as
- // it means that our "silent insertion of statics" could change
- // initializer values (very bad).
- if self.qualif.contains(Qualif::MUTABLE_INTERIOR) {
- // A reference of a MUTABLE_INTERIOR place is instead
- // NOT_CONST (see `if forbidden_mut` below), to avoid
- // duplicate errors (from reborrowing, for example).
- self.qualif = self.qualif - Qualif::MUTABLE_INTERIOR;
- if self.mode != Mode::Fn {
- span_err!(self.tcx.sess, self.span, E0492,
- "cannot borrow a constant which may contain \
- interior mutability, create a static instead");
- }
- } else {
- // We allow immutable borrows of frozen data.
- forbidden_mut = false;
- }
- }
-
- debug!("visit_rvalue: forbidden_mut={:?}", forbidden_mut);
- if forbidden_mut {
- unleash_miri!(self);
- self.add(Qualif::NOT_CONST);
- } else {
- // We might have a candidate for promotion.
- let candidate = Candidate::Ref(location);
- // We can only promote interior borrows of promotable temps.
- let mut place = place;
- while let Place::Projection(ref proj) = *place {
- if proj.elem == ProjectionElem::Deref {
- break;
- }
- place = &proj.base;
- }
- debug!("visit_rvalue: place={:?}", place);
- if let Place::Local(local) = *place {
- if self.mir.local_kind(local) == LocalKind::Temp {
- debug!("visit_rvalue: local={:?}", local);
- if let Some(qualif) = self.local_qualif[local] {
- // `forbidden_mut` is false, so we can safely ignore
- // `MUTABLE_INTERIOR` from the local's qualifications.
- // This allows borrowing fields which don't have
- // `MUTABLE_INTERIOR`, from a type that does, e.g.:
- // `let _: &'static _ = &(Cell::new(1), 2).1;`
- debug!("visit_rvalue: qualif={:?}", qualif);
- if (qualif - Qualif::MUTABLE_INTERIOR).is_empty() {
- debug!("visit_rvalue: candidate={:?}", candidate);
- self.promotion_candidates.push(candidate);
- }
- }
- }
- }
- }
- }
+ Rvalue::Len(_) |
+ Rvalue::Ref(..) |
+ Rvalue::Aggregate(..) => {}
Rvalue::Cast(CastKind::Misc, ref operand, cast_ty) => {
let operand_ty = operand.ty(self.mir, self.tcx);
let cast_out = CastTy::from_ty(cast_ty).expect("bad output type for cast");
match (cast_in, cast_out) {
(CastTy::Ptr(_), CastTy::Int(_)) |
- (CastTy::FnPtr, CastTy::Int(_)) => {
+ (CastTy::FnPtr, CastTy::Int(_)) if self.mode != Mode::Fn => {
unleash_miri!(self);
- if let Mode::Fn = self.mode {
- // in normal functions, mark such casts as not promotable
- self.add(Qualif::NOT_CONST);
- } else if !self.tcx.features().const_raw_ptr_to_usize_cast {
+ if !self.tcx.features().const_raw_ptr_to_usize_cast {
// in const fn and constants require the feature gate
// FIXME: make it unsafe inside const fn and constants
emit_feature_err(
op == BinOp::Offset);
unleash_miri!(self);
- if let Mode::Fn = self.mode {
- // raw pointer operations are not allowed inside promoteds
- self.add(Qualif::NOT_CONST);
- } else if !self.tcx.features().const_compare_raw_pointers {
+ if self.mode != Mode::Fn && !self.tcx.features().const_compare_raw_pointers {
// require the feature gate inside constants and const fn
// FIXME: make it unsafe to use these operations
emit_feature_err(
Rvalue::NullaryOp(NullOp::Box, _) => {
unleash_miri!(self);
- self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
let mut err = struct_span_err!(self.tcx.sess, self.span, E0010,
"allocations are not allowed in {}s", self.mode);
err.emit();
}
}
-
- Rvalue::Aggregate(ref kind, _) => {
- if let AggregateKind::Adt(def, ..) = **kind {
- if def.has_dtor(self.tcx) {
- self.add(Qualif::NEEDS_DROP);
- }
-
- if Some(def.did) == self.tcx.lang_items().unsafe_cell_type() {
- let ty = rvalue.ty(self.mir, self.tcx);
- self.add_type(ty);
- assert!(self.qualif.contains(Qualif::MUTABLE_INTERIOR));
- }
- }
- }
}
}
location: Location) {
debug!("visit_terminator_kind: bb={:?} kind={:?} location={:?}", bb, kind, location);
if let TerminatorKind::Call { ref func, ref args, ref destination, .. } = *kind {
- self.visit_operand(func, location);
+ if let Some((ref dest, _)) = *destination {
+ self.assign(dest, ValueSource::Call {
+ callee: func,
+ args,
+ return_ty: dest.ty(self.mir, self.tcx).to_ty(self.tcx),
+ }, location);
+ }
let fn_ty = func.ty(self.mir, self.tcx);
let mut callee_def_id = None;
let mut is_shuffle = false;
- let mut is_const_fn = false;
- let mut is_promotable_const_fn = false;
match fn_ty.sty {
ty::FnDef(def_id, _) => {
callee_def_id = Some(def_id);
Abi::PlatformIntrinsic => {
assert!(!self.tcx.is_const_fn(def_id));
match &self.tcx.item_name(def_id).as_str()[..] {
- | "size_of"
- | "min_align_of"
- | "needs_drop"
- | "type_id"
- | "bswap"
- | "bitreverse"
- | "ctpop"
- | "cttz"
- | "cttz_nonzero"
- | "ctlz"
- | "ctlz_nonzero"
- | "overflowing_add"
- | "overflowing_sub"
- | "overflowing_mul"
- | "unchecked_shl"
- | "unchecked_shr"
- | "rotate_left"
- | "rotate_right"
- | "add_with_overflow"
- | "sub_with_overflow"
- | "mul_with_overflow"
- // no need to check feature gates, intrinsics are only callable
- // from the libstd or with forever unstable feature gates
- => is_const_fn = true,
// special intrinsic that can be called diretly without an intrinsic
// feature gate needs a language feature gate
"transmute" => {
// never promote transmute calls
if self.mode != Mode::Fn {
- is_const_fn = true;
// const eval transmute calls only with the feature gate
if !self.tcx.features().const_transmute {
emit_feature_err(
is_shuffle = true;
}
+ // no need to check feature gates, intrinsics are only callable
+ // from the libstd or with forever unstable feature gates
_ => {}
}
}
_ => {
- // In normal functions we only care about promotion.
- if self.mode == Mode::Fn {
- // Never promote const fn calls of
- // functions without `#[rustc_promotable]`.
- if self.tcx.is_promotable_const_fn(def_id) {
- is_const_fn = true;
- is_promotable_const_fn = true;
- } else if self.tcx.is_const_fn(def_id) {
- is_const_fn = true;
- }
- } else {
- // stable const fns or unstable const fns with their feature gate
- // active
+ // In normal functions no calls are feature-gated.
+ if self.mode != Mode::Fn {
let unleash_miri = self
.tcx
.sess
.debugging_opts
.unleash_the_miri_inside_of_you;
if self.tcx.is_const_fn(def_id) || unleash_miri {
- is_const_fn = true;
+ // stable const fns or unstable const fns
+ // with their feature gate active
+ // FIXME(eddyb) move stability checks from `is_const_fn` here.
} else if self.is_const_panic_fn(def_id) {
// Check the const_panic feature gate.
// FIXME: cannot allow this inside `allow_internal_unstable`
// because that would make `panic!` insta stable in constants,
// since the macro is marked with the attribute.
- if self.tcx.features().const_panic {
- is_const_fn = true;
- } else {
+ if !self.tcx.features().const_panic {
// Don't allow panics in constants without the feature gate.
emit_feature_err(
&self.tcx.sess.parse_sess,
// Check `#[unstable]` const fns or `#[rustc_const_unstable]`
// functions without the feature gate active in this crate in
// order to report a better error message than the one below.
- if self.span.allows_unstable() {
- // `allow_internal_unstable` can make such calls stable.
- is_const_fn = true;
- } else {
+ if !self.span.allows_unstable(&feature.as_str()) {
let mut err = self.tcx.sess.struct_span_err(self.span,
&format!("`{}` is not yet stable as a const fn",
self.tcx.item_path_str(def_id)));
err.emit();
}
} else {
- // FIXME(#57563): remove this check when const fn stabilizes.
- let (msg, note) = if let UnstableFeatures::Disallow =
- self.tcx.sess.opts.unstable_features {
- (format!("calls in {}s are limited to \
- tuple structs and tuple variants",
- self.mode),
- Some("a limited form of compile-time function \
- evaluation is available on a nightly \
- compiler via `const fn`"))
- } else {
- (format!("calls in {}s are limited \
- to constant functions, \
- tuple structs and tuple variants",
- self.mode),
- None)
- };
let mut err = struct_span_err!(
self.tcx.sess,
self.span,
E0015,
- "{}",
- msg,
+ "calls in {}s are limited to constant functions, \
+ tuple structs and tuple variants",
+ self.mode,
);
- if let Some(note) = note {
- err.span_note(self.span, note);
- }
err.emit();
}
}
}
}
- },
+ }
ty::FnPtr(_) => {
if self.mode != Mode::Fn {
let mut err = self.tcx.sess.struct_span_err(
&format!("function pointers are not allowed in const fn"));
err.emit();
}
- },
+ }
_ => {
self.not_const();
- return
}
}
-
- let constant_arguments = callee_def_id.and_then(|id| {
- args_required_const(self.tcx, id)
- });
- for (i, arg) in args.iter().enumerate() {
- self.nest(|this| {
- this.visit_operand(arg, location);
- if this.mode != Mode::Fn {
- return
- }
- let candidate = Candidate::Argument { bb, index: i };
- if is_shuffle && i == 2 {
- if this.qualif.is_empty() {
- debug!("visit_terminator_kind: candidate={:?}", candidate);
- this.promotion_candidates.push(candidate);
- } else {
- span_err!(this.tcx.sess, this.span, E0526,
- "shuffle indices are not constant");
- }
- return
+ if self.mode == Mode::Fn {
+ let constant_args = callee_def_id.and_then(|id| {
+ args_required_const(self.tcx, id)
+ }).unwrap_or_default();
+ for (i, arg) in args.iter().enumerate() {
+ if !(is_shuffle && i == 2 || constant_args.contains(&i)) {
+ continue;
}
- let constant_arguments = match constant_arguments.as_ref() {
- Some(s) => s,
- None => return,
- };
- if !constant_arguments.contains(&i) {
- return
- }
+ let candidate = Candidate::Argument { bb, index: i };
// Since the argument is required to be constant,
// we care about constness, not promotability.
// If we checked for promotability, we'd miss out on
// which happens even without the user requesting it.
// We can error out with a hard error if the argument is not
// constant here.
- if (this.qualif - Qualif::NOT_PROMOTABLE).is_empty() {
+ if !IsNotConst::in_operand(self, arg) {
debug!("visit_terminator_kind: candidate={:?}", candidate);
- this.promotion_candidates.push(candidate);
+ self.promotion_candidates.push(candidate);
} else {
- this.tcx.sess.span_err(this.span,
- &format!("argument {} is required to be a constant",
- i + 1));
+ if is_shuffle {
+ span_err!(self.tcx.sess, self.span, E0526,
+ "shuffle indices are not constant");
+ } else {
+ self.tcx.sess.span_err(self.span,
+ &format!("argument {} is required to be a constant",
+ i + 1));
+ }
}
- });
- }
-
- // non-const fn calls
- if !is_const_fn {
- self.qualif = Qualif::NOT_CONST;
- if self.mode != Mode::Fn {
- self.tcx.sess.delay_span_bug(
- self.span,
- "should have reported an error about non-const fn calls in constants",
- )
}
}
- if let Some((ref dest, _)) = *destination {
- // Avoid propagating irrelevant callee/argument qualifications.
- if self.qualif.intersects(Qualif::CONST_ERROR) {
- self.qualif = Qualif::NOT_CONST;
- } else {
- // Be conservative about the returned value of a const fn.
- let tcx = self.tcx;
- let ty = dest.ty(self.mir, tcx).to_ty(tcx);
- if is_const_fn && !is_promotable_const_fn && self.mode == Mode::Fn {
- self.qualif = Qualif::NOT_PROMOTABLE;
- } else {
- self.qualif = Qualif::empty();
- }
- self.add_type(ty);
- }
- self.assign(dest, location);
+ // Check callee and argument operands.
+ self.visit_operand(func, location);
+ for arg in args {
+ self.visit_operand(arg, location);
}
} else if let TerminatorKind::Drop { location: ref place, .. } = *kind {
self.super_terminator_kind(bb, kind, location);
// HACK(eddyb): emulate a bit of dataflow analysis,
// conservatively, that drop elaboration will do.
let needs_drop = if let Place::Local(local) = *place {
- if self.local_qualif[local].map_or(true, |q| q.contains(Qualif::NEEDS_DROP)) {
+ if NeedsDrop::in_local(self, local) {
Some(self.mir.local_decls[local].source_info.span)
} else {
None
rvalue: &Rvalue<'tcx>,
location: Location) {
debug!("visit_assign: dest={:?} rvalue={:?} location={:?}", dest, rvalue, location);
- self.visit_rvalue(rvalue, location);
+ self.assign(dest, ValueSource::Rvalue(rvalue), location);
- self.assign(dest, location);
+ self.visit_rvalue(rvalue, location);
}
fn visit_source_info(&mut self, source_info: &SourceInfo) {
fn visit_statement(&mut self, bb: BasicBlock, statement: &Statement<'tcx>, location: Location) {
debug!("visit_statement: bb={:?} statement={:?} location={:?}", bb, statement, location);
- self.nest(|this| {
- this.visit_source_info(&statement.source_info);
- match statement.kind {
- StatementKind::Assign(ref place, ref rvalue) => {
- this.visit_assign(bb, place, rvalue, location);
- }
- StatementKind::FakeRead(..) |
- StatementKind::SetDiscriminant { .. } |
- StatementKind::StorageLive(_) |
- StatementKind::StorageDead(_) |
- StatementKind::InlineAsm {..} |
- StatementKind::Retag { .. } |
- StatementKind::AscribeUserType(..) |
- StatementKind::Nop => {}
+ match statement.kind {
+ StatementKind::Assign(..) => {
+ self.super_statement(bb, statement, location);
}
- });
+ // FIXME(eddyb) should these really do nothing?
+ StatementKind::FakeRead(..) |
+ StatementKind::SetDiscriminant { .. } |
+ StatementKind::StorageLive(_) |
+ StatementKind::StorageDead(_) |
+ StatementKind::InlineAsm {..} |
+ StatementKind::Retag { .. } |
+ StatementKind::AscribeUserType(..) |
+ StatementKind::Nop => {}
+ }
}
fn visit_terminator(&mut self,
terminator: &Terminator<'tcx>,
location: Location) {
debug!("visit_terminator: bb={:?} terminator={:?} location={:?}", bb, terminator, location);
- self.nest(|this| this.super_terminator(bb, terminator, location));
+ self.super_terminator(bb, terminator, location);
}
}
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
*providers = Providers {
mir_const_qualif,
..*providers
if mir.return_ty().references_error() {
tcx.sess.delay_span_bug(mir.span, "mir_const_qualif: Mir had errors");
- return (Qualif::NOT_CONST.bits(), Lrc::new(BitSet::new_empty(0)));
+ return (1 << IsNotConst::IDX, Lrc::new(BitSet::new_empty(0)));
}
- let mut qualifier = Qualifier::new(tcx, def_id, mir, Mode::Const);
- let (qualif, promoted_temps) = qualifier.qualify_const();
- (qualif.bits(), promoted_temps)
+ Checker::new(tcx, def_id, mir, Mode::Const).check_const()
}
pub struct QualifyAndPromoteConstants;
impl MirPass for QualifyAndPromoteConstants {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- src: MirSource,
+ src: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
// There's not really any point in promoting errorful MIR.
if mir.return_ty().references_error() {
return;
}
- let def_id = src.def_id;
- let id = tcx.hir().as_local_node_id(def_id).unwrap();
+ let def_id = src.def_id();
+ let id = tcx.hir().as_local_hir_id(def_id).unwrap();
let mut const_promoted_temps = None;
- let mode = match tcx.hir().body_owner_kind(id) {
+ let mode = match tcx.hir().body_owner_kind_by_hir_id(id) {
hir::BodyOwnerKind::Closure => Mode::Fn,
hir::BodyOwnerKind::Fn => {
if tcx.is_const_fn(def_id) {
debug!("run_pass: mode={:?}", mode);
if mode == Mode::Fn || mode == Mode::ConstFn {
- // This is ugly because Qualifier holds onto mir,
+ // This is ugly because Checker holds onto mir,
// which can't be mutated until its scope ends.
let (temps, candidates) = {
- let mut qualifier = Qualifier::new(tcx, def_id, mir, mode);
+ let mut checker = Checker::new(tcx, def_id, mir, mode);
if mode == Mode::ConstFn {
if tcx.sess.opts.debugging_opts.unleash_the_miri_inside_of_you {
- qualifier.qualify_const();
+ checker.check_const();
} else if tcx.is_min_const_fn(def_id) {
// enforce `min_const_fn` for stable const fns
use super::qualify_min_const_fn::is_min_const_fn;
if let Err((span, err)) = is_min_const_fn(tcx, def_id, mir) {
- tcx.sess.span_err(span, &err);
+ let mut diag = struct_span_err!(
+ tcx.sess,
+ span,
+ E0723,
+ "{} (see issue #57563)",
+ err,
+ );
+ diag.help(
+ "add #![feature(const_fn)] to the crate attributes to enable",
+ );
+ diag.emit();
} else {
// this should not produce any errors, but better safe than sorry
// FIXME(#53819)
- qualifier.qualify_const();
+ checker.check_const();
}
} else {
// Enforce a constant-like CFG for `const fn`.
- qualifier.qualify_const();
+ checker.check_const();
}
} else {
- while let Some((bb, data)) = qualifier.rpo.next() {
- qualifier.visit_basic_block_data(bb, data);
+ while let Some((bb, data)) = checker.rpo.next() {
+ checker.visit_basic_block_data(bb, data);
}
}
- (qualifier.temp_promotion_state, qualifier.promotion_candidates)
+ (checker.temp_promotion_state, checker.promotion_candidates)
};
// Do the actual promotion, now that we know what's viable.
// Already computed by `mir_const_qualif`.
const_promoted_temps.unwrap()
} else {
- Qualifier::new(tcx, def_id, mir, mode).qualify_const().1
+ Checker::new(tcx, def_id, mir, mode).check_const().1
};
// In `const` and `static` everything without `StorageDead`
}
}
-fn args_required_const(tcx: TyCtxt, def_id: DefId) -> Option<FxHashSet<usize>> {
+fn args_required_const(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Option<FxHashSet<usize>> {
let attrs = tcx.get_attrs(def_id);
let attr = attrs.iter().find(|a| a.check_name("rustc_args_required_const"))?;
let mut ret = FxHashSet::default();
}
}
-/// Returns true if the `def_id` refers to an intrisic which we've whitelisted
+/// Returns `true` if the `def_id` refers to an intrisic which we've whitelisted
/// for being called from stable `const fn`s (`min_const_fn`).
///
/// Adding more intrinsics requires sign-off from @rust-lang/lang.
| "overflowing_add" // ~> .wrapping_add
| "overflowing_sub" // ~> .wrapping_sub
| "overflowing_mul" // ~> .wrapping_mul
+ | "saturating_add" // ~> .saturating_add
+ | "saturating_sub" // ~> .saturating_sub
| "unchecked_shl" // ~> .wrapping_shl
| "unchecked_shr" // ~> .wrapping_shr
| "rotate_left" // ~> .rotate_left
use rustc::ty::TyCtxt;
use rustc::mir::*;
use rustc_data_structures::bit_set::BitSet;
-use transform::{MirPass, MirSource};
-use util::patch::MirPatch;
+use crate::transform::{MirPass, MirSource};
+use crate::util::patch::MirPatch;
-/// A pass that removes no-op landing pads and replaces jumps to them with
+/// A pass that removes noop landing pads and replaces jumps to them with
/// `None`. This is important because otherwise LLVM generates terrible
/// code for these.
pub struct RemoveNoopLandingPads;
impl MirPass for RemoveNoopLandingPads {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _src: MirSource,
+ _src: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
remove_noop_landing_pads(tcx, mir);
}
fn is_nop_landing_pad(
&self,
bb: BasicBlock,
- mir: &Mir,
+ mir: &Mir<'_>,
nop_landing_pads: &BitSet<BasicBlock>,
) -> bool {
for stmt in &mir[bb].statements {
}
}
- fn remove_nop_landing_pads(&self, mir: &mut Mir) {
+ fn remove_nop_landing_pads(&self, mir: &mut Mir<'_>) {
// make sure there's a single resume block
let resume_block = {
let patch = MirPatch::new(mir);
use rustc::ty::{self, TyCtxt};
use rustc::mir::{self, Mir, Location};
use rustc_data_structures::bit_set::BitSet;
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
-use dataflow::{do_dataflow, DebugFormatted};
-use dataflow::MoveDataParamEnv;
-use dataflow::BitDenotation;
-use dataflow::DataflowResults;
-use dataflow::{DefinitelyInitializedPlaces, MaybeInitializedPlaces, MaybeUninitializedPlaces};
-use dataflow::move_paths::{MovePathIndex, LookupResult};
-use dataflow::move_paths::{HasMoveData, MoveData};
-use dataflow;
+use crate::dataflow::{do_dataflow, DebugFormatted};
+use crate::dataflow::MoveDataParamEnv;
+use crate::dataflow::BitDenotation;
+use crate::dataflow::DataflowResults;
+use crate::dataflow::{
+ DefinitelyInitializedPlaces, MaybeInitializedPlaces, MaybeUninitializedPlaces
+};
+use crate::dataflow::move_paths::{MovePathIndex, LookupResult};
+use crate::dataflow::move_paths::{HasMoveData, MoveData};
+use crate::dataflow;
-use dataflow::has_rustc_mir_with;
+use crate::dataflow::has_rustc_mir_with;
pub struct SanityCheck;
impl MirPass for SanityCheck {
fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>,
- src: MirSource, mir: &mut Mir<'tcx>) {
- let def_id = src.def_id;
+ src: MirSource<'tcx>, mir: &mut Mir<'tcx>) {
+ let def_id = src.def_id();
let id = tcx.hir().as_local_node_id(def_id).unwrap();
if !tcx.has_attr(def_id, "rustc_mir") {
debug!("skipping rustc_peek::SanityCheck on {}", tcx.item_path_str(def_id));
use rustc::mir::visit::{MutVisitor, Visitor, PlaceContext};
use rustc::session::config::DebugInfo;
use std::borrow::Cow;
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
pub struct SimplifyCfg { label: String }
}
}
-pub fn simplify_cfg(mir: &mut Mir) {
+pub fn simplify_cfg(mir: &mut Mir<'_>) {
CfgSimplifier::new(mir).simplify();
remove_dead_blocks(mir);
fn run_pass<'a, 'tcx>(&self,
_tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _src: MirSource,
+ _src: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
debug!("SimplifyCfg({:?}) - simplifying {:?}", self.label, mir);
simplify_cfg(mir);
}
}
-pub fn remove_dead_blocks(mir: &mut Mir) {
+pub fn remove_dead_blocks(mir: &mut Mir<'_>) {
let mut seen = BitSet::new_empty(mir.basic_blocks().len());
for (bb, _) in traversal::preorder(mir) {
seen.insert(bb.index());
impl MirPass for SimplifyLocals {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _: MirSource,
+ _: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
let mut marker = DeclMarker { locals: BitSet::new_empty(mir.local_decls.len()) };
marker.visit_mir(mir);
use rustc::ty::{TyCtxt, ParamEnv};
use rustc::mir::*;
-use transform::{MirPass, MirSource};
+use crate::transform::{MirPass, MirSource};
use std::borrow::Cow;
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _src: MirSource,
+ _src: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
for block in mir.basic_blocks_mut() {
let terminator = block.terminator_mut();
use rustc::ty::TyCtxt;
use rustc::mir::*;
use rustc::mir::visit::{Visitor, PlaceContext, NonUseContext};
-use transform::{MirPass, MirSource};
-use util::patch::MirPatch;
use rustc_data_structures::indexed_vec::{IndexVec};
+use crate::transform::{MirPass, MirSource};
+use crate::util::patch::MirPatch;
pub struct UniformArrayMoveOut;
impl MirPass for UniformArrayMoveOut {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _src: MirSource,
+ _src: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
let mut patch = MirPatch::new(mir);
{
impl MirPass for RestoreSubsliceArrayMoveOut {
fn run_pass<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- _src: MirSource,
+ _src: MirSource<'tcx>,
mir: &mut Mir<'tcx>) {
let mut patch = MirPatch::new(mir);
{
use rustc::ty::{self, TyCtxt};
use rustc::mir::*;
-/// Return `true` if this place is allowed to be less aligned
+/// Returns `true` if this place is allowed to be less aligned
/// than its containing struct (because it is within a packed
/// struct).
pub fn is_disaligned<'a, 'tcx, L>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
}
impl fmt::Display for Origin {
- fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
// If the user passed `-Z borrowck=compare`, then include
// origin info as part of the error report,
// otherwise
fn cannot_move_out_of_interior_noncopy(
self,
move_from_span: Span,
- ty: ty::Ty,
+ ty: ty::Ty<'_>,
is_index: Option<bool>,
o: Origin,
) -> DiagnosticBuilder<'cx> {
fn cannot_move_out_of_interior_of_drop(
self,
move_from_span: Span,
- container_ty: ty::Ty,
+ container_ty: ty::Ty<'_>,
o: Origin,
) -> DiagnosticBuilder<'cx> {
let mut err = struct_span_err!(
}
}
- /// FIXME(pcwalton): This should update the def-use chains.
+ // FIXME(pcwalton): this should update the def-use chains.
pub fn replace_all_defs_and_uses_with(&self,
local: Local,
mir: &mut Mir<'tcx>,
pub fn defs_not_including_drop(
&self,
- ) -> iter::Filter<slice::Iter<Use<'tcx>>, fn(&&Use<'tcx>) -> bool> {
+ ) -> iter::Filter<slice::Iter<'_, Use<'tcx>>, fn(&&Use<'tcx>) -> bool> {
self.defs_and_uses.iter().filter(|place_use| {
place_use.context.is_mutating_use() && !place_use.context.is_drop()
})
use rustc::ty::subst::Substs;
use rustc::ty::util::IntTypeExt;
use rustc_data_structures::indexed_vec::Idx;
-use util::patch::MirPatch;
+use crate::util::patch::MirPatch;
use std::u32;
/// joined together under the `rest` subpath. They are all controlled
/// by the primary drop flag, but only the last rest-field dropped
/// should clear it (and it must also not clear anything else).
- ///
- /// FIXME: I think we should just control the flags externally
- /// and then we do not need this machinery.
+ //
+ // FIXME: I think we should just control the flags externally,
+ // and then we do not need this machinery.
pub fn elaborate_drop<'a>(&mut self, bb: BasicBlock) {
debug!("elaborate_drop({:?})", self);
let style = self.elaborator.drop_style(self.path, DropFlagMode::Deep);
}
}
- /// Return the place and move path for each field of `variant`,
+ /// Returns the place and move path for each field of `variant`,
/// (the move path is `None` if the field is a rest field).
fn move_paths_for_fields(&self,
base_place: &Place<'tcx>,
}
}
- /// Create one-half of the drop ladder for a list of fields, and return
+ /// Creates one-half of the drop ladder for a list of fields, and return
/// the list of steps in it in reverse order, with the first step
/// dropping 0 fields and so on.
///
)
}
- /// Create a full drop ladder, consisting of 2 connected half-drop-ladders
+ /// Creates a full drop ladder, consisting of 2 connected half-drop-ladders
///
/// For example, with 3 fields, the drop ladder is
///
}
}
- /// Return a basic block that drop a place using the context
+ /// Returns a basic block that drop a place using the context
/// and path in `c`. If `mode` is something, also clear `c`
/// according to it.
///
span: self.source_info.span,
ty: self.tcx().types.usize,
user_ty: None,
- literal: self.tcx().intern_lazy_const(ty::LazyConst::Evaluated(
+ literal: self.tcx().mk_lazy_const(ty::LazyConst::Evaluated(
ty::Const::from_usize(self.tcx(), val.into())
)),
})
-use dot;
use rustc::hir::def_id::DefId;
use rustc::mir::*;
use rustc::ty::TyCtxt;
/// Write a graphviz DOT graph of the MIR.
pub fn write_mir_fn_graphviz<'tcx, W>(tcx: TyCtxt<'_, '_, 'tcx>,
def_id: DefId,
- mir: &Mir,
+ mir: &Mir<'_>,
w: &mut W) -> io::Result<()>
where W: Write
{
/// `init` and `fini` are callbacks for emitting additional rows of
/// data (using HTML enclosed with `<tr>` in the emitted text).
pub fn write_node_label<W: Write, INIT, FINI>(block: BasicBlock,
- mir: &Mir,
+ mir: &Mir<'_>,
w: &mut W,
num_cols: u32,
init: INIT,
}
/// Write a graphviz DOT node for the given basic block.
-fn write_node<W: Write>(block: BasicBlock, mir: &Mir, w: &mut W) -> io::Result<()> {
+fn write_node<W: Write>(block: BasicBlock, mir: &Mir<'_>, w: &mut W) -> io::Result<()> {
// Start a new node with the label to follow, in one of DOT's pseudo-HTML tables.
write!(w, r#" {} [shape="none", label=<"#, node(block))?;
write_node_label(block, mir, w, 1, |_| Ok(()), |_| Ok(()))?;
}
/// Write graphviz DOT edges with labels between the given basic block and all of its successors.
-fn write_edges<W: Write>(source: BasicBlock, mir: &Mir, w: &mut W) -> io::Result<()> {
+fn write_edges<W: Write>(source: BasicBlock, mir: &Mir<'_>, w: &mut W) -> io::Result<()> {
let terminator = mir[source].terminator();
let labels = terminator.kind.fmt_successor_labels();
/// all the variables and temporaries.
fn write_graph_label<'a, 'gcx, 'tcx, W: Write>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
def_id: DefId,
- mir: &Mir,
+ mir: &Mir<'_>,
w: &mut W)
-> io::Result<()> {
write!(w, " label=<fn {}(", dot::escape_html(&tcx.item_path_str(def_id)))?;
-//! Liveness analysis which computes liveness of MIR local variables at the boundary of basic blocks
+//! Liveness analysis which computes liveness of MIR local variables at the boundary of basic
+//! blocks.
//!
//! This analysis considers references as being used only at the point of the
//! borrow. This means that this does not track uses because of references that
//! already exist:
//!
-//! ```Rust
-//! fn foo() {
-//! x = 0;
-//! // `x` is live here
-//! GLOBAL = &x: *const u32;
-//! // but not here, even while it can be accessed through `GLOBAL`.
-//! foo();
-//! x = 1;
-//! // `x` is live again here, because it is assigned to `OTHER_GLOBAL`
-//! OTHER_GLOBAL = &x: *const u32;
-//! // ...
-//! }
+//! ```rust
+//! fn foo() {
+//! x = 0;
+//! // `x` is live here ...
+//! GLOBAL = &x: *const u32;
+//! // ... but not here, even while it can be accessed through `GLOBAL`.
+//! foo();
+//! x = 1;
+//! // `x` is live again here, because it is assigned to `OTHER_GLOBAL`.
+//! OTHER_GLOBAL = &x: *const u32;
+//! // ...
+//! }
//! ```
//!
//! This means that users of this analysis still have to check whether
use std::fs;
use std::io::{self, Write};
use std::path::{Path, PathBuf};
-use transform::MirSource;
-use util::pretty::{dump_enabled, write_basic_block, write_mir_intro};
+use crate::transform::MirSource;
+use crate::util::pretty::{dump_enabled, write_basic_block, write_mir_intro};
pub type LiveVarSet<V> = BitSet<V>;
}
}
-/// Compute which local variables are live within the given function
+/// Computes which local variables are live within the given function
/// `mir`. The liveness mode `mode` determines what sorts of uses are
/// considered to make a variable live (e.g., do drops count?).
pub fn liveness_of_locals<'tcx, V: Idx>(
pub fn dump_mir<'a, 'tcx, V: Idx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
pass_name: &str,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &Mir<'tcx>,
map: &impl LiveVariableMap<LiveVar = V>,
result: &LivenessResult<V>,
}
let node_path = item_path::with_forced_impl_filename_line(|| {
// see notes on #41697 below
- tcx.item_path_str(source.def_id)
+ tcx.item_path_str(source.def_id())
});
dump_matched_mir_node(tcx, pass_name, &node_path, source, mir, map, result);
}
tcx: TyCtxt<'a, 'tcx, 'tcx>,
pass_name: &str,
node_path: &str,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &Mir<'tcx>,
map: &dyn LiveVariableMap<LiveVar = V>,
result: &LivenessResult<V>,
) {
let mut file_path = PathBuf::new();
file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir));
- let item_id = tcx.hir().as_local_node_id(source.def_id).unwrap();
+ let item_id = tcx.hir().as_local_node_id(source.def_id()).unwrap();
let file_name = format!("rustc.node{}{}-liveness.mir", item_id, pass_name);
file_path.push(&file_name);
let _ = fs::File::create(&file_path).and_then(|mut file| {
pub fn write_mir_fn<'a, 'tcx, V: Idx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- src: MirSource,
+ src: MirSource<'tcx>,
mir: &Mir<'tcx>,
map: &dyn LiveVariableMap<LiveVar = V>,
w: &mut dyn Write,
}
}
- pub fn source_info_for_index(data: &BasicBlockData, loc: Location) -> SourceInfo {
+ pub fn source_info_for_index(data: &BasicBlockData<'_>, loc: Location) -> SourceInfo {
match data.statements.get(loc.statement_index) {
Some(stmt) => stmt.source_info,
None => data.terminator().source_info
}
}
- pub fn source_info_for_location(&self, mir: &Mir, loc: Location) -> SourceInfo {
+ pub fn source_info_for_location(&self, mir: &Mir<'_>, loc: Location) -> SourceInfo {
let data = match loc.block.index().checked_sub(mir.basic_blocks().len()) {
Some(new) => &self.new_blocks[new],
None => &mir[loc.block]
-use rustc::hir;
use rustc::hir::def_id::{DefId, LOCAL_CRATE};
use rustc::mir::*;
use rustc::mir::visit::Visitor;
use std::io::{self, Write};
use std::path::{Path, PathBuf};
use super::graphviz::write_mir_fn_graphviz;
-use transform::MirSource;
+use crate::transform::MirSource;
const INDENT: &str = " ";
/// Alignment for lining up comments following MIR statements
pass_num: Option<&dyn Display>,
pass_name: &str,
disambiguator: &dyn Display,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &Mir<'tcx>,
extra_data: F,
) where
let node_path = item_path::with_forced_impl_filename_line(|| {
// see notes on #41697 below
- tcx.item_path_str(source.def_id)
+ tcx.item_path_str(source.def_id())
});
dump_matched_mir_node(
tcx,
pub fn dump_enabled<'a, 'gcx, 'tcx>(
tcx: TyCtxt<'a, 'gcx, 'tcx>,
pass_name: &str,
- source: MirSource,
+ source: MirSource<'tcx>,
) -> bool {
let filters = match tcx.sess.opts.debugging_opts.dump_mir {
None => return false,
};
let node_path = item_path::with_forced_impl_filename_line(|| {
// see notes on #41697 below
- tcx.item_path_str(source.def_id)
+ tcx.item_path_str(source.def_id())
});
filters.split('|').any(|or_filter| {
or_filter.split('&').all(|and_filter| {
pass_name: &str,
node_path: &str,
disambiguator: &dyn Display,
- source: MirSource,
+ source: MirSource<'tcx>,
mir: &Mir<'tcx>,
mut extra_data: F,
) where
F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
{
- let _: io::Result<()> = try_block! {
+ let _: io::Result<()> = try {
let mut file = create_dump_file(tcx, "mir", pass_num, pass_name, disambiguator, source)?;
writeln!(file, "// MIR for `{}`", node_path)?;
writeln!(file, "// source = {:?}", source)?;
};
if tcx.sess.opts.debugging_opts.dump_mir_graphviz {
- let _: io::Result<()> = try_block! {
+ let _: io::Result<()> = try {
let mut file =
create_dump_file(tcx, "dot", pass_num, pass_name, disambiguator, source)?;
- write_mir_fn_graphviz(tcx, source.def_id, mir, &mut file)?;
+ write_mir_fn_graphviz(tcx, source.def_id(), mir, &mut file)?;
};
}
}
pass_num: Option<&dyn Display>,
pass_name: &str,
disambiguator: &dyn Display,
- source: MirSource,
+ source: MirSource<'tcx>,
) -> PathBuf {
let promotion_id = match source.promoted {
Some(id) => format!("-{:?}", id),
let mut file_path = PathBuf::new();
file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir));
- let item_name = tcx.hir()
- .def_path(source.def_id)
+ let item_name = tcx
+ .def_path(source.def_id())
.to_filename_friendly_no_crate();
+ // All drop shims have the same DefId, so we have to add the type
+ // to get unique file names.
+ let shim_disambiguator = match source.instance {
+ ty::InstanceDef::DropGlue(_, Some(ty)) => {
+ // Unfortunately, pretty-printed typed are not very filename-friendly.
+ // We dome some filtering.
+ let mut s = ".".to_owned();
+ s.extend(ty.to_string()
+ .chars()
+ .filter_map(|c| match c {
+ ' ' => None,
+ ':' | '<' | '>' => Some('_'),
+ c => Some(c)
+ }));
+ s
+ }
+ _ => String::new(),
+ };
let file_name = format!(
- "rustc.{}{}{}.{}.{}.{}",
+ "rustc.{}{}{}{}.{}.{}.{}",
item_name,
+ shim_disambiguator,
promotion_id,
pass_num,
pass_name,
pass_num: Option<&dyn Display>,
pass_name: &str,
disambiguator: &dyn Display,
- source: MirSource,
+ source: MirSource<'tcx>,
) -> io::Result<fs::File> {
let file_path = dump_path(tcx, extension, pass_num, pass_name, disambiguator, source);
if let Some(parent) = file_path.parent() {
for (i, mir) in mir.promoted.iter_enumerated() {
writeln!(w, "")?;
let src = MirSource {
- def_id,
+ instance: ty::InstanceDef::Item(def_id),
promoted: Some(i),
};
write_mir_fn(tcx, src, mir, &mut |_, _| Ok(()), w)?;
pub fn write_mir_fn<'a, 'gcx, 'tcx, F>(
tcx: TyCtxt<'a, 'gcx, 'tcx>,
- src: MirSource,
+ src: MirSource<'tcx>,
mir: &Mir<'tcx>,
extra_data: &mut F,
w: &mut dyn Write,
}
}
-fn comment(tcx: TyCtxt, SourceInfo { span, scope }: SourceInfo) -> String {
+fn comment(tcx: TyCtxt<'_, '_, '_>, SourceInfo { span, scope }: SourceInfo) -> String {
format!(
"scope {} at {}",
scope.index(),
///
/// Returns the total number of variables printed.
fn write_scope_tree(
- tcx: TyCtxt,
- mir: &Mir,
+ tcx: TyCtxt<'_, '_, '_>,
+ mir: &Mir<'_>,
scope_tree: &FxHashMap<SourceScope, Vec<SourceScope>>,
w: &mut dyn Write,
parent: SourceScope,
/// local variables (both user-defined bindings and compiler temporaries).
pub fn write_mir_intro<'a, 'gcx, 'tcx>(
tcx: TyCtxt<'a, 'gcx, 'tcx>,
- src: MirSource,
- mir: &Mir,
+ src: MirSource<'tcx>,
+ mir: &Mir<'_>,
w: &mut dyn Write,
) -> io::Result<()> {
write_mir_sig(tcx, src, mir, w)?;
Ok(())
}
-fn write_mir_sig(tcx: TyCtxt, src: MirSource, mir: &Mir, w: &mut dyn Write) -> io::Result<()> {
- let id = tcx.hir().as_local_node_id(src.def_id).unwrap();
- let body_owner_kind = tcx.hir().body_owner_kind(id);
- match (body_owner_kind, src.promoted) {
- (_, Some(i)) => write!(w, "{:?} in", i)?,
- (hir::BodyOwnerKind::Closure, _) |
- (hir::BodyOwnerKind::Fn, _) => write!(w, "fn")?,
- (hir::BodyOwnerKind::Const, _) => write!(w, "const")?,
- (hir::BodyOwnerKind::Static(hir::MutImmutable), _) => write!(w, "static")?,
- (hir::BodyOwnerKind::Static(hir::MutMutable), _) => write!(w, "static mut")?,
+fn write_mir_sig(
+ tcx: TyCtxt<'_, '_, '_>,
+ src: MirSource<'tcx>,
+ mir: &Mir<'_>,
+ w: &mut dyn Write,
+) -> io::Result<()> {
+ use rustc::hir::def::Def;
+
+ trace!("write_mir_sig: {:?}", src.instance);
+ let descr = tcx.describe_def(src.def_id());
+ let is_function = match descr {
+ Some(Def::Fn(_)) | Some(Def::Method(_)) | Some(Def::StructCtor(..)) => true,
+ _ => tcx.is_closure(src.def_id()),
+ };
+ match (descr, src.promoted) {
+ (_, Some(i)) => write!(w, "{:?} in ", i)?,
+ (Some(Def::StructCtor(..)), _) => write!(w, "struct ")?,
+ (Some(Def::Const(_)), _)
+ | (Some(Def::AssociatedConst(_)), _) => write!(w, "const ")?,
+ (Some(Def::Static(_, /*is_mutbl*/false)), _) => write!(w, "static ")?,
+ (Some(Def::Static(_, /*is_mutbl*/true)), _) => write!(w, "static mut ")?,
+ (_, _) if is_function => write!(w, "fn ")?,
+ (None, _) => {}, // things like anon const, not an item
+ _ => bug!("Unexpected def description {:?}", descr),
}
item_path::with_forced_impl_filename_line(|| {
// see notes on #41697 elsewhere
- write!(w, " {}", tcx.item_path_str(src.def_id))
+ write!(w, "{}", tcx.item_path_str(src.def_id()))
})?;
- match (body_owner_kind, src.promoted) {
- (hir::BodyOwnerKind::Closure, None) |
- (hir::BodyOwnerKind::Fn, None) => {
- write!(w, "(")?;
+ if src.promoted.is_none() && is_function {
+ write!(w, "(")?;
- // fn argument types.
- for (i, arg) in mir.args_iter().enumerate() {
- if i != 0 {
- write!(w, ", ")?;
- }
- write!(w, "{:?}: {}", Place::Local(arg), mir.local_decls[arg].ty)?;
+ // fn argument types.
+ for (i, arg) in mir.args_iter().enumerate() {
+ if i != 0 {
+ write!(w, ", ")?;
}
-
- write!(w, ") -> {}", mir.return_ty())?;
- }
- (hir::BodyOwnerKind::Const, _) | (hir::BodyOwnerKind::Static(_), _) | (_, Some(_)) => {
- assert_eq!(mir.arg_count, 0);
- write!(w, ": {} =", mir.return_ty())?;
+ write!(w, "{:?}: {}", Place::Local(arg), mir.local_decls[arg].ty)?;
}
+
+ write!(w, ") -> {}", mir.return_ty())?;
+ } else {
+ assert_eq!(mir.arg_count, 0);
+ write!(w, ": {} =", mir.return_ty())?;
}
if let Some(yield_ty) = mir.yield_ty {
writeln!(w, "yields {}", yield_ty)?;
}
+ write!(w, " ")?;
+ // Next thing that gets printed is the opening {
+
Ok(())
}
-fn write_temp_decls(mir: &Mir, w: &mut dyn Write) -> io::Result<()> {
+fn write_temp_decls(mir: &Mir<'_>, w: &mut dyn Write) -> io::Result<()> {
// Compiler-introduced temporary types.
for temp in mir.temps_iter() {
writeln!(
Ok(())
}
-fn write_user_type_annotations(mir: &Mir, w: &mut dyn Write) -> io::Result<()> {
+fn write_user_type_annotations(mir: &Mir<'_>, w: &mut dyn Write) -> io::Result<()> {
if !mir.user_type_annotations.is_empty() {
writeln!(w, "| User Type Annotations")?;
}
Ok(())
}
-pub fn dump_mir_def_ids(tcx: TyCtxt, single: Option<DefId>) -> Vec<DefId> {
+pub fn dump_mir_def_ids(tcx: TyCtxt<'_, '_, '_>, single: Option<DefId>) -> Vec<DefId> {
if let Some(i) = single {
vec![i]
} else {
#![sanitizer_runtime]
+#![feature(nll)]
#![feature(sanitizer_runtime)]
#![feature(staged_api)]
#![no_std]
authors = ["The Rust Project Developers"]
name = "rustc_passes"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_passes"
syntax = { path = "../libsyntax" }
syntax_ext = { path = "../libsyntax_ext" }
syntax_pos = { path = "../libsyntax_pos" }
-rustc_errors = { path = "../librustc_errors" }
+errors = { path = "../librustc_errors", package = "rustc_errors" }
use syntax::symbol::keywords;
use syntax::ptr::P;
use syntax::visit::{self, Visitor};
+use syntax::{span_err, struct_span_err, walk_list};
use syntax_ext::proc_macro_decls::is_proc_macro_attr;
use syntax_pos::Span;
-use errors;
use errors::Applicability;
+use log::debug;
struct AstValidator<'a> {
session: &'a Session,
}
}
- /// matches '-' lit | lit (cf. parser::Parser::parse_literal_maybe_minus),
- /// or path for ranges.
- ///
- /// FIXME: do we want to allow expr -> pattern conversion to create path expressions?
- /// That means making this work:
- ///
- /// ```rust,ignore (FIXME)
- /// struct S;
- /// macro_rules! m {
- /// ($a:expr) => {
- /// let $a = S;
- /// }
- /// }
- /// m!(S);
- /// ```
+ /// Matches `'-' lit | lit (cf. parser::Parser::parse_literal_maybe_minus)`,
+ /// or paths for ranges.
+ //
+ // FIXME: do we want to allow `expr -> pattern` conversion to create path expressions?
+ // That means making this work:
+ //
+ // ```rust,ignore (FIXME)
+ // struct S;
+ // macro_rules! m {
+ // ($a:expr) => {
+ // let $a = S;
+ // }
+ // }
+ // m!(S);
+ // ```
fn check_expr_within_pat(&self, expr: &Expr, allow_paths: bool) {
match expr.node {
ExprKind::Lit(..) => {}
if let Some(ref type_) = data.output {
// `-> Foo` syntax is essentially an associated type binding,
// so it is also allowed to contain nested `impl Trait`.
- self.with_impl_trait(None, |this| visit::walk_ty(this, type_));
+ self.with_impl_trait(None, |this| this.visit_ty(type_));
}
}
}
#![allow(non_snake_case)]
+use syntax::{register_diagnostic, register_diagnostics, register_long_diagnostics};
+
register_long_diagnostics! {
/*
E0014: r##"
});
entry.count += 1;
- entry.size = ::std::mem::size_of_val(node);
+ entry.size = std::mem::size_of_val(node);
}
fn print(&self, title: &str) {
#![recursion_limit="256"]
-#[macro_use]
-extern crate rustc;
-extern crate rustc_mir;
-extern crate rustc_data_structures;
+#![deny(rust_2018_idioms)]
#[macro_use]
-extern crate log;
-#[macro_use]
-extern crate syntax;
-extern crate syntax_ext;
-extern crate syntax_pos;
-extern crate rustc_errors as errors;
+extern crate rustc;
use rustc::ty::query::Providers;
__build_diagnostic_array! { librustc_passes, DIAGNOSTICS }
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
rvalue_promotion::provide(providers);
loops::provide(providers);
}
-use self::Context::*;
+use Context::*;
use rustc::session::Session;
use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
use rustc::hir::{self, Node, Destination};
use syntax::ast;
+use syntax::struct_span_err;
use syntax_pos::Span;
use errors::Applicability;
}.as_deep_visitor());
}
-pub(crate) fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers<'_>) {
*providers = Providers {
check_mod_loops,
..*providers
use rustc_data_structures::sync::Lrc;
use syntax::ast;
use syntax_pos::{Span, DUMMY_SP};
-use self::Promotability::*;
+use log::debug;
+use Promotability::*;
use std::ops::{BitAnd, BitAndAssign, BitOr};
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
*providers = Providers {
rvalue_promotable_map,
const_is_rvalue_promotable_to_static,
let node_id = tcx.hir().as_local_node_id(def_id)
.expect("rvalue_promotable_map invoked with non-local def-id");
let body_id = tcx.hir().body_owned_by(node_id);
- let body_hir_id = tcx.hir().node_to_hir_id(body_id.node_id);
- tcx.rvalue_promotable_map(def_id).contains(&body_hir_id.local_id)
+ tcx.rvalue_promotable_map(def_id).contains(&body_id.hir_id.local_id)
}
fn rvalue_promotable_map<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
}
/// While the `ExprUseVisitor` walks, we will identify which
- /// expressions are borrowed, and insert their ids into this
+ /// expressions are borrowed, and insert their IDs into this
/// table. Actually, we insert the "borrow-id", which is normally
- /// the id of the expression being borrowed: but in the case of
+ /// the ID of the expression being borrowed: but in the case of
/// `ref mut` borrows, the `id` of the pattern is
- /// inserted. Therefore later we remove that entry from the table
+ /// inserted. Therefore, later we remove that entry from the table
/// and transfer it over to the value being matched. This will
/// then prevent said value from being promoted.
fn remove_mut_rvalue_borrow(&mut self, pat: &hir::Pat) -> bool {
}
fn check_expr(&mut self, ex: &'tcx hir::Expr) -> Promotability {
- let node_ty = self.tables.node_id_to_type(ex.hir_id);
+ let node_ty = self.tables.node_type(ex.hir_id);
let mut outer = check_expr_kind(self, ex, node_ty);
outer &= check_adjustments(self, ex);
if v.tables.is_method_call(e) {
return NotPromotable;
}
- match v.tables.node_id_to_type(lhs.hir_id).sty {
+ match v.tables.node_type(lhs.hir_id).sty {
ty::RawPtr(_) | ty::FnPtr(..) => {
assert!(op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne ||
op.node == hir::BinOpKind::Le || op.node == hir::BinOpKind::Lt ||
ty_result & node_result
}
-/// Check the adjustments of an expression
+/// Checks the adjustments of an expression.
fn check_adjustments<'a, 'tcx>(
v: &mut CheckCrateVisitor<'a, 'tcx>,
e: &hir::Expr) -> Promotability {
fn consume(&mut self,
_consume_id: ast::NodeId,
_consume_span: Span,
- _cmt: &mc::cmt_,
+ _cmt: &mc::cmt_<'_>,
_mode: euv::ConsumeMode) {}
fn borrow(&mut self,
fn mutate(&mut self,
_assignment_id: ast::NodeId,
_assignment_span: Span,
- _assignee_cmt: &mc::cmt_,
+ _assignee_cmt: &mc::cmt_<'_>,
_mode: euv::MutateMode) {
}
- fn matched_pat(&mut self, _: &hir::Pat, _: &mc::cmt_, _: euv::MatchMode) {}
+ fn matched_pat(&mut self, _: &hir::Pat, _: &mc::cmt_<'_>, _: euv::MatchMode) {}
- fn consume_pat(&mut self, _consume_pat: &hir::Pat, _cmt: &mc::cmt_, _mode: euv::ConsumeMode) {}
+ fn consume_pat(&mut self,
+ _consume_pat: &hir::Pat,
+ _cmt: &mc::cmt_<'_>,
+ _mode: euv::ConsumeMode) {}
}
}
}
-/// Find the function marked with `#[plugin_registrar]`, if any.
+/// Finds the function marked with `#[plugin_registrar]`, if any.
pub fn find_plugin_registrar<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>) -> Option<DefId> {
tcx.plugin_registrar_fn(LOCAL_CRATE)
}
//! in various ways.
//!
//! Plugin authors will use the `Registry` type re-exported by
-//! this module, along with its methods. The rest of the module
+//! this module, along with its methods. The rest of the module
//! is for use by `rustc` itself.
//!
//! To define a plugin, build a dylib crate with a
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
+#![feature(nll)]
#![feature(rustc_diagnostic_macros)]
#![recursion_limit="256"]
}
}
- /// Get the plugin's arguments, if any.
+ /// Gets the plugin's arguments, if any.
///
/// These are specified inside the `plugin` crate attribute as
///
edition,
}
}
- IdentTT(ext, _, allow_internal_unstable) => {
- IdentTT(ext, Some(self.krate_span), allow_internal_unstable)
+ IdentTT { expander, span: _, allow_internal_unstable } => {
+ IdentTT { expander, span: Some(self.krate_span), allow_internal_unstable }
}
_ => extension,
}));
self.register_syntax_extension(Symbol::intern(name), NormalTT {
expander: Box::new(expander),
def_info: None,
- allow_internal_unstable: false,
+ allow_internal_unstable: None,
allow_internal_unsafe: false,
local_inner_macros: false,
unstable_feature: None,
#![deny(rust_2018_idioms)]
+#![feature(nll)]
#![feature(rustc_diagnostic_macros)]
#![recursion_limit="256"]
/// Implemented to visit all `DefId`s in a type.
/// Visiting `DefId`s is useful because visibilities and reachabilities are attached to them.
/// The idea is to visit "all components of a type", as documented in
-/// https://github.com/rust-lang/rfcs/blob/master/text/2145-type-privacy.md#how-to-determine-visibility-of-a-type
-/// Default type visitor (`TypeVisitor`) does most of the job, but it has some shortcomings.
-/// First, it doesn't have overridable `fn visit_trait_ref`, so we have to catch trait def-ids
+/// https://github.com/rust-lang/rfcs/blob/master/text/2145-type-privacy.md#how-to-determine-visibility-of-a-type.
+/// The default type visitor (`TypeVisitor`) does most of the job, but it has some shortcomings.
+/// First, it doesn't have overridable `fn visit_trait_ref`, so we have to catch trait `DefId`s
/// manually. Second, it doesn't visit some type components like signatures of fn types, or traits
/// in `impl Trait`, see individual comments in `DefIdVisitorSkeleton::visit_ty`.
trait DefIdVisitor<'a, 'tcx: 'a> {
}
////////////////////////////////////////////////////////////////////////////////
-/// The embargo visitor, used to determine the exports of the ast
+/// The embargo visitor, used to determine the exports of the AST.
////////////////////////////////////////////////////////////////////////////////
struct EmbargoVisitor<'a, 'tcx: 'a> {
def: &'tcx ty::AdtDef, // definition of the struct or enum
field: &'tcx ty::FieldDef) { // definition of the field
let ident = Ident::new(keywords::Invalid.name(), use_ctxt);
- let def_id = self.tcx.adjust_ident(ident, def.did, self.current_item).1;
+ let current_hir = self.tcx.hir().node_to_hir_id(self.current_item);
+ let def_id = self.tcx.adjust_ident(ident, def.did, current_hir).1;
if !def.is_enum() && !field.vis.is_accessible_from(def_id, self.tcx) {
struct_span_err!(self.tcx.sess, span, E0451, "field `{}` of {} `{}` is private",
field.ident, def.variant_descr(), self.tcx.item_path_str(def.did))
// Take node-id of an expression or pattern and check its type for privacy.
fn check_expr_pat_type(&mut self, id: hir::HirId, span: Span) -> bool {
self.span = span;
- if self.visit(self.tables.node_id_to_type(id)) || self.visit(self.tables.node_substs(id)) {
+ if self.visit(self.tables.node_type(id)) || self.visit(self.tables.node_substs(id)) {
return true;
}
if let Some(adjustments) = self.tables.adjustments().get(id) {
self.span = hir_ty.span;
if self.in_body {
// Types in bodies.
- if self.visit(self.tables.node_id_to_type(hir_ty.hir_id)) {
+ if self.visit(self.tables.node_type(hir_ty.hir_id)) {
return;
}
} else {
syntax = { path = "../libsyntax" }
rustc = { path = "../librustc" }
arena = { path = "../libarena" }
-rustc_errors = { path = "../librustc_errors" }
+errors = { path = "../librustc_errors", package = "rustc_errors" }
syntax_pos = { path = "../libsyntax_pos" }
rustc_data_structures = { path = "../librustc_data_structures" }
rustc_metadata = { path = "../librustc_metadata" }
-//! Reduced graph building
+//! Reduced graph building.
//!
//! Here we build the "reduced graph": the graph of the module tree without
//! any imports resolved.
use std::ptr;
use rustc_data_structures::sync::Lrc;
-use crate::errors::Applicability;
+use errors::Applicability;
use syntax::ast::{Name, Ident};
use syntax::attr;
}
}
- // This returns true if we should consider the underlying `extern crate` to be used.
+ /// Returns `true` if we should consider the underlying `extern crate` to be used.
fn process_legacy_macro_imports(&mut self, item: &Item, module: Module<'a>,
parent_scope: &ParentScope<'a>) -> bool {
let mut import_all = None;
import_all.is_some() || !single_imports.is_empty()
}
- // does this attribute list contain "macro_use"?
+ /// Returns `true` if this attribute list contains `macro_use`.
fn contains_macro_use(&mut self, attrs: &[ast::Attribute]) -> bool {
for attr in attrs {
if attr.check_name("macro_escape") {
//
// Unused trait imports can't be checked until the method resolution. We save
// candidates here, and do the actual check in librustc_typeck/check_unused.rs.
+//
+// Checking for unused imports is split into three steps:
+//
+// - `UnusedImportCheckVisitor` walks the AST to find all the unused imports
+// inside of `UseTree`s, recording their `NodeId`s and grouping them by
+// the parent `use` item
+//
+// - `calc_unused_spans` then walks over all the `use` items marked in the
+// previous step to collect the spans associated with the `NodeId`s and to
+// calculate the spans that can be removed by rustfix; This is done in a
+// separate step to be able to collapse the adjacent spans that rustfix
+// will remove
+//
+// - `check_crate` finally emits the diagnostics based on the data generated
+// in the last step
use std::ops::{Deref, DerefMut};
use crate::Resolver;
use crate::resolve_imports::ImportDirectiveSubclass;
-use rustc::{lint, ty};
use rustc::util::nodemap::NodeMap;
+use rustc::{lint, ty};
+use rustc_data_structures::fx::FxHashSet;
use syntax::ast;
use syntax::visit::{self, Visitor};
use syntax_pos::{Span, MultiSpan, DUMMY_SP};
+struct UnusedImport<'a> {
+ use_tree: &'a ast::UseTree,
+ use_tree_id: ast::NodeId,
+ item_span: Span,
+ unused: FxHashSet<ast::NodeId>,
+}
+
+impl<'a> UnusedImport<'a> {
+ fn add(&mut self, id: ast::NodeId) {
+ self.unused.insert(id);
+ }
+}
struct UnusedImportCheckVisitor<'a, 'b: 'a> {
resolver: &'a mut Resolver<'b>,
/// All the (so far) unused imports, grouped path list
- unused_imports: NodeMap<NodeMap<Span>>,
+ unused_imports: NodeMap<UnusedImport<'a>>,
+ base_use_tree: Option<&'a ast::UseTree>,
base_id: ast::NodeId,
item_span: Span,
}
impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> {
// We have information about whether `use` (import) directives are actually
// used now. If an import is not used at all, we signal a lint error.
- fn check_import(&mut self, item_id: ast::NodeId, id: ast::NodeId, span: Span) {
+ fn check_import(&mut self, id: ast::NodeId) {
let mut used = false;
self.per_ns(|this, ns| used |= this.used_imports.contains(&(id, ns)));
if !used {
// Check later.
return;
}
- self.unused_imports.entry(item_id).or_default().insert(id, span);
+ self.unused_import(self.base_id).add(id);
} else {
// This trait import is definitely used, in a way other than
// method resolution.
self.maybe_unused_trait_imports.remove(&id);
- if let Some(i) = self.unused_imports.get_mut(&item_id) {
- i.remove(&id);
+ if let Some(i) = self.unused_imports.get_mut(&self.base_id) {
+ i.unused.remove(&id);
}
}
}
+
+ fn unused_import(&mut self, id: ast::NodeId) -> &mut UnusedImport<'a> {
+ let use_tree_id = self.base_id;
+ let use_tree = self.base_use_tree.unwrap();
+ let item_span = self.item_span;
+
+ self.unused_imports
+ .entry(id)
+ .or_insert_with(|| UnusedImport {
+ use_tree,
+ use_tree_id,
+ item_span,
+ unused: FxHashSet::default(),
+ })
+ }
}
impl<'a, 'b> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b> {
// This allows the grouping of all the lints in the same item
if !nested {
self.base_id = id;
+ self.base_use_tree = Some(use_tree);
}
if let ast::UseTreeKind::Nested(ref items) = use_tree.kind {
- // If it's the parent group, cover the entire use item
- let span = if nested {
- use_tree.span
- } else {
- self.item_span
- };
-
if items.is_empty() {
- self.unused_imports
- .entry(self.base_id)
- .or_default()
- .insert(id, span);
+ self.unused_import(self.base_id).add(id);
}
} else {
- let base_id = self.base_id;
- self.check_import(base_id, id, use_tree.span);
+ self.check_import(id);
}
visit::walk_use_tree(self, use_tree, id);
}
}
+enum UnusedSpanResult {
+ Used,
+ FlatUnused(Span, Span),
+ NestedFullUnused(Vec<Span>, Span),
+ NestedPartialUnused(Vec<Span>, Vec<Span>),
+}
+
+fn calc_unused_spans(
+ unused_import: &UnusedImport<'_>,
+ use_tree: &ast::UseTree,
+ use_tree_id: ast::NodeId,
+) -> UnusedSpanResult {
+ // The full span is the whole item's span if this current tree is not nested inside another
+ // This tells rustfix to remove the whole item if all the imports are unused
+ let full_span = if unused_import.use_tree.span == use_tree.span {
+ unused_import.item_span
+ } else {
+ use_tree.span
+ };
+ match use_tree.kind {
+ ast::UseTreeKind::Simple(..) | ast::UseTreeKind::Glob => {
+ if unused_import.unused.contains(&use_tree_id) {
+ UnusedSpanResult::FlatUnused(use_tree.span, full_span)
+ } else {
+ UnusedSpanResult::Used
+ }
+ }
+ ast::UseTreeKind::Nested(ref nested) => {
+ if nested.len() == 0 {
+ return UnusedSpanResult::FlatUnused(use_tree.span, full_span);
+ }
+
+ let mut unused_spans = Vec::new();
+ let mut to_remove = Vec::new();
+ let mut all_nested_unused = true;
+ let mut previous_unused = false;
+ for (pos, (use_tree, use_tree_id)) in nested.iter().enumerate() {
+ let remove = match calc_unused_spans(unused_import, use_tree, *use_tree_id) {
+ UnusedSpanResult::Used => {
+ all_nested_unused = false;
+ None
+ }
+ UnusedSpanResult::FlatUnused(span, remove) => {
+ unused_spans.push(span);
+ Some(remove)
+ }
+ UnusedSpanResult::NestedFullUnused(mut spans, remove) => {
+ unused_spans.append(&mut spans);
+ Some(remove)
+ }
+ UnusedSpanResult::NestedPartialUnused(mut spans, mut to_remove_extra) => {
+ all_nested_unused = false;
+ unused_spans.append(&mut spans);
+ to_remove.append(&mut to_remove_extra);
+ None
+ }
+ };
+ if let Some(remove) = remove {
+ let remove_span = if nested.len() == 1 {
+ remove
+ } else if pos == nested.len() - 1 || !all_nested_unused {
+ // Delete everything from the end of the last import, to delete the
+ // previous comma
+ nested[pos - 1].0.span.shrink_to_hi().to(use_tree.span)
+ } else {
+ // Delete everything until the next import, to delete the trailing commas
+ use_tree.span.to(nested[pos + 1].0.span.shrink_to_lo())
+ };
+
+ // Try to collapse adjacent spans into a single one. This prevents all cases of
+ // overlapping removals, which are not supported by rustfix
+ if previous_unused && !to_remove.is_empty() {
+ let previous = to_remove.pop().unwrap();
+ to_remove.push(previous.to(remove_span));
+ } else {
+ to_remove.push(remove_span);
+ }
+ }
+ previous_unused = remove.is_some();
+ }
+ if unused_spans.is_empty() {
+ UnusedSpanResult::Used
+ } else if all_nested_unused {
+ UnusedSpanResult::NestedFullUnused(unused_spans, full_span)
+ } else {
+ UnusedSpanResult::NestedPartialUnused(unused_spans, to_remove)
+ }
+ }
+ }
+}
+
pub fn check_crate(resolver: &mut Resolver<'_>, krate: &ast::Crate) {
for directive in resolver.potentially_unused_imports.iter() {
match directive.subclass {
let mut visitor = UnusedImportCheckVisitor {
resolver,
unused_imports: Default::default(),
+ base_use_tree: None,
base_id: ast::DUMMY_NODE_ID,
item_span: DUMMY_SP,
};
visit::walk_crate(&mut visitor, krate);
- for (id, spans) in &visitor.unused_imports {
+ for unused in visitor.unused_imports.values() {
+ let mut fixes = Vec::new();
+ let mut spans = match calc_unused_spans(unused, unused.use_tree, unused.use_tree_id) {
+ UnusedSpanResult::Used => continue,
+ UnusedSpanResult::FlatUnused(span, remove) => {
+ fixes.push((remove, String::new()));
+ vec![span]
+ }
+ UnusedSpanResult::NestedFullUnused(spans, remove) => {
+ fixes.push((remove, String::new()));
+ spans
+ }
+ UnusedSpanResult::NestedPartialUnused(spans, remove) => {
+ for fix in &remove {
+ fixes.push((*fix, String::new()));
+ }
+ spans
+ }
+ };
+
let len = spans.len();
- let mut spans = spans.values().cloned().collect::<Vec<Span>>();
spans.sort();
let ms = MultiSpan::from_spans(spans.clone());
let mut span_snippets = spans.iter()
} else {
String::new()
});
- visitor.session.buffer_lint(lint::builtin::UNUSED_IMPORTS, *id, ms, &msg);
+
+ let fix_msg = if fixes.len() == 1 && fixes[0].0 == unused.item_span {
+ "remove the whole `use` item"
+ } else if spans.len() > 1 {
+ "remove the unused imports"
+ } else {
+ "remove the unused import"
+ };
+
+ visitor.session.buffer_lint_with_diagnostic(
+ lint::builtin::UNUSED_IMPORTS,
+ unused.use_tree_id,
+ ms,
+ &msg,
+ lint::builtin::BuiltinLintDiagnostics::UnusedImports(fix_msg.into(), fixes),
+ );
}
}
-use crate::{CrateLint, PathResult, Segment};
-use crate::macros::ParentScope;
-use crate::resolve_imports::ImportResolver;
+use std::cmp::Reverse;
+use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
+use log::debug;
+use rustc::hir::def::*;
+use rustc::hir::def::Namespace::*;
+use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId};
+use rustc::session::config::nightly_options;
+use syntax::ast::{ExprKind};
use syntax::symbol::keywords;
use syntax_pos::Span;
-use log::debug;
+use crate::macros::ParentScope;
+use crate::resolve_imports::ImportResolver;
+use crate::{import_candidate_to_enum_paths, is_self_type, is_self_value, path_names_to_string};
+use crate::{AssocSuggestion, CrateLint, ImportSuggestion, ModuleOrUniformRoot, PathResult,
+ PathSource, Resolver, Segment};
-use std::cmp::Reverse;
+impl<'a> Resolver<'a> {
+ /// Handles error reporting for `smart_resolve_path_fragment` function.
+ /// Creates base error and amends it with one short label and possibly some longer helps/notes.
+ pub(crate) fn smart_resolve_report_errors(
+ &mut self,
+ path: &[Segment],
+ span: Span,
+ source: PathSource<'_>,
+ def: Option<Def>,
+ ) -> (DiagnosticBuilder<'a>, Vec<ImportSuggestion>) {
+ let ident_span = path.last().map_or(span, |ident| ident.ident.span);
+ let ns = source.namespace();
+ let is_expected = &|def| source.is_expected(def);
+ let is_enum_variant = &|def| if let Def::Variant(..) = def { true } else { false };
+
+ // Make the base error.
+ let expected = source.descr_expected();
+ let path_str = Segment::names_to_string(path);
+ let item_str = path.last().unwrap().ident;
+ let code = source.error_code(def.is_some());
+ let (base_msg, fallback_label, base_span) = if let Some(def) = def {
+ (format!("expected {}, found {} `{}`", expected, def.kind_name(), path_str),
+ format!("not a {}", expected),
+ span)
+ } else {
+ let item_span = path.last().unwrap().ident.span;
+ let (mod_prefix, mod_str) = if path.len() == 1 {
+ (String::new(), "this scope".to_string())
+ } else if path.len() == 2 && path[0].ident.name == keywords::PathRoot.name() {
+ (String::new(), "the crate root".to_string())
+ } else {
+ let mod_path = &path[..path.len() - 1];
+ let mod_prefix = match self.resolve_path_without_parent_scope(
+ mod_path, Some(TypeNS), false, span, CrateLint::No
+ ) {
+ PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
+ module.def(),
+ _ => None,
+ }.map_or(String::new(), |def| format!("{} ", def.kind_name()));
+ (mod_prefix, format!("`{}`", Segment::names_to_string(mod_path)))
+ };
+ (format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str),
+ format!("not found in {}", mod_str),
+ item_span)
+ };
+
+ let code = DiagnosticId::Error(code.into());
+ let mut err = self.session.struct_span_err_with_code(base_span, &base_msg, code);
+
+ // Emit help message for fake-self from other languages (e.g., `this` in Javascript).
+ if ["this", "my"].contains(&&*item_str.as_str())
+ && self.self_value_is_available(path[0].ident.span, span) {
+ err.span_suggestion(
+ span,
+ "did you mean",
+ "self".to_string(),
+ Applicability::MaybeIncorrect,
+ );
+ }
+
+ // Emit special messages for unresolved `Self` and `self`.
+ if is_self_type(path, ns) {
+ __diagnostic_used!(E0411);
+ err.code(DiagnosticId::Error("E0411".into()));
+ err.span_label(span, format!("`Self` is only available in impls, traits, \
+ and type definitions"));
+ return (err, Vec::new());
+ }
+ if is_self_value(path, ns) {
+ debug!("smart_resolve_path_fragment: E0424, source={:?}", source);
+
+ __diagnostic_used!(E0424);
+ err.code(DiagnosticId::Error("E0424".into()));
+ err.span_label(span, match source {
+ PathSource::Pat => {
+ format!("`self` value is a keyword \
+ and may not be bound to \
+ variables or shadowed")
+ }
+ _ => {
+ format!("`self` value is a keyword \
+ only available in methods \
+ with `self` parameter")
+ }
+ });
+ return (err, Vec::new());
+ }
+
+ // Try to lookup name in more relaxed fashion for better error reporting.
+ let ident = path.last().unwrap().ident;
+ let candidates = self.lookup_import_candidates(ident, ns, is_expected)
+ .drain(..)
+ .filter(|ImportSuggestion { did, .. }| {
+ match (did, def.and_then(|def| def.opt_def_id())) {
+ (Some(suggestion_did), Some(actual_did)) => *suggestion_did != actual_did,
+ _ => true,
+ }
+ })
+ .collect::<Vec<_>>();
+ if candidates.is_empty() && is_expected(Def::Enum(DefId::local(CRATE_DEF_INDEX))) {
+ let enum_candidates =
+ self.lookup_import_candidates(ident, ns, is_enum_variant);
+ let mut enum_candidates = enum_candidates.iter()
+ .map(|suggestion| {
+ import_candidate_to_enum_paths(&suggestion)
+ }).collect::<Vec<_>>();
+ enum_candidates.sort();
+
+ if !enum_candidates.is_empty() {
+ // Contextualize for E0412 "cannot find type", but don't belabor the point
+ // (that it's a variant) for E0573 "expected type, found variant".
+ let preamble = if def.is_none() {
+ let others = match enum_candidates.len() {
+ 1 => String::new(),
+ 2 => " and 1 other".to_owned(),
+ n => format!(" and {} others", n)
+ };
+ format!("there is an enum variant `{}`{}; ",
+ enum_candidates[0].0, others)
+ } else {
+ String::new()
+ };
+ let msg = format!("{}try using the variant's enum", preamble);
+
+ err.span_suggestions(
+ span,
+ &msg,
+ enum_candidates.into_iter()
+ .map(|(_variant_path, enum_ty_path)| enum_ty_path)
+ // Variants re-exported in prelude doesn't mean `prelude::v1` is the
+ // type name!
+ // FIXME: is there a more principled way to do this that
+ // would work for other re-exports?
+ .filter(|enum_ty_path| enum_ty_path != "std::prelude::v1")
+ // Also write `Option` rather than `std::prelude::v1::Option`.
+ .map(|enum_ty_path| {
+ // FIXME #56861: DRY-er prelude filtering.
+ enum_ty_path.trim_start_matches("std::prelude::v1::").to_owned()
+ }),
+ Applicability::MachineApplicable,
+ );
+ }
+ }
+ if path.len() == 1 && self.self_type_is_available(span) {
+ if let Some(candidate) = self.lookup_assoc_candidate(ident, ns, is_expected) {
+ let self_is_available = self.self_value_is_available(path[0].ident.span, span);
+ match candidate {
+ AssocSuggestion::Field => {
+ err.span_suggestion(
+ span,
+ "try",
+ format!("self.{}", path_str),
+ Applicability::MachineApplicable,
+ );
+ if !self_is_available {
+ err.span_label(span, format!("`self` value is a keyword \
+ only available in \
+ methods with `self` parameter"));
+ }
+ }
+ AssocSuggestion::MethodWithSelf if self_is_available => {
+ err.span_suggestion(
+ span,
+ "try",
+ format!("self.{}", path_str),
+ Applicability::MachineApplicable,
+ );
+ }
+ AssocSuggestion::MethodWithSelf | AssocSuggestion::AssocItem => {
+ err.span_suggestion(
+ span,
+ "try",
+ format!("Self::{}", path_str),
+ Applicability::MachineApplicable,
+ );
+ }
+ }
+ return (err, candidates);
+ }
+ }
+
+ let mut levenshtein_worked = false;
+
+ // Try Levenshtein algorithm.
+ let suggestion = self.lookup_typo_candidate(path, ns, is_expected, span);
+ if let Some(suggestion) = suggestion {
+ let msg = format!(
+ "{} {} with a similar name exists",
+ suggestion.article, suggestion.kind
+ );
+ err.span_suggestion(
+ ident_span,
+ &msg,
+ suggestion.candidate.to_string(),
+ Applicability::MaybeIncorrect,
+ );
+
+ levenshtein_worked = true;
+ }
+
+ // Try context-dependent help if relaxed lookup didn't work.
+ if let Some(def) = def {
+ if self.smart_resolve_context_dependent_help(&mut err,
+ span,
+ source,
+ def,
+ &path_str,
+ &fallback_label) {
+ return (err, candidates);
+ }
+ }
+
+ // Fallback label.
+ if !levenshtein_worked {
+ err.span_label(base_span, fallback_label);
+ self.type_ascription_suggestion(&mut err, base_span);
+ }
+ (err, candidates)
+ }
+
+ /// Provides context-dependent help for errors reported by the `smart_resolve_path_fragment`
+ /// function.
+ /// Returns `true` if able to provide context-dependent help.
+ fn smart_resolve_context_dependent_help(
+ &mut self,
+ err: &mut DiagnosticBuilder<'a>,
+ span: Span,
+ source: PathSource<'_>,
+ def: Def,
+ path_str: &str,
+ fallback_label: &str,
+ ) -> bool {
+ let ns = source.namespace();
+ let is_expected = &|def| source.is_expected(def);
+
+ match (def, source) {
+ (Def::Macro(..), _) => {
+ err.span_suggestion(
+ span,
+ "use `!` to invoke the macro",
+ format!("{}!", path_str),
+ Applicability::MaybeIncorrect,
+ );
+ }
+ (Def::TyAlias(..), PathSource::Trait(_)) => {
+ err.span_label(span, "type aliases cannot be used as traits");
+ if nightly_options::is_nightly_build() {
+ err.note("did you mean to use a trait alias?");
+ }
+ }
+ (Def::Mod(..), PathSource::Expr(Some(parent))) => match parent.node {
+ ExprKind::Field(_, ident) => {
+ err.span_suggestion(
+ parent.span,
+ "use the path separator to refer to an item",
+ format!("{}::{}", path_str, ident),
+ Applicability::MaybeIncorrect,
+ );
+ }
+ ExprKind::MethodCall(ref segment, ..) => {
+ let span = parent.span.with_hi(segment.ident.span.hi());
+ err.span_suggestion(
+ span,
+ "use the path separator to refer to an item",
+ format!("{}::{}", path_str, segment.ident),
+ Applicability::MaybeIncorrect,
+ );
+ }
+ _ => return false,
+ },
+ (Def::Enum(..), PathSource::TupleStruct)
+ | (Def::Enum(..), PathSource::Expr(..)) => {
+ if let Some(variants) = self.collect_enum_variants(def) {
+ err.note(&format!("did you mean to use one \
+ of the following variants?\n{}",
+ variants.iter()
+ .map(|suggestion| path_names_to_string(suggestion))
+ .map(|suggestion| format!("- `{}`", suggestion))
+ .collect::<Vec<_>>()
+ .join("\n")));
+ } else {
+ err.note("did you mean to use one of the enum's variants?");
+ }
+ },
+ (Def::Struct(def_id), _) if ns == ValueNS => {
+ if let Some((ctor_def, ctor_vis))
+ = self.struct_constructors.get(&def_id).cloned() {
+ let accessible_ctor = self.is_accessible(ctor_vis);
+ if is_expected(ctor_def) && !accessible_ctor {
+ err.span_label(span, format!("constructor is not visible \
+ here due to private fields"));
+ }
+ } else {
+ // HACK(estebank): find a better way to figure out that this was a
+ // parser issue where a struct literal is being used on an expression
+ // where a brace being opened means a block is being started. Look
+ // ahead for the next text to see if `span` is followed by a `{`.
+ let sm = self.session.source_map();
+ let mut sp = span;
+ loop {
+ sp = sm.next_point(sp);
+ match sm.span_to_snippet(sp) {
+ Ok(ref snippet) => {
+ if snippet.chars().any(|c| { !c.is_whitespace() }) {
+ break;
+ }
+ }
+ _ => break,
+ }
+ }
+ let followed_by_brace = match sm.span_to_snippet(sp) {
+ Ok(ref snippet) if snippet == "{" => true,
+ _ => false,
+ };
+ // In case this could be a struct literal that needs to be surrounded
+ // by parenthesis, find the appropriate span.
+ let mut i = 0;
+ let mut closing_brace = None;
+ loop {
+ sp = sm.next_point(sp);
+ match sm.span_to_snippet(sp) {
+ Ok(ref snippet) => {
+ if snippet == "}" {
+ let sp = span.to(sp);
+ if let Ok(snippet) = sm.span_to_snippet(sp) {
+ closing_brace = Some((sp, snippet));
+ }
+ break;
+ }
+ }
+ _ => break,
+ }
+ i += 1;
+ // The bigger the span, the more likely we're incorrect --
+ // bound it to 100 chars long.
+ if i > 100 {
+ break;
+ }
+ }
+ match source {
+ PathSource::Expr(Some(parent)) => {
+ match parent.node {
+ ExprKind::MethodCall(ref path_assignment, _) => {
+ err.span_suggestion(
+ sm.start_point(parent.span)
+ .to(path_assignment.ident.span),
+ "use `::` to access an associated function",
+ format!("{}::{}",
+ path_str,
+ path_assignment.ident),
+ Applicability::MaybeIncorrect
+ );
+ },
+ _ => {
+ err.span_label(
+ span,
+ format!("did you mean `{} {{ /* fields */ }}`?",
+ path_str),
+ );
+ },
+ }
+ },
+ PathSource::Expr(None) if followed_by_brace == true => {
+ if let Some((sp, snippet)) = closing_brace {
+ err.span_suggestion(
+ sp,
+ "surround the struct literal with parenthesis",
+ format!("({})", snippet),
+ Applicability::MaybeIncorrect,
+ );
+ } else {
+ err.span_label(
+ span,
+ format!("did you mean `({} {{ /* fields */ }})`?",
+ path_str),
+ );
+ }
+ },
+ _ => {
+ err.span_label(
+ span,
+ format!("did you mean `{} {{ /* fields */ }}`?",
+ path_str),
+ );
+ },
+ }
+ }
+ }
+ (Def::Union(..), _) |
+ (Def::Variant(..), _) |
+ (Def::VariantCtor(_, CtorKind::Fictive), _) if ns == ValueNS => {
+ err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?",
+ path_str));
+ }
+ (Def::SelfTy(..), _) if ns == ValueNS => {
+ err.span_label(span, fallback_label);
+ err.note("can't use `Self` as a constructor, you must use the \
+ implemented struct");
+ }
+ (Def::TyAlias(_), _) | (Def::AssociatedTy(..), _) if ns == ValueNS => {
+ err.note("can't use a type alias as a constructor");
+ }
+ _ => return false,
+ }
+ true
+ }
+}
impl<'a, 'b:'a> ImportResolver<'a, 'b> {
- /// Add suggestions for a path that cannot be resolved.
+ /// Adds suggestions for a path that cannot be resolved.
pub(crate) fn make_path_suggestion(
&mut self,
span: Span,
// On 2015 `{{root}}` is usually added implicitly.
(Some(fst), Some(snd)) if fst.ident.name == keywords::PathRoot.name() &&
!snd.ident.is_path_segment_keyword() => {}
- // `ident::...` on 2018
+ // `ident::...` on 2018.
(Some(fst), _) if fst.ident.span.rust_2018() &&
!fst.ident.is_path_segment_keyword() => {
// Insert a placeholder that's later replaced by `self`/`super`/etc.
}
}
- /// Suggest a missing `crate::` if that resolves to an correct module.
+ /// Suggests a missing `crate::` if that resolves to an correct module.
///
/// ```
/// |
}
}
- /// Suggest a missing `super::` if that resolves to an correct module.
+ /// Suggests a missing `super::` if that resolves to an correct module.
///
/// ```
/// |
}
}
- /// Suggest a missing external crate name if that resolves to an correct module.
+ /// Suggests a missing external crate name if that resolves to an correct module.
///
/// ```
/// |
}
// Sort extern crate names in reverse order to get
- // 1) some consistent ordering for emitted dignostics and
+ // 1) some consistent ordering for emitted dignostics, and
// 2) `std` suggestions before `core` suggestions.
let mut extern_crate_names =
self.resolver.extern_prelude.iter().map(|(ident, _)| ident.name).collect::<Vec<_>>();
#![feature(crate_visibility_modifier)]
#![feature(label_break_value)]
+#![feature(nll)]
#![feature(rustc_diagnostic_macros)]
-#![feature(slice_sort_by_cached_key)]
#![recursion_limit="256"]
#![deny(rust_2018_idioms)]
-use rustc_errors as errors;
-
pub use rustc::hir::def::{Namespace, PerNS};
use GenericParameters::*;
use rustc::hir::def::Namespace::*;
use rustc::hir::def_id::{CRATE_DEF_INDEX, LOCAL_CRATE, DefId};
use rustc::hir::{Freevar, FreevarMap, TraitCandidate, TraitMap, GlobMap};
-use rustc::session::config::nightly_options;
-use rustc::ty;
+use rustc::ty::{self, DefIdTree};
use rustc::util::nodemap::{NodeMap, NodeSet, FxHashMap, FxHashSet, DefIdMap};
use rustc::{bug, span_bug};
/// A free importable items suggested in case of resolution failure.
struct ImportSuggestion {
+ did: Option<DefId>,
path: Path,
}
}
enum ResolutionError<'a> {
- /// error E0401: can't use type or const parameters from outer function
+ /// Error E0401: can't use type or const parameters from outer function.
GenericParamsFromOuterFunction(Def),
- /// error E0403: the name is already used for a type/const parameter in this list of
- /// generic parameters
+ /// Error E0403: the name is already used for a type or const parameter in this generic
+ /// parameter list.
NameAlreadyUsedInParameterList(Name, &'a Span),
- /// error E0407: method is not a member of trait
+ /// Error E0407: method is not a member of trait.
MethodNotMemberOfTrait(Name, &'a str),
- /// error E0437: type is not a member of trait
+ /// Error E0437: type is not a member of trait.
TypeNotMemberOfTrait(Name, &'a str),
- /// error E0438: const is not a member of trait
+ /// Error E0438: const is not a member of trait.
ConstNotMemberOfTrait(Name, &'a str),
- /// error E0408: variable `{}` is not bound in all patterns
+ /// Error E0408: variable `{}` is not bound in all patterns.
VariableNotBoundInPattern(&'a BindingError),
- /// error E0409: variable `{}` is bound in inconsistent ways within the same match arm
+ /// Error E0409: variable `{}` is bound in inconsistent ways within the same match arm.
VariableBoundWithDifferentMode(Name, Span),
- /// error E0415: identifier is bound more than once in this parameter list
+ /// Error E0415: identifier is bound more than once in this parameter list.
IdentifierBoundMoreThanOnceInParameterList(&'a str),
- /// error E0416: identifier is bound more than once in the same pattern
+ /// Error E0416: identifier is bound more than once in the same pattern.
IdentifierBoundMoreThanOnceInSamePattern(&'a str),
- /// error E0426: use of undeclared label
+ /// Error E0426: use of undeclared label.
UndeclaredLabel(&'a str, Option<Name>),
- /// error E0429: `self` imports are only allowed within a { } list
+ /// Error E0429: `self` imports are only allowed within a `{ }` list.
SelfImportsOnlyAllowedWithin,
- /// error E0430: `self` import can only appear once in the list
+ /// Error E0430: `self` import can only appear once in the list.
SelfImportCanOnlyAppearOnceInTheList,
- /// error E0431: `self` import can only appear in an import list with a non-empty prefix
+ /// Error E0431: `self` import can only appear in an import list with a non-empty prefix.
SelfImportOnlyInImportListWithNonEmptyPrefix,
- /// error E0433: failed to resolve
+ /// Error E0433: failed to resolve.
FailedToResolve(&'a str),
- /// error E0434: can't capture dynamic environment in a fn item
+ /// Error E0434: can't capture dynamic environment in a fn item.
CannotCaptureDynamicEnvironmentInFnItem,
- /// error E0435: attempt to use a non-constant value in a constant
+ /// Error E0435: attempt to use a non-constant value in a constant.
AttemptToUseNonConstantValueInConstant,
- /// error E0530: X bindings cannot shadow Ys
+ /// Error E0530: `X` bindings cannot shadow `Y`s.
BindingShadowsSomethingUnacceptable(&'a str, Name, &'a NameBinding<'a>),
- /// error E0128: type parameters with a default cannot use forward declared identifiers
+ /// Error E0128: type parameters with a default cannot use forward-declared identifiers.
ForwardDeclaredTyParam, // FIXME(const_generics:defaults)
}
-/// Combines an error with provided span and emits it
+/// Combines an error with provided span and emits it.
///
/// This takes the error provided, combines it with the span and any additional spans inside the
/// error and emits it.
/// Adjust the impl span so that just the `impl` keyword is taken by removing
/// everything after `<` (`"impl<T> Iterator for A<T> {}" -> "impl"`) and
-/// everything after the first whitespace (`"impl Iterator for A" -> "impl"`)
+/// everything after the first whitespace (`"impl Iterator for A" -> "impl"`).
///
-/// Attention: The method used is very fragile since it essentially duplicates the work of the
+/// *Attention*: the method used is very fragile since it essentially duplicates the work of the
/// parser. If you need to use this function or something similar, please consider updating the
-/// source_map functions and this function to something more robust.
+/// `source_map` functions and this function to something more robust.
fn reduce_impl_span_to_impl_keyword(cm: &SourceMap, impl_span: Span) -> Span {
let impl_span = cm.span_until_char(impl_span, '<');
let impl_span = cm.span_until_whitespace(impl_span);
}
}
-/// This thing walks the whole crate in DFS manner, visiting each item, resolving names as it goes.
+/// Walks the whole crate in DFS order, visiting each item, resolving names as it goes.
impl<'a, 'tcx> Visitor<'tcx> for Resolver<'a> {
fn visit_item(&mut self, item: &'tcx Item) {
self.resolve_item(item);
/// No translation needs to be applied.
NormalRibKind,
- /// We passed through a closure scope at the given node ID.
+ /// We passed through a closure scope at the given `NodeId`.
/// Translate upvars as appropriate.
ClosureRibKind(NodeId /* func id */),
ForwardTyParamBanRibKind,
}
-/// One local scope.
+/// A single local scope.
///
/// A rib represents a scope names can live in. Note that these appear in many places, not just
/// around braces. At any place where the list of accessible names (of the given namespace)
}
enum ModuleKind {
- /// An anonymous module, eg. just a block.
+ /// An anonymous module; e.g., just a block.
///
/// ```
/// fn main() {
struct UseError<'a> {
err: DiagnosticBuilder<'a>,
- /// Attach `use` statements for these candidates
+ /// Attach `use` statements for these candidates.
candidates: Vec<ImportSuggestion>,
- /// The node id of the module to place the use statements in
+ /// The `NodeId` of the module to place the use-statements in.
node_id: NodeId,
- /// Whether the diagnostic should state that it's "better"
+ /// Whether the diagnostic should state that it's "better".
better: bool,
}
prelude: Option<Module<'a>>,
pub extern_prelude: FxHashMap<Ident, ExternPreludeEntry<'a>>,
- /// n.b. This is used only for better diagnostics, not name resolution itself.
+ /// N.B., this is used only for better diagnostics, not name resolution itself.
has_self: FxHashSet<DefId>,
/// Names of fields of an item `DefId` accessible with dot syntax.
/// they are used (in a `break` or `continue` statement)
pub unused_labels: FxHashMap<NodeId, Span>,
- /// privacy errors are delayed until the end in order to deduplicate them
+ /// Privacy errors are delayed until the end in order to deduplicate them.
privacy_errors: Vec<PrivacyError<'a>>,
- /// ambiguity errors are delayed for deduplication
+ /// Ambiguity errors are delayed for deduplication.
ambiguity_errors: Vec<AmbiguityError<'a>>,
- /// `use` injections are delayed for better placement and deduplication
+ /// `use` injections are delayed for better placement and deduplication.
use_injections: Vec<UseError<'a>>,
- /// crate-local macro expanded `macro_export` referred to by a module-relative path
+ /// Crate-local macro expanded `macro_export` referred to by a module-relative path.
macro_expanded_macro_export_errors: BTreeSet<(Span, Span)>,
arenas: &'a ResolverArenas<'a>,
potentially_unused_imports: Vec<&'a ImportDirective<'a>>,
- /// This table maps struct IDs into struct constructor IDs,
+ /// Table for mapping struct IDs into struct constructor IDs,
/// it's not used during normal resolution, only for better error reporting.
struct_constructors: DefIdMap<(Def, ty::Visibility)>,
- /// Only used for better errors on `fn(): fn()`
+ /// Only used for better errors on `fn(): fn()`.
current_type_ascription: Vec<Span>,
injected_crate: Option<Module<'a>>,
}
-/// Nothing really interesting here, it just provides memory for the rest of the crate.
+/// Nothing really interesting here; it just provides memory for the rest of the crate.
#[derive(Default)]
pub struct ResolverArenas<'a> {
modules: arena::TypedArena<ModuleData<'a>>,
}
impl<'a> Resolver<'a> {
- /// Rustdoc uses this to resolve things in a recoverable way. ResolutionError<'a>
+ /// Rustdoc uses this to resolve things in a recoverable way. `ResolutionError<'a>`
/// isn't something that can be returned because it can't be made to live that long,
/// and also it's a private type. Fortunately rustdoc doesn't need to know the error,
/// just that an error occurred.
}
}
- /// resolve_hir_path, but takes a callback in case there was an error
+ /// Like `resolve_hir_path`, but takes a callback in case there was an error.
fn resolve_hir_path_cb<F>(
&mut self,
path: &ast::Path,
let span = path.span;
let segments = &path.segments;
let path = Segment::from_path(&path);
- // FIXME (Manishearth): Intra doc links won't get warned of epoch changes
+ // FIXME(Manishearth): intra-doc links won't get warned of epoch changes.
let def = match self.resolve_path_without_parent_scope(&path, Some(namespace), true,
span, CrateLint::No) {
PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
}
}
- /// Searches the current set of local scopes for labels. Returns the first non-None label that
+ /// Searches the current set of local scopes for labels. Returns the first non-`None` label that
/// is returned by the given predicate function
///
/// Stops after meeting a closure.
result
}
- /// This is called to resolve a trait reference from an `impl` (i.e., `impl Trait for Foo`)
+ /// This is called to resolve a trait reference from an `impl` (i.e., `impl Trait for Foo`).
fn with_optional_trait_ref<T, F>(&mut self, opt_trait_ref: Option<&TraitRef>, f: F) -> T
where F: FnOnce(&mut Resolver<'_>, Option<DefId>) -> T
{
/// sometimes needed for the lint that recommends rewriting
/// absolute paths to `crate`, so that it knows how to frame the
/// suggestion. If you are just resolving a path like `foo::bar`
- /// that appears...somewhere, though, then you just want
+ /// that appears in an arbitrary location, then you just want
/// `CrateLint::SimplePath`, which is what `smart_resolve_path`
/// already provides.
fn smart_resolve_path_with_crate_lint(
source: PathSource<'_>,
crate_lint: CrateLint)
-> PathResolution {
- let ident_span = path.last().map_or(span, |ident| ident.ident.span);
let ns = source.namespace();
let is_expected = &|def| source.is_expected(def);
- let is_enum_variant = &|def| if let Def::Variant(..) = def { true } else { false };
-
- // Base error is amended with one short label and possibly some longer helps/notes.
- let report_errors = |this: &mut Self, def: Option<Def>| {
- // Make the base error.
- let expected = source.descr_expected();
- let path_str = Segment::names_to_string(path);
- let item_str = path.last().unwrap().ident;
- let code = source.error_code(def.is_some());
- let (base_msg, fallback_label, base_span) = if let Some(def) = def {
- (format!("expected {}, found {} `{}`", expected, def.kind_name(), path_str),
- format!("not a {}", expected),
- span)
- } else {
- let item_span = path.last().unwrap().ident.span;
- let (mod_prefix, mod_str) = if path.len() == 1 {
- (String::new(), "this scope".to_string())
- } else if path.len() == 2 && path[0].ident.name == keywords::PathRoot.name() {
- (String::new(), "the crate root".to_string())
- } else {
- let mod_path = &path[..path.len() - 1];
- let mod_prefix = match this.resolve_path_without_parent_scope(
- mod_path, Some(TypeNS), false, span, CrateLint::No
- ) {
- PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
- module.def(),
- _ => None,
- }.map_or(String::new(), |def| format!("{} ", def.kind_name()));
- (mod_prefix, format!("`{}`", Segment::names_to_string(mod_path)))
- };
- (format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str),
- format!("not found in {}", mod_str),
- item_span)
- };
-
- let code = DiagnosticId::Error(code.into());
- let mut err = this.session.struct_span_err_with_code(base_span, &base_msg, code);
-
- // Emit help message for fake-self from other languages like `this`(javascript)
- if ["this", "my"].contains(&&*item_str.as_str())
- && this.self_value_is_available(path[0].ident.span, span) {
- err.span_suggestion(
- span,
- "did you mean",
- "self".to_string(),
- Applicability::MaybeIncorrect,
- );
- }
-
- // Emit special messages for unresolved `Self` and `self`.
- if is_self_type(path, ns) {
- __diagnostic_used!(E0411);
- err.code(DiagnosticId::Error("E0411".into()));
- err.span_label(span, format!("`Self` is only available in impls, traits, \
- and type definitions"));
- return (err, Vec::new());
- }
- if is_self_value(path, ns) {
- debug!("smart_resolve_path_fragment E0424 source:{:?}", source);
-
- __diagnostic_used!(E0424);
- err.code(DiagnosticId::Error("E0424".into()));
- err.span_label(span, match source {
- PathSource::Pat => {
- format!("`self` value is a keyword \
- and may not be bound to \
- variables or shadowed")
- }
- _ => {
- format!("`self` value is a keyword \
- only available in methods \
- with `self` parameter")
- }
- });
- return (err, Vec::new());
- }
-
- // Try to lookup the name in more relaxed fashion for better error reporting.
- let ident = path.last().unwrap().ident;
- let candidates = this.lookup_import_candidates(ident, ns, is_expected);
- if candidates.is_empty() && is_expected(Def::Enum(DefId::local(CRATE_DEF_INDEX))) {
- let enum_candidates =
- this.lookup_import_candidates(ident, ns, is_enum_variant);
- let mut enum_candidates = enum_candidates.iter()
- .map(|suggestion| {
- import_candidate_to_enum_paths(&suggestion)
- }).collect::<Vec<_>>();
- enum_candidates.sort();
-
- if !enum_candidates.is_empty() {
- // contextualize for E0412 "cannot find type", but don't belabor the point
- // (that it's a variant) for E0573 "expected type, found variant"
- let preamble = if def.is_none() {
- let others = match enum_candidates.len() {
- 1 => String::new(),
- 2 => " and 1 other".to_owned(),
- n => format!(" and {} others", n)
- };
- format!("there is an enum variant `{}`{}; ",
- enum_candidates[0].0, others)
- } else {
- String::new()
- };
- let msg = format!("{}try using the variant's enum", preamble);
-
- err.span_suggestions(
- span,
- &msg,
- enum_candidates.into_iter()
- .map(|(_variant_path, enum_ty_path)| enum_ty_path)
- // variants reëxported in prelude doesn't mean `prelude::v1` is the
- // type name! FIXME: is there a more principled way to do this that
- // would work for other reëxports?
- .filter(|enum_ty_path| enum_ty_path != "std::prelude::v1")
- // also say `Option` rather than `std::prelude::v1::Option`
- .map(|enum_ty_path| {
- // FIXME #56861: DRYer prelude filtering
- enum_ty_path.trim_start_matches("std::prelude::v1::").to_owned()
- }),
- Applicability::MachineApplicable,
- );
- }
- }
- if path.len() == 1 && this.self_type_is_available(span) {
- if let Some(candidate) = this.lookup_assoc_candidate(ident, ns, is_expected) {
- let self_is_available = this.self_value_is_available(path[0].ident.span, span);
- match candidate {
- AssocSuggestion::Field => {
- err.span_suggestion(
- span,
- "try",
- format!("self.{}", path_str),
- Applicability::MachineApplicable,
- );
- if !self_is_available {
- err.span_label(span, format!("`self` value is a keyword \
- only available in \
- methods with `self` parameter"));
- }
- }
- AssocSuggestion::MethodWithSelf if self_is_available => {
- err.span_suggestion(
- span,
- "try",
- format!("self.{}", path_str),
- Applicability::MachineApplicable,
- );
- }
- AssocSuggestion::MethodWithSelf | AssocSuggestion::AssocItem => {
- err.span_suggestion(
- span,
- "try",
- format!("Self::{}", path_str),
- Applicability::MachineApplicable,
- );
- }
- }
- return (err, candidates);
- }
- }
-
- let mut levenshtein_worked = false;
-
- // Try Levenshtein algorithm.
- let suggestion = this.lookup_typo_candidate(path, ns, is_expected, span);
- if let Some(suggestion) = suggestion {
- let msg = format!(
- "{} {} with a similar name exists",
- suggestion.article, suggestion.kind
- );
- err.span_suggestion(
- ident_span,
- &msg,
- suggestion.candidate.to_string(),
- Applicability::MaybeIncorrect,
- );
- levenshtein_worked = true;
- }
-
- // Try context dependent help if relaxed lookup didn't work.
- if let Some(def) = def {
- match (def, source) {
- (Def::Macro(..), _) => {
- err.span_suggestion(
- span,
- "use `!` to invoke the macro",
- format!("{}!", path_str),
- Applicability::MaybeIncorrect,
- );
- return (err, candidates);
- }
- (Def::TyAlias(..), PathSource::Trait(_)) => {
- err.span_label(span, "type aliases cannot be used as traits");
- if nightly_options::is_nightly_build() {
- err.note("did you mean to use a trait alias?");
- }
- return (err, candidates);
- }
- (Def::Mod(..), PathSource::Expr(Some(parent))) => match parent.node {
- ExprKind::Field(_, ident) => {
- err.span_suggestion(
- parent.span,
- "use the path separator to refer to an item",
- format!("{}::{}", path_str, ident),
- Applicability::MaybeIncorrect,
- );
- return (err, candidates);
- }
- ExprKind::MethodCall(ref segment, ..) => {
- let span = parent.span.with_hi(segment.ident.span.hi());
- err.span_suggestion(
- span,
- "use the path separator to refer to an item",
- format!("{}::{}", path_str, segment.ident),
- Applicability::MaybeIncorrect,
- );
- return (err, candidates);
- }
- _ => {}
- },
- (Def::Enum(..), PathSource::TupleStruct)
- | (Def::Enum(..), PathSource::Expr(..)) => {
- if let Some(variants) = this.collect_enum_variants(def) {
- err.note(&format!("did you mean to use one \
- of the following variants?\n{}",
- variants.iter()
- .map(|suggestion| path_names_to_string(suggestion))
- .map(|suggestion| format!("- `{}`", suggestion))
- .collect::<Vec<_>>()
- .join("\n")));
-
- } else {
- err.note("did you mean to use one of the enum's variants?");
- }
- return (err, candidates);
- },
- (Def::Struct(def_id), _) if ns == ValueNS => {
- if let Some((ctor_def, ctor_vis))
- = this.struct_constructors.get(&def_id).cloned() {
- let accessible_ctor = this.is_accessible(ctor_vis);
- if is_expected(ctor_def) && !accessible_ctor {
- err.span_label(span, format!("constructor is not visible \
- here due to private fields"));
- }
- } else {
- // HACK(estebank): find a better way to figure out that this was a
- // parser issue where a struct literal is being used on an expression
- // where a brace being opened means a block is being started. Look
- // ahead for the next text to see if `span` is followed by a `{`.
- let sm = this.session.source_map();
- let mut sp = span;
- loop {
- sp = sm.next_point(sp);
- match sm.span_to_snippet(sp) {
- Ok(ref snippet) => {
- if snippet.chars().any(|c| { !c.is_whitespace() }) {
- break;
- }
- }
- _ => break,
- }
- }
- let followed_by_brace = match sm.span_to_snippet(sp) {
- Ok(ref snippet) if snippet == "{" => true,
- _ => false,
- };
- // In case this could be a struct literal that needs to be surrounded
- // by parenthesis, find the appropriate span.
- let mut i = 0;
- let mut closing_brace = None;
- loop {
- sp = sm.next_point(sp);
- match sm.span_to_snippet(sp) {
- Ok(ref snippet) => {
- if snippet == "}" {
- let sp = span.to(sp);
- if let Ok(snippet) = sm.span_to_snippet(sp) {
- closing_brace = Some((sp, snippet));
- }
- break;
- }
- }
- _ => break,
- }
- i += 1;
- if i > 100 { // The bigger the span the more likely we're
- break; // incorrect. Bound it to 100 chars long.
- }
- }
- match source {
- PathSource::Expr(Some(parent)) => {
- match parent.node {
- ExprKind::MethodCall(ref path_assignment, _) => {
- err.span_suggestion(
- sm.start_point(parent.span)
- .to(path_assignment.ident.span),
- "use `::` to access an associated function",
- format!("{}::{}",
- path_str,
- path_assignment.ident),
- Applicability::MaybeIncorrect
- );
- return (err, candidates);
- },
- _ => {
- err.span_label(
- span,
- format!("did you mean `{} {{ /* fields */ }}`?",
- path_str),
- );
- return (err, candidates);
- },
- }
- },
- PathSource::Expr(None) if followed_by_brace == true => {
- if let Some((sp, snippet)) = closing_brace {
- err.span_suggestion(
- sp,
- "surround the struct literal with parenthesis",
- format!("({})", snippet),
- Applicability::MaybeIncorrect,
- );
- } else {
- err.span_label(
- span,
- format!("did you mean `({} {{ /* fields */ }})`?",
- path_str),
- );
- }
- return (err, candidates);
- },
- _ => {
- err.span_label(
- span,
- format!("did you mean `{} {{ /* fields */ }}`?",
- path_str),
- );
- return (err, candidates);
- },
- }
- }
- return (err, candidates);
- }
- (Def::Union(..), _) |
- (Def::Variant(..), _) |
- (Def::VariantCtor(_, CtorKind::Fictive), _) if ns == ValueNS => {
- err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?",
- path_str));
- return (err, candidates);
- }
- (Def::SelfTy(..), _) if ns == ValueNS => {
- err.span_label(span, fallback_label);
- err.note("can't use `Self` as a constructor, you must use the \
- implemented struct");
- return (err, candidates);
- }
- (Def::TyAlias(_), _) | (Def::AssociatedTy(..), _) if ns == ValueNS => {
- err.note("can't use a type alias as a constructor");
- return (err, candidates);
- }
- _ => {}
- }
- }
-
- // Fallback label.
- if !levenshtein_worked {
- err.span_label(base_span, fallback_label);
- this.type_ascription_suggestion(&mut err, base_span);
- }
- (err, candidates)
- };
let report_errors = |this: &mut Self, def: Option<Def>| {
- let (err, candidates) = report_errors(this, def);
+ let (err, candidates) = this.smart_resolve_report_errors(path, span, source, def);
let def_id = this.current_module.normal_ancestor_id;
let node_id = this.definitions.as_local_node_id(def_id).unwrap();
let better = def.is_some();
debug!("self.current_type_ascription {:?}", self.current_type_ascription);
if let Some(sp) = self.current_type_ascription.last() {
let mut sp = *sp;
- loop { // try to find the `:`, bail on first non-':'/non-whitespace
+ loop {
+ // Try to find the `:`; bail on first non-':' / non-whitespace.
sp = cm.next_point(sp);
if let Ok(snippet) = cm.span_to_snippet(sp.to(cm.next_point(sp))) {
debug!("snippet {:?}", snippet);
// collect results based on the filter function
if ident.name == lookup_ident.name && ns == namespace {
- if filter_fn(name_binding.def()) {
+ let def = name_binding.def();
+ if filter_fn(def) {
// create the path
let mut segms = path_segments.clone();
if lookup_ident.span.rust_2018() {
// declared as public (due to pruning, we don't explore
// outside crate private modules => no need to check this)
if !in_module_is_extern || name_binding.vis == ty::Visibility::Public {
- candidates.push(ImportSuggestion { path });
+ let did = match def {
+ Def::StructCtor(did, _) | Def::VariantCtor(did, _) =>
+ self.parent(did),
+ _ => def.opt_def_id(),
+ };
+ candidates.push(ImportSuggestion { did, path });
}
}
}
/// When name resolution fails, this method can be used to look up candidate
/// entities with the expected name. It allows filtering them using the
/// supplied predicate (which should be used to only accept the types of
- /// definitions expected e.g., traits). The lookup spans across all crates.
+ /// definitions expected, e.g., traits). The lookup spans across all crates.
///
- /// NOTE: The method does not look into imports, but this is not a problem,
+ /// N.B., the method does not look into imports, but this is not a problem,
/// since we report the definitions (thus, the de-aliased imports).
fn lookup_import_candidates<FilterFn>(&mut self,
lookup_ident: Ident,
span: name_binding.span,
segments: path_segments,
};
- result = Some((module, ImportSuggestion { path }));
+ let did = module.def().and_then(|def| def.opt_def_id());
+ result = Some((module, ImportSuggestion { did, path }));
} else {
// add the module to the lookup
if seen_modules.insert(module.def_id().unwrap()) {
.collect::<Vec<_>>())
}
-/// Get the stringified path for an enum from an `ImportSuggestion` for an enum variant.
+/// Gets the stringified path for an enum from an `ImportSuggestion` for an enum variant.
fn import_candidate_to_enum_paths(suggestion: &ImportSuggestion) -> (String, String) {
let variant_path = &suggestion.path;
let variant_path_string = path_names_to_string(variant_path);
(variant_path_string, enum_path_string)
}
-
/// When an entity with a given name is not available in scope, we search for
/// entities with that name in all crates. This method allows outputting the
/// results of this search in a programmer-friendly way
#[derive(Copy, Clone, Debug)]
enum CrateLint {
- /// Do not issue the lint
+ /// Do not issue the lint.
No,
- /// This lint applies to some random path like `impl ::foo::Bar`
- /// or whatever. In this case, we can take the span of that path.
+ /// This lint applies to some arbitrary path; e.g., `impl ::foo::Bar`.
+ /// In this case, we can take the span of that path.
SimplePath(NodeId),
/// This lint comes from a `use` statement. In this case, what we
use syntax::visit::Visitor;
use syntax::util::lev_distance::find_best_match_for_name;
use syntax_pos::{Span, DUMMY_SP};
-use crate::errors::Applicability;
+use errors::Applicability;
use std::cell::Cell;
use std::{mem, ptr};
#[derive(Clone, Debug)]
pub struct InvocationData<'a> {
def_index: DefIndex,
- /// Module in which the macro was invoked.
+ /// The module in which the macro was invoked.
crate module: Cell<Module<'a>>,
- /// Legacy scope in which the macro was invoked.
+ /// The legacy scope in which the macro was invoked.
/// The invocation path is resolved in this scope.
crate parent_legacy_scope: Cell<LegacyScope<'a>>,
- /// Legacy scope *produced* by expanding this macro invocation,
+ /// The legacy scope *produced* by expanding this macro invocation,
/// includes all the macro_rules items, other invocations, etc generated by it.
/// `None` if the macro is not expanded yet.
crate output_legacy_scope: Cell<Option<LegacyScope<'a>>>,
ident: Ident,
}
-/// Scope introduced by a `macro_rules!` macro.
-/// Starts at the macro's definition and ends at the end of the macro's parent module
-/// (named or unnamed), or even further if it escapes with `#[macro_use]`.
+/// The scope introduced by a `macro_rules!` macro.
+/// This starts at the macro's definition and ends at the end of the macro's parent
+/// module (named or unnamed), or even further if it escapes with `#[macro_use]`.
/// Some macro invocations need to introduce legacy scopes too because they
-/// potentially can expand into macro definitions.
+/// can potentially expand into macro definitions.
#[derive(Copy, Clone, Debug)]
pub enum LegacyScope<'a> {
- /// Created when invocation data is allocated in the arena,
+ /// Created when invocation data is allocated in the arena;
/// must be replaced with a proper scope later.
Uninitialized,
/// Empty "root" scope at the crate start containing no names.
Empty,
- /// Scope introduced by a `macro_rules!` macro definition.
+ /// The scope introduced by a `macro_rules!` macro definition.
Binding(&'a LegacyBinding<'a>),
- /// Scope introduced by a macro invocation that can potentially
+ /// The scope introduced by a macro invocation that can potentially
/// create a `macro_rules!` macro definition.
Invocation(&'a InvocationData<'a>),
}
/// One import directive.
#[derive(Debug,Clone)]
crate struct ImportDirective<'a> {
- /// The id of the `extern crate`, `UseTree` etc that imported this `ImportDirective`.
+ /// The ID of the `extern crate`, `UseTree` etc that imported this `ImportDirective`.
///
/// In the case where the `ImportDirective` was expanded from a "nested" use tree,
- /// this id is the id of the leaf tree. For example:
+ /// this id is the ID of the leaf tree. For example:
///
/// ```ignore (pacify the mercilous tidy)
/// use foo::bar::{a, b}
/// ```
///
- /// If this is the import directive for `foo::bar::a`, we would have the id of the `UseTree`
+ /// If this is the import directive for `foo::bar::a`, we would have the ID of the `UseTree`
/// for `a` in this field.
pub id: NodeId,
/// The `id` of the "root" use-kind -- this is always the same as
/// `id` except in the case of "nested" use trees, in which case
/// it will be the `id` of the root use tree. e.g., in the example
- /// from `id`, this would be the id of the `use foo::bar`
+ /// from `id`, this would be the ID of the `use foo::bar`
/// `UseTree` node.
pub root_id: NodeId,
authors = ["The Rust Project Developers"]
name = "rustc_save_analysis"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_save_analysis"
//! Write the output of rustc's analysis to an implementor of Dump.
//!
//! Dumping the analysis is implemented by walking the AST and getting a bunch of
-//! info out from all over the place. We use Def IDs to identify objects. The
+//! info out from all over the place. We use `DefId`s to identify objects. The
//! tricky part is getting syntactic (span, source text) and semantic (reference
-//! Def IDs) information for parts of expressions which the compiler has discarded.
+//! `DefId`s) information for parts of expressions which the compiler has discarded.
//! E.g., in a path `foo::bar::baz`, the compiler only keeps a span for the whole
//! path and a reference to `baz`, but we want spans and references for all three
//! idents.
use rustc::hir::def::Def as HirDef;
use rustc::hir::def_id::DefId;
use rustc::session::config::Input;
+use rustc::span_bug;
use rustc::ty::{self, TyCtxt};
use rustc_data_structures::fx::FxHashSet;
};
use syntax::ptr::P;
use syntax::source_map::{Spanned, DUMMY_SP, respan};
+use syntax::walk_list;
use syntax_pos::*;
-use {escape, generated_code, lower_attributes, PathCollector, SaveContext};
-use json_dumper::{Access, DumpOutput, JsonDumper};
-use span_utils::SpanUtils;
-use sig;
+use crate::{escape, generated_code, id_from_def_id, id_from_node_id, lower_attributes,
+ PathCollector, SaveContext};
+use crate::json_dumper::{Access, DumpOutput, JsonDumper};
+use crate::span_utils::SpanUtils;
+use crate::sig;
use rls_data::{CompilationOptions, CratePreludeData, Def, DefKind, GlobalCrateId, Import,
ImportKind, Ref, RefKind, Relation, RelationKind, SpanData};
+use log::{debug, error};
+
macro_rules! down_cast_data {
($id:ident, $kind:ident, $sp:expr) => {
let $id = if let super::Data::$kind(data) = $id {
};
}
-pub struct DumpVisitor<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> {
+pub struct DumpVisitor<'l, 'tcx: 'l, 'll, O: DumpOutput> {
save_ctxt: SaveContext<'l, 'tcx>,
tcx: TyCtxt<'l, 'tcx, 'tcx>,
dumper: &'ll mut JsonDumper<O>,
for (id, ident, ..) in collector.collected_idents {
let hir_id = self.tcx.hir().node_to_hir_id(id);
- let typ = match self.save_ctxt.tables.node_id_to_type_opt(hir_id) {
+ let typ = match self.save_ctxt.tables.node_type_opt(hir_id) {
Some(s) => s.to_string(),
None => continue,
};
if !self.span.filter_generated(ident.span) {
- let id = ::id_from_node_id(id, &self.save_ctxt);
+ let id = id_from_node_id(id, &self.save_ctxt);
let span = self.span_from_span(ident.span);
self.dumper.dump_def(
debug!("process_method: {}:{}", id, ident);
if let Some(mut method_data) = self.save_ctxt.get_method_data(id, ident, span) {
- let sig_str = ::make_signature(&sig.decl, &generics);
+ let sig_str = crate::make_signature(&sig.decl, &generics);
if body.is_some() {
self.nest_tables(
id,
// Append $id to name to make sure each one is unique.
let qualname = format!("{}::{}${}", prefix, name, id);
if !self.span.filter_generated(param_ss) {
- let id = ::id_from_node_id(param.id, &self.save_ctxt);
+ let id = id_from_node_id(param.id, &self.save_ctxt);
let span = self.span_from_span(param_ss);
self.dumper.dump_def(
&access_from!(self.save_ctxt, vis, id),
Def {
kind: DefKind::Const,
- id: ::id_from_node_id(id, &self.save_ctxt),
+ id: id_from_node_id(id, &self.save_ctxt),
span,
name: ident.name.to_string(),
qualname,
value: ty_to_string(&typ),
- parent: Some(::id_from_def_id(parent_id)),
+ parent: Some(id_from_def_id(parent_id)),
children: vec![],
decl_id: None,
docs: self.save_ctxt.docs_for_attrs(attrs),
value,
fields
.iter()
- .map(|f| ::id_from_node_id(f.id, &self.save_ctxt))
+ .map(|f| id_from_node_id(f.id, &self.save_ctxt))
.collect(),
)
}
&access_from!(self.save_ctxt, item),
Def {
kind,
- id: ::id_from_node_id(item.id, &self.save_ctxt),
+ id: id_from_node_id(item.id, &self.save_ctxt),
span,
name,
qualname: qualname.clone(),
let value = format!("{}::{} {{ {} }}", enum_data.name, name, fields_str);
if !self.span.filter_generated(name_span) {
let span = self.span_from_span(name_span);
- let id = ::id_from_node_id(variant.node.data.id(), &self.save_ctxt);
- let parent = Some(::id_from_node_id(item.id, &self.save_ctxt));
+ let id = id_from_node_id(variant.node.data.id(), &self.save_ctxt);
+ let parent = Some(id_from_node_id(item.id, &self.save_ctxt));
self.dumper.dump_def(
&access,
}
if !self.span.filter_generated(name_span) {
let span = self.span_from_span(name_span);
- let id = ::id_from_node_id(variant.node.data.id(), &self.save_ctxt);
- let parent = Some(::id_from_node_id(item.id, &self.save_ctxt));
+ let id = id_from_node_id(variant.node.data.id(), &self.save_ctxt);
+ let parent = Some(id_from_node_id(item.id, &self.save_ctxt));
self.dumper.dump_def(
&access,
val.push_str(&bounds_to_string(trait_refs));
}
if !self.span.filter_generated(item.ident.span) {
- let id = ::id_from_node_id(item.id, &self.save_ctxt);
+ let id = id_from_node_id(item.id, &self.save_ctxt);
let span = self.span_from_span(item.ident.span);
let children = methods
.iter()
- .map(|i| ::id_from_node_id(i.id, &self.save_ctxt))
+ .map(|i| id_from_node_id(i.id, &self.save_ctxt))
.collect();
self.dumper.dump_def(
&access_from!(self.save_ctxt, item),
self.dumper.dump_ref(Ref {
kind: RefKind::Type,
span: span.clone(),
- ref_id: ::id_from_def_id(id),
+ ref_id: id_from_def_id(id),
});
self.dumper.dump_relation(Relation {
kind: RelationKind::SuperTrait,
span,
- from: ::id_from_def_id(id),
- to: ::id_from_node_id(item.id, &self.save_ctxt),
+ from: id_from_def_id(id),
+ to: id_from_node_id(item.id, &self.save_ctxt),
});
}
}
PatKind::Struct(ref _path, ref fields, _) => {
// FIXME do something with _path?
let hir_id = self.tcx.hir().node_to_hir_id(p.id);
- let adt = match self.save_ctxt.tables.node_id_to_type_opt(hir_id) {
+ let adt = match self.save_ctxt.tables.node_type_opt(hir_id) {
Some(ty) => ty.ty_adt_def().unwrap(),
None => {
visit::walk_pat(self, p);
self.dumper.dump_ref(Ref {
kind: RefKind::Variable,
span,
- ref_id: ::id_from_def_id(variant.fields[index].did),
+ ref_id: id_from_def_id(variant.fields[index].did),
});
}
}
let hir_id = self.tcx.hir().node_to_hir_id(id);
let typ = self.save_ctxt
.tables
- .node_id_to_type_opt(hir_id)
+ .node_type_opt(hir_id)
.map(|t| t.to_string())
.unwrap_or_default();
value.push_str(": ");
if !self.span.filter_generated(ident.span) {
let qualname = format!("{}${}", ident.to_string(), id);
- let id = ::id_from_node_id(id, &self.save_ctxt);
+ let id = id_from_node_id(id, &self.save_ctxt);
let span = self.span_from_span(ident.span);
self.dumper.dump_def(
_ => String::new(),
};
let hir_id = self.tcx.hir().node_to_hir_id(id);
- let typ = match self.save_ctxt.tables.node_id_to_type_opt(hir_id) {
+ let typ = match self.save_ctxt.tables.node_type_opt(hir_id) {
Some(typ) => {
let typ = typ.to_string();
if !value.is_empty() {
// Rust uses the id of the pattern for var lookups, so we'll use it too.
if !self.span.filter_generated(ident.span) {
let qualname = format!("{}${}", ident.to_string(), id);
- let id = ::id_from_node_id(id, &self.save_ctxt);
+ let id = id_from_node_id(id, &self.save_ctxt);
let span = self.span_from_span(ident.span);
self.dumper.dump_def(
}
}
- /// Extract macro use and definition information from the AST node defined
+ /// Extracts macro use and definition information from the AST node defined
/// by the given NodeId, using the expansion information from the node's
/// span.
///
if !self.span.filter_generated(trait_item.ident.span) {
let span = self.span_from_span(trait_item.ident.span);
- let id = ::id_from_node_id(trait_item.id, &self.save_ctxt);
+ let id = id_from_node_id(trait_item.id, &self.save_ctxt);
self.dumper.dump_def(
&Access {
name,
qualname,
value: self.span.snippet(trait_item.span),
- parent: Some(::id_from_def_id(trait_id)),
+ parent: Some(id_from_def_id(trait_id)),
children: vec![],
decl_id: None,
docs: self.save_ctxt.docs_for_attrs(&trait_item.attrs),
///
/// A use tree is an import that may contain nested braces (RFC 2128). The `use_tree` parameter
/// is the current use tree under scrutiny, while `id` and `prefix` are its corresponding node
- /// id and path. `root_item` is the topmost use tree in the hierarchy.
+ /// ID and path. `root_item` is the topmost use tree in the hierarchy.
///
/// If `use_tree` is a simple or glob import, it is dumped into the analysis data. Otherwise,
/// each child use tree is dumped recursively.
// The parent def id of a given use tree is always the enclosing item.
let parent = self.save_ctxt.tcx.hir().opt_local_def_id(id)
.and_then(|id| self.save_ctxt.tcx.parent_def_id(id))
- .map(::id_from_def_id);
+ .map(id_from_def_id);
match use_tree.kind {
ast::UseTreeKind::Simple(alias, ..) => {
let sub_span = path.segments.last().unwrap().ident.span;
if !self.span.filter_generated(sub_span) {
- let ref_id = self.lookup_def_id(id).map(|id| ::id_from_def_id(id));
+ let ref_id = self.lookup_def_id(id).map(|id| id_from_def_id(id));
let alias_span = alias.map(|i| self.span_from_span(i.span));
let span = self.span_from_span(sub_span);
self.dumper.import(&access, Import {
let cm = self.tcx.sess.source_map();
let filename = cm.span_to_filename(span);
- let data_id = ::id_from_node_id(id, &self.save_ctxt);
+ let data_id = id_from_node_id(id, &self.save_ctxt);
let children = m.items
.iter()
- .map(|i| ::id_from_node_id(i.id, &self.save_ctxt))
+ .map(|i| id_from_node_id(i.id, &self.save_ctxt))
.collect();
let span = self.span_from_span(span);
let span = self.span_from_span(name_span);
let parent = self.save_ctxt.tcx.hir().opt_local_def_id(item.id)
.and_then(|id| self.save_ctxt.tcx.parent_def_id(id))
- .map(::id_from_def_id);
+ .map(id_from_def_id);
self.dumper.import(
&Access {
public: false,
let value = ty_to_string(&ty);
if !self.span.filter_generated(item.ident.span) {
let span = self.span_from_span(item.ident.span);
- let id = ::id_from_node_id(item.id, &self.save_ctxt);
+ let id = id_from_node_id(item.id, &self.save_ctxt);
self.dumper.dump_def(
&access_from!(self.save_ctxt, item),
let value = String::new();
if !self.span.filter_generated(item.ident.span) {
let span = self.span_from_span(item.ident.span);
- let id = ::id_from_node_id(item.id, &self.save_ctxt);
+ let id = id_from_node_id(item.id, &self.save_ctxt);
self.dumper.dump_def(
&access_from!(self.save_ctxt, item),
self.dumper.dump_ref(Ref {
kind: RefKind::Type,
span,
- ref_id: ::id_from_def_id(id),
+ ref_id: id_from_def_id(id),
});
}
MacroRef, Ref, RefKind, Relation};
use rls_span::{Column, Row};
+use log::error;
+
#[derive(Debug)]
pub struct Access {
pub reachable: bool,
fn dump(&mut self, result: &Analysis);
}
-pub struct WriteOutput<'b, W: Write + 'b> {
+pub struct WriteOutput<'b, W: Write> {
output: &'b mut W,
}
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
#![feature(custom_attribute)]
#![feature(nll)]
+#![deny(rust_2018_idioms)]
#![allow(unused_attributes)]
#![recursion_limit="256"]
-#[macro_use]
-extern crate rustc;
-
-#[macro_use]
-extern crate log;
-extern crate rustc_data_structures;
-extern crate rustc_codegen_utils;
-extern crate rustc_serialize;
-extern crate rustc_target;
-extern crate rustc_typeck;
-#[macro_use]
-extern crate syntax;
-extern crate syntax_pos;
-
-extern crate rls_data;
-extern crate rls_span;
-
mod json_dumper;
mod dump_visitor;
use rustc::middle::cstore::ExternCrate;
use rustc::session::config::{CrateType, Input, OutputType};
use rustc::ty::{self, TyCtxt};
+use rustc::{bug, span_bug};
use rustc_typeck::hir_ty_to_ty;
use rustc_codegen_utils::link::{filename_for_metadata, out_filename};
use rustc_data_structures::sync::Lrc;
RelationKind, SpanData, Impl, ImplKind};
use rls_data::config::Config;
+use log::{debug, error, info};
+
pub struct SaveContext<'l, 'tcx: 'l> {
tcx: TyCtxt<'l, 'tcx, 'tcx>,
ast::ForeignItemKind::Static(ref ty, _) => {
filter!(self.span_utils, item.ident.span);
- let id = ::id_from_node_id(item.id, self);
+ let id = id_from_node_id(item.id, self);
let span = self.span_from_span(item.ident.span);
Some(Data::DefData(Def {
Some(def) if def != HirDef::Err => def,
_ => self.get_path_def(self.tcx.hir().get_parent_node(id)),
}
- },
+ }
+
Node::Expr(&hir::Expr {
node: hir::ExprKind::Struct(ref qpath, ..),
..
- }) |
+ }) => {
+ let hir_id = self.tcx.hir().node_to_hir_id(id);
+ self.tables.qpath_def(qpath, hir_id)
+ }
+
Node::Expr(&hir::Expr {
node: hir::ExprKind::Path(ref qpath),
..
/// Attempt to return MacroRef for any AST node.
///
/// For a given piece of AST defined by the supplied Span and NodeId,
- /// returns None if the node is not macro-generated or the span is malformed,
+ /// returns `None` if the node is not macro-generated or the span is malformed,
/// else uses the expansion callsite and callee to return some MacroRef.
pub fn get_macro_use_data(&self, span: Span) -> Option<MacroRef> {
if !generated_code(span) {
}
}
- fn output_file(&self, ctx: &SaveContext) -> File {
+ fn output_file(&self, ctx: &SaveContext<'_, '_>) -> File {
let sess = &ctx.tcx.sess;
let file_name = match ctx.config.output_file {
Some(ref s) => PathBuf::from(s),
}
}
-fn id_from_node_id(id: NodeId, scx: &SaveContext) -> rls_data::Id {
+fn id_from_node_id(id: NodeId, scx: &SaveContext<'_, '_>) -> rls_data::Id {
let def_id = scx.tcx.hir().opt_local_def_id(id);
def_id.map(|id| id_from_def_id(id)).unwrap_or_else(|| {
// Create a *fake* `DefId` out of a `NodeId` by subtracting the `NodeId`
}
}
-fn lower_attributes(attrs: Vec<Attribute>, scx: &SaveContext) -> Vec<rls_data::Attribute> {
+fn lower_attributes(attrs: Vec<Attribute>, scx: &SaveContext<'_, '_>) -> Vec<rls_data::Attribute> {
attrs.into_iter()
// Only retain real attributes. Doc comments are lowered separately.
.filter(|attr| attr.path != "doc")
//
// FIXME where clauses need implementing, defs/refs in generics are mostly missing.
-use {id_from_def_id, id_from_node_id, SaveContext};
+use crate::{id_from_def_id, id_from_node_id, SaveContext};
use rls_data::{SigElement, Signature};
use syntax::print::pprust;
-pub fn item_signature(item: &ast::Item, scx: &SaveContext) -> Option<Signature> {
+pub fn item_signature(item: &ast::Item, scx: &SaveContext<'_, '_>) -> Option<Signature> {
if !scx.config.signatures {
return None;
}
item.make(0, None, scx).ok()
}
-pub fn foreign_item_signature(item: &ast::ForeignItem, scx: &SaveContext) -> Option<Signature> {
+pub fn foreign_item_signature(
+ item: &ast::ForeignItem,
+ scx: &SaveContext<'_, '_>
+) -> Option<Signature> {
if !scx.config.signatures {
return None;
}
/// Signature for a struct or tuple field declaration.
/// Does not include a trailing comma.
-pub fn field_signature(field: &ast::StructField, scx: &SaveContext) -> Option<Signature> {
+pub fn field_signature(field: &ast::StructField, scx: &SaveContext<'_, '_>) -> Option<Signature> {
if !scx.config.signatures {
return None;
}
}
/// Does not include a trailing comma.
-pub fn variant_signature(variant: &ast::Variant, scx: &SaveContext) -> Option<Signature> {
+pub fn variant_signature(variant: &ast::Variant, scx: &SaveContext<'_, '_>) -> Option<Signature> {
if !scx.config.signatures {
return None;
}
ident: ast::Ident,
generics: &ast::Generics,
m: &ast::MethodSig,
- scx: &SaveContext,
+ scx: &SaveContext<'_, '_>,
) -> Option<Signature> {
if !scx.config.signatures {
return None;
ident: ast::Name,
ty: &ast::Ty,
default: Option<&ast::Expr>,
- scx: &SaveContext,
+ scx: &SaveContext<'_, '_>,
) -> Option<Signature> {
if !scx.config.signatures {
return None;
ident: ast::Ident,
bounds: Option<&ast::GenericBounds>,
default: Option<&ast::Ty>,
- scx: &SaveContext,
+ scx: &SaveContext<'_, '_>,
) -> Option<Signature> {
if !scx.config.signatures {
return None;
make_assoc_type_signature(id, ident, bounds, default, scx).ok()
}
-type Result = ::std::result::Result<Signature, &'static str>;
+type Result = std::result::Result<Signature, &'static str>;
trait Sig {
- fn make(&self, offset: usize, id: Option<NodeId>, scx: &SaveContext) -> Result;
+ fn make(&self, offset: usize, id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result;
}
fn extend_sig(
}
impl Sig for ast::Ty {
- fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext) -> Result {
+ fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
let id = Some(self.id);
match self.node {
ast::TyKind::Slice(ref ty) => {
if f.unsafety == ast::Unsafety::Unsafe {
text.push_str("unsafe ");
}
- if f.abi != ::rustc_target::spec::abi::Abi::Rust {
+ if f.abi != rustc_target::spec::abi::Abi::Rust {
text.push_str("extern");
text.push_str(&f.abi.to_string());
text.push(' ');
}
impl Sig for ast::Item {
- fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext) -> Result {
+ fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
let id = Some(self.id);
match self.node {
if header.unsafety == ast::Unsafety::Unsafe {
text.push_str("unsafe ");
}
- if header.abi != ::rustc_target::spec::abi::Abi::Rust {
+ if header.abi != rustc_target::spec::abi::Abi::Rust {
text.push_str("extern");
text.push_str(&header.abi.to_string());
text.push(' ');
}
impl Sig for ast::Path {
- fn make(&self, offset: usize, id: Option<NodeId>, scx: &SaveContext) -> Result {
+ fn make(&self, offset: usize, id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
let def = scx.get_path_def(id.ok_or("Missing id for Path")?);
let (name, start, end) = match def {
// This does not cover the where clause, which must be processed separately.
impl Sig for ast::Generics {
- fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext) -> Result {
+ fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
if self.params.is_empty() {
return Ok(text_sig(String::new()));
}
}
impl Sig for ast::StructField {
- fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext) -> Result {
+ fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
let mut text = String::new();
let mut defs = None;
if let Some(ident) = self.ident {
impl Sig for ast::Variant_ {
- fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext) -> Result {
+ fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
let mut text = self.ident.to_string();
match self.data {
ast::VariantData::Struct(ref fields, id) => {
}
impl Sig for ast::ForeignItem {
- fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext) -> Result {
+ fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
let id = Some(self.id);
match self.node {
ast::ForeignItemKind::Fn(ref decl, ref generics) => {
generics: &ast::Generics,
id: NodeId,
name: ast::Ident,
- scx: &SaveContext,
+ scx: &SaveContext<'_, '_>,
) -> Result {
let name = name.to_string();
let def = SigElement {
ident: ast::Ident,
bounds: Option<&ast::GenericBounds>,
default: Option<&ast::Ty>,
- scx: &SaveContext,
+ scx: &SaveContext<'_, '_>,
) -> Result {
let mut text = "type ".to_owned();
let name = ident.to_string();
ident: ast::Name,
ty: &ast::Ty,
default: Option<&ast::Expr>,
- scx: &SaveContext,
+ scx: &SaveContext<'_, '_>,
) -> Result {
let mut text = "const ".to_owned();
let name = ident.to_string();
ident: ast::Ident,
generics: &ast::Generics,
m: &ast::MethodSig,
- scx: &SaveContext,
+ scx: &SaveContext<'_, '_>,
) -> Result {
// FIXME code dup with function signature
let mut text = String::new();
if m.header.unsafety == ast::Unsafety::Unsafe {
text.push_str("unsafe ");
}
- if m.header.abi != ::rustc_target::spec::abi::Abi::Rust {
+ if m.header.abi != rustc_target::spec::abi::Abi::Rust {
text.push_str("extern");
text.push_str(&m.header.abi.to_string());
text.push(' ');
use rustc::session::Session;
-use generated_code;
+use crate::generated_code;
use std::cell::Cell;
authors = ["The Rust Project Developers"]
name = "rustc_target"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_target"
-use abi::call::{FnType, ArgType, Reg, RegKind, Uniform};
-use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
+use crate::abi::call::{FnType, ArgType, Reg, RegKind, Uniform};
+use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
fn is_homogeneous_aggregate<'a, Ty, C>(cx: &C, arg: &mut ArgType<'a, Ty>)
-> Option<Uniform>
-use abi::call::{ArgType, FnType, };
-use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
+use crate::abi::call::{ArgType, FnType, };
+use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
fn classify_ret_ty<'a, Ty, C>(_cx: &C, ret: &mut ArgType<'a, Ty>)
where Ty: TyLayoutMethods<'a, C> + Copy,
-use abi::call::{Conv, FnType, ArgType, Reg, RegKind, Uniform};
-use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
-use spec::HasTargetSpec;
+use crate::abi::call::{Conv, FnType, ArgType, Reg, RegKind, Uniform};
+use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
+use crate::spec::HasTargetSpec;
fn is_homogeneous_aggregate<'a, Ty, C>(cx: &C, arg: &mut ArgType<'a, Ty>)
-> Option<Uniform>
-use abi::call::{FnType, ArgType, Uniform};
-use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
+use crate::abi::call::{FnType, ArgType, Uniform};
+use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
// Data layout: e-p:32:32-i64:64-v128:32:128-n32-S128
}
}
-fn classify_arg_ty<Ty>(arg: &mut ArgType<Ty>) {
+fn classify_arg_ty<Ty>(arg: &mut ArgType<'_, Ty>) {
if arg.layout.is_aggregate() {
arg.make_indirect_byval();
}
#![allow(non_upper_case_globals)]
-use abi::call::{FnType, ArgType};
+use crate::abi::call::{FnType, ArgType};
-fn classify_ret_ty<Ty>(ret: &mut ArgType<Ty>) {
+fn classify_ret_ty<Ty>(ret: &mut ArgType<'_, Ty>) {
if ret.layout.is_aggregate() && ret.layout.size.bits() > 64 {
ret.make_indirect();
} else {
}
}
-fn classify_arg_ty<Ty>(arg: &mut ArgType<Ty>) {
+fn classify_arg_ty<Ty>(arg: &mut ArgType<'_, Ty>) {
if arg.layout.is_aggregate() && arg.layout.size.bits() > 64 {
arg.make_indirect();
} else {
}
}
-pub fn compute_abi_info<Ty>(fty: &mut FnType<Ty>) {
+pub fn compute_abi_info<Ty>(fty: &mut FnType<'_,Ty>) {
if !fty.ret.is_ignore() {
classify_ret_ty(&mut fty.ret);
}
-use abi::call::{ArgType, FnType, Reg, Uniform};
-use abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods};
+use crate::abi::call::{ArgType, FnType, Reg, Uniform};
+use crate::abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods};
-fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType<Ty>, offset: &mut Size)
+fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType<'_, Ty>, offset: &mut Size)
where Ty: TyLayoutMethods<'a, C>, C: LayoutOf<Ty = Ty> + HasDataLayout
{
if !ret.layout.is_aggregate() {
}
}
-fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType<Ty>, offset: &mut Size)
+fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType<'_, Ty>, offset: &mut Size)
where Ty: TyLayoutMethods<'a, C>, C: LayoutOf<Ty = Ty> + HasDataLayout
{
let dl = cx.data_layout();
*offset = offset.align_to(align) + size.align_to(align);
}
-pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<Ty>)
+pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<'_, Ty>)
where Ty: TyLayoutMethods<'a, C>, C: LayoutOf<Ty = Ty> + HasDataLayout
{
let mut offset = Size::ZERO;
-use abi::call::{ArgAttribute, ArgType, CastTarget, FnType, PassMode, Reg, RegKind, Uniform};
-use abi::{self, HasDataLayout, LayoutOf, Size, TyLayout, TyLayoutMethods};
+use crate::abi::call::{ArgAttribute, ArgType, CastTarget, FnType, PassMode, Reg, RegKind, Uniform};
+use crate::abi::{self, HasDataLayout, LayoutOf, Size, TyLayout, TyLayoutMethods};
-fn extend_integer_width_mips<Ty>(arg: &mut ArgType<Ty>, bits: u64) {
+fn extend_integer_width_mips<Ty>(arg: &mut ArgType<'_, Ty>, bits: u64) {
// Always sign extend u32 values on 64-bit mips
if let abi::Abi::Scalar(ref scalar) = arg.layout.abi {
if let abi::Int(i, signed) = scalar.value {
-use abi::{self, Abi, Align, FieldPlacement, Size};
-use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
-use spec::HasTargetSpec;
+use crate::abi::{self, Abi, Align, FieldPlacement, Size};
+use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
+use crate::spec::{self, HasTargetSpec};
mod aarch64;
mod amdgpu;
// Hack to disable non_upper_case_globals only for the bitflags! and not for the rest
// of this module
-pub use self::attr_impl::ArgAttribute;
+pub use attr_impl::ArgAttribute;
#[allow(non_upper_case_globals)]
#[allow(unused)]
mod attr_impl {
// The subset of llvm::Attribute needed for arguments, packed into a bitfield.
- bitflags! {
+ bitflags::bitflags! {
#[derive(Default)]
pub struct ArgAttribute: u16 {
const ByVal = 1 << 0;
pub unit: Reg,
/// The total size of the argument, which can be:
- /// * equal to `unit.size` (one scalar/vector)
- /// * a multiple of `unit.size` (an array of scalar/vectors)
+ /// * equal to `unit.size` (one scalar/vector),
+ /// * a multiple of `unit.size` (an array of scalar/vectors),
/// * if `unit.kind` is `Integer`, the last element
/// can be shorter, i.e., `{ i64, i64, i32 }` for
- /// 64-bit integers with a total size of 20 bytes
+ /// 64-bit integers with a total size of 20 bytes.
pub total: Size,
}
}
}
-/// Return value from the `homogeneous_aggregate` test function.
+/// Returns value from the `homogeneous_aggregate` test function.
#[derive(Copy, Clone, Debug)]
pub enum HomogeneousAggregate {
/// Yes, all the "leaf fields" of this struct are passed in the
}
}
- /// True if this layout is an aggregate containing fields of only
+ /// Returns `true` if this layout is an aggregate containing fields of only
/// a single type (e.g., `(u32, u32)`). Such aggregates are often
/// special-cased in ABIs.
///
/// Note: We generally ignore fields of zero-sized type when computing
- /// this value (cc #56877).
+ /// this value (see #56877).
///
/// This is public so that it can be used in unit tests, but
/// should generally only be relevant to the ABI details of
}
impl<'a, Ty> FnType<'a, Ty> {
- pub fn adjust_for_cabi<C>(&mut self, cx: &C, abi: ::spec::abi::Abi) -> Result<(), String>
+ pub fn adjust_for_cabi<C>(&mut self, cx: &C, abi: spec::abi::Abi) -> Result<(), String>
where Ty: TyLayoutMethods<'a, C> + Copy,
C: LayoutOf<Ty = Ty, TyLayout = TyLayout<'a, Ty>> + HasDataLayout + HasTargetSpec
{
match &cx.target_spec().arch[..] {
"x86" => {
- let flavor = if abi == ::spec::abi::Abi::Fastcall {
+ let flavor = if abi == spec::abi::Abi::Fastcall {
x86::Flavor::Fastcall
} else {
x86::Flavor::General
};
x86::compute_abi_info(cx, self, flavor);
},
- "x86_64" => if abi == ::spec::abi::Abi::SysV64 {
+ "x86_64" => if abi == spec::abi::Abi::SysV64 {
x86_64::compute_abi_info(cx, self);
- } else if abi == ::spec::abi::Abi::Win64 || cx.target_spec().options.is_like_windows {
+ } else if abi == spec::abi::Abi::Win64 || cx.target_spec().options.is_like_windows {
x86_win64::compute_abi_info(self);
} else {
x86_64::compute_abi_info(cx, self);
// Reference: MSP430 Embedded Application Binary Interface
// http://www.ti.com/lit/an/slaa534/slaa534.pdf
-use abi::call::{ArgType, FnType};
+use crate::abi::call::{ArgType, FnType};
// 3.5 Structures or Unions Passed and Returned by Reference
//
// returned by reference. To pass a structure or union by reference, the caller
// places its address in the appropriate location: either in a register or on
// the stack, according to its position in the argument list. (..)"
-fn classify_ret_ty<Ty>(ret: &mut ArgType<Ty>) {
+fn classify_ret_ty<Ty>(ret: &mut ArgType<'_, Ty>) {
if ret.layout.is_aggregate() && ret.layout.size.bits() > 32 {
ret.make_indirect();
} else {
}
}
-fn classify_arg_ty<Ty>(arg: &mut ArgType<Ty>) {
+fn classify_arg_ty<Ty>(arg: &mut ArgType<'_, Ty>) {
if arg.layout.is_aggregate() && arg.layout.size.bits() > 32 {
arg.make_indirect();
} else {
}
}
-pub fn compute_abi_info<Ty>(fty: &mut FnType<Ty>) {
+pub fn compute_abi_info<Ty>(fty: &mut FnType<'_, Ty>) {
if !fty.ret.is_ignore() {
classify_ret_ty(&mut fty.ret);
}
// Reference: PTX Writer's Guide to Interoperability
// http://docs.nvidia.com/cuda/ptx-writers-guide-to-interoperability
-use abi::call::{ArgType, FnType};
+use crate::abi::call::{ArgType, FnType};
-fn classify_ret_ty<Ty>(ret: &mut ArgType<Ty>) {
+fn classify_ret_ty<Ty>(ret: &mut ArgType<'_, Ty>) {
if ret.layout.is_aggregate() && ret.layout.size.bits() > 32 {
ret.make_indirect();
} else {
}
}
-fn classify_arg_ty<Ty>(arg: &mut ArgType<Ty>) {
+fn classify_arg_ty<Ty>(arg: &mut ArgType<'_, Ty>) {
if arg.layout.is_aggregate() && arg.layout.size.bits() > 32 {
arg.make_indirect();
} else {
}
}
-pub fn compute_abi_info<Ty>(fty: &mut FnType<Ty>) {
+pub fn compute_abi_info<Ty>(fty: &mut FnType<'_, Ty>) {
if !fty.ret.is_ignore() {
classify_ret_ty(&mut fty.ret);
}
// Reference: PTX Writer's Guide to Interoperability
// http://docs.nvidia.com/cuda/ptx-writers-guide-to-interoperability
-use abi::call::{ArgType, FnType};
+use crate::abi::call::{ArgType, FnType};
-fn classify_ret_ty<Ty>(ret: &mut ArgType<Ty>) {
+fn classify_ret_ty<Ty>(ret: &mut ArgType<'_, Ty>) {
if ret.layout.is_aggregate() && ret.layout.size.bits() > 64 {
ret.make_indirect();
} else {
}
}
-fn classify_arg_ty<Ty>(arg: &mut ArgType<Ty>) {
+fn classify_arg_ty<Ty>(arg: &mut ArgType<'_, Ty>) {
if arg.layout.is_aggregate() && arg.layout.size.bits() > 64 {
arg.make_indirect();
} else {
}
}
-pub fn compute_abi_info<Ty>(fty: &mut FnType<Ty>) {
+pub fn compute_abi_info<Ty>(fty: &mut FnType<'_, Ty>) {
if !fty.ret.is_ignore() {
classify_ret_ty(&mut fty.ret);
}
-use abi::call::{ArgType, FnType, Reg, Uniform};
-use abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods};
+use crate::abi::call::{ArgType, FnType, Reg, Uniform};
+use crate::abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods};
-fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType<Ty>, offset: &mut Size)
+fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType<'_, Ty>, offset: &mut Size)
where Ty: TyLayoutMethods<'a, C>, C: LayoutOf<Ty = Ty> + HasDataLayout
{
if !ret.layout.is_aggregate() {
}
}
-fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType<Ty>, offset: &mut Size)
+fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType<'_, Ty>, offset: &mut Size)
where Ty: TyLayoutMethods<'a, C>, C: LayoutOf<Ty = Ty> + HasDataLayout
{
let dl = cx.data_layout();
*offset = offset.align_to(align) + size.align_to(align);
}
-pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<Ty>)
+pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<'_, Ty>)
where Ty: TyLayoutMethods<'a, C>, C: LayoutOf<Ty = Ty> + HasDataLayout
{
let mut offset = Size::ZERO;
// Alignment of 128 bit types is not currently handled, this will
// need to be fixed when PowerPC vector support is added.
-use abi::call::{FnType, ArgType, Reg, RegKind, Uniform};
-use abi::{Endian, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
-use spec::HasTargetSpec;
+use crate::abi::call::{FnType, ArgType, Reg, RegKind, Uniform};
+use crate::abi::{Endian, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
+use crate::spec::HasTargetSpec;
#[derive(Debug, Clone, Copy, PartialEq)]
enum ABI {
ELFv1, // original ABI used for powerpc64 (big-endian)
ELFv2, // newer ABI used for powerpc64le and musl (both endians)
}
-use self::ABI::*;
+use ABI::*;
fn is_homogeneous_aggregate<'a, Ty, C>(cx: &C, arg: &mut ArgType<'a, Ty>, abi: ABI)
-> Option<Uniform>
// Reference: RISC-V ELF psABI specification
// https://github.com/riscv/riscv-elf-psabi-doc
-use abi::call::{ArgType, FnType};
+use crate::abi::call::{ArgType, FnType};
-fn classify_ret_ty<Ty>(arg: &mut ArgType<Ty>, xlen: u64) {
+fn classify_ret_ty<Ty>(arg: &mut ArgType<'_, Ty>, xlen: u64) {
// "Scalars wider than 2✕XLEN are passed by reference and are replaced in
// the argument list with the address."
// "Aggregates larger than 2✕XLEN bits are passed by reference and are
arg.extend_integer_width_to(xlen); // this method only affects integer scalars
}
-fn classify_arg_ty<Ty>(arg: &mut ArgType<Ty>, xlen: u64) {
+fn classify_arg_ty<Ty>(arg: &mut ArgType<'_, Ty>, xlen: u64) {
// "Scalars wider than 2✕XLEN are passed by reference and are replaced in
// the argument list with the address."
// "Aggregates larger than 2✕XLEN bits are passed by reference and are
arg.extend_integer_width_to(xlen); // this method only affects integer scalars
}
-pub fn compute_abi_info<Ty>(fty: &mut FnType<Ty>, xlen: u64) {
+pub fn compute_abi_info<Ty>(fty: &mut FnType<'_, Ty>, xlen: u64) {
if !fty.ret.is_ignore() {
classify_ret_ty(&mut fty.ret, xlen);
}
// FIXME: The assumes we're using the non-vector ABI, i.e., compiling
// for a pre-z13 machine or using -mno-vx.
-use abi::call::{FnType, ArgType, Reg};
-use abi::{self, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
+use crate::abi::call::{FnType, ArgType, Reg};
+use crate::abi::{self, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
-fn classify_ret_ty<'a, Ty, C>(ret: &mut ArgType<Ty>)
+fn classify_ret_ty<'a, Ty, C>(ret: &mut ArgType<'_, Ty>)
where Ty: TyLayoutMethods<'a, C>, C: LayoutOf<Ty = Ty> + HasDataLayout
{
if !ret.layout.is_aggregate() && ret.layout.size.bits() <= 64 {
-use abi::call::{ArgType, FnType, Reg, Uniform};
-use abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods};
+use crate::abi::call::{ArgType, FnType, Reg, Uniform};
+use crate::abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods};
-fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType<Ty>, offset: &mut Size)
+fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType<'_, Ty>, offset: &mut Size)
where Ty: TyLayoutMethods<'a, C>, C: LayoutOf<Ty = Ty> + HasDataLayout
{
if !ret.layout.is_aggregate() {
}
}
-fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType<Ty>, offset: &mut Size)
+fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType<'_, Ty>, offset: &mut Size)
where Ty: TyLayoutMethods<'a, C>, C: LayoutOf<Ty = Ty> + HasDataLayout
{
let dl = cx.data_layout();
*offset = offset.align_to(align) + size.align_to(align);
}
-pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<Ty>)
+pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<'_, Ty>)
where Ty: TyLayoutMethods<'a, C>, C: LayoutOf<Ty = Ty> + HasDataLayout
{
let mut offset = Size::ZERO;
// FIXME: This needs an audit for correctness and completeness.
-use abi::call::{FnType, ArgType, Reg, RegKind, Uniform};
-use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
+use crate::abi::call::{FnType, ArgType, Reg, RegKind, Uniform};
+use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
fn is_homogeneous_aggregate<'a, Ty, C>(cx: &C, arg: &mut ArgType<'a, Ty>)
-> Option<Uniform>
-use abi::call::{FnType, ArgType};
+use crate::abi::call::{FnType, ArgType};
-fn classify_ret_ty<Ty>(ret: &mut ArgType<Ty>) {
+fn classify_ret_ty<Ty>(ret: &mut ArgType<'_, Ty>) {
ret.extend_integer_width_to(32);
}
-fn classify_arg_ty<Ty>(arg: &mut ArgType<Ty>) {
+fn classify_arg_ty<Ty>(arg: &mut ArgType<'_, Ty>) {
arg.extend_integer_width_to(32);
}
-pub fn compute_abi_info<Ty>(fty: &mut FnType<Ty>) {
+pub fn compute_abi_info<Ty>(fty: &mut FnType<'_, Ty>) {
if !fty.ret.is_ignore() {
classify_ret_ty(&mut fty.ret);
}
-use abi::call::{ArgAttribute, FnType, PassMode, Reg, RegKind};
-use abi::{self, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
-use spec::HasTargetSpec;
+use crate::abi::call::{ArgAttribute, FnType, PassMode, Reg, RegKind};
+use crate::abi::{self, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
+use crate::spec::HasTargetSpec;
#[derive(PartialEq)]
pub enum Flavor {
// The classification code for the x86_64 ABI is taken from the clay language
// https://github.com/jckarter/clay/blob/master/compiler/src/externals.cpp
-use abi::call::{ArgType, CastTarget, FnType, Reg, RegKind};
-use abi::{self, Abi, HasDataLayout, LayoutOf, Size, TyLayout, TyLayoutMethods};
+use crate::abi::call::{ArgType, CastTarget, FnType, Reg, RegKind};
+use crate::abi::{self, Abi, HasDataLayout, LayoutOf, Size, TyLayout, TyLayoutMethods};
/// Classification of "eightbyte" components.
// N.B., the order of the variants is from general to specific,
-use abi::call::{ArgType, FnType, Reg};
-use abi::Abi;
+use crate::abi::call::{ArgType, FnType, Reg};
+use crate::abi::Abi;
// Win64 ABI: http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
-pub fn compute_abi_info<Ty>(fty: &mut FnType<Ty>) {
- let fixup = |a: &mut ArgType<Ty>| {
+pub fn compute_abi_info<Ty>(fty: &mut FnType<'_, Ty>) {
+ let fixup = |a: &mut ArgType<'_, Ty>| {
match a.layout.abi {
Abi::Uninhabited => {}
Abi::ScalarPair(..) |
-pub use self::Integer::*;
-pub use self::Primitive::*;
+pub use Integer::*;
+pub use Primitive::*;
-use spec::Target;
+use crate::spec::Target;
use std::fmt;
use std::ops::{Add, Deref, Sub, Mul, AddAssign, Range, RangeInclusive};
Ok(dl)
}
- /// Return exclusive upper bound on object size.
+ /// Returns exclusive upper bound on object size.
///
/// The theoretical maximum object size is defined as the maximum positive `isize` value.
/// This ensures that the `offset` semantics remain well-defined by allowing it to correctly
self.bytes() * 8
}
- /// Compute the best alignment possible for the given offset
+ /// Computes the best alignment possible for the given offset
/// (the largest power of two that the offset is a multiple of).
///
/// N.B., for an offset of `0`, this happens to return `2^64`.
}
}
- /// Find the smallest Integer type which can represent the signed value.
+ /// Finds the smallest Integer type which can represent the signed value.
pub fn fit_signed(x: i128) -> Integer {
match x {
-0x0000_0000_0000_0080..=0x0000_0000_0000_007f => I8,
}
}
- /// Find the smallest Integer type which can represent the unsigned value.
+ /// Finds the smallest Integer type which can represent the unsigned value.
pub fn fit_unsigned(x: u128) -> Integer {
match x {
0..=0x0000_0000_0000_00ff => I8,
}
}
- /// Find the smallest integer with the given alignment.
+ /// Finds the smallest integer with the given alignment.
pub fn for_align<C: HasDataLayout>(cx: &C, wanted: Align) -> Option<Integer> {
let dl = cx.data_layout();
}
impl fmt::Debug for FloatTy {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(self, f)
}
}
impl fmt::Display for FloatTy {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.ty_to_string())
}
}
}
}
- /// Get source indices of the fields by increasing offsets.
+ /// Gets source indices of the fields by increasing offsets.
#[inline]
pub fn index_by_increasing_offset<'a>(&'a self) -> impl Iterator<Item=usize>+'a {
let mut inverse_small = [0u8; 64];
}
impl Abi {
- /// Returns true if the layout corresponds to an unsized type.
+ /// Returns `true` if the layout corresponds to an unsized type.
pub fn is_unsized(&self) -> bool {
match *self {
Abi::Uninhabited |
}
}
- /// Returns true if this is a single signed integer scalar
+ /// Returns `true` if this is a single signed integer scalar
pub fn is_signed(&self) -> bool {
match *self {
Abi::Scalar(ref scal) => match scal.value {
}
}
- /// Returns true if this is an uninhabited type
+ /// Returns `true` if this is an uninhabited type
pub fn is_uninhabited(&self) -> bool {
match *self {
Abi::Uninhabited => true,
}
impl<'a, Ty> TyLayout<'a, Ty> {
- /// Returns true if the layout corresponds to an unsized type.
+ /// Returns `true` if the layout corresponds to an unsized type.
pub fn is_unsized(&self) -> bool {
self.abi.is_unsized()
}
- /// Returns true if the type is a ZST and not unsized.
+ /// Returns `true` if the type is a ZST and not unsized.
pub fn is_zst(&self) -> bool {
match self.abi {
Abi::Scalar(_) |
//! compiler 'backend', though LLVM is rustc's backend, so rustc_target
//! is really just odds-and-ends relating to code gen and linking.
//! This crate mostly exists to make rustc smaller, so we might put
-//! more 'stuff' here in the future. It does not have a dependency on
+//! more 'stuff' here in the future. It does not have a dependency on
//! LLVM.
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
#![feature(slice_patterns)]
#![feature(step_trait)]
-#[macro_use]
-extern crate bitflags;
-extern crate serialize;
+#![deny(rust_2018_idioms)]
+
#[macro_use] extern crate log;
+#[allow(unused_extern_crates)]
extern crate serialize as rustc_serialize; // used by deriving
// See librustc_cratesio_shim/Cargo.toml for a comment explaining this.
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use super::apple_ios_base::{opts, Arch};
pub fn target() -> TargetResult {
-use spec::{LldFlavor, LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LldFlavor, LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::fuchsia_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
// See https://developer.android.com/ndk/guides/abis.html#arm64-v8a
// for target ABI requirements.
-use spec::{LinkerFlavor, Target, TargetResult, PanicStrategy};
+use crate::spec::{LinkerFlavor, Target, TargetResult, PanicStrategy};
pub fn target() -> TargetResult {
let mut base = super::windows_msvc_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::cloudabi_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::freebsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::hermit_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_musl_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::netbsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::openbsd_base::opts();
}
impl fmt::Display for Abi {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "\"{}\"", self.name())
}
}
-use spec::{LinkerFlavor, TargetOptions};
+use crate::spec::{LinkerFlavor, TargetOptions};
pub fn opts() -> TargetOptions {
let mut base = super::linux_base::opts();
use std::env;
-use spec::{LinkArgs, TargetOptions};
+use crate::spec::{LinkArgs, TargetOptions};
pub fn opts() -> TargetOptions {
// ELF TLS is only available in macOS 10.7+. If you try to compile for 10.6
use std::io;
use std::process::Command;
-use spec::{LinkArgs, LinkerFlavor, TargetOptions};
+use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions};
-use self::Arch::*;
+use Arch::*;
#[allow(non_camel_case_types)]
#[derive(Copy, Clone)]
-use spec::abi::Abi;
+use crate::spec::abi::Abi;
// All the calling conventions trigger an assertion(Unsupported calling convention) in llvm on arm
pub fn abi_blacklist() -> Vec<Abi> {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::android_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_musl_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_musl_base::opts();
// Targets the Big endian Cortex-R4/R5 processor (ARMv7-R)
use std::default::Default;
-use spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
// Targets the Cortex-R4F/R5F processor (ARMv7-R)
use std::default::Default;
-use spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let base = super::linux_musl_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::netbsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use super::apple_ios_base::{opts, Arch};
pub fn target() -> TargetResult {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
// This target if is for the baseline of the Android v7a ABI
// in thumb mode. It's named armv7-* instead of thumbv7-*
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::cloudabi_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
// This target is for glibc Linux on ARMv7 without NEON or
// thumb-mode. See the thumbv7neon variant for enabling both.
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
// This target is for musl Linux on ARMv7 without thumb-mode or NEON.
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
let base = super::netbsd_base::opts();
// Targets the Little-endian Cortex-R4/R5 processor (ARMv7-R)
use std::default::Default;
-use spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
// Targets the Little-endian Cortex-R4F/R5F processor (ARMv7-R)
use std::default::Default;
-use spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use super::apple_ios_base::{opts, Arch};
pub fn target() -> TargetResult {
-use spec::{TargetOptions, RelroLevel};
+use crate::spec::{TargetOptions, RelroLevel};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
+use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
pub fn opts() -> TargetOptions {
let mut args = LinkArgs::new();
-use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
+use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
+use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LldFlavor, LinkArgs, LinkerFlavor, TargetOptions};
+use crate::spec::{LldFlavor, LinkArgs, LinkerFlavor, TargetOptions};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{TargetOptions, RelroLevel};
+use crate::spec::{TargetOptions, RelroLevel};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkArgs, LinkerFlavor, PanicStrategy, TargetOptions};
+use crate::spec::{LinkArgs, LinkerFlavor, PanicStrategy, TargetOptions};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use super::apple_ios_base::{opts, Arch};
pub fn target() -> TargetResult {
-use spec::TargetResult;
+use crate::spec::TargetResult;
pub fn target() -> TargetResult {
let mut base = super::i686_pc_windows_msvc::target()?;
-use spec::TargetResult;
+use crate::spec::TargetResult;
pub fn target() -> TargetResult {
let mut base = super::i686_unknown_linux_gnu::target()?;
-use spec::TargetResult;
+use crate::spec::TargetResult;
pub fn target() -> TargetResult {
let mut base = super::i686_unknown_linux_musl::target()?;
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::apple_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
// See https://developer.android.com/ndk/guides/abis.html#x86
// for target ABI requirements.
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::windows_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::windows_msvc_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::cloudabi_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::dragonfly_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::freebsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::haiku_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_musl_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::netbsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::openbsd_base::opts();
-use spec::{LinkArgs, LinkerFlavor, PanicStrategy, TargetOptions};
+use crate::spec::{LinkArgs, LinkerFlavor, PanicStrategy, TargetOptions};
use std::default::Default;
//use std::process::Command;
-use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
+use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkerFlavor, TargetOptions};
+use crate::spec::{LinkerFlavor, TargetOptions};
pub fn opts() -> TargetOptions {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_musl_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_musl_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
use std::{fmt, io};
use std::path::{Path, PathBuf};
use std::str::FromStr;
-use spec::abi::{Abi, lookup as lookup_abi};
+use crate::spec::abi::{Abi, lookup as lookup_abi};
pub mod abi;
mod android_base;
pub pre_link_objects_exe_crt: Vec<String>, // ... when linking an executable with a bundled crt
pub pre_link_objects_dll: Vec<String>, // ... when linking a dylib
/// Linker arguments that are unconditionally passed after any
- /// user-defined but before post_link_objects. Standard platform
+ /// user-defined but before post_link_objects. Standard platform
/// libraries that should be always be linked to, usually go here.
pub late_link_args: LinkArgs,
/// Objects to link after all others, always found within the
pub allow_asm: bool,
/// Whether the target uses a custom unwind resumption routine.
/// By default LLVM lowers `resume` instructions into calls to `_Unwind_Resume`
- /// defined in libgcc. If this option is enabled, the target must provide
+ /// defined in libgcc. If this option is enabled, the target must provide
/// `eh_unwind_resume` lang item.
pub custom_unwind_resume: bool,
/// for this target unconditionally.
pub no_builtins: bool,
- /// Whether to lower 128-bit operations to compiler_builtins calls. Use if
+ /// Whether to lower 128-bit operations to compiler_builtins calls. Use if
/// your backend only supports 64-bit and smaller math.
pub i128_lowering: bool,
}
impl Default for TargetOptions {
- /// Create a set of "sane defaults" for any target. This is still
+ /// Creates a set of "sane defaults" for any target. This is still
/// incomplete, and if used for compilation, will certainly not work.
fn default() -> TargetOptions {
TargetOptions {
abi.generic() || !self.options.abi_blacklist.contains(&abi)
}
- /// Load a target descriptor from a JSON object.
+ /// Loads a target descriptor from a JSON object.
pub fn from_json(obj: Json) -> TargetResult {
// While ugly, this code must remain this way to retain
// compatibility with existing JSON fields and the internal
}
impl fmt::Display for TargetTriple {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.debug_triple())
}
}
-use spec::{LinkerFlavor, PanicStrategy, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, PanicStrategy, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
+use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult, PanicStrategy, MergeFunctions};
-use spec::abi::Abi;
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult, PanicStrategy, MergeFunctions};
+use crate::spec::abi::Abi;
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
+use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::freebsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult, RelroLevel};
+use crate::spec::{LinkerFlavor, Target, TargetResult, RelroLevel};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_musl_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_musl_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_musl_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::netbsd_base::opts();
-use spec::{LinkArgs, LinkerFlavor, TargetOptions};
+use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkerFlavor, LldFlavor, PanicStrategy,
+use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy,
Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
-use spec::{LinkerFlavor, LldFlavor, PanicStrategy,
+use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy,
Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
-use spec::abi::Abi;
+use crate::spec::abi::Abi;
// All the calling conventions trigger an assertion(Unsupported calling
// convention) in llvm on RISCV
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::TargetOptions;
+use crate::spec::TargetOptions;
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::netbsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::solaris_base::opts();
// build scripts / gcc flags.
use std::default::Default;
-use spec::{PanicStrategy, TargetOptions};
+use crate::spec::{PanicStrategy, TargetOptions};
pub fn opts() -> TargetOptions {
// See rust-lang/rfcs#1645 for a discussion about these defaults
// Targets the Cortex-M0, Cortex-M0+ and Cortex-M1 processors (ARMv6-M architecture)
-use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult, PanicStrategy};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult, PanicStrategy};
pub fn target() -> TargetResult {
let mut base = super::windows_msvc_base::opts();
// To opt-in to hardware accelerated floating point operations, you can use, for example,
// `-C target-feature=+vfp4` or `-C target-cpu=cortex-m4`.
-use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
//
// To opt into double precision hardware support, use the `-C target-feature=-fp-only-sp` flag.
-use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
// Targets the Cortex-M3 processor (ARMv7-M)
-use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
// This target if is for the Android v7a ABI in thumb mode with
// NEON unconditionally enabled and, therefore, with 32 FPU registers
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
// This target is for glibc Linux on ARMv7 with thumb mode enabled
// (for consistency with Android and Debian-based distributions)
// Targets the Cortex-M23 processor (Baseline ARMv8-M)
-use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
// Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile),
// without the Floating Point extension.
-use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
// Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile),
// with the Floating Point extension.
-use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult};
pub fn target() -> TargetResult {
Ok(Target {
// UEFI uses COFF/PE32+ format for binaries. All binaries must be statically linked. No dynamic
// linker is supported. As native to COFF, binaries are position-dependent, but will be relocated
// by the loader if the pre-chosen memory location is already in use.
-// UEFI forbids running code on anything but the boot-CPU. Not interrupts are allowed other than
+// UEFI forbids running code on anything but the boot-CPU. No interrupts are allowed other than
// the timer-interrupt. Device-drivers are required to use polling-based models. Furthermore, all
// code runs in the same environment, no process separation is supported.
-use spec::{LinkArgs, LinkerFlavor, LldFlavor, PanicStrategy, TargetOptions};
+use crate::spec::{LinkArgs, LinkerFlavor, LldFlavor, PanicStrategy, TargetOptions};
use std::default::Default;
pub fn opts() -> TargetOptions {
"/NOLOGO".to_string(),
// UEFI is fully compatible to non-executable data pages. Tell the compiler that
- // non-code sections can be marked as non-executable, including stack pages.
+ // non-code sections can be marked as non-executable, including stack pages. In fact,
+ // firmware might enforce this, so we better let the linker know about this, so it
+ // will fail if the compiler ever tries placing code on the stack (e.g., trampoline
+ // constructs and alike).
"/NXCOMPAT".to_string(),
// There is no runtime for UEFI targets, prevent them from being linked. UEFI targets
-use spec::{LinkArgs, LinkerFlavor, TargetOptions};
+use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkArgs, LinkerFlavor, TargetOptions};
+use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions};
use std::default::Default;
pub fn opts() -> TargetOptions {
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::apple_base::opts();
-use spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
use super::apple_ios_base::{opts, Arch};
pub fn target() -> TargetResult {
-use spec::{LldFlavor, LinkerFlavor, Target, TargetResult};
+use crate::spec::{LldFlavor, LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::fuchsia_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::android_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::windows_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::windows_msvc_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::netbsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::solaris_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::bitrig_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::cloudabi_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::dragonfly_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::freebsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::haiku_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::hermit_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::l4re_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::linux_musl_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::netbsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::openbsd_base::opts();
-use spec::{LinkerFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::redox_base::opts();
// The win64 ABI is used. It differs from the sysv64 ABI, so we must use a windows target with
// LLVM. "x86_64-unknown-windows" is used to get the minimal subset of windows-specific features.
-use spec::{LinkerFlavor, LldFlavor, Target, TargetResult};
+use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult};
pub fn target() -> TargetResult {
let mut base = super::uefi_base::opts();
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
- // We disable MMX and SSE for now. UEFI does not prevent these from being used, but there have
- // been reports to GRUB that some firmware does not initialize the FP exception handlers
- // properly. Therefore, using FP coprocessors will end you up at random memory locations when
- // you throw FP exceptions.
- // To be safe, we disable them for now and force soft-float. This can be revisited when we
- // have more test coverage. Disabling FP served GRUB well so far, so it should be good for us
- // as well.
+ // We disable MMX and SSE for now, even though UEFI allows using them. Problem is, you have to
+ // enable these CPU features explicitly before their first use, otherwise their instructions
+ // will trigger an exception. Rust does not inject any code that enables AVX/MMX/SSE
+ // instruction sets, so this must be done by the firmware. However, existing firmware is known
+ // to leave these uninitialized, thus triggering exceptions if we make use of them. Which is
+ // why we avoid them and instead use soft-floats. This is also what GRUB and friends did so
+ // far.
+ // If you initialize FP units yourself, you can override these flags with custom linker
+ // arguments, thus giving you access to full MMX/SSE acceleration.
base.features = "-mmx,-sse,+soft-float".to_string();
// UEFI systems run without a host OS, hence we cannot assume any code locality. We must tell
// places no locality-restrictions, so it fits well here.
base.code_model = Some("large".to_string());
- // UEFI mostly mirrors the calling-conventions used on windows. In case of x86-64 this means
- // small structs will be returned as int. This shouldn't matter much, since the restrictions
- // placed by the UEFI specifications forbid any ABI to return structures.
+ // UEFI mirrors the calling-conventions used on windows. In case of x86-64 this means small
+ // structs will be returned as int. This shouldn't matter much, since the restrictions placed
+ // by the UEFI specifications forbid any ABI to return structures.
base.abi_return_struct_as_int = true;
Ok(Target {
authors = ["The Rust Project Developers"]
name = "rustc_traits"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_traits"
}
impl context::ContextOps<ChalkArenas<'gcx>> for ChalkContext<'cx, 'gcx> {
- /// True if this is a coinductive goal: basically proving that an auto trait
+ /// Returns `true` if this is a coinductive goal: basically proving that an auto trait
/// is implemented or proving that a trait reference is well-formed.
fn is_coinductive(
&self,
}
}
- /// Create an inference table for processing a new goal and instantiate that goal
+ /// Creates an inference table for processing a new goal and instantiate that goal
/// in that context, returning "all the pieces".
///
/// More specifically: given a u-canonical goal `arg`, creates a
/// each bound variable in `arg` to a fresh inference variable
/// from T. Returns:
///
- /// - the table `T`
- /// - the substitution `S`
- /// - the environment and goal found by substitution `S` into `arg`
+ /// - the table `T`,
+ /// - the substitution `S`,
+ /// - the environment and goal found by substitution `S` into `arg`.
fn instantiate_ucanonical_goal<R>(
&self,
arg: &Canonical<'gcx, InEnvironment<'gcx, Goal<'gcx>>>,
})
}
- /// True if this solution has no region constraints.
+ /// Returns `true` if this solution has no region constraints.
fn empty_constraints(ccs: &Canonical<'gcx, ConstrainedSubst<'gcx>>) -> bool {
ccs.value.constraints.is_empty()
}
type ChalkExClause<'tcx> = ExClause<ChalkArenas<'tcx>>;
impl Debug for ChalkContext<'cx, 'gcx> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "ChalkContext")
}
}
impl Debug for ChalkInferenceContext<'cx, 'gcx, 'tcx> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "ChalkInferenceContext")
}
}
}
}
-crate fn provide(p: &mut Providers) {
+crate fn provide(p: &mut Providers<'_>) {
*p = Providers {
evaluate_goal,
..*p
def_id: sized_trait,
substs: tcx.mk_substs_trait(ty, ty::List::empty()),
};
- let sized_implemented: DomainGoal = ty::TraitPredicate {
+ let sized_implemented: DomainGoal<'_> = ty::TraitPredicate {
trait_ref: sized_implemented
}.lower();
def_id: sized_trait,
substs: tcx.mk_substs_trait(ty, ty::List::empty()),
};
- let sized_implemented: DomainGoal = ty::TraitPredicate {
+ let sized_implemented: DomainGoal<'_> = ty::TraitPredicate {
trait_ref: sized_implemented
}.lower();
mutbl,
});
- let _outlives: DomainGoal = ty::OutlivesPredicate(ty, region).lower();
+ let _outlives: DomainGoal<'_> = ty::OutlivesPredicate(ty, region).lower();
let wf_clause = ProgramClause {
goal: DomainGoal::WellFormed(WellFormed::Ty(ref_ty)),
hypotheses: ty::List::empty(),
use rustc_data_structures::sync::Lrc;
use syntax::source_map::{Span, DUMMY_SP};
-crate fn provide(p: &mut Providers) {
+crate fn provide(p: &mut Providers<'_>) {
*p = Providers {
dropck_outlives,
adt_dtorck_constraint,
)
}
-/// Return a set of constraints that needs to be satisfied in
+/// Returns a set of constraints that needs to be satisfied in
/// order for `ty` to be valid for destruction.
fn dtorck_constraint_for_ty<'a, 'gcx, 'tcx>(
tcx: TyCtxt<'a, 'gcx, 'tcx>,
let mut result = def.all_fields()
.map(|field| tcx.type_of(field.did))
.map(|fty| dtorck_constraint_for_ty(tcx, span, fty, 0, fty))
- .collect::<Result<DtorckConstraint, NoSolution>>()?;
+ .collect::<Result<DtorckConstraint<'_>, NoSolution>>()?;
result.outlives.extend(tcx.destructor_constraints(def));
dedup_dtorck_constraint(&mut result);
use rustc::ty::{ParamEnvAnd, TyCtxt};
use syntax::source_map::DUMMY_SP;
-crate fn provide(p: &mut Providers) {
+crate fn provide(p: &mut Providers<'_>) {
*p = Providers {
evaluate_obligation,
..*p
//! Provider for the `implied_outlives_bounds` query.
//! Do not call this query directory. See [`rustc::traits::query::implied_outlives_bounds`].
+use rustc::hir;
use rustc::infer::InferCtxt;
use rustc::infer::canonical::{self, Canonical};
use rustc::traits::{TraitEngine, TraitEngineExt};
use rustc::ty::query::Providers;
use rustc::ty::wf;
use smallvec::{SmallVec, smallvec};
-use syntax::ast::DUMMY_NODE_ID;
use syntax::source_map::DUMMY_SP;
use rustc::traits::FulfillmentContext;
use rustc_data_structures::sync::Lrc;
-crate fn provide(p: &mut Providers) {
+crate fn provide(p: &mut Providers<'_>) {
*p = Providers {
implied_outlives_bounds,
..*p
// unresolved inference variables here anyway, but there might be
// during typeck under some circumstances.)
let obligations =
- wf::obligations(infcx, param_env, DUMMY_NODE_ID, ty, DUMMY_SP).unwrap_or(vec![]);
+ wf::obligations(infcx, param_env, hir::DUMMY_HIR_ID, ty, DUMMY_SP).unwrap_or(vec![]);
// N.B., all of these predicates *ought* to be easily proven
// true. In fact, their correctness is (mostly) implied by
//! New recursive solver modeled on Chalk's recursive solver. Most of
//! the guts are broken up into modules; see the comments in those modules.
+#![deny(rust_2018_idioms)]
+
#![feature(crate_visibility_modifier)]
#![feature(in_band_lifetimes)]
#![feature(nll)]
#![recursion_limit="256"]
-extern crate chalk_engine;
#[macro_use]
extern crate log;
#[macro_use]
extern crate rustc;
-extern crate rustc_data_structures;
-extern crate rustc_target;
-extern crate syntax;
-extern crate syntax_pos;
-extern crate smallvec;
mod chalk_context;
mod dropck_outlives;
use rustc::ty::query::Providers;
-pub fn provide(p: &mut Providers) {
+pub fn provide(p: &mut Providers<'_>) {
dropck_outlives::provide(p);
evaluate_obligation::provide(p);
implied_outlives_bounds::provide(p);
use std::iter;
-crate fn provide(p: &mut Providers) {
+crate fn provide(p: &mut Providers<'_>) {
*p = Providers {
program_clauses_for,
program_clauses_for_env: environment::program_clauses_for_env,
};
// `Implemented(Self: Trait<P1..Pn>)`
- let impl_trait: DomainGoal = trait_pred.lower();
+ let impl_trait: DomainGoal<'_> = trait_pred.lower();
// `FromEnv(Self: Trait<P1..Pn>)`
let from_env_goal = tcx.mk_goal(impl_trait.into_from_env_goal().into_goal());
let ty = tcx.type_of(item_id);
// `Implemented(A0: Trait<A1..An>)`
- let trait_implemented: DomainGoal = ty::TraitPredicate { trait_ref }.lower();
+ let trait_implemented: DomainGoal<'_> = ty::TraitPredicate { trait_ref }.lower();
// `<A0 as Trait<A1..An>>::AssocType<Pn+1..Pm>`
let projection_ty = ty::ProjectionTy::from_ref_and_name(tcx, trait_ref, item.ident);
use rustc::ty::{self, ParamEnvAnd, Ty, TyCtxt};
use std::sync::atomic::Ordering;
-crate fn provide(p: &mut Providers) {
+crate fn provide(p: &mut Providers<'_>) {
*p = Providers {
normalize_ty_after_erasing_regions,
..*p
+use rustc::hir;
use rustc::infer::canonical::{Canonical, QueryResponse};
use rustc::traits::query::{normalize::NormalizationResult, CanonicalProjectionGoal, NoSolution};
use rustc::traits::{self, ObligationCause, SelectionContext, TraitEngineExt};
use rustc::ty::{ParamEnvAnd, TyCtxt};
use rustc_data_structures::sync::Lrc;
use std::sync::atomic::Ordering;
-use syntax::ast::DUMMY_NODE_ID;
use syntax_pos::DUMMY_SP;
-crate fn provide(p: &mut Providers) {
+crate fn provide(p: &mut Providers<'_>) {
*p = Providers {
normalize_projection_ty,
..*p
value: goal,
}| {
let selcx = &mut SelectionContext::new(infcx);
- let cause = ObligationCause::misc(DUMMY_SP, DUMMY_NODE_ID);
+ let cause = ObligationCause::misc(DUMMY_SP, hir::DUMMY_HIR_ID);
let mut obligations = vec![];
let answer = traits::normalize_projection_type(
selcx,
use rustc::infer::at::ToTrace;
use rustc::infer::canonical::{Canonical, QueryResponse};
use rustc::infer::InferCtxt;
+use rustc::hir;
use rustc::hir::def_id::DefId;
use rustc::traits::query::type_op::ascribe_user_type::AscribeUserType;
use rustc::traits::query::type_op::eq::Eq;
};
use rustc_data_structures::sync::Lrc;
use std::fmt;
-use syntax::ast;
use syntax_pos::DUMMY_SP;
-crate fn provide(p: &mut Providers) {
+crate fn provide(p: &mut Providers<'_>) {
*p = Providers {
type_op_ascribe_user_type,
type_op_eq,
self.infcx
.partially_normalize_associated_types_in(
DUMMY_SP,
- ast::CRATE_NODE_ID,
+ hir::CRATE_HIR_ID,
self.param_env,
&value,
)
#![sanitizer_runtime]
+#![feature(nll)]
#![feature(sanitizer_runtime)]
#![feature(staged_api)]
#![no_std]
authors = ["The Rust Project Developers"]
name = "rustc_typeck"
version = "0.0.0"
+edition = "2018"
[lib]
name = "rustc_typeck"
log = "0.4"
rustc = { path = "../librustc" }
rustc_data_structures = { path = "../librustc_data_structures" }
-rustc_errors = { path = "../librustc_errors" }
+errors = { path = "../librustc_errors", package = "rustc_errors" }
rustc_target = { path = "../librustc_target" }
smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
syntax = { path = "../libsyntax" }
//! instance of `AstConv`.
use errors::{Applicability, DiagnosticId};
-use hir::{self, GenericArg, GenericArgs};
-use hir::def::Def;
-use hir::def_id::DefId;
-use hir::HirVec;
-use lint;
-use middle::resolve_lifetime as rl;
-use namespace::Namespace;
+use crate::hir::{self, GenericArg, GenericArgs};
+use crate::hir::def::Def;
+use crate::hir::def_id::DefId;
+use crate::hir::HirVec;
+use crate::lint;
+use crate::middle::resolve_lifetime as rl;
+use crate::namespace::Namespace;
use rustc::lint::builtin::AMBIGUOUS_ASSOCIATED_ITEMS;
use rustc::traits;
use rustc::ty::{self, Ty, TyCtxt, ToPredicate, TypeFoldable};
use rustc::ty::wf::object_region_bounds;
use rustc_data_structures::sync::Lrc;
use rustc_target::spec::abi;
-use require_c_abi_if_variadic;
+use crate::require_c_abi_if_variadic;
use smallvec::SmallVec;
use syntax::ast;
use syntax::feature_gate::{GateIssue, emit_feature_err};
use syntax::ptr::P;
use syntax::util::lev_distance::find_best_match_for_name;
use syntax_pos::{DUMMY_SP, Span, MultiSpan};
-use util::common::ErrorReported;
-use util::nodemap::FxHashMap;
+use crate::util::common::ErrorReported;
+use crate::util::nodemap::FxHashMap;
use std::collections::BTreeSet;
use std::iter;
{
let tcx = self.tcx();
let lifetime_name = |def_id| {
- tcx.hir().name(tcx.hir().as_local_node_id(def_id).unwrap()).as_interned_str()
+ tcx.hir().name_by_hir_id(tcx.hir().as_local_hir_id(def_id).unwrap()).as_interned_str()
};
let r = match tcx.named_region(lifetime.hir_id) {
impl_trait
}
- /// Check that the correct number of generic arguments have been provided.
+ /// Checks that the correct number of generic arguments have been provided.
/// Used specifically for function calls.
pub fn check_generic_arg_count_for_call(
tcx: TyCtxt,
).0
}
- /// Check that the correct number of generic arguments have been provided.
+ /// Checks that the correct number of generic arguments have been provided.
/// This is used both for datatypes and function calls.
fn check_generic_arg_count(
tcx: TyCtxt,
/// Creates the relevant generic argument substitutions
/// corresponding to a set of generic parameters. This is a
- /// rather complex little function. Let me try to explain the
- /// role of each of its parameters:
+ /// rather complex function. Let us try to explain the role
+ /// of each of its parameters:
///
/// To start, we are given the `def_id` of the thing we are
/// creating the substitutions for, and a partial set of
/// we can append those and move on. Otherwise, it invokes the
/// three callback functions:
///
- /// - `args_for_def_id`: given the def-id `P`, supplies back the
+ /// - `args_for_def_id`: given the `DefId` `P`, supplies back the
/// generic arguments that were given to that parent from within
- /// the path; so e.g., if you have `<T as Foo>::Bar`, the def-id
+ /// the path; so e.g., if you have `<T as Foo>::Bar`, the `DefId`
/// might refer to the trait `Foo`, and the arguments might be
/// `[T]`. The boolean value indicates whether to infer values
/// for arguments whose values were not explicitly provided.
/// bound to a valid trait type. Returns the def_id for the defining trait.
/// The type _cannot_ be a type other than a trait type.
///
- /// If the `projections` argument is `None`, then assoc type bindings like `Foo<T=X>`
+ /// If the `projections` argument is `None`, then assoc type bindings like `Foo<T = X>`
/// are disallowed. Otherwise, they are pushed onto the vector given.
pub fn instantiate_mono_trait_ref(&self,
trait_ref: &hir::TraitRef,
binding.item_name, binding.span)
}?;
+ let hir_ref_id = self.tcx().hir().node_to_hir_id(ref_id);
let (assoc_ident, def_scope) =
- tcx.adjust_ident(binding.item_name, candidate.def_id(), ref_id);
+ tcx.adjust_ident(binding.item_name, candidate.def_id(), hir_ref_id);
let assoc_ty = tcx.associated_items(candidate.def_id()).find(|i| {
i.kind == ty::AssociatedKind::Type && i.ident.modern() == assoc_ident
}).expect("missing associated type");
};
let trait_did = bound.def_id();
- let (assoc_ident, def_scope) = tcx.adjust_ident(assoc_ident, trait_did, ref_id);
+ let hir_ref_id = self.tcx().hir().node_to_hir_id(ref_id);
+ let (assoc_ident, def_scope) = tcx.adjust_ident(assoc_ident, trait_did, hir_ref_id);
let item = tcx.associated_items(trait_did).find(|i| {
Namespace::from(i.kind) == Namespace::Type &&
i.ident.modern() == assoc_ident
assert_eq!(opt_self_ty, None);
self.prohibit_generics(&path.segments);
- let node_id = tcx.hir().as_local_node_id(did).unwrap();
- let item_id = tcx.hir().get_parent_node(node_id);
- let item_def_id = tcx.hir().local_def_id(item_id);
+ let hir_id = tcx.hir().as_local_hir_id(did).unwrap();
+ let item_id = tcx.hir().get_parent_node_by_hir_id(hir_id);
+ let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
let generics = tcx.generics_of(item_def_id);
- let index = generics.param_def_id_to_index[&tcx.hir().local_def_id(node_id)];
- tcx.mk_ty_param(index, tcx.hir().name(node_id).as_interned_str())
+ let index = generics.param_def_id_to_index[
+ &tcx.hir().local_def_id_from_hir_id(hir_id)];
+ tcx.mk_ty_param(index, tcx.hir().name_by_hir_id(hir_id).as_interned_str())
}
Def::SelfTy(_, Some(def_id)) => {
// `Self` in impl (we know the concrete type).
let length_def_id = tcx.hir().local_def_id(length.id);
let substs = Substs::identity_for_item(tcx, length_def_id);
let length = ty::LazyConst::Unevaluated(length_def_id, substs);
- let length = tcx.intern_lazy_const(length);
+ let length = tcx.mk_lazy_const(length);
let array_ty = tcx.mk_ty(ty::Array(self.ast_ty_to_ty(&ty), length));
self.normalize_ty(ast_ty.span, array_ty)
}
-use check::{FnCtxt, Expectation, Diverges, Needs};
-use check::coercion::CoerceMany;
+use crate::check::{FnCtxt, Expectation, Diverges, Needs};
+use crate::check::coercion::CoerceMany;
+use crate::util::nodemap::FxHashMap;
use errors::Applicability;
use rustc::hir::{self, PatKind};
use rustc::hir::def::{Def, CtorKind};
use syntax::ptr::P;
use syntax::util::lev_distance::find_best_match_for_name;
use syntax_pos::Span;
-use util::nodemap::FxHashMap;
use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::cmp;
CoerceMany::with_coercion_sites(coerce_first, arms)
};
+ let mut other_arms = vec![]; // used only for diagnostics
+ let mut prior_arm_ty = None;
for (i, (arm, pats_diverge)) in arms.iter().zip(all_arm_pats_diverge).enumerate() {
if let Some(ref g) = arm.guard {
self.diverges.set(pats_diverge);
_ => false
};
+ let arm_span = if let hir::ExprKind::Block(ref blk, _) = arm.body.node {
+ // Point at the block expr instead of the entire block
+ blk.expr.as_ref().map(|e| e.span).unwrap_or(arm.body.span)
+ } else {
+ arm.body.span
+ };
if is_if_let_fallback {
let cause = self.cause(expr.span, ObligationCauseCode::IfExpressionWithNoElse);
assert!(arm_ty.is_unit());
coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
} else {
- let cause = self.cause(expr.span, ObligationCauseCode::MatchExpressionArm {
- arm_span: arm.body.span,
- source: match_src
- });
+ let cause = if i == 0 {
+ // The reason for the first arm to fail is not that the match arms diverge,
+ // but rather that there's a prior obligation that doesn't hold.
+ self.cause(arm_span, ObligationCauseCode::BlockTailExpression(arm.body.id))
+ } else {
+ self.cause(expr.span, ObligationCauseCode::MatchExpressionArm {
+ arm_span,
+ source: match_src,
+ prior_arms: other_arms.clone(),
+ last_ty: prior_arm_ty.unwrap(),
+ })
+ };
coercion.coerce(self, &cause, &arm.body, arm_ty);
}
+ other_arms.push(arm_span);
+ if other_arms.len() > 5 {
+ other_arms.remove(0);
+ }
+ prior_arm_ty = Some(arm_ty);
}
// We won't diverge unless the discriminant or all arms diverge.
use super::{FnCtxt, PlaceOp, Needs};
use super::method::MethodCallee;
+use rustc::hir;
use rustc::infer::{InferCtxt, InferOk};
use rustc::session::DiagnosticMessageId;
use rustc::traits::{self, TraitEngine};
use rustc::ty::adjustment::{Adjustment, Adjust, OverloadedDeref};
use syntax_pos::Span;
-use syntax::ast::{self, Ident};
+use syntax::ast::Ident;
use std::iter;
pub struct Autoderef<'a, 'gcx: 'tcx, 'tcx: 'a> {
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
param_env: ty::ParamEnv<'tcx>,
steps: Vec<(Ty<'tcx>, AutoderefKind)>,
cur_ty: Ty<'tcx>,
impl<'a, 'gcx, 'tcx> Autoderef<'a, 'gcx, 'tcx> {
pub fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
span: Span,
base_ty: Ty<'tcx>)
-> Autoderef<'a, 'gcx, 'tcx>
use rustc::hir;
-/// Check that it is legal to call methods of the trait corresponding
+/// Checks that it is legal to call methods of the trait corresponding
/// to `trait_id` (this only cares about the trait, not the specific
-/// method that is called)
+/// method that is called).
pub fn check_legal_trait_for_method_call(tcx: TyCtxt, span: Span, trait_id: DefId) {
if tcx.lang_items().drop_trait() == Some(trait_id) {
struct_span_err!(tcx.sess, span, E0040, "explicit use of destructor method")
enum CallStep<'tcx> {
Builtin(Ty<'tcx>),
DeferredClosure(ty::FnSig<'tcx>),
- /// e.g., enum variant constructors
+ /// E.g., enum variant constructors.
Overloaded(MethodCallee<'tcx>),
}
use super::FnCtxt;
use errors::{DiagnosticBuilder,Applicability};
-use hir::def_id::DefId;
-use lint;
+use crate::hir::def_id::DefId;
+use crate::lint;
use rustc::hir;
use rustc::session::Session;
use rustc::traits;
use rustc::middle::lang_items;
use syntax::ast;
use syntax_pos::Span;
-use util::common::ErrorReported;
+use crate::util::common::ErrorReported;
/// Reifies a cast check to be checked once we have full type information for
/// a function context.
CastToBool,
CastToChar,
DifferingKinds,
- /// Cast of thin to fat raw ptr (eg. `*const () as *const [u8]`)
+ /// Cast of thin to fat raw ptr (e.g., `*const () as *const [u8]`).
SizedUnsizedCast,
IllegalCast,
NeedDeref,
.emit();
}
CastError::SizedUnsizedCast => {
- use structured_errors::{SizedUnsizedCastError, StructuredDiagnostic};
+ use crate::structured_errors::{SizedUnsizedCastError, StructuredDiagnostic};
SizedUnsizedCastError::new(&fcx.tcx.sess,
self.span,
self.expr_ty,
}
}
- /// Check a cast, and report an error if one exists. In some cases, this
+ /// Checks a cast, and report an error if one exists. In some cases, this
/// can return Ok and create type errors in the fcx rather than returning
/// directly. coercion-cast is handled in check instead of here.
fn do_check(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Result<CastKind, CastError> {
use super::{check_fn, Expectation, FnCtxt, GeneratorTypes};
-use astconv::AstConv;
-use middle::region;
+use crate::astconv::AstConv;
+use crate::middle::region;
use rustc::hir::def_id::DefId;
use rustc::infer::{InferOk, InferResult};
use rustc::infer::LateBoundRegionConversionTime;
///
/// # Arguments
///
- /// - `expr_def_id`: the def-id of the closure expression
+ /// - `expr_def_id`: the `DefId` of the closure expression
/// - `decl`: the HIR declaration of the closure
/// - `body`: the body of the closure
/// - `expected_sig`: the expected signature (if any). Note that
self.closure_sigs(expr_def_id, body, error_sig)
}
- /// Enforce the user's types against the expectation. See
+ /// Enforce the user's types against the expectation. See
/// `sig_of_closure_with_expectation` for details on the overall
/// strategy.
fn check_supplied_sig_against_expectation(
.liberate_late_bound_regions(expr_def_id, &bound_sig);
let liberated_sig = self.inh.normalize_associated_types_in(
body.value.span,
- body.value.id,
+ body.value.hir_id,
self.param_env,
&liberated_sig,
);
//! # Type Coercion
//!
//! Under certain circumstances we will coerce from one type to another,
-//! for example by auto-borrowing. This occurs in situations where the
+//! for example by auto-borrowing. This occurs in situations where the
//! compiler has a firm 'expected type' that was supplied from the user,
//! and where the actual type is similar to that expected type in purpose
//! but not in representation (so actual subtyping is inappropriate).
//! ## Reborrowing
//!
//! Note that if we are expecting a reference, we will *reborrow*
-//! even if the argument provided was already a reference. This is
+//! even if the argument provided was already a reference. This is
//! useful for freezing mut/const things (that is, when the expected is &T
//! but you have &const T or &mut T) and also for avoiding the linearity
-//! of mut things (when the expected is &mut T and you have &mut T). See
+//! of mut things (when the expected is &mut T and you have &mut T). See
//! the various `src/test/run-pass/coerce-reborrow-*.rs` tests for
//! examples of where this is useful.
//!
//! ## Subtle note
//!
//! When deciding what type coercions to consider, we do not attempt to
-//! resolve any type variables we may encounter. This is because `b`
+//! resolve any type variables we may encounter. This is because `b`
//! represents the expected type "as the user wrote it", meaning that if
//! the user defined a generic function like
//!
//! fn foo<A>(a: A, b: A) { ... }
//!
//! and then we wrote `foo(&1, @2)`, we will not auto-borrow
-//! either argument. In older code we went to some lengths to
+//! either argument. In older code we went to some lengths to
//! resolve the `b` variable, which could mean that we'd
//! auto-borrow later arguments but not earlier ones, which
//! seems very confusing.
//! foo::<&int>(@1, @2)
//!
//! then we *will* auto-borrow, because we can't distinguish this from a
-//! function that declared `&int`. This is inconsistent but it's easiest
+//! function that declared `&int`. This is inconsistent but it's easiest
//! at the moment. The right thing to do, I think, is to consider the
//! *unsubstituted* type when deciding whether to auto-borrow, but the
//! *substituted* type when considering the bounds and so forth. But most
//! of our methods don't give access to the unsubstituted type, and
-//! rightly so because they'd be error-prone. So maybe the thing to do is
+//! rightly so because they'd be error-prone. So maybe the thing to do is
//! to actually determine the kind of coercions that should occur
-//! separately and pass them in. Or maybe it's ok as is. Anyway, it's
-//! sort of a minor point so I've opted to leave it for later---after all
+//! separately and pass them in. Or maybe it's ok as is. Anyway, it's
+//! sort of a minor point so I've opted to leave it for later -- after all,
//! we may want to adjust precisely when coercions occur.
-use check::{FnCtxt, Needs};
+use crate::check::{FnCtxt, Needs};
use errors::DiagnosticBuilder;
use rustc::hir;
use rustc::hir::def_id::DefId;
}
}
- /// Return the "expected type" with which this coercion was
- /// constructed. This represents the "downward propagated" type
+ /// Returns the "expected type" with which this coercion was
+ /// constructed. This represents the "downward propagated" type
/// that was given to us at the start of typing whatever construct
/// we are typing (e.g., the match expression).
///
///
/// # Parameters
///
-/// - impl_m: type of the method we are checking
-/// - impl_m_span: span to use for reporting errors
-/// - trait_m: the method in the trait
-/// - impl_trait_ref: the TraitRef corresponding to the trait implementation
+/// - `impl_m`: type of the method we are checking
+/// - `impl_m_span`: span to use for reporting errors
+/// - `trait_m`: the method in the trait
+/// - `impl_trait_ref`: the TraitRef corresponding to the trait implementation
pub fn compare_impl_method<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
impl_m: &ty::AssociatedItem,
// `ObligationCause` (and the `FnCtxt`). This is what
// `regionck_item` expects.
let impl_m_node_id = tcx.hir().as_local_node_id(impl_m.def_id).unwrap();
+ let impl_m_hir_id = tcx.hir().node_to_hir_id(impl_m_node_id);
let cause = ObligationCause {
span: impl_m_span,
- body_id: impl_m_node_id,
+ body_id: impl_m_hir_id,
code: ObligationCauseCode::CompareImplMethodObligation {
item_name: impl_m.ident.name,
impl_item_def_id: impl_m.def_id,
// Construct trait parameter environment and then shift it into the placeholder viewpoint.
// The key step here is to update the caller_bounds's predicates to be
// the new hybrid bounds we computed.
- let normalize_cause = traits::ObligationCause::misc(impl_m_span, impl_m_node_id);
+ let normalize_cause = traits::ObligationCause::misc(impl_m_span, impl_m_hir_id);
let param_env = ty::ParamEnv::new(
tcx.intern_predicates(&hybrid_preds.predicates),
Reveal::UserFacing,
);
let impl_sig =
inh.normalize_associated_types_in(impl_m_span,
- impl_m_node_id,
+ impl_m_hir_id,
param_env,
&impl_sig);
let impl_fty = tcx.mk_fn_ptr(ty::Binder::bind(impl_sig));
trait_sig.subst(tcx, trait_to_skol_substs);
let trait_sig =
inh.normalize_associated_types_in(impl_m_span,
- impl_m_node_id,
+ impl_m_hir_id,
param_env,
&trait_sig);
let trait_fty = tcx.mk_fn_ptr(ty::Binder::bind(trait_sig));
// Finally, resolve all regions. This catches wily misuses of
// lifetime parameters.
- let fcx = FnCtxt::new(&inh, param_env, impl_m_node_id);
- fcx.regionck_item(impl_m_node_id, impl_m_span, &[]);
+ let fcx = FnCtxt::new(&inh, param_env, impl_m_hir_id);
+ fcx.regionck_item(impl_m_hir_id, impl_m_span, &[]);
Ok(())
})
in impl_m_type_params.zip(trait_m_type_params)
{
if impl_synthetic != trait_synthetic {
- let impl_node_id = tcx.hir().as_local_node_id(impl_def_id).unwrap();
- let impl_span = tcx.hir().span(impl_node_id);
+ let impl_hir_id = tcx.hir().as_local_hir_id(impl_def_id).unwrap();
+ let impl_span = tcx.hir().span_by_hir_id(impl_hir_id);
let trait_span = tcx.def_span(trait_def_id);
let mut err = struct_span_err!(tcx.sess,
impl_span,
match param.kind {
GenericParamKind::Lifetime { .. } => None,
GenericParamKind::Type { .. } => {
- if param.id == impl_node_id {
+ if param.hir_id == impl_hir_id {
Some(¶m.bounds)
} else {
None
// Create a parameter environment that represents the implementation's
// method.
let impl_c_node_id = tcx.hir().as_local_node_id(impl_c.def_id).unwrap();
+ let impl_c_hir_id = tcx.hir().node_to_hir_id(impl_c_node_id);
// Compute placeholder form of impl and trait const tys.
let impl_ty = tcx.type_of(impl_c.def_id);
let trait_ty = tcx.type_of(trait_c.def_id).subst(tcx, trait_to_impl_substs);
- let mut cause = ObligationCause::misc(impl_c_span, impl_c_node_id);
+ let mut cause = ObligationCause::misc(impl_c_span, impl_c_hir_id);
// There is no "body" here, so just pass dummy id.
let impl_ty = inh.normalize_associated_types_in(impl_c_span,
- impl_c_node_id,
+ impl_c_hir_id,
param_env,
&impl_ty);
debug!("compare_const_impl: impl_ty={:?}", impl_ty);
let trait_ty = inh.normalize_associated_types_in(impl_c_span,
- impl_c_node_id,
+ impl_c_hir_id,
param_env,
&trait_ty);
return;
}
- let fcx = FnCtxt::new(&inh, param_env, impl_c_node_id);
- fcx.regionck_item(impl_c_node_id, impl_c_span, &[]);
+ let fcx = FnCtxt::new(&inh, param_env, impl_c_hir_id);
+ fcx.regionck_item(impl_c_hir_id, impl_c_span, &[]);
});
}
-use check::FnCtxt;
+use crate::check::FnCtxt;
use rustc::infer::InferOk;
use rustc::traits::{ObligationCause, ObligationCauseCode};
/// ```
/// opt.map(|arg| { takes_ref(arg) });
/// ```
- fn can_use_as_ref(&self, expr: &hir::Expr) -> Option<(Span, &'static str, String)> {
+ fn can_use_as_ref(
+ &self,
+ expr: &hir::Expr,
+ ) -> Option<(Span, &'static str, String)> {
if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.node {
if let hir::def::Def::Local(id) = path.def {
let parent = self.tcx.hir().get_parent_node(id);
node: hir::ExprKind::MethodCall(path, span, expr),
..
})), 1) = (self.tcx.hir().find(parent), decl.inputs.len()) {
- let self_ty = self.tables.borrow().node_id_to_type(expr[0].hir_id);
+ let self_ty = self.tables.borrow().node_type(expr[0].hir_id);
let self_ty = format!("{:?}", self_ty);
let name = path.ident.as_str();
let is_as_ref_able = (
self_ty.starts_with("std::option::Option") ||
self_ty.starts_with("std::result::Result")
) && (name == "map" || name == "and_then");
- if is_as_ref_able {
- return Some((span.shrink_to_lo(),
- "consider using `as_ref` instead",
- "as_ref().".into()));
+ match (is_as_ref_able, self.sess().source_map().span_to_snippet(*span)) {
+ (true, Ok(src)) => {
+ return Some((*span, "consider using `as_ref` instead",
+ format!("as_ref().{}", src)));
+ },
+ _ => ()
}
}
}
match expr.node {
// All built-in range literals but `..=` and `..` desugar to Structs
- ExprKind::Struct(QPath::Resolved(None, ref path), _, _) |
+ ExprKind::Struct(ref qpath, _, _) => {
+ if let QPath::Resolved(None, ref path) = **qpath {
+ return is_range_path(&path) && span_is_range_literal(&expr.span);
+ }
+ }
// `..` desugars to its struct path
ExprKind::Path(QPath::Resolved(None, ref path)) => {
return is_range_path(&path) && span_is_range_literal(&expr.span);
-use check::regionck::RegionCtxt;
+use crate::check::regionck::RegionCtxt;
-use hir::def_id::DefId;
+use crate::hir;
+use crate::hir::def_id::DefId;
use rustc::infer::outlives::env::OutlivesEnvironment;
use rustc::infer::{self, InferOk, SuppressRegionErrors};
use rustc::middle::region;
use rustc::traits::{ObligationCause, TraitEngine, TraitEngineExt};
use rustc::ty::subst::{Subst, Substs, UnpackedKind};
use rustc::ty::{self, Ty, TyCtxt};
-use util::common::ErrorReported;
+use crate::util::common::ErrorReported;
-use syntax::ast;
use syntax_pos::Span;
-/// check_drop_impl confirms that the Drop implementation identified by
+/// This function confirms that the `Drop` implementation identified by
/// `drop_impl_did` is not any more specialized than the type it is
/// attached to (Issue #8142).
///
/// 1. The self type must be nominal (this is already checked during
/// coherence),
///
-/// 2. The generic region/type parameters of the impl's self-type must
+/// 2. The generic region/type parameters of the impl's self type must
/// all be parameters of the Drop impl itself (i.e., no
/// specialization like `impl Drop for Foo<i32>`), and,
///
drop_impl_ty: Ty<'tcx>,
self_type_did: DefId,
) -> Result<(), ErrorReported> {
- let drop_impl_node_id = tcx.hir().as_local_node_id(drop_impl_did).unwrap();
+ let drop_impl_hir_id = tcx.hir().as_local_hir_id(drop_impl_did).unwrap();
// check that the impl type can be made to match the trait type.
let fresh_impl_substs = infcx.fresh_substs_for_item(drop_impl_span, drop_impl_did);
let fresh_impl_self_ty = drop_impl_ty.subst(tcx, fresh_impl_substs);
- let cause = &ObligationCause::misc(drop_impl_span, drop_impl_node_id);
+ let cause = &ObligationCause::misc(drop_impl_span, drop_impl_hir_id);
match infcx
.at(cause, impl_param_env)
.eq(named_type, fresh_impl_self_ty)
// absent. So we report an error that the Drop impl injected a
// predicate that is not present on the struct definition.
- let self_type_node_id = tcx.hir().as_local_node_id(self_type_did).unwrap();
+ let self_type_hir_id = tcx.hir().as_local_hir_id(self_type_did).unwrap();
let drop_impl_span = tcx.def_span(drop_impl_did);
// repeated `contains` calls.
if !assumptions_in_impl_context.contains(&predicate) {
- let item_span = tcx.hir().span(self_type_node_id);
+ let item_span = tcx.hir().span_by_hir_id(self_type_hir_id);
struct_span_err!(
tcx.sess,
drop_impl_span,
result
}
-/// check_safety_of_destructor_if_necessary confirms that the type
+/// This function confirms that the type
/// expression `typ` conforms to the "Drop Check Rule" from the Sound
-/// Generic Drop (RFC 769).
+/// Generic Drop RFC (#769).
///
/// ----
///
/// expected to break the needed parametricity property beyond
/// repair.)
///
-/// Therefore we have scaled back Drop-Check to a more conservative
+/// Therefore, we have scaled back Drop-Check to a more conservative
/// rule that does not attempt to deduce whether a `Drop`
/// implementation could not possible access data of a given lifetime;
/// instead Drop-Check now simply assumes that if a destructor has
/// this conservative assumption (and thus assume the obligation of
/// ensuring that they do not access data nor invoke methods of
/// values that have been previously dropped).
-///
pub fn check_safety_of_destructor_if_necessary<'a, 'gcx, 'tcx>(
rcx: &mut RegionCtxt<'a, 'gcx, 'tcx>,
ty: Ty<'tcx>,
span: Span,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
scope: region::Scope,
) -> Result<(), ErrorReported> {
debug!("check_safety_of_destructor_if_necessary typ: {:?} scope: {:?}",
use rustc_data_structures::sync::Lrc;
use syntax_pos::Span;
use super::FnCtxt;
-use util::nodemap::FxHashMap;
+use crate::util::nodemap::FxHashMap;
struct InteriorVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
use rustc::traits::{ObligationCause, ObligationCauseCode};
use rustc::ty::{self, TyCtxt, Ty};
use rustc::ty::subst::Subst;
-use require_same_types;
+use crate::require_same_types;
use rustc_target::spec::abi::Abi;
use syntax::symbol::Symbol;
safety,
abi
)));
- let cause = ObligationCause::new(it.span, it.id, ObligationCauseCode::IntrinsicType);
+ let cause = ObligationCause::new(it.span, it.hir_id, ObligationCauseCode::IntrinsicType);
require_same_types(tcx, &cause, tcx.mk_fn_ptr(tcx.fn_sig(def_id)), fty);
}
-/// Returns whether the given intrinsic is unsafe to call or not.
+/// Returns `true` if the given intrinsic is unsafe to call or not.
pub fn intrisic_operation_unsafety(intrinsic: &str) -> hir::Unsafety {
match intrinsic {
"size_of" | "min_align_of" | "needs_drop" |
use super::{probe, MethodCallee};
-use astconv::AstConv;
-use check::{FnCtxt, PlaceOp, callee, Needs};
-use hir::GenericArg;
-use hir::def_id::DefId;
+use crate::astconv::AstConv;
+use crate::check::{FnCtxt, PlaceOp, callee, Needs};
+use crate::hir::GenericArg;
+use crate::hir::def_id::DefId;
use rustc::ty::subst::Substs;
use rustc::traits;
use rustc::ty::{self, Ty, GenericParamDefKind};
pub use self::CandidateSource::*;
pub use self::suggest::{SelfSource, TraitInfo};
-use check::FnCtxt;
+use crate::check::FnCtxt;
+use crate::namespace::Namespace;
use errors::{Applicability, DiagnosticBuilder};
-use namespace::Namespace;
use rustc_data_structures::sync::Lrc;
use rustc::hir;
use rustc::hir::def::Def;
use crate::{check_type_alias_enum_variants_enabled};
use self::probe::{IsSuggestion, ProbeScope};
-pub fn provide(providers: &mut ty::query::Providers) {
+pub fn provide(providers: &mut ty::query::Providers<'_>) {
suggest::provide(providers);
probe::provide(providers);
}
}
}
- /// Add a suggestion to call the given method to the provided diagnostic.
+ /// Adds a suggestion to call the given method to the provided diagnostic.
crate fn suggest_method_call(
&self,
err: &mut DiagnosticBuilder<'a>,
/// `lookup_method_in_trait` is used for overloaded operators.
/// It does a very narrow slice of what the normal probe/confirm path does.
/// In particular, it doesn't really do any probing: it simply constructs
- /// an obligation for a particular trait with the given self-type and checks
+ /// an obligation for a particular trait with the given self type and checks
/// whether that trait is implemented.
- ///
- /// FIXME(#18741): it seems likely that we can consolidate some of this
- /// code with the other method-lookup code. In particular, the second half
- /// of this method is basically the same as confirmation.
+ //
+ // FIXME(#18741): it seems likely that we can consolidate some of this
+ // code with the other method-lookup code. In particular, the second half
+ // of this method is basically the same as confirmation.
pub fn lookup_method_in_trait(&self,
span: Span,
m_name: ast::Ident,
Ok(def)
}
- /// Find item with name `item_name` defined in impl/trait `def_id`
+ /// Finds item with name `item_name` defined in impl/trait `def_id`
/// and return it, or `None`, if no such item was defined there.
pub fn associated_item(&self, def_id: DefId, item_name: ast::Ident, ns: Namespace)
-> Option<ty::AssociatedItem> {
use super::{CandidateSource, ImplSource, TraitSource};
use super::suggest;
-use check::autoderef::{self, Autoderef};
-use check::FnCtxt;
-use hir::def_id::DefId;
-use hir::def::Def;
-use namespace::Namespace;
+use crate::check::autoderef::{self, Autoderef};
+use crate::check::FnCtxt;
+use crate::hir::def_id::DefId;
+use crate::hir::def::Def;
+use crate::namespace::Namespace;
use rustc_data_structures::sync::Lrc;
use rustc::hir;
#[derive(Debug)]
struct Candidate<'tcx> {
+ // Candidates are (I'm not quite sure, but they are mostly) basically
+ // some metadata on top of a `ty::AssociatedItem` (without substs).
+ //
+ // However, method probing wants to be able to evaluate the predicates
+ // for a function with the substs applied - for example, if a function
+ // has `where Self: Sized`, we don't want to consider it unless `Self`
+ // is actually `Sized`, and similarly, return-type suggestions want
+ // to consider the "actual" return type.
+ //
+ // The way this is handled is through `xform_self_ty`. It contains
+ // the receiver type of this candidate, but `xform_self_ty`,
+ // `xform_ret_ty` and `kind` (which contains the predicates) have the
+ // generic parameters of this candidate substituted with the *same set*
+ // of inference variables, which acts as some weird sort of "query".
+ //
+ // When we check out a candidate, we require `xform_self_ty` to be
+ // a subtype of the passed-in self-type, and this equates the type
+ // variables in the rest of the fields.
+ //
+ // For example, if we have this candidate:
+ // ```
+ // trait Foo {
+ // fn foo(&self) where Self: Sized;
+ // }
+ // ```
+ //
+ // Then `xform_self_ty` will be `&'erased ?X` and `kind` will contain
+ // the predicate `?X: Sized`, so if we are evaluating `Foo` for a
+ // the receiver `&T`, we'll do the subtyping which will make `?X`
+ // get the right value, then when we evaluate the predicate we'll check
+ // if `T: Sized`.
xform_self_ty: Ty<'tcx>,
xform_ret_ty: Option<Ty<'tcx>>,
item: ty::AssociatedItem,
tcx.infer_ctxt().enter_with_canonical(DUMMY_SP, &goal, |ref infcx, goal, inference_vars| {
let ParamEnvAnd { param_env, value: self_ty } = goal;
- let mut autoderef = Autoderef::new(infcx, param_env, ast::DUMMY_NODE_ID, DUMMY_SP, self_ty)
+ let mut autoderef = Autoderef::new(infcx, param_env, hir::DUMMY_HIR_ID, DUMMY_SP, self_ty)
.include_raw_pointers()
.silence_errors();
let mut reached_raw_pointer = false;
match self_ty.value.value.sty {
ty::Dynamic(ref data, ..) => {
if let Some(p) = data.principal() {
- let InferOk { value: instantiated_self_ty, obligations: _ } =
- self.fcx.probe_instantiate_query_response(
- self.span, &self.orig_steps_var_values, self_ty)
- .unwrap_or_else(|_| {
- span_bug!(self.span, "{:?} was applicable but now isn't?", self_ty)
- });
- self.assemble_inherent_candidates_from_object(instantiated_self_ty);
+ // Subtle: we can't use `instantiate_query_response` here: using it will
+ // commit to all of the type equalities assumed by inference going through
+ // autoderef (see the `method-probe-no-guessing` test).
+ //
+ // However, in this code, it is OK if we end up with an object type that is
+ // "more general" than the object type that we are evaluating. For *every*
+ // object type `MY_OBJECT`, a function call that goes through a trait-ref
+ // of the form `<MY_OBJECT as SuperTraitOf(MY_OBJECT)>::func` is a valid
+ // `ObjectCandidate`, and it should be discoverable "exactly" through one
+ // of the iterations in the autoderef loop, so there is no problem with it
+ // being discoverable in another one of these iterations.
+ //
+ // Using `instantiate_canonical_with_fresh_inference_vars` on our
+ // `Canonical<QueryResponse<Ty<'tcx>>>` and then *throwing away* the
+ // `CanonicalVarValues` will exactly give us such a generalization - it
+ // will still match the original object type, but it won't pollute our
+ // type variables in any form, so just do that!
+ let (QueryResponse { value: generalized_self_ty, .. }, _ignored_var_values) =
+ self.fcx.instantiate_canonical_with_fresh_inference_vars(
+ self.span, &self_ty);
+
+ self.assemble_inherent_candidates_from_object(generalized_self_ty);
self.assemble_inherent_impl_candidates_for_type(p.def_id());
}
}
stable_pick: &Pick,
unstable_candidates: &[(&Candidate<'tcx>, Symbol)],
) {
- let mut diag = self.tcx.struct_span_lint_node(
+ let mut diag = self.tcx.struct_span_lint_hir(
lint::builtin::UNSTABLE_NAME_COLLISIONS,
self.fcx.body_id,
self.span,
}
}
- /// Get the type of an impl and generate substitutions with placeholders.
+ /// Gets the type of an impl and generate substitutions with placeholders.
fn impl_ty_and_substs(&self, impl_def_id: DefId) -> (Ty<'tcx>, &'tcx Substs<'tcx>) {
(self.tcx.type_of(impl_def_id), self.fresh_item_substs(impl_def_id))
}
})
}
- /// Replace late-bound-regions bound by `value` with `'static` using
+ /// Replaces late-bound-regions bound by `value` with `'static` using
/// `ty::erase_late_bound_regions`.
///
/// This is only a reasonable thing to do during the *probe* phase, not the *confirm* phase, of
self.tcx.erase_late_bound_regions(value)
}
- /// Find the method with the appropriate name (or return type, as the case may be). If
+ /// Finds the method with the appropriate name (or return type, as the case may be). If
/// `allow_similar_names` is set, find methods with close-matching names.
fn impl_or_trait_item(&self, def_id: DefId) -> Vec<ty::AssociatedItem> {
if let Some(name) = self.method_name {
//! Give useful errors and suggestions to users when an item can't be
//! found or is otherwise invalid.
-use check::FnCtxt;
+use crate::check::FnCtxt;
+use crate::middle::lang_items::FnOnceTraitLangItem;
+use crate::namespace::Namespace;
+use crate::util::nodemap::FxHashSet;
use errors::{Applicability, DiagnosticBuilder};
-use middle::lang_items::FnOnceTraitLangItem;
-use namespace::Namespace;
use rustc_data_structures::sync::Lrc;
use rustc::hir::{self, ExprKind, Node, QPath};
use rustc::hir::def::Def;
use rustc::traits::Obligation;
use rustc::ty::{self, Adt, Ty, TyCtxt, ToPolyTraitRef, ToPredicate, TypeFoldable};
use rustc::ty::item_path::with_crate_prefix;
-use util::nodemap::FxHashSet;
use syntax_pos::{Span, FileName};
use syntax::ast;
use syntax::util::lev_distance::find_best_match_for_name;
};
let field_ty = field.ty(tcx, substs);
- let scope = self.tcx.hir().get_module_parent(self.body_id);
+ let scope = self.tcx.hir().get_module_parent_by_hir_id(
+ self.body_id);
if field.vis.is_accessible_from(scope, self.tcx) {
if self.is_fn_ty(&field_ty, span) {
err.help(&format!("use `({0}.{1})(...)` if you \
err: &mut DiagnosticBuilder,
mut msg: String,
candidates: Vec<DefId>) {
- let module_did = self.tcx.hir().get_module_parent(self.body_id);
+ let module_did = self.tcx.hir().get_module_parent_by_hir_id(self.body_id);
let module_id = self.tcx.hir().as_local_node_id(module_did).unwrap();
let krate = self.tcx.hir().krate();
let (span, found_use) = UsePlacementFinder::check(self.tcx, krate, module_id);
}
}
-/// Retrieve all traits in this crate and any dependent crates.
+/// Retrieves all traits in this crate and any dependent crates.
pub fn all_traits<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Vec<TraitInfo> {
tcx.all_traits(LOCAL_CRATE).iter().map(|&def_id| TraitInfo { def_id }).collect()
}
-/// Compute all traits in this crate and any dependent crates.
+/// Computes all traits in this crate and any dependent crates.
fn compute_all_traits<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Vec<DefId> {
use hir::itemlikevisit;
traits: &mut Vec<DefId>,
external_mods: &mut FxHashSet<DefId>,
def: Def) {
- let def_id = def.def_id();
match def {
- Def::Trait(..) => {
+ Def::Trait(def_id) => {
traits.push(def_id);
}
- Def::Mod(..) => {
+ Def::Mod(def_id) => {
if !external_mods.insert(def_id) {
return;
}
/*!
-# check.rs
+# typeck: check phase
Within the check phase of type check, we check each item one at a time
(bodies of function expressions are checked as part of the containing
pub mod intrinsic;
mod op;
-use astconv::{AstConv, PathSeg};
+use crate::astconv::{AstConv, PathSeg};
use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
use rustc::hir::def::{CtorKind, Def};
use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
use rustc::hir::itemlikevisit::ItemLikeVisitor;
-use middle::lang_items;
-use namespace::Namespace;
+use crate::middle::lang_items;
+use crate::namespace::Namespace;
use rustc::infer::{self, InferCtxt, InferOk, InferResult, RegionVariableOrigin};
use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
use rustc_data_structures::indexed_vec::Idx;
use std::ops::{self, Deref};
use std::slice;
-use require_c_abi_if_variadic;
-use session::{CompileIncomplete, Session};
-use session::config::EntryFnType;
-use TypeAndSubsts;
-use lint;
-use util::captures::Captures;
-use util::common::{ErrorReported, indenter};
-use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
+use crate::require_c_abi_if_variadic;
+use crate::session::{CompileIncomplete, Session};
+use crate::session::config::EntryFnType;
+use crate::TypeAndSubsts;
+use crate::lint;
+use crate::util::captures::Captures;
+use crate::util::common::{ErrorReported, indenter};
+use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
pub use self::Expectation::*;
use self::autoderef::Autoderef;
revealed_ty: Ty<'tcx>
}
-/// A wrapper for InferCtxt's `in_progress_tables` field.
+/// A wrapper for `InferCtxt`'s `in_progress_tables` field.
#[derive(Copy, Clone)]
struct MaybeInProgressTables<'a, 'tcx: 'a> {
maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
}
}
-/// closures defined within the function. For example:
+/// Closures defined within the function. For example:
///
/// fn foo() {
/// bar(move|| { ... })
/// This expression is an `if` condition, it must resolve to `bool`.
ExpectIfCondition,
- /// This expression should have the type given (or some subtype)
+ /// This expression should have the type given (or some subtype).
ExpectHasType(Ty<'tcx>),
- /// This expression will be cast to the `Ty`
+ /// This expression will be cast to the `Ty`.
ExpectCastableToType(Ty<'tcx>),
/// This rvalue expression will be wrapped in `&` or `Box` and coerced
}
}
- /// Provide an expectation for an rvalue expression given an *optional*
+ /// Provides an expectation for an rvalue expression given an *optional*
/// hint, which is not required for type safety (the resulting type might
/// be checked higher up, as is the case with `&expr` and `box expr`), but
/// is useful in determining the concrete type.
Always,
/// Same as `Always` but with a reachability
- /// warning already emitted
+ /// warning already emitted.
WarnedAlways
}
}
pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
- body_id: ast::NodeId,
+ body_id: hir::HirId,
/// The parameter environment used for proving trait obligations
/// in this function. This can change when we descend into
ps: RefCell<UnsafetyState>,
/// Whether the last checked node generates a divergence (e.g.,
- /// `return` will set this to Always). In general, when entering
+ /// `return` will set this to `Always`). In general, when entering
/// an expression or other node in the tree, the initial value
/// indicates whether prior parts of the containing expression may
/// have diverged. It is then typically set to `Maybe` (and the
/// old value remembered) for processing the subparts of the
/// current expression. As each subpart is processed, they may set
- /// the flag to `Always` etc. Finally, at the end, we take the
+ /// the flag to `Always`, etc. Finally, at the end, we take the
/// result and "union" it with the original value, so that when we
/// return the flag indicates if any subpart of the parent
- /// expression (up to and including this part) has diverged. So,
+ /// expression (up to and including this part) has diverged. So,
/// if you read it after evaluating a subexpression `X`, the value
/// you get indicates whether any subexpression that was
/// evaluating up to and including `X` diverged.
/// foo();}` or `{return; 22}`, where we would warn on the
/// `foo()` or `22`.
///
- /// An expression represents dead-code if, after checking it,
+ /// An expression represents dead code if, after checking it,
/// the diverges flag is set to something other than `Maybe`.
diverges: Cell<Diverges>,
}
}
-/// Helper type of a temporary returned by Inherited::build(...).
+/// Helper type of a temporary returned by `Inherited::build(...)`.
/// Necessary because we can't write the following bound:
-/// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>).
+/// `F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>)`.
pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
def_id: DefId,
fn normalize_associated_types_in<T>(&self,
span: Span,
- body_id: ast::NodeId,
+ body_id: hir::HirId,
param_env: ty::ParamEnv<'tcx>,
value: &T) -> T
where T : TypeFoldable<'tcx>
tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
}
-/// If this def-id is a "primary tables entry", returns `Some((body_id, decl))`
+/// If this `DefId` is a "primary tables entry", returns `Some((body_id, decl))`
/// with information about it's body-id and fn-decl (if any). Otherwise,
/// returns `None`.
///
/// If this function returns "some", then `typeck_tables(def_id)` will
/// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
-/// may not succeed. In some cases where this function returns `None`
+/// may not succeed. In some cases where this function returns `None`
/// (notably closures), `typeck_tables(def_id)` would wind up
/// redirecting to the owning function.
fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
tcx.liberate_late_bound_regions(def_id, &fn_sig);
let fn_sig =
inh.normalize_associated_types_in(body.value.span,
- body_id.node_id,
+ body_id.hir_id,
param_env,
&fn_sig);
let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
fcx
} else {
- let fcx = FnCtxt::new(&inh, param_env, body.value.id);
+ let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
let expected_type = tcx.type_of(def_id);
let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
/// Types that are captured (see `GeneratorInterior` for more).
interior: ty::Ty<'tcx>,
- /// Indicates if the generator is movable or static (immovable)
+ /// Indicates if the generator is movable or static (immovable).
movability: hir::GeneratorMovability,
}
// Create the function context. This is either derived from scratch or,
// in the case of closures, based on the outer context.
- let mut fcx = FnCtxt::new(inherited, param_env, body.value.id);
+ let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
*fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
let declared_ret_ty = fn_sig.output();
let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
let trait_ref = ty::TraitRef::new(term_id, substs);
let return_ty_span = decl.output.span();
+ let fn_hir_id = fcx.tcx.hir().node_to_hir_id(fn_id);
let cause = traits::ObligationCause::new(
- return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
+ return_ty_span, fn_hir_id, ObligationCauseCode::MainFunctionType);
inherited.register_predicate(
traits::Obligation::new(
// Check for duplicate discriminant values
if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
let variant_did = def.variants[VariantIdx::new(i)].did;
- let variant_i_node_id = tcx.hir().as_local_node_id(variant_did).unwrap();
- let variant_i = tcx.hir().expect_variant(variant_i_node_id);
+ let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
+ let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
let i_span = match variant_i.node.disr_expr {
- Some(ref expr) => tcx.hir().span(expr.id),
- None => tcx.hir().span(variant_i_node_id)
+ Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
+ None => tcx.hir().span_by_hir_id(variant_i_hir_id)
};
let span = match v.node.disr_expr {
- Some(ref expr) => tcx.hir().span(expr.id),
+ Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
None => v.span
};
struct_span_err!(tcx.sess, span, E0081,
impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
- body_id: ast::NodeId)
+ body_id: hir::HirId)
-> FnCtxt<'a, 'gcx, 'tcx> {
FnCtxt {
body_id,
self.tcx.sess.err_count() - self.err_count_on_creation
}
- /// Produce warning on the given node, if the current point in the
+ /// Produces warning on the given node, if the current point in the
/// function is unreachable, and there hasn't been another warning.
fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
if self.diverges.get() == Diverges::Always {
result
}
- /// Replace the opaque types from the given value with type variables,
+ /// Replaces the opaque types from the given value with type variables,
/// and records the `OpaqueTypeMap` for later use during writeback. See
/// `InferCtxt::instantiate_opaque_types` for more details.
fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
// arguments which we skipped above.
if variadic {
fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
- use structured_errors::{VariadicError, StructuredDiagnostic};
+ use crate::structured_errors::{VariadicError, StructuredDiagnostic};
VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
}
display
}
- fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
- -> DiagnosticBuilder {
+ fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
+ -> DiagnosticBuilder<'_> {
type_error_struct!(self.tcx().sess, span, expr_t, E0609,
"no field `{}` on type `{}`",
field, expr_t)
if element_ty.references_error() {
tcx.types.err
} else if let Ok(count) = count {
- tcx.mk_ty(ty::Array(t, tcx.intern_lazy_const(ty::LazyConst::Evaluated(count))))
+ tcx.mk_ty(ty::Array(t, tcx.mk_lazy_const(ty::LazyConst::Evaluated(count))))
} else {
tcx.types.err
}
}
}
- // Resolve associated value path into a base type and associated constant or method definition.
- // The newly resolved definition is written into `type_dependent_defs`.
+ /// Resolves associated value path into a base type and associated constant or method
+ /// definition. The newly resolved definition is written into `type_dependent_defs`.
pub fn resolve_ty_and_def_ufcs<'b>(&self,
qpath: &'b QPath,
node_id: ast::NodeId,
None
}
- /// Given a function block's `NodeId`, return its `FnDecl` if it exists, or `None` otherwise.
+ /// Given a function block's `NodeId`, returns its `FnDecl` if it exists, or `None` otherwise.
fn get_parent_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, ast::Ident)> {
let parent = self.tcx.hir().get(self.tcx.hir().get_parent(blk_id));
self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
})
}
- /// On implicit return expressions with mismatched types, provide the following suggestions:
+ /// On implicit return expressions with mismatched types, provides the following suggestions:
///
- /// - Point out the method's return type as the reason for the expected type
- /// - Possible missing semicolon
- /// - Possible missing return type if the return type is the default, and not `fn main()`
+ /// - Points out the method's return type as the reason for the expected type.
+ /// - Possible missing semicolon.
+ /// - Possible missing return type if the return type is the default, and not `fn main()`.
pub fn suggest_mismatched_types_on_tail(
&self,
err: &mut DiagnosticBuilder<'tcx>,
}
}
- /// A common error is to forget to add a semicolon at the end of a block:
+ /// A common error is to forget to add a semicolon at the end of a block, e.g.,
///
/// ```
/// fn foo() {
&self,
blk: &'gcx hir::Block,
expected_ty: Ty<'tcx>,
- err: &mut DiagnosticBuilder,
+ err: &mut DiagnosticBuilder<'_>,
) {
if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
err.span_suggestion(
query_result)
}
- /// Returns whether an expression is contained inside the LHS of an assignment expression.
+ /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
fn expr_in_place(&self, mut expr_id: ast::NodeId) -> bool {
let mut contained_in_place = false;
});
for (&used, param) in types_used.iter().zip(types) {
if !used {
- let id = tcx.hir().as_local_node_id(param.def_id).unwrap();
- let span = tcx.hir().span(id);
+ let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
+ let span = tcx.hir().span_by_hir_id(id);
struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
.span_label(span, "unused type parameter")
.emit();
);
handler.note_without_error(&format!("rustc {} running on {}",
option_env!("CFG_VERSION").unwrap_or("unknown_version"),
- ::session::config::host_triple(),
+ crate::session::config::host_triple(),
));
}
use rustc::hir;
impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
- /// Check a `a <op>= b`
+ /// Checks a `a <op>= b`
pub fn check_binop_assign(&self,
expr: &'gcx hir::Expr,
op: hir::BinOp,
ty
}
- /// Check a potentially overloaded binary operator.
+ /// Checks a potentially overloaded binary operator.
pub fn check_binop(&self,
expr: &'gcx hir::Expr,
op: hir::BinOp,
Unary(hir::UnOp, Span),
}
-/// Returns true if this is a built-in arithmetic operation (e.g., u32
+/// Returns `true` if this is a built-in arithmetic operation (e.g., u32
/// + u32, i16x4 == i16x4) and false if these types would have to be
/// overloaded to be legal. There are two reasons that we distinguish
/// builtin operations from overloaded ones (vs trying to drive
///
/// 1. Builtin operations can trivially be evaluated in constants.
/// 2. For comparison operators applied to SIMD types the result is
-/// not of type `bool`. For example, `i16x4==i16x4` yields a
+/// not of type `bool`. For example, `i16x4 == i16x4` yields a
/// type like `i16x4`. This means that the overloaded trait
/// `PartialEq` is not applicable.
///
//! The region check is a final pass that runs over the AST after we have
//! inferred the type constraints but before we have actually finalized
-//! the types. Its purpose is to embed a variety of region constraints.
+//! the types. Its purpose is to embed a variety of region constraints.
//! Inserting these constraints as a separate pass is good because (1) it
//! localizes the code that has to do with region inference and (2) often
//! we cannot know what constraints are needed until the basic types have
//! #### Reborrows
//!
//! Generally speaking, `regionck` does NOT try to ensure that the data
-//! `data` will outlive the pointer `x`. That is the job of borrowck. The
+//! `data` will outlive the pointer `x`. That is the job of borrowck. The
//! one exception is when "re-borrowing" the contents of another borrowed
//! pointer. For example, imagine you have a borrowed pointer `b` with
-//! lifetime L1 and you have an expression `&*b`. The result of this
-//! expression will be another borrowed pointer with lifetime L2 (which is
+//! lifetime `L1` and you have an expression `&*b`. The result of this
+//! expression will be another borrowed pointer with lifetime `L2` (which is
//! an inference variable). The borrow checker is going to enforce the
-//! constraint that L2 < L1, because otherwise you are re-borrowing data
-//! for a lifetime larger than the original loan. However, without the
+//! constraint that `L2 < L1`, because otherwise you are re-borrowing data
+//! for a lifetime larger than the original loan. However, without the
//! routines in this module, the region inferencer would not know of this
-//! dependency and thus it might infer the lifetime of L2 to be greater
-//! than L1 (issue #3148).
+//! dependency and thus it might infer the lifetime of `L2` to be greater
+//! than `L1` (issue #3148).
//!
//! There are a number of troublesome scenarios in the tests
//! `region-dependent-*.rs`, but here is one example:
//!
//! The key point here is that when you are borrowing a value that
//! is "guaranteed" by a borrowed pointer, you must link the
-//! lifetime of that borrowed pointer (L1, here) to the lifetime of
-//! the borrow itself (L2). What do I mean by "guaranteed" by a
+//! lifetime of that borrowed pointer (`L1`, here) to the lifetime of
+//! the borrow itself (`L2`). What do I mean by "guaranteed" by a
//! borrowed pointer? I mean any data that is reached by first
//! dereferencing a borrowed pointer and then either traversing
-//! interior offsets or boxes. We say that the guarantor
+//! interior offsets or boxes. We say that the guarantor
//! of such data is the region of the borrowed pointer that was
-//! traversed. This is essentially the same as the ownership
+//! traversed. This is essentially the same as the ownership
//! relation, except that a borrowed pointer never owns its
//! contents.
-use check::dropck;
-use check::FnCtxt;
-use middle::mem_categorization as mc;
-use middle::mem_categorization::Categorization;
-use middle::region;
+use crate::check::dropck;
+use crate::check::FnCtxt;
+use crate::middle::mem_categorization as mc;
+use crate::middle::mem_categorization::Categorization;
+use crate::middle::region;
use rustc::hir::def_id::DefId;
use rustc::infer::outlives::env::OutlivesEnvironment;
use rustc::infer::{self, RegionObligation, SuppressRegionErrors};
impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
pub fn regionck_expr(&self, body: &'gcx hir::Body) {
let subject = self.tcx.hir().body_owner_def_id(body.id());
- let id = body.value.id;
+ let id = body.value.hir_id;
let mut rcx = RegionCtxt::new(
self,
RepeatingScope(id),
/// Region checking during the WF phase for items. `wf_tys` are the
/// types from which we should derive implied bounds, if any.
- pub fn regionck_item(&self, item_id: ast::NodeId, span: Span, wf_tys: &[Ty<'tcx>]) {
+ pub fn regionck_item(&self, item_id: hir::HirId, span: Span, wf_tys: &[Ty<'tcx>]) {
debug!("regionck_item(item.id={:?}, wf_tys={:?})", item_id, wf_tys);
- let subject = self.tcx.hir().local_def_id(item_id);
+ let subject = self.tcx.hir().local_def_id_from_hir_id(item_id);
let mut rcx = RegionCtxt::new(
self,
RepeatingScope(item_id),
pub fn regionck_fn(&self, fn_id: ast::NodeId, body: &'gcx hir::Body) {
debug!("regionck_fn(id={})", fn_id);
let subject = self.tcx.hir().body_owner_def_id(body.id());
- let node_id = body.value.id;
+ let hir_id = body.value.hir_id;
let mut rcx = RegionCtxt::new(
self,
- RepeatingScope(node_id),
- node_id,
+ RepeatingScope(hir_id),
+ hir_id,
Subject(subject),
self.param_env,
);
if self.err_count_since_creation() == 0 {
+ let fn_hir_id = self.tcx.hir().node_to_hir_id(fn_id);
// regionck assumes typeck succeeded
- rcx.visit_fn_body(fn_id, body, self.tcx.hir().span(fn_id));
+ rcx.visit_fn_body(fn_hir_id, body, self.tcx.hir().span_by_hir_id(fn_hir_id));
}
rcx.resolve_regions_and_report_errors(SuppressRegionErrors::when_nll_is_enabled(self.tcx));
outlives_environment: OutlivesEnvironment<'tcx>,
// id of innermost fn body id
- body_id: ast::NodeId,
+ body_id: hir::HirId,
// call_site scope of innermost fn
call_site_scope: Option<region::Scope>,
// id of innermost fn or loop
- repeating_scope: ast::NodeId,
+ repeating_scope: hir::HirId,
// id of AST node being analyzed (the subject of the analysis).
subject_def_id: DefId,
}
}
-pub struct RepeatingScope(ast::NodeId);
+pub struct RepeatingScope(hir::HirId);
pub struct Subject(DefId);
impl<'a, 'gcx, 'tcx> RegionCtxt<'a, 'gcx, 'tcx> {
pub fn new(
fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
RepeatingScope(initial_repeating_scope): RepeatingScope,
- initial_body_id: ast::NodeId,
+ initial_body_id: hir::HirId,
Subject(subject): Subject,
param_env: ty::ParamEnv<'tcx>,
) -> RegionCtxt<'a, 'gcx, 'tcx> {
}
}
- fn set_repeating_scope(&mut self, scope: ast::NodeId) -> ast::NodeId {
+ fn set_repeating_scope(&mut self, scope: hir::HirId) -> hir::HirId {
mem::replace(&mut self.repeating_scope, scope)
}
- /// Try to resolve the type for the given node, returning t_err if an error results. Note that
+ /// Try to resolve the type for the given node, returning `t_err` if an error results. Note that
/// we never care about the details of the error, the same error will be detected and reported
/// in the writeback phase.
///
- /// Note one important point: we do not attempt to resolve *region variables* here. This is
+ /// Note one important point: we do not attempt to resolve *region variables* here. This is
/// because regionck is essentially adding constraints to those region variables and so may yet
/// influence how they are resolved.
///
/// }
/// ```
///
- /// Here, the region of `b` will be `<R0>`. `<R0>` is constrained to be some subregion of the
- /// block B and some superregion of the call. If we forced it now, we'd choose the smaller
- /// region (the call). But that would make the *b illegal. Since we don't resolve, the type
+ /// Here, the region of `b` will be `<R0>`. `<R0>` is constrained to be some subregion of the
+ /// block B and some superregion of the call. If we forced it now, we'd choose the smaller
+ /// region (the call). But that would make the *b illegal. Since we don't resolve, the type
/// of b will be `&<R0>.i32` and then `*b` will require that `<R0>` be bigger than the let and
/// the `*b` expression, so we will effectively resolve `<R0>` to be the block B.
pub fn resolve_type(&self, unresolved_ty: Ty<'tcx>) -> Ty<'tcx> {
/// `intravisit::Visitor` impl below.)
fn visit_fn_body(
&mut self,
- id: ast::NodeId, // the id of the fn itself
+ id: hir::HirId, // the id of the fn itself
body: &'gcx hir::Body,
span: Span,
) {
// When we enter a function, we can derive
- debug!("visit_fn_body(id={})", id);
+ debug!("visit_fn_body(id={:?})", id);
let body_id = body.id();
- self.body_id = body_id.node_id;
+ self.body_id = body_id.hir_id;
let call_site = region::Scope {
id: body.value.hir_id.local_id,
self.call_site_scope = Some(call_site);
let fn_sig = {
- let fn_hir_id = self.tcx.hir().node_to_hir_id(id);
- match self.tables.borrow().liberated_fn_sigs().get(fn_hir_id) {
+ match self.tables.borrow().liberated_fn_sigs().get(id) {
Some(f) => f.clone(),
None => {
- bug!("No fn-sig entry for id={}", id);
+ bug!("No fn-sig entry for id={:?}", id);
}
}
};
self.outlives_environment.add_implied_bounds(
self.fcx,
&fn_sig_tys[..],
- body_id.node_id,
+ body_id.hir_id,
span,
);
self.outlives_environment
- .save_implied_bounds(body_id.node_id);
+ .save_implied_bounds(body_id.hir_id);
self.link_fn_args(
region::Scope {
id: body.value.hir_id.local_id,
&body.arguments,
);
self.visit_body(body);
- self.visit_region_obligations(body_id.node_id);
+ self.visit_region_obligations(body_id.hir_id);
let call_site_scope = self.call_site_scope.unwrap();
debug!(
);
let call_site_region = self.tcx.mk_region(ty::ReScope(call_site_scope));
- let body_hir_id = self.tcx.hir().node_to_hir_id(body_id.node_id);
- self.type_of_node_must_outlive(infer::CallReturn(span), body_hir_id, call_site_region);
+ self.type_of_node_must_outlive(infer::CallReturn(span), body_id.hir_id, call_site_region);
self.constrain_opaque_types(
&self.fcx.opaque_types.borrow(),
);
}
- fn visit_region_obligations(&mut self, node_id: ast::NodeId) {
- debug!("visit_region_obligations: node_id={}", node_id);
+ fn visit_region_obligations(&mut self, hir_id: hir::HirId) {
+ debug!("visit_region_obligations: hir_id={:?}", hir_id);
// region checking can introduce new pending obligations
// which, when processed, might generate new region
let env_snapshot = self.outlives_environment.push_snapshot_pre_closure();
let body = self.tcx.hir().body(body_id);
- self.visit_fn_body(id, body, span);
+ let hir_id = self.tcx.hir().node_to_hir_id(id);
+ self.visit_fn_body(hir_id, body, span);
// Restore state from previous function.
self.outlives_environment
fn visit_expr(&mut self, expr: &'gcx hir::Expr) {
debug!(
- "regionck::visit_expr(e={:?}, repeating_scope={})",
+ "regionck::visit_expr(e={:?}, repeating_scope={:?})",
expr, self.repeating_scope
);
}
debug!(
- "regionck::visit_expr(e={:?}, repeating_scope={}) - visiting subexprs",
+ "regionck::visit_expr(e={:?}, repeating_scope={:?}) - visiting subexprs",
expr, self.repeating_scope
);
match expr.node {
}
hir::ExprKind::Loop(ref body, _, _) => {
- let repeating_scope = self.set_repeating_scope(body.id);
+ let repeating_scope = self.set_repeating_scope(body.hir_id);
intravisit::walk_expr(self, expr);
self.set_repeating_scope(repeating_scope);
}
hir::ExprKind::While(ref cond, ref body, _) => {
- let repeating_scope = self.set_repeating_scope(cond.id);
+ let repeating_scope = self.set_repeating_scope(cond.hir_id);
self.visit_expr(&cond);
- self.set_repeating_scope(body.id);
+ self.set_repeating_scope(body.hir_id);
self.visit_block(&body);
self.set_repeating_scope(repeating_scope);
}
fn check_expr_fn_block(&mut self, expr: &'gcx hir::Expr, body_id: hir::BodyId) {
- let repeating_scope = self.set_repeating_scope(body_id.node_id);
+ let repeating_scope = self.set_repeating_scope(body_id.hir_id);
intravisit::walk_expr(self, expr);
self.set_repeating_scope(repeating_scope);
}
}
}
- /// Create a temporary `MemCategorizationContext` and pass it to the closure.
+ /// Creates a temporary `MemCategorizationContext` and pass it to the closure.
fn with_mc<F, R>(&self, f: F) -> R
where
F: for<'b> FnOnce(mc::MemCategorizationContext<'b, 'gcx, 'tcx>) -> R,
use super::FnCtxt;
-use middle::expr_use_visitor as euv;
-use middle::mem_categorization as mc;
-use middle::mem_categorization::Categorization;
+use crate::middle::expr_use_visitor as euv;
+use crate::middle::mem_categorization as mc;
+use crate::middle::mem_categorization::Categorization;
use rustc::hir;
use rustc::hir::def_id::DefId;
use rustc::hir::def_id::LocalDefId;
}
fn var_name(tcx: TyCtxt, var_hir_id: hir::HirId) -> ast::Name {
- let var_node_id = tcx.hir().hir_to_node_id(var_hir_id);
- tcx.hir().name(var_node_id)
+ tcx.hir().name_by_hir_id(var_hir_id)
}
-use check::{Inherited, FnCtxt};
-use constrained_type_params::{identify_constrained_type_params, Parameter};
+use crate::check::{Inherited, FnCtxt};
+use crate::constrained_type_params::{identify_constrained_type_params, Parameter};
-use hir::def_id::DefId;
+use crate::hir::def_id::DefId;
use rustc::traits::{self, ObligationCauseCode};
use rustc::ty::{self, Lift, Ty, TyCtxt, TyKind, GenericParamDefKind, TypeFoldable, ToPredicate};
use rustc::ty::subst::{Subst, Substs};
/// `F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(FnCtxt<'b, 'gcx, 'tcx>)`.
struct CheckWfFcxBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
inherited: super::InheritedBuilder<'a, 'gcx, 'tcx>,
- id: ast::NodeId,
+ id: hir::HirId,
span: Span,
param_env: ty::ParamEnv<'tcx>,
}
/// not included it frequently leads to confusing errors in fn bodies. So it's better to check
/// the types first.
pub fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
- let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
- let item = tcx.hir().expect_item(node_id);
+ let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
+ let item = tcx.hir().expect_item_by_hir_id(hir_id);
- debug!("check_item_well_formed(it.id={}, it.name={})",
- item.id,
+ debug!("check_item_well_formed(it.hir_id={:?}, it.name={})",
+ item.hir_id,
tcx.item_path_str(def_id));
match item.node {
// won't be allowed unless there's an *explicit* implementation of `Send`
// for `T`
hir::ItemKind::Impl(_, polarity, defaultness, _, ref trait_ref, ref self_ty, _) => {
- let is_auto = tcx.impl_trait_ref(tcx.hir().local_def_id(item.id))
+ let is_auto = tcx.impl_trait_ref(tcx.hir().local_def_id_from_hir_id(item.hir_id))
.map_or(false, |trait_ref| tcx.trait_is_auto(trait_ref.def_id));
if let (hir::Defaultness::Default { .. }, true) = (defaultness, is_auto) {
tcx.sess.span_err(item.span, "impls of auto traits cannot be default");
fn for_id<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, id: ast::NodeId, span: Span)
-> CheckWfFcxBuilder<'a, 'gcx, 'tcx> {
let def_id = tcx.hir().local_def_id(id);
+ let hir_id = tcx.hir().node_to_hir_id(id);
CheckWfFcxBuilder {
inherited: Inherited::build(tcx, def_id),
- id,
+ id: hir_id,
span,
param_env: tcx.param_env(def_id),
}
});
}
-/// Checks where clauses and inline bounds that are declared on def_id.
+/// Checks where-clauses and inline bounds that are declared on `def_id`.
fn check_where_clauses<'a, 'gcx, 'fcx, 'tcx>(
tcx: TyCtxt<'a, 'gcx, 'gcx>,
fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
/// through a `*const/mut T` raw pointer. If the feature is not enabled, the requirements are more
/// strict: `receiver_ty` must implement `Receiver` and directly implement `Deref<Target=self_ty>`.
///
-/// NB: there are cases this function returns `true` but causes an error to be emitted,
+/// N.B., there are cases this function returns `true` but causes an error to be emitted,
/// particularly when `receiver_ty` derefs to a type that is the same as `self_ty` but has the
/// wrong lifetime. Be careful of this if you are calling this function speculatively.
fn receiver_is_valid<'fcx, 'tcx, 'gcx>(
}
}
-/// Feature gates RFC 2056 - trivial bounds, checking for global bounds that
+/// Feature gates RFC 2056 -- trivial bounds, checking for global bounds that
/// aren't true.
fn check_false_global_bounds<'a, 'gcx, 'tcx>(
fcx: &FnCtxt<'a, 'gcx, 'tcx>,
span: Span,
- id: ast::NodeId)
+ id: hir::HirId)
{
use rustc::ty::TypeFoldable;
let empty_env = ty::ParamEnv::empty();
- let def_id = fcx.tcx.hir().local_def_id(id);
+ let def_id = fcx.tcx.hir().local_def_id_from_hir_id(id);
let predicates = fcx.tcx.predicates_of(def_id).predicates
.iter()
.map(|(p, _)| *p)
// unresolved type variables and replaces "ty_var" types with their
// substitutions.
-use check::FnCtxt;
+use crate::check::FnCtxt;
use errors::DiagnosticBuilder;
use rustc::hir;
use rustc::hir::def_id::{DefId, DefIndex};
body: &'gcx hir::Body,
rustc_dump_user_substs: bool,
) -> WritebackCx<'cx, 'gcx, 'tcx> {
- let owner = fcx.tcx.hir().definitions().node_to_hir_id(body.id().node_id);
+ let owner = body.id().hir_id;
WritebackCx {
fcx,
if let ty::UserType::TypeOf(_, user_substs) = c_ty.value {
if self.rustc_dump_user_substs {
// This is a unit-testing mechanism.
- let node_id = self.tcx().hir().hir_to_node_id(hir_id);
- let span = self.tcx().hir().span(node_id);
+ let span = self.tcx().hir().span_by_hir_id(hir_id);
// We need to buffer the errors in order to guarantee a consistent
// order when emitting them.
let err = self.tcx().sess.struct_span_err(
impl Locatable for DefIndex {
fn to_span(&self, tcx: &TyCtxt) -> Span {
- let node_id = tcx.hir().def_index_to_node_id(*self);
- tcx.hir().span(node_id)
+ let hir_id = tcx.hir().def_index_to_hir_id(*self);
+ tcx.hir().span_by_hir_id(hir_id)
}
}
impl Locatable for hir::HirId {
fn to_span(&self, tcx: &TyCtxt) -> Span {
- let node_id = tcx.hir().hir_to_node_id(*self);
- tcx.hir().span(node_id)
+ tcx.hir().span_by_hir_id(*self)
}
}
-use lint;
+use crate::lint;
use rustc::ty::TyCtxt;
use errors::Applicability;
}
struct ExternCrateToLint {
- /// def-id of the extern crate
+ /// `DefId` of the extern crate
def_id: DefId,
/// span from the item
fn visit_implementation_of_copy<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_did: DefId) {
debug!("visit_implementation_of_copy: impl_did={:?}", impl_did);
- let impl_node_id = if let Some(n) = tcx.hir().as_local_node_id(impl_did) {
+ let impl_hir_id = if let Some(n) = tcx.hir().as_local_hir_id(impl_did) {
n
} else {
debug!("visit_implementation_of_copy(): impl not in this crate");
debug!("visit_implementation_of_copy: self_type={:?} (bound)",
self_type);
- let span = tcx.hir().span(impl_node_id);
+ let span = tcx.hir().span_by_hir_id(impl_hir_id);
let param_env = tcx.param_env(impl_did);
assert!(!self_type.has_escaping_bound_vars());
match param_env.can_type_implement_copy(tcx, self_type) {
Ok(()) => {}
Err(CopyImplementationError::InfrigingFields(fields)) => {
- let item = tcx.hir().expect_item(impl_node_id);
+ let item = tcx.hir().expect_item_by_hir_id(impl_hir_id);
let span = if let ItemKind::Impl(.., Some(ref tr), _, _) = item.node {
tr.path.span
} else {
err.emit()
}
Err(CopyImplementationError::NotAnAdt) => {
- let item = tcx.hir().expect_item(impl_node_id);
+ let item = tcx.hir().expect_item_by_hir_id(impl_hir_id);
let span = if let ItemKind::Impl(.., ref ty, _) = item.node {
ty.span
} else {
if impl_did.is_local() {
let dispatch_from_dyn_trait = tcx.lang_items().dispatch_from_dyn_trait().unwrap();
- let impl_node_id = tcx.hir().as_local_node_id(impl_did).unwrap();
- let span = tcx.hir().span(impl_node_id);
+ let impl_hir_id = tcx.hir().as_local_hir_id(impl_did).unwrap();
+ let span = tcx.hir().span_by_hir_id(impl_hir_id);
let source = tcx.type_of(impl_did);
assert!(!source.has_escaping_bound_vars());
};
tcx.infer_ctxt().enter(|infcx| {
- let cause = ObligationCause::misc(span, impl_node_id);
+ let cause = ObligationCause::misc(span, impl_hir_id);
use ty::TyKind::*;
match (&source.sty, &target.sty) {
});
// this provider should only get invoked for local def-ids
- let impl_node_id = gcx.hir().as_local_node_id(impl_did).unwrap_or_else(|| {
+ let impl_hir_id = gcx.hir().as_local_hir_id(impl_did).unwrap_or_else(|| {
bug!("coerce_unsized_info: invoked for non-local def-id {:?}", impl_did)
});
source,
target);
- let span = gcx.hir().span(impl_node_id);
+ let span = gcx.hir().span_by_hir_id(impl_hir_id);
let param_env = gcx.param_env(impl_did);
assert!(!source.has_escaping_bound_vars());
target);
gcx.infer_ctxt().enter(|infcx| {
- let cause = ObligationCause::misc(span, impl_node_id);
+ let cause = ObligationCause::misc(span, impl_hir_id);
let check_mutbl = |mt_a: ty::TypeAndMut<'gcx>,
mt_b: ty::TypeAndMut<'gcx>,
mk_ptr: &dyn Fn(Ty<'gcx>) -> Ty<'gcx>| {
being coerced, none found");
return err_info;
} else if diff_fields.len() > 1 {
- let item = gcx.hir().expect_item(impl_node_id);
+ let item = gcx.hir().expect_item_by_hir_id(impl_hir_id);
let span = if let ItemKind::Impl(.., Some(ref t), _, _) = item.node {
t.path.span
} else {
- gcx.hir().span(impl_node_id)
+ gcx.hir().span_by_hir_id(impl_hir_id)
};
let mut err = struct_span_err!(gcx.sess,
let mut fulfill_cx = TraitEngine::new(infcx.tcx);
// Register an obligation for `A: Trait<B>`.
- let cause = traits::ObligationCause::misc(span, impl_node_id);
+ let cause = traits::ObligationCause::misc(span, impl_hir_id);
let predicate = gcx.predicate_for_trait_def(param_env,
cause,
trait_def_id,
-use namespace::Namespace;
+use crate::namespace::Namespace;
use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
use rustc::hir;
use rustc::hir::itemlikevisit::ItemLikeVisitor;
use rustc::traits::{self, IntercrateMode};
use rustc::ty::TyCtxt;
-use lint;
+use crate::lint;
pub fn crate_inherent_impls_overlap_check<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
crate_num: CrateNum) {
// done by the orphan and overlap modules. Then we build up various
// mappings. That mapping code resides here.
-use hir::def_id::{DefId, LOCAL_CRATE};
+use crate::hir::def_id::{DefId, LOCAL_CRATE};
use rustc::traits;
use rustc::ty::{self, TyCtxt, TypeFoldable};
use rustc::ty::query::Providers;
tcx.ensure().crate_inherent_impls_overlap_check(LOCAL_CRATE);
}
-/// Overlap: No two impls for the same trait are implemented for the
+/// Overlap: no two impls for the same trait are implemented for the
/// same type. Likewise, no two inherent impls for a given type
/// constructor provide a method with the same name.
fn check_impl_overlap<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, node_id: ast::NodeId) {
impl<'cx, 'tcx, 'v> ItemLikeVisitor<'v> for OrphanChecker<'cx, 'tcx> {
/// Checks exactly one impl for orphan rules and other such
- /// restrictions. In this fn, it can happen that multiple errors
+ /// restrictions. In this fn, it can happen that multiple errors
/// apply to a specific impl, so just return after reporting one
/// to prevent inundating the user with a bunch of similar error
/// reports.
//! At present, however, we do run collection across all items in the
//! crate as a kind of pass. This should eventually be factored away.
-use astconv::{AstConv, Bounds};
-use constrained_type_params as ctp;
-use check::intrinsic::intrisic_operation_unsafety;
-use lint;
-use middle::lang_items::SizedTraitLangItem;
-use middle::resolve_lifetime as rl;
-use middle::weak_lang_items;
+use crate::astconv::{AstConv, Bounds};
+use crate::constrained_type_params as ctp;
+use crate::check::intrinsic::intrisic_operation_unsafety;
+use crate::lint;
+use crate::middle::lang_items::SizedTraitLangItem;
+use crate::middle::resolve_lifetime as rl;
+use crate::middle::weak_lang_items;
use rustc::mir::mono::Linkage;
use rustc::ty::query::Providers;
use rustc::ty::subst::Substs;
);
}
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
*providers = Providers {
type_of,
generics_of,
///////////////////////////////////////////////////////////////////////////
/// Context specific to some particular item. This is what implements
-/// AstConv. It has information about the predicates that are defined
+/// `AstConv`. It has information about the predicates that are defined
/// on the trait. Unfortunately, this predicate information is
/// available in various different forms at various points in the
/// process. So we can't just store a pointer to e.g., the AST or the
}
impl<'a, 'tcx> ItemCtxt<'a, 'tcx> {
- /// Find bounds from `hir::Generics`. This requires scanning through the
+ /// Finds bounds from `hir::Generics`. This requires scanning through the
/// AST. We do this to avoid having to convert *all* the bounds, which
/// would create artificial cycles. Instead we can only convert the
/// bounds for a type parameter `X` if `X::Foo` is used.
}
/// Tests whether this is the AST for a reference to the type
-/// parameter with id `param_id`. We use this so as to avoid running
+/// parameter with ID `param_id`. We use this so as to avoid running
/// `ast_ty_to_ty`, because we want to avoid triggering an all-out
/// conversion of the type to avoid inducing unnecessary cycles.
fn is_param<'a, 'tcx>(
tcx.alloc_adt_def(def_id, kind, variants, repr)
}
-/// Ensures that the super-predicates of the trait with def-id
+/// Ensures that the super-predicates of the trait with `DefId`
/// trait_def_id are converted and stored. This also ensures that
/// the transitive super-predicates are converted;
fn super_predicates_of<'a, 'tcx>(
}
fn trait_def<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty::TraitDef {
- let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
- let item = tcx.hir().expect_item(node_id);
+ let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
+ let item = tcx.hir().expect_item_by_hir_id(hir_id);
let (is_auto, unsafety) = match item.node {
hir::ItemKind::Trait(is_auto, unsafety, ..) => (is_auto == hir::IsAuto::Yes, unsafety),
}) => {
if gen.is_some() {
let hir_id = tcx.hir().node_to_hir_id(node_id);
- return tcx.typeck_tables_of(def_id).node_id_to_type(hir_id);
+ return tcx.typeck_tables_of(def_id).node_type(hir_id);
}
let substs = ty::ClosureSubsts {
) -> Option<ty::TraitRef<'tcx>> {
let icx = ItemCtxt::new(tcx, def_id);
- let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
- match tcx.hir().expect_item(node_id).node {
+ let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
+ match tcx.hir().expect_item_by_hir_id(hir_id).node {
hir::ItemKind::Impl(.., ref opt_trait_ref, _, _) => {
opt_trait_ref.as_ref().map(|ast_trait_ref| {
let selfty = tcx.type_of(def_id);
}
fn impl_polarity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> hir::ImplPolarity {
- let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
- match tcx.hir().expect_item(node_id).node {
+ let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
+ match tcx.hir().expect_item_by_hir_id(hir_id).node {
hir::ItemKind::Impl(_, polarity, ..) => polarity,
ref item => bug!("impl_polarity: {:?} not an impl", item),
}
}
/// Returns the early-bound lifetimes declared in this generics
-/// listing. For anything other than fns/methods, this is just all
+/// listing. For anything other than fns/methods, this is just all
/// the lifetimes that are declared. For fns or methods, we have to
/// screen out those that do not appear in any where-clauses etc using
/// `resolve_lifetime::early_bound_lifetimes`.
})
}
+/// Returns a list of type predicates for the definition with ID `def_id`, including inferred
+/// lifetime constraints. This includes all predicates returned by `explicit_predicates_of`, plus
+/// inferred constraints concerning which regions outlive other regions.
fn predicates_defined_on<'a, 'tcx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId,
result
}
+/// Returns a list of all type predicates (explicit and implicit) for the definition with
+/// ID `def_id`. This includes all predicates returned by `predicates_defined_on`, plus
+/// `Self: Trait` predicates for traits.
fn predicates_of<'a, 'tcx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId,
result
}
+/// Returns a list of user-specified type predicates for the definition with ID `def_id`.
+/// N.B., this does not include any implied/inferred constraints.
fn explicit_predicates_of<'a, 'tcx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId,
}
/// Converts a specific `GenericBound` from the AST into a set of
-/// predicates that apply to the self-type. A vector is returned
-/// because this can be anywhere from zero predicates (`T : ?Sized` adds no
-/// predicates) to one (`T : Foo`) to many (`T : Bar<X=i32>` adds `T : Bar`
+/// predicates that apply to the self type. A vector is returned
+/// because this can be anywhere from zero predicates (`T: ?Sized` adds no
+/// predicates) to one (`T: Foo`) to many (`T: Bar<X=i32>` adds `T: Bar`
/// and `<T as Bar>::X == i32`).
fn predicates_from_bound<'tcx>(
astconv: &dyn AstConv<'tcx, 'tcx>,
fn from(param: ty::EarlyBoundRegion) -> Self { Parameter(param.index) }
}
-/// Return the set of parameters constrained by the impl header.
+/// Returns the set of parameters constrained by the impl header.
pub fn parameters_for_impl<'tcx>(impl_self_ty: Ty<'tcx>,
impl_trait_ref: Option<ty::TraitRef<'tcx>>)
-> FxHashSet<Parameter>
/// parameters so constrained to `input_parameters`. For example,
/// imagine the following impl:
///
-/// impl<T: Debug, U: Iterator<Item=T>> Trait for U
+/// impl<T: Debug, U: Iterator<Item = T>> Trait for U
///
/// The impl's predicates are collected from left to right. Ignoring
/// the implicit `Sized` bounds, these are
/// We *do* have to be somewhat careful when projection targets contain
/// projections themselves, for example in
/// impl<S,U,V,W> Trait for U where
-/// /* 0 */ S: Iterator<Item=U>,
+/// /* 0 */ S: Iterator<Item = U>,
/// /* - */ U: Iterator,
/// /* 1 */ <U as Iterator>::Item: ToOwned<Owned=(W,<V as Iterator>::Item)>
-/// /* 2 */ W: Iterator<Item=V>
+/// /* 2 */ W: Iterator<Item = V>
/// /* 3 */ V: Debug
/// we have to evaluate the projections in the order I wrote them:
/// `V: Debug` requires `V` to be evaluated. The only projection that
/// which is determined by 1, which requires `U`, that is determined
/// by 0. I should probably pick a less tangled example, but I can't
/// think of any.
-pub fn setup_constraining_predicates<'tcx>(tcx: TyCtxt,
+pub fn setup_constraining_predicates<'tcx>(tcx: TyCtxt<'_, '_, '_>,
predicates: &mut [(ty::Predicate<'tcx>, Span)],
impl_trait_ref: Option<ty::TraitRef<'tcx>>,
input_parameters: &mut FxHashSet<Parameter>)
+// ignore-tidy-linelength
#![allow(non_snake_case)]
register_long_diagnostics! {
It is not possible to declare type parameters on a function that has the `start`
attribute. Such a function must have the following type signature (for more
-information: http://doc.rust-lang.org/stable/book/first-edition/no-stdlib.html):
+information, view [the unstable book][1]):
+
+[1]: https://doc.rust-lang.org/unstable-book/language-features/lang-items.html#writing-an-executable-without-stdlib
```
# let _:
E0374: r##"
A struct without a field containing an unsized type cannot implement
-`CoerceUnsized`. An
-[unsized type](https://doc.rust-lang.org/book/first-edition/unsized-types.html)
-is any type that the compiler doesn't know the length or alignment of at
-compile time. Any struct containing an unsized type is also unsized.
+`CoerceUnsized`. An [unsized type][1] is any type that the compiler
+doesn't know the length or alignment of at compile time. Any struct
+containing an unsized type is also unsized.
+
+[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait
Example of erroneous code:
`CoerceUnsized`. This only occurs when you are trying to coerce one of the
types in your struct to another type in the struct. In this case we try to
impl `CoerceUnsized` from `T` to `U` which are both types that the struct
-takes. An [unsized type] is any type that the compiler doesn't know the length
-or alignment of at compile time. Any struct containing an unsized type is also
-unsized.
+takes. An [unsized type][1] is any type that the compiler doesn't know the
+length or alignment of at compile time. Any struct containing an unsized type
+is also unsized.
Example of erroneous code:
}
```
-[unsized type]: https://doc.rust-lang.org/book/first-edition/unsized-types.html
+[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait
"##,
E0376: r##"
`CoerceUnsized` can only be implemented for a struct. Unsized types are
already able to be coerced without an implementation of `CoerceUnsized`
whereas a struct containing an unsized type needs to know the unsized type
-field it's containing is able to be coerced. An
-[unsized type](https://doc.rust-lang.org/book/first-edition/unsized-types.html)
+field it's containing is able to be coerced. An [unsized type][1]
is any type that the compiler doesn't know the length or alignment of at
compile time. Any struct containing an unsized type is also unsized.
+[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait
+
Example of erroneous code:
```compile_fail,E0376
assert_eq!(c, 'V');
```
-For more information about casts, take a look at The Book:
-https://doc.rust-lang.org/book/first-edition/casting-between-types.html
+For more information about casts, take a look at the Type cast section in
+[The Reference Book][1].
+
+[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions
"##,
E0605: r##"
v as *const i8; // ok!
```
-For more information about casts, take a look at The Book:
-https://doc.rust-lang.org/book/first-edition/casting-between-types.html
+For more information about casts, take a look at the Type cast section in
+[The Reference Book][1].
+
+[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions
"##,
E0606: r##"
let y: u32 = *x as u32; // We dereference it first and then cast it.
```
-For more information about casts, take a look at The Book:
-https://doc.rust-lang.org/book/first-edition/casting-between-types.html
+For more information about casts, take a look at the Type cast section in
+[The Reference Book][1].
+
+[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions
"##,
E0607: r##"
To fix this error, don't try to cast directly between thin and fat pointers.
-For more information about casts, take a look at The Book:
-https://doc.rust-lang.org/book/first-edition/casting-between-types.html
+For more information about casts, take a look at the Type cast section in
+[The Reference Book][1].
+
+[1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions
"##,
E0609: r##"
```
For more information about primitives and structs, take a look at The Book:
-https://doc.rust-lang.org/book/first-edition/primitive-types.html
-https://doc.rust-lang.org/book/first-edition/structs.html
+https://doc.rust-lang.org/book/ch03-02-data-types.html
+https://doc.rust-lang.org/book/ch05-00-structs.html
"##,
E0614: r##"
//! specialization errors. These things can (and probably should) be
//! fixed, but for the moment it's easier to do these checks early.
-use constrained_type_params as ctp;
+use crate::constrained_type_params as ctp;
use rustc::hir;
use rustc::hir::itemlikevisit::ItemLikeVisitor;
use rustc::hir::def_id::DefId;
use syntax_pos::Span;
/// Checks that all the type/lifetime parameters on an impl also
-/// appear in the trait ref or self-type (or are constrained by a
+/// appear in the trait ref or self type (or are constrained by a
/// where-clause). These rules are needed to ensure that, given a
/// trait ref like `<T as Trait<U>>`, we can derive the values of all
/// parameters on the impl (which is needed to make specialization
/// possible).
///
/// However, in the case of lifetimes, we only enforce these rules if
-/// the lifetime parameter is used in an associated type. This is a
+/// the lifetime parameter is used in an associated type. This is a
/// concession to backwards compatibility; see comment at the end of
/// the fn for details.
///
/// impl<T> Trait<Foo<T>> for Bar { ... }
/// // ^ T appears in `Foo<T>`, ok.
///
-/// impl<T> Trait<Foo> for Bar where Bar: Iterator<Item=T> { ... }
+/// impl<T> Trait<Foo> for Bar where Bar: Iterator<Item = T> { ... }
/// // ^ T is bound to `<Bar as Iterator>::Item`, ok.
///
/// impl<'a> Trait<Foo> for Bar { }
// used elsewhere are not projected back out.
}
-fn report_unused_parameter(tcx: TyCtxt,
+fn report_unused_parameter(tcx: TyCtxt<'_, '_, '_>,
span: Span,
kind: &str,
name: &str)
/*!
-# typeck.rs
+# typeck
The type checker is responsible for:
#![feature(refcell_replace_swap)]
#![feature(rustc_diagnostic_macros)]
#![feature(slice_patterns)]
-#![feature(slice_sort_by_cached_key)]
#![feature(never_type)]
#![recursion_limit="256"]
+#![deny(rust_2018_idioms)]
+#![allow(explicit_outlives_requirements)]
+
+#![allow(elided_lifetimes_in_paths)] // WIP
+
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
-extern crate syntax_pos;
-
-extern crate arena;
#[macro_use] extern crate rustc;
-extern crate rustc_data_structures;
-extern crate rustc_errors as errors;
-extern crate rustc_target;
-extern crate smallvec;
// N.B., this module needs to be declared first so diagnostics are
// registered before they are used.
}
}
-fn require_c_abi_if_variadic(tcx: TyCtxt,
+fn require_c_abi_if_variadic(tcx: TyCtxt<'_, '_, '_>,
decl: &hir::FnDecl,
abi: Abi,
span: Span) {
}
fn check_main_fn_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, main_def_id: DefId) {
- let main_id = tcx.hir().as_local_node_id(main_def_id).unwrap();
+ let main_id = tcx.hir().as_local_hir_id(main_def_id).unwrap();
let main_span = tcx.def_span(main_def_id);
let main_t = tcx.type_of(main_def_id);
match main_t.sty {
ty::FnDef(..) => {
- if let Some(Node::Item(it)) = tcx.hir().find(main_id) {
+ if let Some(Node::Item(it)) = tcx.hir().find_by_hir_id(main_id) {
if let hir::ItemKind::Fn(.., ref generics, _) = it.node {
let mut error = false;
if !generics.params.is_empty() {
}
fn check_start_fn_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, start_def_id: DefId) {
- let start_id = tcx.hir().as_local_node_id(start_def_id).unwrap();
+ let start_id = tcx.hir().as_local_hir_id(start_def_id).unwrap();
let start_span = tcx.def_span(start_def_id);
let start_t = tcx.type_of(start_def_id);
match start_t.sty {
ty::FnDef(..) => {
- if let Some(Node::Item(it)) = tcx.hir().find(start_id) {
+ if let Some(Node::Item(it)) = tcx.hir().find_by_hir_id(start_id) {
if let hir::ItemKind::Fn(.., ref generics, _) = it.node {
let mut error = false;
if !generics.params.is_empty() {
}
}
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
collect::provide(providers);
coherence::provide(providers);
check::provide(providers);
use rustc::hir::def_id::DefId;
use rustc::ty::{self, OutlivesPredicate, TyCtxt};
-use util::nodemap::FxHashMap;
+use crate::util::nodemap::FxHashMap;
use super::utils::*;
-use rustc::hir;
-use hir::Node;
+use rustc::hir::{self, Node};
use rustc::hir::def_id::DefId;
use rustc::hir::itemlikevisit::ItemLikeVisitor;
use rustc::ty::subst::{Kind, Subst, UnpackedKind};
/// Infer predicates for the items in the crate.
///
-/// global_inferred_outlives: this is initially the empty map that
+/// `global_inferred_outlives`: this is initially the empty map that
/// was generated by walking the items in the crate. This will
/// now be filled with inferred predicates.
pub fn infer_predicates<'tcx>(
pub mod test;
mod utils;
-pub fn provide(providers: &mut Providers) {
+pub fn provide(providers: &mut Providers<'_>) {
*providers = Providers {
inferred_outlives_of,
inferred_outlives_crate,
pointers.
For more information about casts, take a look at The Book:
-https://doc.rust-lang.org/book/first-edition/casting-between-types.html");
+https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions");
err
}
}
/// }
///
/// then while we are visiting `Bar<T>`, the `CurrentItem` would have
-/// the def-id and the start of `Foo`'s inferreds.
+/// the `DefId` and the start of `Foo`'s inferreds.
pub struct CurrentItem {
inferred_start: InferredIndex,
}
fn variances_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item_def_id: DefId)
-> Lrc<Vec<ty::Variance>> {
- let id = tcx.hir().as_local_node_id(item_def_id).expect("expected local def-id");
+ let id = tcx.hir().as_local_hir_id(item_def_id).expect("expected local def-id");
let unsupported = || {
// Variance not relevant.
- span_bug!(tcx.hir().span(id), "asked to compute variance for wrong kind of item")
+ span_bug!(tcx.hir().span_by_hir_id(id), "asked to compute variance for wrong kind of item")
};
- match tcx.hir().get(id) {
+ match tcx.hir().get_by_hir_id(id) {
Node::Item(item) => match item.node {
hir::ItemKind::Enum(..) |
hir::ItemKind::Struct(..) |
use syntax::ast;
use rustc::hir;
use rustc::hir::itemlikevisit::ItemLikeVisitor;
-use util::nodemap::NodeMap;
+use crate::util::nodemap::NodeMap;
use self::VarianceTerm::*;
-//! Representation of a `#[doc(cfg(...))]` attribute.
+//! The representation of a `#[doc(cfg(...))]` attribute.
// FIXME: Once the portability lint RFC is implemented (see tracking issue #41619),
// switch to use those structures instead.
False,
/// A generic configuration option, e.g., `test` or `target_os = "linux"`.
Cfg(Symbol, Option<Symbol>),
- /// Negate a configuration requirement, i.e., `not(x)`.
+ /// Negates a configuration requirement, i.e., `not(x)`.
Not(Box<Cfg>),
/// Union of a list of configuration requirements, i.e., `any(...)`.
Any(Vec<Cfg>),
StaticItem(Static),
ConstantItem(Constant),
TraitItem(Trait),
+ TraitAliasItem(TraitAlias),
ImplItem(Impl),
/// A method signature only. Used for required methods in traits (ie,
/// non-default-methods).
ItemEnum::TyMethodItem(ref i) => &i.generics,
ItemEnum::MethodItem(ref i) => &i.generics,
ItemEnum::ForeignFunctionItem(ref f) => &f.generics,
+ ItemEnum::TraitAliasItem(ref ta) => &ta.generics,
_ => return None,
})
}
items.extend(self.impls.iter().flat_map(|x| x.clean(cx)));
items.extend(self.macros.iter().map(|x| x.clean(cx)));
items.extend(self.proc_macros.iter().map(|x| x.clean(cx)));
+ items.extend(self.trait_aliases.iter().map(|x| x.clean(cx)));
// determine if we should display the inner contents or
// the outer `mod` item for the source code.
}
pub trait NestedAttributesExt {
- /// Returns whether the attribute list contains a specific `Word`
+ /// Returns `true` if the attribute list contains a specific `Word`
fn has_word(self, word: &str) -> bool;
}
}
}
- /// Get links as a vector
+ /// Gets links as a vector
///
/// Cache must be populated before call
pub fn links(&self, krate: &CrateNum) -> Vec<(String, String)> {
pub fn self_type(&self) -> Option<SelfTy> {
self.inputs.values.get(0).and_then(|v| v.to_self())
}
+
+ /// Returns the sugared return type for an async function.
+ ///
+ /// For example, if the return type is `impl std::future::Future<Output = i32>`, this function
+ /// will return `i32`.
+ ///
+ /// # Panics
+ ///
+ /// This function will panic if the return type does not match the expected sugaring for async
+ /// functions.
+ pub fn sugared_async_return_type(&self) -> FunctionRetTy {
+ match &self.output {
+ FunctionRetTy::Return(Type::ImplTrait(bounds)) => {
+ match &bounds[0] {
+ GenericBound::TraitBound(PolyTrait { trait_, .. }, ..) => {
+ let bindings = trait_.bindings().unwrap();
+ FunctionRetTy::Return(bindings[0].ty.clone())
+ }
+ _ => panic!("unexpected desugaring of async function"),
+ }
+ }
+ _ => panic!("unexpected desugaring of async function"),
+ }
+ }
}
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)]
items: self.items.clean(cx),
generics: self.generics.clean(cx),
bounds: self.bounds.clean(cx),
- is_spotlight: is_spotlight,
+ is_spotlight,
is_auto: self.is_auto.clean(cx),
}),
}
}
}
+#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
+pub struct TraitAlias {
+ pub generics: Generics,
+ pub bounds: Vec<GenericBound>,
+}
+
+impl Clean<Item> for doctree::TraitAlias {
+ fn clean(&self, cx: &DocContext) -> Item {
+ let attrs = self.attrs.clean(cx);
+ Item {
+ name: Some(self.name.clean(cx)),
+ attrs,
+ source: self.whence.clean(cx),
+ def_id: cx.tcx.hir().local_def_id(self.id),
+ visibility: self.vis.clean(cx),
+ stability: self.stab.clean(cx),
+ deprecation: self.depr.clean(cx),
+ inner: TraitAliasItem(TraitAlias {
+ generics: self.generics.clean(cx),
+ bounds: self.bounds.clean(cx),
+ }),
+ }
+ }
+}
+
impl Clean<bool> for hir::IsAuto {
fn clean(&self, _: &DocContext) -> bool {
match *self {
/// it does not preserve mutability or boxes.
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)]
pub enum Type {
- /// structs/enums/traits (most that'd be an hir::TyKind::Path)
+ /// Structs/enums/traits (most that'd be an `hir::TyKind::Path`).
ResolvedPath {
path: Path,
typarams: Option<Vec<GenericBound>>,
did: DefId,
- /// true if is a `T::Name` path for associated types
+ /// `true` if is a `T::Name` path for associated types.
is_generic: bool,
},
/// For parameterized types, so the consumer of the JSON don't go
Macro,
Attr,
Derive,
+ TraitAlias,
}
pub trait GetDefId {
_ => None,
}
}
+
+ pub fn bindings(&self) -> Option<&[TypeBinding]> {
+ match *self {
+ ResolvedPath { ref path, .. } => {
+ path.segments.last().and_then(|seg| {
+ if let GenericArgs::AngleBracketed { ref bindings, .. } = seg.args {
+ Some(&**bindings)
+ } else {
+ None
+ }
+ })
+ }
+ _ => None
+ }
+ }
}
impl GetDefId for Type {
}
fn print_const_expr(cx: &DocContext, body: hir::BodyId) -> String {
- cx.tcx.hir().node_to_pretty_string(body.node_id)
+ cx.tcx.hir().hir_to_pretty_string(body.hir_id)
}
/// Given a type Path, resolve it to a Type using the TyCtxt
MacroKind::Derive => (i, TypeKind::Derive),
MacroKind::ProcMacroStub => unreachable!(),
},
+ Def::TraitAlias(i) => (i, TypeKind::TraitAlias),
Def::SelfTy(Some(def_id), _) => (def_id, TypeKind::Trait),
- Def::SelfTy(_, Some(impl_def_id)) => {
- return impl_def_id
- }
+ Def::SelfTy(_, Some(impl_def_id)) => return impl_def_id,
_ => return def.def_id()
};
if did.is_local() { return did }
}
}
-/// An equality constraint on an associated type, e.g., `A=Bar` in `Foo<A=Bar>`
+/// An equality constraint on an associated type, e.g., `A = Bar` in `Foo<A = Bar>`
#[derive(Clone, PartialEq, Eq, RustcDecodable, RustcEncodable, Debug, Hash)]
pub struct TypeBinding {
pub name: String,
-//! Simplification of where clauses and parameter bounds into a prettier and
+//! Simplification of where-clauses and parameter bounds into a prettier and
//! more canonical form.
//!
//! Currently all cross-crate-inlined function use `rustc::ty` to reconstruct
//! the AST (e.g., see all of `clean::inline`), but this is not always a
-//! non-lossy transformation. The current format of storage for where clauses
+//! non-lossy transformation. The current format of storage for where-clauses
//! for functions and such is simply a list of predicates. One example of this
-//! is that the AST predicate of: `where T: Trait<Foo=Bar>` is encoded as:
+//! is that the AST predicate of: `where T: Trait<Foo = Bar>` is encoded as:
//! `where T: Trait, <T as Trait>::Foo = Bar`.
//!
//! This module attempts to reconstruct the original where and/or parameter
pub playground_url: Option<String>,
/// Whether to sort modules alphabetically on a module page instead of using declaration order.
/// `true` by default.
- ///
- /// FIXME(misdreavus): the flag name is `--sort-modules-by-appearance` but the meaning is
- /// inverted once read
+ //
+ // FIXME(misdreavus): the flag name is `--sort-modules-by-appearance` but the meaning is
+ // inverted once read.
pub sort_modules_alphabetically: bool,
/// List of themes to extend the docs with. Original argument name is included to assist in
/// displaying errors if it fails a theme check.
pub resource_suffix: String,
/// Whether to run the static CSS/JavaScript through a minifier when outputting them. `true` by
/// default.
- ///
- /// FIXME(misdreavus): the flag name is `--disable-minification` but the meaning is inverted
- /// once read
+ //
+ // FIXME(misdreavus): the flag name is `--disable-minification` but the meaning is inverted
+ // once read.
pub enable_minification: bool,
/// Whether to create an index page in the root of the output directory. If this is true but
/// `enable_index_page` is None, generate a static listing of crates instead.
})
}
- /// Returns whether the file given as `self.input` is a Markdown file.
+ /// Returns `true` if the file given as `self.input` is a Markdown file.
pub fn markdown_input(&self) -> bool {
self.input.extension()
.map_or(false, |e| e == "md" || e == "markdown")
/// Table type parameter definition -> substituted type
pub ty_substs: RefCell<FxHashMap<Def, clean::Type>>,
- /// Table node id of lifetime parameter definition -> substituted lifetime
+ /// Table `NodeId` of lifetime parameter definition -> substituted lifetime
pub lt_substs: RefCell<FxHashMap<DefId, clean::Lifetime>>,
/// Table DefId of `impl Trait` in argument position -> bounds
pub impl_trait_bounds: RefCell<FxHashMap<DefId, Vec<clean::GenericBound>>>,
pub foreigns: Vec<hir::ForeignMod>,
pub macros: Vec<Macro>,
pub proc_macros: Vec<ProcMacro>,
+ pub trait_aliases: Vec<TraitAlias>,
pub is_crate: bool,
}
where_inner: syntax_pos::DUMMY_SP,
attrs : hir::HirVec::new(),
extern_crates: Vec::new(),
- imports : Vec::new(),
- structs : Vec::new(),
- unions : Vec::new(),
- enums : Vec::new(),
- fns : Vec::new(),
- mods : Vec::new(),
- typedefs : Vec::new(),
- existentials: Vec::new(),
- statics : Vec::new(),
- constants : Vec::new(),
- traits : Vec::new(),
- impls : Vec::new(),
- foreigns : Vec::new(),
- macros : Vec::new(),
- proc_macros: Vec::new(),
+ imports : Vec::new(),
+ structs : Vec::new(),
+ unions : Vec::new(),
+ enums : Vec::new(),
+ fns : Vec::new(),
+ mods : Vec::new(),
+ typedefs : Vec::new(),
+ existentials: Vec::new(),
+ statics : Vec::new(),
+ constants : Vec::new(),
+ traits : Vec::new(),
+ impls : Vec::new(),
+ foreigns : Vec::new(),
+ macros : Vec::new(),
+ proc_macros: Vec::new(),
+ trait_aliases: Vec::new(),
is_crate : false,
}
}
pub depr: Option<attr::Deprecation>,
}
+pub struct TraitAlias {
+ pub name: Name,
+ pub generics: hir::Generics,
+ pub bounds: hir::HirVec<hir::GenericBound>,
+ pub attrs: hir::HirVec<ast::Attribute>,
+ pub id: ast::NodeId,
+ pub whence: Span,
+ pub vis: hir::Visibility,
+ pub stab: Option<attr::Stability>,
+ pub depr: Option<attr::Deprecation>,
+}
+
#[derive(Debug)]
pub struct Impl {
pub unsafety: hir::Unsafety,
-//! HTML Escaping
+//! HTML escaping.
//!
-//! This module contains one unit-struct which can be used to HTML-escape a
+//! This module contains one unit struct, which can be used to HTML-escape a
//! string of text (for use in a format string).
use std::fmt;
//! assume that HTML output is desired, although it may be possible to redesign
//! them in the future to instead emit any format desired.
+use std::borrow::Cow;
use std::fmt;
use rustc::hir::def_id::DefId;
pub struct CommaSep<'a, T: 'a>(pub &'a [T]);
pub struct AbiSpace(pub Abi);
-/// Wrapper struct for properly emitting a method declaration.
-pub struct Method<'a> {
+/// Wrapper struct for properly emitting a function or method declaration.
+pub struct Function<'a> {
/// The declaration to emit.
pub decl: &'a clean::FnDecl,
/// The length of the function's "name", used to determine line-wrapping.
pub name_len: usize,
/// The number of spaces to indent each successive line with, if line-wrapping is necessary.
pub indent: usize,
+ /// Whether the function is async or not.
+ pub asyncness: hir::IsAsync,
}
-/// Wrapper struct for emitting a where clause from Generics.
+/// Wrapper struct for emitting a where-clause from Generics.
pub struct WhereClause<'a>{
- /// The Generics from which to emit a where clause.
+ /// The Generics from which to emit a where-clause.
pub gens: &'a clean::Generics,
/// The number of spaces to indent each line with.
pub indent: usize,
- /// Whether the where clause needs to add a comma and newline after the last bound.
+ /// Whether the where-clause needs to add a comma and newline after the last bound.
pub end_newline: bool,
}
}
}
-impl<'a> fmt::Display for Method<'a> {
+impl<'a> fmt::Display for Function<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let &Method { decl, name_len, indent } = self;
+ let &Function { decl, name_len, indent, asyncness } = self;
let amp = if f.alternate() { "&" } else { "&" };
let mut args = String::new();
let mut args_plain = String::new();
args_plain.push_str(", ...");
}
- let arrow_plain = format!("{:#}", decl.output);
+ let output = if let hir::IsAsync::Async = asyncness {
+ Cow::Owned(decl.sugared_async_return_type())
+ } else {
+ Cow::Borrowed(&decl.output)
+ };
+
+ let arrow_plain = format!("{:#}", &output);
let arrow = if f.alternate() {
- format!("{:#}", decl.output)
+ format!("{:#}", &output)
} else {
- decl.output.to_string()
+ output.to_string()
};
let pad = " ".repeat(name_len);
/// Called at the end of a span of highlighted text.
fn exit_span(&mut self) -> io::Result<()>;
- /// Called for a span of text. If the text should be highlighted differently from the
+ /// Called for a span of text. If the text should be highlighted differently from the
/// surrounding text, then the `Class` argument will be a value other than `None`.
///
/// The following sequences of callbacks are equivalent:
Existential = 22,
ProcAttribute = 23,
ProcDerive = 24,
+ TraitAlias = 25,
}
clean::AssociatedTypeItem(..) => ItemType::AssociatedType,
clean::ForeignTypeItem => ItemType::ForeignType,
clean::KeywordItem(..) => ItemType::Keyword,
+ clean::TraitAliasItem(..) => ItemType::TraitAlias,
clean::ProcMacroItem(ref mac) => match mac.kind {
MacroKind::Bang => ItemType::Macro,
MacroKind::Attr => ItemType::ProcAttribute,
impl From<clean::TypeKind> for ItemType {
fn from(kind: clean::TypeKind) -> ItemType {
match kind {
- clean::TypeKind::Struct => ItemType::Struct,
- clean::TypeKind::Union => ItemType::Union,
- clean::TypeKind::Enum => ItemType::Enum,
- clean::TypeKind::Function => ItemType::Function,
- clean::TypeKind::Trait => ItemType::Trait,
- clean::TypeKind::Module => ItemType::Module,
- clean::TypeKind::Static => ItemType::Static,
- clean::TypeKind::Const => ItemType::Constant,
- clean::TypeKind::Variant => ItemType::Variant,
- clean::TypeKind::Typedef => ItemType::Typedef,
- clean::TypeKind::Foreign => ItemType::ForeignType,
- clean::TypeKind::Macro => ItemType::Macro,
- clean::TypeKind::Attr => ItemType::ProcAttribute,
- clean::TypeKind::Derive => ItemType::ProcDerive,
+ clean::TypeKind::Struct => ItemType::Struct,
+ clean::TypeKind::Union => ItemType::Union,
+ clean::TypeKind::Enum => ItemType::Enum,
+ clean::TypeKind::Function => ItemType::Function,
+ clean::TypeKind::Trait => ItemType::Trait,
+ clean::TypeKind::Module => ItemType::Module,
+ clean::TypeKind::Static => ItemType::Static,
+ clean::TypeKind::Const => ItemType::Constant,
+ clean::TypeKind::Variant => ItemType::Variant,
+ clean::TypeKind::Typedef => ItemType::Typedef,
+ clean::TypeKind::Foreign => ItemType::ForeignType,
+ clean::TypeKind::Macro => ItemType::Macro,
+ clean::TypeKind::Attr => ItemType::ProcAttribute,
+ clean::TypeKind::Derive => ItemType::ProcDerive,
+ clean::TypeKind::TraitAlias => ItemType::TraitAlias,
}
}
}
ItemType::Existential => "existential",
ItemType::ProcAttribute => "attr",
ItemType::ProcDerive => "derive",
+ ItemType::TraitAlias => "traitalias",
}
}
ItemType::Primitive |
ItemType::AssociatedType |
ItemType::Existential |
+ ItemType::TraitAlias |
ItemType::ForeignType => NameSpace::Type,
ItemType::ExternCrate |
-//! Markdown formatting for rustdoc
+//! Markdown formatting for rustdoc.
//!
//! This module implements markdown formatting through the pulldown-cmark
//! rust-library. This module exposes all of the
-//! functionality through a unit-struct, `Markdown`, which has an implementation
+//! functionality through a unit struct, `Markdown`, which has an implementation
//! of `fmt::Display`. Example usage:
//!
//! ```
RefCell::new(None)
});
-/// Adds syntax highlighting and playground Run buttons to rust code blocks.
+/// Adds syntax highlighting and playground Run buttons to Rust code blocks.
struct CodeBlocks<'a, I: Iterator<Item = Event<'a>>> {
inner: I,
check_error_codes: ErrorCodes,
}
}
-/// Make headings links with anchor ids and build up TOC.
+/// Make headings links with anchor IDs and build up TOC.
struct LinkReplacer<'a, 'b, I: Iterator<Item = Event<'a>>> {
inner: I,
links: &'b [(String, String)],
}
}
-/// Make headings links with anchor ids and build up TOC.
+/// Make headings links with anchor IDs and build up TOC.
struct HeadingLinks<'a, 'b, 'ids, I: Iterator<Item = Event<'a>>> {
inner: I,
toc: Option<&'b mut TocBuilder>,
-//! Rustdoc's HTML Rendering module
+//! Rustdoc's HTML rendering module.
//!
//! This modules contains the bulk of the logic necessary for rendering a
//! rustdoc `clean::Crate` instance to a set of static HTML pages. This
use html::escape::Escape;
use html::format::{AsyncSpace, ConstnessSpace};
use html::format::{GenericBounds, WhereClause, href, AbiSpace};
-use html::format::{VisSpace, Method, UnsafetySpace, MutableSpace};
+use html::format::{VisSpace, Function, UnsafetySpace, MutableSpace};
use html::format::fmt_impl_for_trait_page;
use html::item_type::ItemType;
use html::markdown::{self, Markdown, MarkdownHtml, MarkdownSummaryLine, ErrorCodes, IdMap};
}
impl SharedContext {
- /// Returns whether the `collapse-docs` pass was run on this crate.
+ /// Returns `true` if the `collapse-docs` pass was run on this crate.
pub fn was_collapsed(&self) -> bool {
self.passes.contains("collapse-docs")
}
#[derive(Default)]
pub struct Cache {
/// Mapping of typaram ids to the name of the type parameter. This is used
- /// when pretty-printing a type (so pretty printing doesn't have to
+ /// when pretty-printing a type (so pretty-printing doesn't have to
/// painfully maintain a context like this)
pub typarams: FxHashMap<DefId, String>,
- /// Maps a type id to all known implementations for that type. This is only
+ /// Maps a type ID to all known implementations for that type. This is only
/// recognized for intra-crate `ResolvedPath` types, and is used to print
/// out extra documentation on the page of an enum/struct.
///
/// found on that implementation.
pub impls: FxHashMap<DefId, Vec<Impl>>,
- /// Maintains a mapping of local crate node ids to the fully qualified name
+ /// Maintains a mapping of local crate `NodeId`s to the fully qualified name
/// and "short type description" of that node. This is used when generating
/// URLs when a type is being linked to. External paths are not located in
/// this map because the `External` type itself has all the information
/// generating explicit hyperlinks to other crates.
pub external_paths: FxHashMap<DefId, (Vec<String>, ItemType)>,
- /// Maps local def ids of exported types to fully qualified paths.
+ /// Maps local `DefId`s of exported types to fully qualified paths.
/// Unlike 'paths', this mapping ignores any renames that occur
/// due to 'use' statements.
///
cx.krate(krate)
}
-/// Build the search index from the collected metadata
+/// Builds the search index from the collected metadata
fn build_index(krate: &clean::Crate, cache: &mut Cache) -> String {
let mut nodeid_to_pathid = FxHashMap::default();
let mut crate_items = Vec::with_capacity(cache.search_index.len());
keywords: FxHashSet<ItemEntry>,
attributes: FxHashSet<ItemEntry>,
derives: FxHashSet<ItemEntry>,
+ trait_aliases: FxHashSet<ItemEntry>,
}
impl AllTypes {
keywords: new_set(100),
attributes: new_set(100),
derives: new_set(100),
+ trait_aliases: new_set(100),
}
}
ItemType::Constant => self.constants.insert(ItemEntry::new(new_url, name)),
ItemType::ProcAttribute => self.attributes.insert(ItemEntry::new(new_url, name)),
ItemType::ProcDerive => self.derives.insert(ItemEntry::new(new_url, name)),
+ ItemType::TraitAlias => self.trait_aliases.insert(ItemEntry::new(new_url, name)),
_ => true,
};
}
print_entries(f, &self.derives, "Derive Macros", "derives")?;
print_entries(f, &self.functions, "Functions", "functions")?;
print_entries(f, &self.typedefs, "Typedefs", "typedefs")?;
+ print_entries(f, &self.trait_aliases, "Trait Aliases", "trait-aliases")?;
print_entries(f, &self.existentials, "Existentials", "existentials")?;
print_entries(f, &self.statics, "Statics", "statics")?;
print_entries(f, &self.constants, "Constants", "constants")
}
impl<'a> Item<'a> {
- /// Generate a url appropriate for an `href` attribute back to the source of
+ /// Generates a url appropriate for an `href` attribute back to the source of
/// this item.
///
/// The url generated, when clicked, will redirect the browser back to the
clean::ForeignTypeItem => write!(fmt, "Foreign Type ")?,
clean::KeywordItem(..) => write!(fmt, "Keyword ")?,
clean::ExistentialItem(..) => write!(fmt, "Existential Type ")?,
+ clean::TraitAliasItem(..) => write!(fmt, "Trait Alias ")?,
_ => {
// We don't generate pages for any other type.
unreachable!();
clean::ForeignTypeItem => item_foreign_type(fmt, self.cx, self.item),
clean::KeywordItem(ref k) => item_keyword(fmt, self.cx, self.item, k),
clean::ExistentialItem(ref e, _) => item_existential(fmt, self.cx, self.item, e),
+ clean::TraitAliasItem(ref ta) => item_trait_alias(fmt, self.cx, self.item, ta),
_ => {
// We don't generate pages for any other type.
unreachable!();
// The trailing space after each tag is to space it properly against the rest of the docs.
if item.deprecation().is_some() {
- tags += &tag_html("deprecated", "Deprecated");
+ let mut message = "Deprecated";
+ if let Some(ref stab) = item.stability {
+ if let Some(ref depr) = stab.deprecation {
+ if let Some(ref since) = depr.since {
+ if !stability::deprecation_in_effect(&since) {
+ message = "Deprecation planned";
+ }
+ }
+ }
+ }
+ tags += &tag_html("deprecated", message);
}
if let Some(stab) = item
let mut stability = vec![];
let error_codes = ErrorCodes::from(UnstableFeatures::from_environment().is_nightly_build());
- if let Some(Deprecation { since, note }) = &item.deprecation() {
+ if let Some(Deprecation { note, since }) = &item.deprecation() {
+ // We display deprecation messages for #[deprecated] and #[rustc_deprecated]
+ // but only display the future-deprecation messages for #[rustc_deprecated].
let mut message = if let Some(since) = since {
- if stability::deprecation_in_effect(since) {
- format!("Deprecated since {}", Escape(since))
- } else {
- format!("Deprecating in {}", Escape(since))
- }
+ format!("Deprecated since {}", Escape(since))
} else {
String::from("Deprecated")
};
+ if let Some(ref stab) = item.stability {
+ if let Some(ref depr) = stab.deprecation {
+ if let Some(ref since) = depr.since {
+ if !stability::deprecation_in_effect(&since) {
+ message = format!("Deprecating in {}", Escape(&since));
+ }
+ }
+ }
+ }
if let Some(note) = note {
let mut ids = cx.id_map.borrow_mut();
name = it.name.as_ref().unwrap(),
generics = f.generics,
where_clause = WhereClause { gens: &f.generics, indent: 0, end_newline: true },
- decl = Method {
+ decl = Function {
decl: &f.decl,
name_len,
indent: 0,
+ asyncness: f.header.asyncness,
})?;
document(w, cx, it)
}
Ok(())
}
-fn bounds(t_bounds: &[clean::GenericBound]) -> String {
+fn bounds(t_bounds: &[clean::GenericBound], trait_alias: bool) -> String {
let mut bounds = String::new();
- let mut bounds_plain = String::new();
if !t_bounds.is_empty() {
- if !bounds.is_empty() {
- bounds.push(' ');
- bounds_plain.push(' ');
+ if !trait_alias {
+ bounds.push_str(": ");
}
- bounds.push_str(": ");
- bounds_plain.push_str(": ");
for (i, p) in t_bounds.iter().enumerate() {
if i > 0 {
bounds.push_str(" + ");
- bounds_plain.push_str(" + ");
}
bounds.push_str(&(*p).to_string());
- bounds_plain.push_str(&format!("{:#}", *p));
}
}
bounds
it: &clean::Item,
t: &clean::Trait,
) -> fmt::Result {
- let bounds = bounds(&t.bounds);
+ let bounds = bounds(&t.bounds, false);
let types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>();
let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>();
let required = t.items.iter().filter(|m| m.is_ty_method()).collect::<Vec<_>>();
href = href,
name = name,
generics = *g,
- decl = Method {
+ decl = Function {
decl: d,
name_len: head_len,
indent,
+ asyncness: header.asyncness,
},
where_clause = WhereClause {
gens: g,
it.name.as_ref().unwrap(),
t.generics,
where_clause = WhereClause { gens: &t.generics, indent: 0, end_newline: true },
- bounds = bounds(&t.bounds))?;
+ bounds = bounds(&t.bounds, false))?;
+
+ document(w, cx, it)?;
+
+ // Render any items associated directly to this alias, as otherwise they
+ // won't be visible anywhere in the docs. It would be nice to also show
+ // associated items from the aliased type (see discussion in #32077), but
+ // we need #14072 to make sense of the generics.
+ render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
+}
+
+fn item_trait_alias(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
+ t: &clean::TraitAlias) -> fmt::Result {
+ write!(w, "<pre class='rust trait-alias'>")?;
+ render_attributes(w, it)?;
+ write!(w, "trait {}{}{} = {};</pre>",
+ it.name.as_ref().unwrap(),
+ t.generics,
+ WhereClause { gens: &t.generics, indent: 0, end_newline: true },
+ bounds(&t.bounds, true))?;
document(w, cx, it)?;
ItemType::Existential => ("existentials", "Existentials"),
ItemType::ProcAttribute => ("attributes", "Attribute Macros"),
ItemType::ProcDerive => ("derives", "Derive Macros"),
+ ItemType::TraitAlias => ("trait-aliases", "Trait aliases"),
}
}
"keyword",
"existential",
"attr",
- "derive"];
+ "derive",
+ "traitalias"];
var search_input = document.getElementsByClassName("search-input")[0];
// 2 for "In Return Types"
var currentTab = 0;
- var themesWidth = null;
-
var titleBeforeSearch = document.title;
function getPageId() {
return String.fromCharCode(c);
}
- function displayHelp(display, ev) {
+ function displayHelp(display, ev, help) {
if (display === true) {
if (hasClass(help, "hidden")) {
ev.preventDefault();
hideModal();
var search = document.getElementById("search");
if (hasClass(help, "hidden") === false) {
- displayHelp(false, ev);
+ displayHelp(false, ev, help);
} else if (hasClass(search, "hidden") === false) {
ev.preventDefault();
addClass(search, "hidden");
case "s":
case "S":
- displayHelp(false, ev);
+ displayHelp(false, ev, help);
hideModal();
ev.preventDefault();
focusSearchBar();
case "?":
if (ev.shiftKey) {
hideModal();
- displayHelp(true, ev);
+ displayHelp(true, ev, help);
}
break;
}
return MAX_LEV_DISTANCE + 1;
}
}
- return lev_distance;//Math.ceil(total / done);
+ return Math.ceil(total / done);
}
}
return MAX_LEV_DISTANCE + 1;
block("type", "Type Definitions");
block("foreigntype", "Foreign Types");
block("keyword", "Keywords");
+ block("traitalias", "Trait Aliases");
}
window.initSidebarItems = initSidebarItems;
} else if (action === "hide") {
addClass(relatedDoc, "fns-now-collapsed");
addClass(docblock, "hidden-by-usual-hider");
- onEachLazy(toggle.childNodes, adjustToggle(true, dontApplyBlockRule);
+ onEachLazy(toggle.childNodes, adjustToggle(true, dontApplyBlockRule));
onEachLazy(relatedDoc.childNodes, implHider(true, dontApplyBlockRule));
}
}
// for vertical layout (column-oriented flex layout for divs caused
// errors in mobile browsers).
if (e.tagName === "H2" || e.tagName === "H3") {
- let nextTagName = e.nextElementSibling.tagName;
+ var nextTagName = e.nextElementSibling.tagName;
if (nextTagName == "H2" || nextTagName == "H3") {
e.nextElementSibling.style.display = "flex";
} else {
}
.content .highlighted a, .content .highlighted span { color: #eee !important; }
.content .highlighted.trait { background-color: #013191; }
+.content .highlighted.traitalias { background-color: #013191; }
.content .highlighted.mod,
.content .highlighted.externcrate { background-color: #afc6e4; }
.content .highlighted.mod { background-color: #803a1b; }
.content span.externcrate,
.content span.mod, .content a.mod, .block a.current.mod { color: #bda000; }
.content span.trait, .content a.trait, .block a.current.trait { color: #b78cf2; }
+.content span.traitalias, .content a.traitalias, .block a.current.traitalias { color: #b397da; }
.content span.fn, .content a.fn, .block a.current.fn,
.content span.method, .content a.method, .block a.current.method,
.content span.tymethod, .content a.tymethod, .block a.current.tymethod,
}
.content .highlighted a, .content .highlighted span { color: #000 !important; }
.content .highlighted.trait { background-color: #c7b6ff; }
+.content .highlighted.traitalias { background-color: #c7b6ff; }
.content .highlighted.mod,
.content .highlighted.externcrate { background-color: #afc6e4; }
.content .highlighted.enum { background-color: #b4d1b9; }
.content span.externcrate,
.content span.mod, .content a.mod, .block a.current.mod { color: #4d76ae; }
.content span.trait, .content a.trait, .block a.current.trait { color: #7c5af3; }
+.content span.traitalias, .content a.traitalias, .block a.current.traitalias { color: #6841f1; }
.content span.fn, .content a.fn, .block a.current.fn,
.content span.method, .content a.method, .block a.current.method,
.content span.tymethod, .content a.tymethod, .block a.current.tymethod,
}
- /// Convert into a true `Toc` struct.
+ /// Converts into a true `Toc` struct.
pub fn into_toc(mut self) -> Toc {
// we know all levels are >= 1.
self.fold_until(0);
#![feature(box_syntax)]
#![feature(nll)]
#![feature(set_stdio)]
-#![feature(slice_sort_by_cached_key)]
#![feature(test)]
#![feature(vec_remove_item)]
#![feature(ptr_offset_from)]
}
}
-/// Run any tests/code examples in the markdown file `input`.
+/// Runs any tests/code examples in the markdown file `input`.
pub fn test(mut options: Options, diag: &errors::Handler) -> isize {
let input_str = match load_string(&options.input, diag) {
Ok(s) => s,
}
}
- /// Resolve a given string as a path, along with whether or not it is
+ /// Resolves a given string as a path, along with whether or not it is
/// in the value namespace. Also returns an optional URL fragment in the case
/// of variants and methods.
fn resolve(&self,
}
}
-/// Resolve a string as a macro.
+/// Resolves a string as a macro.
fn macro_resolve(cx: &DocContext, path_str: &str) -> Option<Def> {
use syntax::ext::base::{MacroKind, SyntaxExtension};
let segment = ast::PathSegment::from_ident(Ident::from_str(path_str));
| clean::ConstantItem(..)
| clean::UnionItem(..)
| clean::AssociatedConstItem(..)
+ | clean::TraitAliasItem(..)
| clean::ForeignTypeItem => {
if i.def_id.is_local() {
if !self.access_levels.is_exported(i.def_id) {
}
}
-/// Return a span encompassing all the given attributes.
+/// Returns a span encompassing all the given attributes.
crate fn span_of_attrs(attrs: &clean::Attributes) -> Span {
if attrs.doc_strings.is_empty() {
return DUMMY_SP;
/// Cross-crate inlining occurs later on during crate cleaning
/// and follows different rules.
///
- /// Returns true if the target has been inlined.
+ /// Returns `true` if the target has been inlined.
fn maybe_inline_local(&mut self,
id: ast::NodeId,
def: Def,
};
om.traits.push(t);
},
- hir::ItemKind::TraitAlias(..) => {
- unimplemented!("trait objects are not yet implemented")
+ hir::ItemKind::TraitAlias(ref gen, ref b) => {
+ let t = TraitAlias {
+ name: ident.name,
+ generics: gen.clone(),
+ bounds: b.iter().cloned().collect(),
+ id: item.id,
+ attrs: item.attrs.clone(),
+ whence: item.span,
+ vis: item.vis.clone(),
+ stab: self.stability(item.id),
+ depr: self.deprecation(item.id),
+ };
+ om.trait_aliases.push(t);
},
hir::ItemKind::Impl(unsafety,
}
for item in self.cx.tcx.item_children(def_id).iter() {
- if self.cx.tcx.def_key(item.def.def_id()).parent.map_or(false, |d| d == def_id.index) ||
- item.vis == Visibility::Public {
- self.visit_item(item.def);
+ if let Some(def_id) = item.def.opt_def_id() {
+ if self.cx.tcx.def_key(def_id).parent.map_or(false, |d| d == def_id.index) ||
+ item.vis == Visibility::Public {
+ self.visit_item(item.def);
+ }
}
}
}
authors = ["The Rust Project Developers"]
name = "serialize"
version = "0.0.0"
+edition = "2018"
[lib]
name = "serialize"
use std::hash::{Hash, BuildHasher};
-use {Decodable, Encodable, Decoder, Encoder};
+use crate::{Decodable, Encodable, Decoder, Encoder};
use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet};
use std::rc::Rc;
use std::sync::Arc;
}
impl fmt::Display for FromHexError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
InvalidHexCharacter(ch, idx) =>
write!(f, "Invalid character '{}' at position {}", ch, idx),
impl FromHex for str {
- /// Convert any hexadecimal encoded string (literal, `@`, `&`, or `~`)
+ /// Converts any hexadecimal encoded string (literal, `@`, `&`, or `~`)
/// to the byte values it encodes.
///
/// You can use the `String::from_utf8` function to turn a
#[cfg(test)]
mod tests {
extern crate test;
- use self::test::Bencher;
- use hex::{FromHex, ToHex};
+ use test::Bencher;
+ use crate::hex::{FromHex, ToHex};
#[test]
pub fn test_to_hex() {
use std::str::FromStr;
use std::string;
use std::{char, f64, fmt, str};
-use std;
-use Encodable;
+use crate::Encodable;
/// Represents a json value
#[derive(Clone, PartialEq, PartialOrd, Debug)]
pub struct PrettyJson<'a> { inner: &'a Json }
-pub struct AsJson<'a, T: 'a> { inner: &'a T }
-pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<usize> }
+pub struct AsJson<'a, T> { inner: &'a T }
+pub struct AsPrettyJson<'a, T> { inner: &'a T, indent: Option<usize> }
/// The errors that can arise while parsing a JSON stream.
#[derive(Clone, Copy, PartialEq, Debug)]
}
/// Shortcut function to decode a JSON `&str` into an object
-pub fn decode<T: ::Decodable>(s: &str) -> DecodeResult<T> {
+pub fn decode<T: crate::Decodable>(s: &str) -> DecodeResult<T> {
let json = match from_str(s) {
Ok(x) => x,
Err(e) => return Err(ParseError(e))
};
let mut decoder = Decoder::new(json);
- ::Decodable::decode(&mut decoder)
+ crate::Decodable::decode(&mut decoder)
}
/// Shortcut function to encode a `T` into a JSON `String`
-pub fn encode<T: ::Encodable>(object: &T) -> Result<string::String, EncoderError> {
+pub fn encode<T: crate::Encodable>(object: &T) -> Result<string::String, EncoderError> {
let mut s = String::new();
{
let mut encoder = Encoder::new(&mut s);
}
impl fmt::Display for ErrorCode {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
error_str(*self).fmt(f)
}
}
}
impl fmt::Display for ParserError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// FIXME this should be a nicer error
fmt::Debug::fmt(self, f)
}
}
impl fmt::Display for DecoderError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// FIXME this should be a nicer error
fmt::Debug::fmt(self, f)
}
}
impl fmt::Display for EncoderError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// FIXME this should be a nicer error
fmt::Debug::fmt(self, f)
}
})
}
-impl<'a> ::Encoder for Encoder<'a> {
+impl<'a> crate::Encoder for Encoder<'a> {
type Error = EncoderError;
fn emit_unit(&mut self) -> EncodeResult {
}
}
- /// Set the number of spaces to indent for each level.
+ /// Sets the number of spaces to indent for each level.
/// This is safe to set during encoding.
pub fn set_indent(&mut self, indent: usize) {
// self.indent very well could be 0 so we need to use checked division.
}
}
-impl<'a> ::Encoder for PrettyEncoder<'a> {
+impl<'a> crate::Encoder for PrettyEncoder<'a> {
type Error = EncoderError;
fn emit_unit(&mut self) -> EncodeResult {
}
impl Encodable for Json {
- fn encode<E: ::Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
+ fn encode<E: crate::Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
match *self {
Json::I64(v) => v.encode(e),
Json::U64(v) => v.encode(e),
}
}
-/// Create an `AsJson` wrapper which can be used to print a value as JSON
+/// Creates an `AsJson` wrapper which can be used to print a value as JSON
/// on-the-fly via `write!`
-pub fn as_json<T>(t: &T) -> AsJson<T> {
+pub fn as_json<T>(t: &T) -> AsJson<'_, T> {
AsJson { inner: t }
}
-/// Create an `AsPrettyJson` wrapper which can be used to print a value as JSON
+/// Creates an `AsPrettyJson` wrapper which can be used to print a value as JSON
/// on-the-fly via `write!`
-pub fn as_pretty_json<T>(t: &T) -> AsPrettyJson<T> {
+pub fn as_pretty_json<T>(t: &T) -> AsPrettyJson<'_, T> {
AsPrettyJson { inner: t, indent: None }
}
impl Json {
/// Borrow this json object as a pretty object to generate a pretty
/// representation for it via `Display`.
- pub fn pretty(&self) -> PrettyJson {
+ pub fn pretty(&self) -> PrettyJson<'_> {
PrettyJson { inner: self }
}
}
/// Attempts to get a nested Json Object for each key in `keys`.
- /// If any key is found not to exist, find_path will return None.
+ /// If any key is found not to exist, `find_path` will return `None`.
/// Otherwise, it will return the Json value associated with the final key.
pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Json>{
let mut target = self;
/// If the Json value is an Object, performs a depth-first search until
/// a value associated with the provided key is found. If no value is found
- /// or the Json value is not an Object, returns None.
+ /// or the Json value is not an Object, returns `None`.
pub fn search<'a>(&'a self, key: &str) -> Option<&'a Json> {
match self {
&Json::Object(ref map) => {
}
}
- /// Returns true if the Json value is an Object. Returns false otherwise.
+ /// Returns `true` if the Json value is an `Object`.
pub fn is_object(&self) -> bool {
self.as_object().is_some()
}
- /// If the Json value is an Object, returns the associated BTreeMap.
- /// Returns None otherwise.
+ /// If the Json value is an `Object`, returns the associated `BTreeMap`;
+ /// returns `None` otherwise.
pub fn as_object(&self) -> Option<&Object> {
match *self {
Json::Object(ref map) => Some(map),
}
}
- /// Returns true if the Json value is an Array. Returns false otherwise.
+ /// Returns `true` if the Json value is an `Array`.
pub fn is_array(&self) -> bool {
self.as_array().is_some()
}
- /// If the Json value is an Array, returns the associated vector.
- /// Returns None otherwise.
+ /// If the Json value is an `Array`, returns the associated vector;
+ /// returns `None` otherwise.
pub fn as_array(&self) -> Option<&Array> {
match *self {
Json::Array(ref array) => Some(&*array),
}
}
- /// Returns true if the Json value is a String. Returns false otherwise.
+ /// Returns `true` if the Json value is a `String`.
pub fn is_string(&self) -> bool {
self.as_string().is_some()
}
- /// If the Json value is a String, returns the associated str.
- /// Returns None otherwise.
+ /// If the Json value is a `String`, returns the associated `str`;
+ /// returns `None` otherwise.
pub fn as_string(&self) -> Option<&str> {
match *self {
Json::String(ref s) => Some(&s[..]),
}
}
- /// Returns true if the Json value is a Number. Returns false otherwise.
+ /// Returns `true` if the Json value is a `Number`.
pub fn is_number(&self) -> bool {
match *self {
Json::I64(_) | Json::U64(_) | Json::F64(_) => true,
}
}
- /// Returns true if the Json value is a i64. Returns false otherwise.
+ /// Returns `true` if the Json value is a `i64`.
pub fn is_i64(&self) -> bool {
match *self {
Json::I64(_) => true,
}
}
- /// Returns true if the Json value is a u64. Returns false otherwise.
+ /// Returns `true` if the Json value is a `u64`.
pub fn is_u64(&self) -> bool {
match *self {
Json::U64(_) => true,
}
}
- /// Returns true if the Json value is a f64. Returns false otherwise.
+ /// Returns `true` if the Json value is a `f64`.
pub fn is_f64(&self) -> bool {
match *self {
Json::F64(_) => true,
}
}
- /// If the Json value is a number, return or cast it to a i64.
- /// Returns None otherwise.
+ /// If the Json value is a number, returns or cast it to a `i64`;
+ /// returns `None` otherwise.
pub fn as_i64(&self) -> Option<i64> {
match *self {
Json::I64(n) => Some(n),
}
}
- /// If the Json value is a number, return or cast it to a u64.
- /// Returns None otherwise.
+ /// If the Json value is a number, returns or cast it to a `u64`;
+ /// returns `None` otherwise.
pub fn as_u64(&self) -> Option<u64> {
match *self {
Json::I64(n) => Some(n as u64),
}
}
- /// If the Json value is a number, return or cast it to a f64.
- /// Returns None otherwise.
+ /// If the Json value is a number, returns or cast it to a `f64`;
+ /// returns `None` otherwise.
pub fn as_f64(&self) -> Option<f64> {
match *self {
Json::I64(n) => Some(n as f64),
}
}
- /// Returns true if the Json value is a Boolean. Returns false otherwise.
+ /// Returns `true` if the Json value is a `Boolean`.
pub fn is_boolean(&self) -> bool {
self.as_boolean().is_some()
}
- /// If the Json value is a Boolean, returns the associated bool.
- /// Returns None otherwise.
+ /// If the Json value is a `Boolean`, returns the associated `bool`;
+ /// returns `None` otherwise.
pub fn as_boolean(&self) -> Option<bool> {
match *self {
Json::Boolean(b) => Some(b),
}
}
- /// Returns true if the Json value is a Null. Returns false otherwise.
+ /// Returns `true` if the Json value is a `Null`.
pub fn is_null(&self) -> bool {
self.as_null().is_some()
}
- /// If the Json value is a Null, returns ().
- /// Returns None otherwise.
+ /// If the Json value is a `Null`, returns `()`;
+ /// returns `None` otherwise.
pub fn as_null(&self) -> Option<()> {
match *self {
Json::Null => Some(()),
/// Returns The number of elements in the Stack.
pub fn len(&self) -> usize { self.stack.len() }
- /// Returns true if the stack is empty.
+ /// Returns `true` if the stack is empty.
pub fn is_empty(&self) -> bool { self.stack.is_empty() }
/// Provides access to the StackElement at a given index.
/// lower indices are at the bottom of the stack while higher indices are
/// at the top.
- pub fn get(&self, idx: usize) -> StackElement {
+ pub fn get(&self, idx: usize) -> StackElement<'_> {
match self.stack[idx] {
InternalIndex(i) => StackElement::Index(i),
InternalKey(start, size) => {
}
}
- /// Compares this stack with an array of StackElements.
- pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
+ /// Compares this stack with an array of StackElement<'_>s.
+ pub fn is_equal_to(&self, rhs: &[StackElement<'_>]) -> bool {
if self.stack.len() != rhs.len() { return false; }
for (i, r) in rhs.iter().enumerate() {
if self.get(i) != *r { return false; }
true
}
- /// Returns true if the bottom-most elements of this stack are the same as
+ /// Returns `true` if the bottom-most elements of this stack are the same as
/// the ones passed as parameter.
- pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
+ pub fn starts_with(&self, rhs: &[StackElement<'_>]) -> bool {
if self.stack.len() < rhs.len() { return false; }
for (i, r) in rhs.iter().enumerate() {
if self.get(i) != *r { return false; }
true
}
- /// Returns true if the top-most elements of this stack are the same as
+ /// Returns `true` if the top-most elements of this stack are the same as
/// the ones passed as parameter.
- pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
+ pub fn ends_with(&self, rhs: &[StackElement<'_>]) -> bool {
if self.stack.len() < rhs.len() { return false; }
let offset = self.stack.len() - rhs.len();
for (i, r) in rhs.iter().enumerate() {
}
/// Returns the top-most element (if any).
- pub fn top(&self) -> Option<StackElement> {
+ pub fn top(&self) -> Option<StackElement<'_>> {
match self.stack.last() {
None => None,
Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
}
impl<T: Iterator<Item=char>> Builder<T> {
- /// Create a JSON Builder.
+ /// Creates a JSON Builder.
pub fn new(src: T) -> Builder<T> {
Builder { parser: Parser::new(src), token: None, }
}
}
}
-impl ::Decoder for Decoder {
+impl crate::Decoder for Decoder {
type Error = DecoderError;
fn read_nil(&mut self) -> DecodeResult<()> {
Err(ExpectedError("single character string".to_owned(), s.to_string()))
}
- fn read_str(&mut self) -> DecodeResult<Cow<str>> {
+ fn read_str(&mut self) -> DecodeResult<Cow<'_, str>> {
expect!(self.pop(), String).map(Cow::Owned)
}
impl fmt::Display for Json {
/// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut shim = FormatShim { inner: f };
let mut encoder = Encoder::new(&mut shim);
match self.encode(&mut encoder) {
impl<'a> fmt::Display for PrettyJson<'a> {
/// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut shim = FormatShim { inner: f };
let mut encoder = PrettyEncoder::new(&mut shim);
match self.inner.encode(&mut encoder) {
impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> {
/// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut shim = FormatShim { inner: f };
let mut encoder = Encoder::new(&mut shim);
match self.inner.encode(&mut encoder) {
}
impl<'a, T> AsPrettyJson<'a, T> {
- /// Set the indentation level for the emitted JSON
+ /// Sets the indentation level for the emitted JSON
pub fn indent(mut self, indent: usize) -> AsPrettyJson<'a, T> {
self.indent = Some(indent);
self
impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> {
/// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut shim = FormatShim { inner: f };
let mut encoder = PrettyEncoder::new(&mut shim);
if let Some(n) = self.indent {
#[cfg(test)]
mod tests {
+ // Benchmarks and tests that require private items
+
extern crate test;
- use self::Animal::*;
- use self::test::Bencher;
- use {Encodable, Decodable};
- use super::Json::*;
- use super::ErrorCode::*;
- use super::ParserError::*;
- use super::DecoderError::*;
- use super::JsonEvent::*;
- use super::{Json, from_str, DecodeResult, DecoderError, JsonEvent, Parser,
- StackElement, Stack, Decoder, Encoder, EncoderError};
- use std::{i64, u64, f32, f64};
- use std::io::prelude::*;
- use std::collections::BTreeMap;
+ use test::Bencher;
+ use super::{from_str, Parser, StackElement, Stack};
use std::string;
- #[derive(RustcDecodable, Eq, PartialEq, Debug)]
- struct OptionData {
- opt: Option<usize>,
- }
-
- #[test]
- fn test_decode_option_none() {
- let s ="{}";
- let obj: OptionData = super::decode(s).unwrap();
- assert_eq!(obj, OptionData { opt: None });
- }
-
- #[test]
- fn test_decode_option_some() {
- let s = "{ \"opt\": 10 }";
- let obj: OptionData = super::decode(s).unwrap();
- assert_eq!(obj, OptionData { opt: Some(10) });
- }
-
- #[test]
- fn test_decode_option_malformed() {
- check_err::<OptionData>("{ \"opt\": [] }",
- ExpectedError("Number".to_string(), "[]".to_string()));
- check_err::<OptionData>("{ \"opt\": false }",
- ExpectedError("Number".to_string(), "false".to_string()));
- }
-
- #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
- enum Animal {
- Dog,
- Frog(string::String, isize)
- }
-
- #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
- struct Inner {
- a: (),
- b: usize,
- c: Vec<string::String>,
- }
-
- #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
- struct Outer {
- inner: Vec<Inner>,
- }
-
- fn mk_object(items: &[(string::String, Json)]) -> Json {
- let mut d = BTreeMap::new();
-
- for item in items {
- match *item {
- (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
- }
- };
-
- Object(d)
- }
-
- #[test]
- fn test_from_str_trait() {
- let s = "null";
- assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
- }
-
- #[test]
- fn test_write_null() {
- assert_eq!(Null.to_string(), "null");
- assert_eq!(Null.pretty().to_string(), "null");
- }
-
- #[test]
- fn test_write_i64() {
- assert_eq!(U64(0).to_string(), "0");
- assert_eq!(U64(0).pretty().to_string(), "0");
-
- assert_eq!(U64(1234).to_string(), "1234");
- assert_eq!(U64(1234).pretty().to_string(), "1234");
-
- assert_eq!(I64(-5678).to_string(), "-5678");
- assert_eq!(I64(-5678).pretty().to_string(), "-5678");
-
- assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
- assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
- }
-
- #[test]
- fn test_write_f64() {
- assert_eq!(F64(3.0).to_string(), "3.0");
- assert_eq!(F64(3.0).pretty().to_string(), "3.0");
-
- assert_eq!(F64(3.1).to_string(), "3.1");
- assert_eq!(F64(3.1).pretty().to_string(), "3.1");
-
- assert_eq!(F64(-1.5).to_string(), "-1.5");
- assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
-
- assert_eq!(F64(0.5).to_string(), "0.5");
- assert_eq!(F64(0.5).pretty().to_string(), "0.5");
-
- assert_eq!(F64(f64::NAN).to_string(), "null");
- assert_eq!(F64(f64::NAN).pretty().to_string(), "null");
-
- assert_eq!(F64(f64::INFINITY).to_string(), "null");
- assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null");
-
- assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null");
- assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null");
- }
-
- #[test]
- fn test_write_str() {
- assert_eq!(String("".to_string()).to_string(), "\"\"");
- assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
-
- assert_eq!(String("homura".to_string()).to_string(), "\"homura\"");
- assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\"");
- }
-
- #[test]
- fn test_write_bool() {
- assert_eq!(Boolean(true).to_string(), "true");
- assert_eq!(Boolean(true).pretty().to_string(), "true");
-
- assert_eq!(Boolean(false).to_string(), "false");
- assert_eq!(Boolean(false).pretty().to_string(), "false");
- }
-
- #[test]
- fn test_write_array() {
- assert_eq!(Array(vec![]).to_string(), "[]");
- assert_eq!(Array(vec![]).pretty().to_string(), "[]");
-
- assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
- assert_eq!(
- Array(vec![Boolean(true)]).pretty().to_string(),
- "\
- [\n \
- true\n\
- ]"
- );
-
- let long_test_array = Array(vec![
- Boolean(false),
- Null,
- Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
-
- assert_eq!(long_test_array.to_string(),
- "[false,null,[\"foo\\nbar\",3.5]]");
- assert_eq!(
- long_test_array.pretty().to_string(),
- "\
- [\n \
- false,\n \
- null,\n \
- [\n \
- \"foo\\nbar\",\n \
- 3.5\n \
- ]\n\
- ]"
- );
- }
-
- #[test]
- fn test_write_object() {
- assert_eq!(mk_object(&[]).to_string(), "{}");
- assert_eq!(mk_object(&[]).pretty().to_string(), "{}");
-
- assert_eq!(
- mk_object(&[
- ("a".to_string(), Boolean(true))
- ]).to_string(),
- "{\"a\":true}"
- );
- assert_eq!(
- mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(),
- "\
- {\n \
- \"a\": true\n\
- }"
- );
-
- let complex_obj = mk_object(&[
- ("b".to_string(), Array(vec![
- mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
- mk_object(&[("d".to_string(), String("".to_string()))])
- ]))
- ]);
-
- assert_eq!(
- complex_obj.to_string(),
- "{\
- \"b\":[\
- {\"c\":\"\\f\\r\"},\
- {\"d\":\"\"}\
- ]\
- }"
- );
- assert_eq!(
- complex_obj.pretty().to_string(),
- "\
- {\n \
- \"b\": [\n \
- {\n \
- \"c\": \"\\f\\r\"\n \
- },\n \
- {\n \
- \"d\": \"\"\n \
- }\n \
- ]\n\
- }"
- );
-
- let a = mk_object(&[
- ("a".to_string(), Boolean(true)),
- ("b".to_string(), Array(vec![
- mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
- mk_object(&[("d".to_string(), String("".to_string()))])
- ]))
- ]);
-
- // We can't compare the strings directly because the object fields be
- // printed in a different order.
- assert_eq!(a.clone(), a.to_string().parse().unwrap());
- assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
- }
-
- #[test]
- fn test_write_enum() {
- let animal = Dog;
- assert_eq!(
- super::as_json(&animal).to_string(),
- "\"Dog\""
- );
- assert_eq!(
- super::as_pretty_json(&animal).to_string(),
- "\"Dog\""
- );
-
- let animal = Frog("Henry".to_string(), 349);
- assert_eq!(
- super::as_json(&animal).to_string(),
- "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
- );
- assert_eq!(
- super::as_pretty_json(&animal).to_string(),
- "{\n \
- \"variant\": \"Frog\",\n \
- \"fields\": [\n \
- \"Henry\",\n \
- 349\n \
- ]\n\
- }"
- );
- }
-
- macro_rules! check_encoder_for_simple {
- ($value:expr, $expected:expr) => ({
- let s = super::as_json(&$value).to_string();
- assert_eq!(s, $expected);
-
- let s = super::as_pretty_json(&$value).to_string();
- assert_eq!(s, $expected);
- })
- }
-
- #[test]
- fn test_write_some() {
- check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\"");
- }
-
- #[test]
- fn test_write_none() {
- check_encoder_for_simple!(None::<string::String>, "null");
- }
-
- #[test]
- fn test_write_char() {
- check_encoder_for_simple!('a', "\"a\"");
- check_encoder_for_simple!('\t', "\"\\t\"");
- check_encoder_for_simple!('\u{0000}', "\"\\u0000\"");
- check_encoder_for_simple!('\u{001b}', "\"\\u001b\"");
- check_encoder_for_simple!('\u{007f}', "\"\\u007f\"");
- check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
- check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
- check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\"");
- }
-
- #[test]
- fn test_trailing_characters() {
- assert_eq!(from_str("nulla"), Err(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(from_str("truea"), Err(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
- assert_eq!(from_str("1a"), Err(SyntaxError(TrailingCharacters, 1, 2)));
- assert_eq!(from_str("[]a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
- assert_eq!(from_str("{}a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
- }
-
- #[test]
- fn test_read_identifiers() {
- assert_eq!(from_str("n"), Err(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(from_str("nul"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(from_str("t"), Err(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(from_str("f"), Err(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(from_str("faz"), Err(SyntaxError(InvalidSyntax, 1, 3)));
-
- assert_eq!(from_str("null"), Ok(Null));
- assert_eq!(from_str("true"), Ok(Boolean(true)));
- assert_eq!(from_str("false"), Ok(Boolean(false)));
- assert_eq!(from_str(" null "), Ok(Null));
- assert_eq!(from_str(" true "), Ok(Boolean(true)));
- assert_eq!(from_str(" false "), Ok(Boolean(false)));
- }
-
- #[test]
- fn test_decode_identifiers() {
- let v: () = super::decode("null").unwrap();
- assert_eq!(v, ());
-
- let v: bool = super::decode("true").unwrap();
- assert_eq!(v, true);
-
- let v: bool = super::decode("false").unwrap();
- assert_eq!(v, false);
- }
-
- #[test]
- fn test_read_number() {
- assert_eq!(from_str("+"), Err(SyntaxError(InvalidSyntax, 1, 1)));
- assert_eq!(from_str("."), Err(SyntaxError(InvalidSyntax, 1, 1)));
- assert_eq!(from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
- assert_eq!(from_str("-"), Err(SyntaxError(InvalidNumber, 1, 2)));
- assert_eq!(from_str("00"), Err(SyntaxError(InvalidNumber, 1, 2)));
- assert_eq!(from_str("1."), Err(SyntaxError(InvalidNumber, 1, 3)));
- assert_eq!(from_str("1e"), Err(SyntaxError(InvalidNumber, 1, 3)));
- assert_eq!(from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
-
- assert_eq!(from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
- assert_eq!(from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
-
- assert_eq!(from_str("3"), Ok(U64(3)));
- assert_eq!(from_str("3.1"), Ok(F64(3.1)));
- assert_eq!(from_str("-1.2"), Ok(F64(-1.2)));
- assert_eq!(from_str("0.4"), Ok(F64(0.4)));
- assert_eq!(from_str("0.4e5"), Ok(F64(0.4e5)));
- assert_eq!(from_str("0.4e+15"), Ok(F64(0.4e15)));
- assert_eq!(from_str("0.4e-01"), Ok(F64(0.4e-01)));
- assert_eq!(from_str(" 3 "), Ok(U64(3)));
-
- assert_eq!(from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
- assert_eq!(from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
- assert_eq!(from_str("18446744073709551615"), Ok(U64(u64::MAX)));
- }
-
- #[test]
- fn test_decode_numbers() {
- let v: f64 = super::decode("3").unwrap();
- assert_eq!(v, 3.0);
-
- let v: f64 = super::decode("3.1").unwrap();
- assert_eq!(v, 3.1);
-
- let v: f64 = super::decode("-1.2").unwrap();
- assert_eq!(v, -1.2);
-
- let v: f64 = super::decode("0.4").unwrap();
- assert_eq!(v, 0.4);
-
- let v: f64 = super::decode("0.4e5").unwrap();
- assert_eq!(v, 0.4e5);
-
- let v: f64 = super::decode("0.4e15").unwrap();
- assert_eq!(v, 0.4e15);
-
- let v: f64 = super::decode("0.4e-01").unwrap();
- assert_eq!(v, 0.4e-01);
-
- let v: u64 = super::decode("0").unwrap();
- assert_eq!(v, 0);
-
- let v: u64 = super::decode("18446744073709551615").unwrap();
- assert_eq!(v, u64::MAX);
-
- let v: i64 = super::decode("-9223372036854775808").unwrap();
- assert_eq!(v, i64::MIN);
-
- let v: i64 = super::decode("9223372036854775807").unwrap();
- assert_eq!(v, i64::MAX);
-
- let res: DecodeResult<i64> = super::decode("765.25");
- assert_eq!(res, Err(ExpectedError("Integer".to_string(),
- "765.25".to_string())));
- }
-
- #[test]
- fn test_read_str() {
- assert_eq!(from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2)));
- assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
-
- assert_eq!(from_str("\"\""), Ok(String("".to_string())));
- assert_eq!(from_str("\"foo\""), Ok(String("foo".to_string())));
- assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string())));
- assert_eq!(from_str("\"\\b\""), Ok(String("\x08".to_string())));
- assert_eq!(from_str("\"\\n\""), Ok(String("\n".to_string())));
- assert_eq!(from_str("\"\\r\""), Ok(String("\r".to_string())));
- assert_eq!(from_str("\"\\t\""), Ok(String("\t".to_string())));
- assert_eq!(from_str(" \"foo\" "), Ok(String("foo".to_string())));
- assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string())));
- assert_eq!(from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string())));
- }
-
- #[test]
- fn test_decode_str() {
- let s = [("\"\"", ""),
- ("\"foo\"", "foo"),
- ("\"\\\"\"", "\""),
- ("\"\\b\"", "\x08"),
- ("\"\\n\"", "\n"),
- ("\"\\r\"", "\r"),
- ("\"\\t\"", "\t"),
- ("\"\\u12ab\"", "\u{12ab}"),
- ("\"\\uAB12\"", "\u{AB12}")];
-
- for &(i, o) in &s {
- let v: string::String = super::decode(i).unwrap();
- assert_eq!(v, o);
- }
- }
-
- #[test]
- fn test_read_array() {
- assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
- assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
- assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
- assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
-
- assert_eq!(from_str("[]"), Ok(Array(vec![])));
- assert_eq!(from_str("[ ]"), Ok(Array(vec![])));
- assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)])));
- assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
- assert_eq!(from_str("[null]"), Ok(Array(vec![Null])));
- assert_eq!(from_str("[3, 1]"),
- Ok(Array(vec![U64(3), U64(1)])));
- assert_eq!(from_str("\n[3, 2]\n"),
- Ok(Array(vec![U64(3), U64(2)])));
- assert_eq!(from_str("[2, [4, 1]]"),
- Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
- }
-
- #[test]
- fn test_decode_array() {
- let v: Vec<()> = super::decode("[]").unwrap();
- assert_eq!(v, []);
-
- let v: Vec<()> = super::decode("[null]").unwrap();
- assert_eq!(v, [()]);
-
- let v: Vec<bool> = super::decode("[true]").unwrap();
- assert_eq!(v, [true]);
-
- let v: Vec<isize> = super::decode("[3, 1]").unwrap();
- assert_eq!(v, [3, 1]);
-
- let v: Vec<Vec<usize>> = super::decode("[[3], [1, 2]]").unwrap();
- assert_eq!(v, [vec![3], vec![1, 2]]);
- }
-
- #[test]
- fn test_decode_tuple() {
- let t: (usize, usize, usize) = super::decode("[1, 2, 3]").unwrap();
- assert_eq!(t, (1, 2, 3));
-
- let t: (usize, string::String) = super::decode("[1, \"two\"]").unwrap();
- assert_eq!(t, (1, "two".to_string()));
- }
-
- #[test]
- fn test_decode_tuple_malformed_types() {
- assert!(super::decode::<(usize, string::String)>("[1, 2]").is_err());
- }
-
- #[test]
- fn test_decode_tuple_malformed_length() {
- assert!(super::decode::<(usize, usize)>("[1, 2, 3]").is_err());
- }
-
- #[test]
- fn test_read_object() {
- assert_eq!(from_str("{"), Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
- assert_eq!(from_str("{ "), Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
- assert_eq!(from_str("{1"), Err(SyntaxError(KeyMustBeAString, 1, 2)));
- assert_eq!(from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
- assert_eq!(from_str("{\"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
- assert_eq!(from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
-
- assert_eq!(from_str("{\"a\" 1"), Err(SyntaxError(ExpectedColon, 1, 6)));
- assert_eq!(from_str("{\"a\":"), Err(SyntaxError(EOFWhileParsingValue, 1, 6)));
- assert_eq!(from_str("{\"a\":1"), Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
- assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8)));
- assert_eq!(from_str("{\"a\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
-
- assert_eq!(from_str("{}").unwrap(), mk_object(&[]));
- assert_eq!(from_str("{\"a\": 3}").unwrap(),
- mk_object(&[("a".to_string(), U64(3))]));
-
- assert_eq!(from_str(
- "{ \"a\": null, \"b\" : true }").unwrap(),
- mk_object(&[
- ("a".to_string(), Null),
- ("b".to_string(), Boolean(true))]));
- assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
- mk_object(&[
- ("a".to_string(), Null),
- ("b".to_string(), Boolean(true))]));
- assert_eq!(from_str(
- "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
- mk_object(&[
- ("a".to_string(), F64(1.0)),
- ("b".to_string(), Array(vec![Boolean(true)]))
- ]));
- assert_eq!(from_str(
- "{\
- \"a\": 1.0, \
- \"b\": [\
- true,\
- \"foo\\nbar\", \
- { \"c\": {\"d\": null} } \
- ]\
- }").unwrap(),
- mk_object(&[
- ("a".to_string(), F64(1.0)),
- ("b".to_string(), Array(vec![
- Boolean(true),
- String("foo\nbar".to_string()),
- mk_object(&[
- ("c".to_string(), mk_object(&[("d".to_string(), Null)]))
- ])
- ]))
- ]));
- }
-
- #[test]
- fn test_decode_struct() {
- let s = "{
- \"inner\": [
- { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
- ]
- }";
-
- let v: Outer = super::decode(s).unwrap();
- assert_eq!(
- v,
- Outer {
- inner: vec![
- Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
- ]
- }
- );
- }
-
- #[derive(RustcDecodable)]
- struct FloatStruct {
- f: f64,
- a: Vec<f64>
- }
- #[test]
- fn test_decode_struct_with_nan() {
- let s = "{\"f\":null,\"a\":[null,123]}";
- let obj: FloatStruct = super::decode(s).unwrap();
- assert!(obj.f.is_nan());
- assert!(obj.a[0].is_nan());
- assert_eq!(obj.a[1], 123f64);
- }
-
- #[test]
- fn test_decode_option() {
- let value: Option<string::String> = super::decode("null").unwrap();
- assert_eq!(value, None);
-
- let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
- assert_eq!(value, Some("jodhpurs".to_string()));
- }
-
- #[test]
- fn test_decode_enum() {
- let value: Animal = super::decode("\"Dog\"").unwrap();
- assert_eq!(value, Dog);
-
- let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
- let value: Animal = super::decode(s).unwrap();
- assert_eq!(value, Frog("Henry".to_string(), 349));
- }
-
- #[test]
- fn test_decode_map() {
- let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
- \"fields\":[\"Henry\", 349]}}";
- let mut map: BTreeMap<string::String, Animal> = super::decode(s).unwrap();
-
- assert_eq!(map.remove(&"a".to_string()), Some(Dog));
- assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
- }
-
- #[test]
- fn test_multiline_errors() {
- assert_eq!(from_str("{\n \"foo\":\n \"bar\""),
- Err(SyntaxError(EOFWhileParsingObject, 3, 8)));
- }
-
- #[derive(RustcDecodable)]
- #[allow(dead_code)]
- struct DecodeStruct {
- x: f64,
- y: bool,
- z: string::String,
- w: Vec<DecodeStruct>
- }
- #[derive(RustcDecodable)]
- enum DecodeEnum {
- A(f64),
- B(string::String)
- }
- fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) {
- let res: DecodeResult<T> = match from_str(to_parse) {
- Err(e) => Err(ParseError(e)),
- Ok(json) => Decodable::decode(&mut Decoder::new(json))
- };
- match res {
- Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`",
- to_parse, expected),
- Err(ParseError(e)) => panic!("`{:?}` is not valid json: {:?}",
- to_parse, e),
- Err(e) => {
- assert_eq!(e, expected);
- }
- }
- }
- #[test]
- fn test_decode_errors_struct() {
- check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
- check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
- ExpectedError("Number".to_string(), "true".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
- ExpectedError("Boolean".to_string(), "[]".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
- ExpectedError("String".to_string(), "{}".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
- ExpectedError("Array".to_string(), "null".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
- MissingFieldError("w".to_string()));
- }
- #[test]
- fn test_decode_errors_enum() {
- check_err::<DecodeEnum>("{}",
- MissingFieldError("variant".to_string()));
- check_err::<DecodeEnum>("{\"variant\": 1}",
- ExpectedError("String".to_string(), "1".to_string()));
- check_err::<DecodeEnum>("{\"variant\": \"A\"}",
- MissingFieldError("fields".to_string()));
- check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
- ExpectedError("Array".to_string(), "null".to_string()));
- check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
- UnknownVariantError("C".to_string()));
- }
-
- #[test]
- fn test_find(){
- let json_value = from_str("{\"dog\" : \"cat\"}").unwrap();
- let found_str = json_value.find("dog");
- assert!(found_str.unwrap().as_string().unwrap() == "cat");
- }
-
- #[test]
- fn test_find_path(){
- let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
- let found_str = json_value.find_path(&["dog", "cat", "mouse"]);
- assert!(found_str.unwrap().as_string().unwrap() == "cheese");
- }
-
- #[test]
- fn test_search(){
- let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
- let found_str = json_value.search("mouse").and_then(|j| j.as_string());
- assert!(found_str.unwrap() == "cheese");
- }
-
- #[test]
- fn test_index(){
- let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
- let ref array = json_value["animals"];
- assert_eq!(array[0].as_string().unwrap(), "dog");
- assert_eq!(array[1].as_string().unwrap(), "cat");
- assert_eq!(array[2].as_string().unwrap(), "mouse");
- }
-
- #[test]
- fn test_is_object(){
- let json_value = from_str("{}").unwrap();
- assert!(json_value.is_object());
- }
-
- #[test]
- fn test_as_object(){
- let json_value = from_str("{}").unwrap();
- let json_object = json_value.as_object();
- assert!(json_object.is_some());
- }
-
- #[test]
- fn test_is_array(){
- let json_value = from_str("[1, 2, 3]").unwrap();
- assert!(json_value.is_array());
- }
-
- #[test]
- fn test_as_array(){
- let json_value = from_str("[1, 2, 3]").unwrap();
- let json_array = json_value.as_array();
- let expected_length = 3;
- assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
- }
-
- #[test]
- fn test_is_string(){
- let json_value = from_str("\"dog\"").unwrap();
- assert!(json_value.is_string());
- }
-
- #[test]
- fn test_as_string(){
- let json_value = from_str("\"dog\"").unwrap();
- let json_str = json_value.as_string();
- let expected_str = "dog";
- assert_eq!(json_str, Some(expected_str));
- }
-
- #[test]
- fn test_is_number(){
- let json_value = from_str("12").unwrap();
- assert!(json_value.is_number());
- }
-
- #[test]
- fn test_is_i64(){
- let json_value = from_str("-12").unwrap();
- assert!(json_value.is_i64());
-
- let json_value = from_str("12").unwrap();
- assert!(!json_value.is_i64());
-
- let json_value = from_str("12.0").unwrap();
- assert!(!json_value.is_i64());
- }
-
- #[test]
- fn test_is_u64(){
- let json_value = from_str("12").unwrap();
- assert!(json_value.is_u64());
-
- let json_value = from_str("-12").unwrap();
- assert!(!json_value.is_u64());
-
- let json_value = from_str("12.0").unwrap();
- assert!(!json_value.is_u64());
- }
-
- #[test]
- fn test_is_f64(){
- let json_value = from_str("12").unwrap();
- assert!(!json_value.is_f64());
-
- let json_value = from_str("-12").unwrap();
- assert!(!json_value.is_f64());
-
- let json_value = from_str("12.0").unwrap();
- assert!(json_value.is_f64());
-
- let json_value = from_str("-12.0").unwrap();
- assert!(json_value.is_f64());
- }
-
- #[test]
- fn test_as_i64(){
- let json_value = from_str("-12").unwrap();
- let json_num = json_value.as_i64();
- assert_eq!(json_num, Some(-12));
- }
-
- #[test]
- fn test_as_u64(){
- let json_value = from_str("12").unwrap();
- let json_num = json_value.as_u64();
- assert_eq!(json_num, Some(12));
- }
-
- #[test]
- fn test_as_f64(){
- let json_value = from_str("12.0").unwrap();
- let json_num = json_value.as_f64();
- assert_eq!(json_num, Some(12f64));
- }
-
- #[test]
- fn test_is_boolean(){
- let json_value = from_str("false").unwrap();
- assert!(json_value.is_boolean());
- }
-
- #[test]
- fn test_as_boolean(){
- let json_value = from_str("false").unwrap();
- let json_bool = json_value.as_boolean();
- let expected_bool = false;
- assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
- }
-
- #[test]
- fn test_is_null(){
- let json_value = from_str("null").unwrap();
- assert!(json_value.is_null());
- }
-
- #[test]
- fn test_as_null(){
- let json_value = from_str("null").unwrap();
- let json_null = json_value.as_null();
- let expected_null = ();
- assert!(json_null.is_some() && json_null.unwrap() == expected_null);
- }
-
- #[test]
- fn test_encode_hashmap_with_numeric_key() {
- use std::str::from_utf8;
- use std::collections::HashMap;
- let mut hm: HashMap<usize, bool> = HashMap::new();
- hm.insert(1, true);
- let mut mem_buf = Vec::new();
- write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
- let json_str = from_utf8(&mem_buf[..]).unwrap();
- match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
- _ => {} // it parsed and we are good to go
- }
- }
-
- #[test]
- fn test_prettyencode_hashmap_with_numeric_key() {
- use std::str::from_utf8;
- use std::collections::HashMap;
- let mut hm: HashMap<usize, bool> = HashMap::new();
- hm.insert(1, true);
- let mut mem_buf = Vec::new();
- write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
- let json_str = from_utf8(&mem_buf[..]).unwrap();
- match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
- _ => {} // it parsed and we are good to go
- }
- }
-
- #[test]
- fn test_prettyencoder_indent_level_param() {
- use std::str::from_utf8;
- use std::collections::BTreeMap;
-
- let mut tree = BTreeMap::new();
-
- tree.insert("hello".to_string(), String("guten tag".to_string()));
- tree.insert("goodbye".to_string(), String("sayonara".to_string()));
-
- let json = Array(
- // The following layout below should look a lot like
- // the pretty-printed JSON (indent * x)
- vec!
- ( // 0x
- String("greetings".to_string()), // 1x
- Object(tree), // 1x + 2x + 2x + 1x
- ) // 0x
- // End JSON array (7 lines)
- );
-
- // Helper function for counting indents
- fn indents(source: &str) -> usize {
- let trimmed = source.trim_start_matches(' ');
- source.len() - trimmed.len()
- }
-
- // Test up to 4 spaces of indents (more?)
- for i in 0..4 {
- let mut writer = Vec::new();
- write!(&mut writer, "{}",
- super::as_pretty_json(&json).indent(i)).unwrap();
-
- let printed = from_utf8(&writer[..]).unwrap();
-
- // Check for indents at each line
- let lines: Vec<&str> = printed.lines().collect();
- assert_eq!(lines.len(), 7); // JSON should be 7 lines
-
- assert_eq!(indents(lines[0]), 0 * i); // [
- assert_eq!(indents(lines[1]), 1 * i); // "greetings",
- assert_eq!(indents(lines[2]), 1 * i); // {
- assert_eq!(indents(lines[3]), 2 * i); // "hello": "guten tag",
- assert_eq!(indents(lines[4]), 2 * i); // "goodbye": "sayonara"
- assert_eq!(indents(lines[5]), 1 * i); // },
- assert_eq!(indents(lines[6]), 0 * i); // ]
-
- // Finally, test that the pretty-printed JSON is valid
- from_str(printed).ok().expect("Pretty-printed JSON is invalid!");
- }
- }
-
- #[test]
- fn test_hashmap_with_enum_key() {
- use std::collections::HashMap;
- use json;
- #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)]
- enum Enum {
- Foo,
- #[allow(dead_code)]
- Bar,
- }
- let mut map = HashMap::new();
- map.insert(Enum::Foo, 0);
- let result = json::encode(&map).unwrap();
- assert_eq!(&result[..], r#"{"Foo":0}"#);
- let decoded: HashMap<Enum, _> = json::decode(&result).unwrap();
- assert_eq!(map, decoded);
- }
-
- #[test]
- fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
- use std::collections::HashMap;
- use Decodable;
- let json_str = "{\"1\":true}";
- let json_obj = match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
- Ok(o) => o
- };
- let mut decoder = Decoder::new(json_obj);
- let _hm: HashMap<usize, bool> = Decodable::decode(&mut decoder).unwrap();
- }
-
- #[test]
- fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
- use std::collections::HashMap;
- use Decodable;
- let json_str = "{\"a\":true}";
- let json_obj = match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
- Ok(o) => o
- };
- let mut decoder = Decoder::new(json_obj);
- let result: Result<HashMap<usize, bool>, DecoderError> = Decodable::decode(&mut decoder);
- assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
- }
-
- fn assert_stream_equal(src: &str,
- expected: Vec<(JsonEvent, Vec<StackElement>)>) {
- let mut parser = Parser::new(src.chars());
- let mut i = 0;
- loop {
- let evt = match parser.next() {
- Some(e) => e,
- None => { break; }
- };
- let (ref expected_evt, ref expected_stack) = expected[i];
- if !parser.stack().is_equal_to(expected_stack) {
- panic!("Parser stack is not equal to {:?}", expected_stack);
- }
- assert_eq!(&evt, expected_evt);
- i+=1;
- }
- }
- #[test]
- fn test_streaming_parser() {
- assert_stream_equal(
- r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
- vec![
- (ObjectStart, vec![]),
- (StringValue("bar".to_string()), vec![StackElement::Key("foo")]),
- (ArrayStart, vec![StackElement::Key("array")]),
- (U64Value(0), vec![StackElement::Key("array"), StackElement::Index(0)]),
- (U64Value(1), vec![StackElement::Key("array"), StackElement::Index(1)]),
- (U64Value(2), vec![StackElement::Key("array"), StackElement::Index(2)]),
- (U64Value(3), vec![StackElement::Key("array"), StackElement::Index(3)]),
- (U64Value(4), vec![StackElement::Key("array"), StackElement::Index(4)]),
- (U64Value(5), vec![StackElement::Key("array"), StackElement::Index(5)]),
- (ArrayEnd, vec![StackElement::Key("array")]),
- (ArrayStart, vec![StackElement::Key("idents")]),
- (NullValue, vec![StackElement::Key("idents"),
- StackElement::Index(0)]),
- (BooleanValue(true), vec![StackElement::Key("idents"),
- StackElement::Index(1)]),
- (BooleanValue(false), vec![StackElement::Key("idents"),
- StackElement::Index(2)]),
- (ArrayEnd, vec![StackElement::Key("idents")]),
- (ObjectEnd, vec![]),
- ]
- );
- }
- fn last_event(src: &str) -> JsonEvent {
- let mut parser = Parser::new(src.chars());
- let mut evt = NullValue;
- loop {
- evt = match parser.next() {
- Some(e) => e,
- None => return evt,
- }
- }
- }
-
- #[test]
- fn test_read_object_streaming() {
- assert_eq!(last_event("{ "), Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
- assert_eq!(last_event("{1"), Error(SyntaxError(KeyMustBeAString, 1, 2)));
- assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
- assert_eq!(last_event("{\"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
- assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
-
- assert_eq!(last_event("{\"a\" 1"), Error(SyntaxError(ExpectedColon, 1, 6)));
- assert_eq!(last_event("{\"a\":"), Error(SyntaxError(EOFWhileParsingValue, 1, 6)));
- assert_eq!(last_event("{\"a\":1"), Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
- assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax, 1, 8)));
- assert_eq!(last_event("{\"a\":1,"), Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
- assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8)));
-
- assert_stream_equal(
- "{}",
- vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]
- );
- assert_stream_equal(
- "{\"a\": 3}",
- vec![
- (ObjectStart, vec![]),
- (U64Value(3), vec![StackElement::Key("a")]),
- (ObjectEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "{ \"a\": null, \"b\" : true }",
- vec![
- (ObjectStart, vec![]),
- (NullValue, vec![StackElement::Key("a")]),
- (BooleanValue(true), vec![StackElement::Key("b")]),
- (ObjectEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "{\"a\" : 1.0 ,\"b\": [ true ]}",
- vec![
- (ObjectStart, vec![]),
- (F64Value(1.0), vec![StackElement::Key("a")]),
- (ArrayStart, vec![StackElement::Key("b")]),
- (BooleanValue(true),vec![StackElement::Key("b"), StackElement::Index(0)]),
- (ArrayEnd, vec![StackElement::Key("b")]),
- (ObjectEnd, vec![]),
- ]
- );
- assert_stream_equal(
- r#"{
- "a": 1.0,
- "b": [
- true,
- "foo\nbar",
- { "c": {"d": null} }
- ]
- }"#,
- vec![
- (ObjectStart, vec![]),
- (F64Value(1.0), vec![StackElement::Key("a")]),
- (ArrayStart, vec![StackElement::Key("b")]),
- (BooleanValue(true), vec![StackElement::Key("b"),
- StackElement::Index(0)]),
- (StringValue("foo\nbar".to_string()), vec![StackElement::Key("b"),
- StackElement::Index(1)]),
- (ObjectStart, vec![StackElement::Key("b"),
- StackElement::Index(2)]),
- (ObjectStart, vec![StackElement::Key("b"),
- StackElement::Index(2),
- StackElement::Key("c")]),
- (NullValue, vec![StackElement::Key("b"),
- StackElement::Index(2),
- StackElement::Key("c"),
- StackElement::Key("d")]),
- (ObjectEnd, vec![StackElement::Key("b"),
- StackElement::Index(2),
- StackElement::Key("c")]),
- (ObjectEnd, vec![StackElement::Key("b"),
- StackElement::Index(2)]),
- (ArrayEnd, vec![StackElement::Key("b")]),
- (ObjectEnd, vec![]),
- ]
- );
- }
- #[test]
- fn test_read_array_streaming() {
- assert_stream_equal(
- "[]",
- vec![
- (ArrayStart, vec![]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[ ]",
- vec![
- (ArrayStart, vec![]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[true]",
- vec![
- (ArrayStart, vec![]),
- (BooleanValue(true), vec![StackElement::Index(0)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[ false ]",
- vec![
- (ArrayStart, vec![]),
- (BooleanValue(false), vec![StackElement::Index(0)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[null]",
- vec![
- (ArrayStart, vec![]),
- (NullValue, vec![StackElement::Index(0)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[3, 1]",
- vec![
- (ArrayStart, vec![]),
- (U64Value(3), vec![StackElement::Index(0)]),
- (U64Value(1), vec![StackElement::Index(1)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "\n[3, 2]\n",
- vec![
- (ArrayStart, vec![]),
- (U64Value(3), vec![StackElement::Index(0)]),
- (U64Value(2), vec![StackElement::Index(1)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[2, [4, 1]]",
- vec![
- (ArrayStart, vec![]),
- (U64Value(2), vec![StackElement::Index(0)]),
- (ArrayStart, vec![StackElement::Index(1)]),
- (U64Value(4), vec![StackElement::Index(1), StackElement::Index(0)]),
- (U64Value(1), vec![StackElement::Index(1), StackElement::Index(1)]),
- (ArrayEnd, vec![StackElement::Index(1)]),
- (ArrayEnd, vec![]),
- ]
- );
-
- assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2)));
-
- assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
- assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
- assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
- assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
-
- }
- #[test]
- fn test_trailing_characters_streaming() {
- assert_eq!(last_event("nulla"), Error(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(last_event("truea"), Error(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6)));
- assert_eq!(last_event("1a"), Error(SyntaxError(TrailingCharacters, 1, 2)));
- assert_eq!(last_event("[]a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
- assert_eq!(last_event("{}a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
- }
- #[test]
- fn test_read_identifiers_streaming() {
- assert_eq!(Parser::new("null".chars()).next(), Some(NullValue));
- assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
- assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
-
- assert_eq!(last_event("n"), Error(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(last_event("nul"), Error(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(last_event("t"), Error(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(last_event("f"), Error(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(last_event("faz"), Error(SyntaxError(InvalidSyntax, 1, 3)));
- }
-
#[test]
fn test_stack() {
let mut stack = Stack::new();
assert!(stack.get(1) == StackElement::Key("foo"));
}
- #[test]
- fn test_to_json() {
- use std::collections::{HashMap,BTreeMap};
- use super::ToJson;
-
- let array2 = Array(vec![U64(1), U64(2)]);
- let array3 = Array(vec![U64(1), U64(2), U64(3)]);
- let object = {
- let mut tree_map = BTreeMap::new();
- tree_map.insert("a".to_string(), U64(1));
- tree_map.insert("b".to_string(), U64(2));
- Object(tree_map)
- };
-
- assert_eq!(array2.to_json(), array2);
- assert_eq!(object.to_json(), object);
- assert_eq!(3_isize.to_json(), I64(3));
- assert_eq!(4_i8.to_json(), I64(4));
- assert_eq!(5_i16.to_json(), I64(5));
- assert_eq!(6_i32.to_json(), I64(6));
- assert_eq!(7_i64.to_json(), I64(7));
- assert_eq!(8_usize.to_json(), U64(8));
- assert_eq!(9_u8.to_json(), U64(9));
- assert_eq!(10_u16.to_json(), U64(10));
- assert_eq!(11_u32.to_json(), U64(11));
- assert_eq!(12_u64.to_json(), U64(12));
- assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
- assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
- assert_eq!(().to_json(), Null);
- assert_eq!(f32::INFINITY.to_json(), Null);
- assert_eq!(f64::NAN.to_json(), Null);
- assert_eq!(true.to_json(), Boolean(true));
- assert_eq!(false.to_json(), Boolean(false));
- assert_eq!("abc".to_json(), String("abc".to_string()));
- assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
- assert_eq!((1_usize, 2_usize).to_json(), array2);
- assert_eq!((1_usize, 2_usize, 3_usize).to_json(), array3);
- assert_eq!([1_usize, 2_usize].to_json(), array2);
- assert_eq!((&[1_usize, 2_usize, 3_usize]).to_json(), array3);
- assert_eq!((vec![1_usize, 2_usize]).to_json(), array2);
- assert_eq!(vec![1_usize, 2_usize, 3_usize].to_json(), array3);
- let mut tree_map = BTreeMap::new();
- tree_map.insert("a".to_string(), 1 as usize);
- tree_map.insert("b".to_string(), 2);
- assert_eq!(tree_map.to_json(), object);
- let mut hash_map = HashMap::new();
- hash_map.insert("a".to_string(), 1 as usize);
- hash_map.insert("b".to_string(), 2);
- assert_eq!(hash_map.to_json(), object);
- assert_eq!(Some(15).to_json(), I64(15));
- assert_eq!(Some(15 as usize).to_json(), U64(15));
- assert_eq!(None::<isize>.to_json(), Null);
- }
-
- #[test]
- fn test_encode_hashmap_with_arbitrary_key() {
- use std::collections::HashMap;
- #[derive(PartialEq, Eq, Hash, RustcEncodable)]
- struct ArbitraryType(usize);
- let mut hm: HashMap<ArbitraryType, bool> = HashMap::new();
- hm.insert(ArbitraryType(1), true);
- let mut mem_buf = string::String::new();
- let mut encoder = Encoder::new(&mut mem_buf);
- let result = hm.encode(&mut encoder);
- match result.unwrap_err() {
- EncoderError::BadHashmapKey => (),
- _ => panic!("expected bad hash map key")
- }
- }
-
#[bench]
fn bench_streaming_small(b: &mut Bencher) {
b.iter( || {
html_playground_url = "https://play.rust-lang.org/",
test(attr(allow(unused_variables), deny(warnings))))]
+#![deny(rust_2018_idioms)]
+
#![feature(box_syntax)]
#![feature(core_intrinsics)]
#![feature(specialization)]
pub use self::serialize::{SpecializationError, SpecializedEncoder, SpecializedDecoder};
pub use self::serialize::{UseSpecializedEncodable, UseSpecializedDecodable};
-extern crate smallvec;
-
mod serialize;
mod collection_impls;
pub mod opaque;
pub mod leb128;
-
-mod rustc_serialize {
- pub use serialize::*;
-}
-use leb128::{self, read_signed_leb128, write_signed_leb128};
+use crate::leb128::{self, read_signed_leb128, write_signed_leb128};
+use crate::serialize;
use std::borrow::Cow;
-use serialize;
// -----------------------------------------------------------------------------
// Encoder
}
#[inline]
- fn read_str(&mut self) -> Result<Cow<str>, Self::Error> {
+ fn read_str(&mut self) -> Result<Cow<'_, str>, Self::Error> {
let len = self.read_usize()?;
let s = ::std::str::from_utf8(&self.data[self.position..self.position + len]).unwrap();
self.position += len;
err.to_string()
}
}
-
-
-#[cfg(test)]
-mod tests {
- use serialize::{Encodable, Decodable};
- use std::fmt::Debug;
- use super::{Encoder, Decoder};
-
- #[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)]
- struct Struct {
- a: (),
- b: u8,
- c: u16,
- d: u32,
- e: u64,
- f: usize,
-
- g: i8,
- h: i16,
- i: i32,
- j: i64,
- k: isize,
-
- l: char,
- m: String,
- n: f32,
- o: f64,
- p: bool,
- q: Option<u32>,
- }
-
-
- fn check_round_trip<T: Encodable + Decodable + PartialEq + Debug>(values: Vec<T>) {
- let mut encoder = Encoder::new(Vec::new());
-
- for value in &values {
- Encodable::encode(&value, &mut encoder).unwrap();
- }
-
- let data = encoder.into_inner();
- let mut decoder = Decoder::new(&data[..], 0);
-
- for value in values {
- let decoded = Decodable::decode(&mut decoder).unwrap();
- assert_eq!(value, decoded);
- }
- }
-
- #[test]
- fn test_unit() {
- check_round_trip(vec![(), (), (), ()]);
- }
-
- #[test]
- fn test_u8() {
- let mut vec = vec![];
- for i in ::std::u8::MIN..::std::u8::MAX {
- vec.push(i);
- }
- check_round_trip(vec);
- }
-
- #[test]
- fn test_u16() {
- for i in ::std::u16::MIN..::std::u16::MAX {
- check_round_trip(vec![1, 2, 3, i, i, i]);
- }
- }
-
- #[test]
- fn test_u32() {
- check_round_trip(vec![1, 2, 3, ::std::u32::MIN, 0, 1, ::std::u32::MAX, 2, 1]);
- }
-
- #[test]
- fn test_u64() {
- check_round_trip(vec![1, 2, 3, ::std::u64::MIN, 0, 1, ::std::u64::MAX, 2, 1]);
- }
-
- #[test]
- fn test_usize() {
- check_round_trip(vec![1, 2, 3, ::std::usize::MIN, 0, 1, ::std::usize::MAX, 2, 1]);
- }
-
- #[test]
- fn test_i8() {
- let mut vec = vec![];
- for i in ::std::i8::MIN..::std::i8::MAX {
- vec.push(i);
- }
- check_round_trip(vec);
- }
-
- #[test]
- fn test_i16() {
- for i in ::std::i16::MIN..::std::i16::MAX {
- check_round_trip(vec![-1, 2, -3, i, i, i, 2]);
- }
- }
-
- #[test]
- fn test_i32() {
- check_round_trip(vec![-1, 2, -3, ::std::i32::MIN, 0, 1, ::std::i32::MAX, 2, 1]);
- }
-
- #[test]
- fn test_i64() {
- check_round_trip(vec![-1, 2, -3, ::std::i64::MIN, 0, 1, ::std::i64::MAX, 2, 1]);
- }
-
- #[test]
- fn test_isize() {
- check_round_trip(vec![-1, 2, -3, ::std::isize::MIN, 0, 1, ::std::isize::MAX, 2, 1]);
- }
-
- #[test]
- fn test_bool() {
- check_round_trip(vec![false, true, true, false, false]);
- }
-
- #[test]
- fn test_f32() {
- let mut vec = vec![];
- for i in -100..100 {
- vec.push((i as f32) / 3.0);
- }
- check_round_trip(vec);
- }
-
- #[test]
- fn test_f64() {
- let mut vec = vec![];
- for i in -100..100 {
- vec.push((i as f64) / 3.0);
- }
- check_round_trip(vec);
- }
-
- #[test]
- fn test_char() {
- let vec = vec!['a', 'b', 'c', 'd', 'A', 'X', ' ', '#', 'Ö', 'Ä', 'µ', '€'];
- check_round_trip(vec);
- }
-
- #[test]
- fn test_string() {
- let vec = vec!["abcbuÖeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
- "abcbuÖganeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
- "abcbuÖganeiovÄnameÜavmpßvmea€µsbpapmaebn".to_string(),
- "abcbuÖganeiovÄnameÜavmpßvmeabpnvapeapmaebn".to_string(),
- "abcbuÖganeiÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
- "abcbuÖganeiovÄnameÜavmpßvmea€µsbpmaebn".to_string(),
- "abcbuÖganeiovÄnameÜavmpßvmea€µnvapeapmaebn".to_string()];
-
- check_round_trip(vec);
- }
-
- #[test]
- fn test_option() {
- check_round_trip(vec![Some(-1i8)]);
- check_round_trip(vec![Some(-2i16)]);
- check_round_trip(vec![Some(-3i32)]);
- check_round_trip(vec![Some(-4i64)]);
- check_round_trip(vec![Some(-5isize)]);
-
- let none_i8: Option<i8> = None;
- check_round_trip(vec![none_i8]);
-
- let none_i16: Option<i16> = None;
- check_round_trip(vec![none_i16]);
-
- let none_i32: Option<i32> = None;
- check_round_trip(vec![none_i32]);
-
- let none_i64: Option<i64> = None;
- check_round_trip(vec![none_i64]);
-
- let none_isize: Option<isize> = None;
- check_round_trip(vec![none_isize]);
- }
-
- #[test]
- fn test_struct() {
- check_round_trip(vec![Struct {
- a: (),
- b: 10,
- c: 11,
- d: 12,
- e: 13,
- f: 14,
-
- g: 15,
- h: 16,
- i: 17,
- j: 18,
- k: 19,
-
- l: 'x',
- m: "abc".to_string(),
- n: 20.5,
- o: 21.5,
- p: false,
- q: None,
- }]);
-
- check_round_trip(vec![Struct {
- a: (),
- b: 101,
- c: 111,
- d: 121,
- e: 131,
- f: 141,
-
- g: -15,
- h: -16,
- i: -17,
- j: -18,
- k: -19,
-
- l: 'y',
- m: "def".to_string(),
- n: -20.5,
- o: -21.5,
- p: true,
- q: Some(1234567),
- }]);
- }
-
- #[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)]
- enum Enum {
- Variant1,
- Variant2(usize, f32),
- Variant3 {
- a: i32,
- b: char,
- c: bool,
- },
- }
-
- #[test]
- fn test_enum() {
- check_round_trip(vec![Enum::Variant1,
- Enum::Variant2(1, 2.5),
- Enum::Variant3 {
- a: 3,
- b: 'b',
- c: false,
- },
- Enum::Variant3 {
- a: -4,
- b: 'f',
- c: true,
- }]);
- }
-
- #[test]
- fn test_sequence() {
- let mut vec = vec![];
- for i in -100i64..100i64 {
- vec.push(i * 100000);
- }
-
- check_round_trip(vec![vec]);
- }
-
- #[test]
- fn test_hash_map() {
- use std::collections::HashMap;
- let mut map = HashMap::new();
- for i in -100i64..100i64 {
- map.insert(i * 100000, i * 10000);
- }
-
- check_round_trip(vec![map]);
- }
-
- #[test]
- fn test_tuples() {
- check_round_trip(vec![('x', (), false, 0.5f32)]);
- check_round_trip(vec![(9i8, 10u16, 1.5f64)]);
- check_round_trip(vec![(-12i16, 11u8, 12usize)]);
- check_round_trip(vec![(1234567isize, 100000000000000u64, 99999999999999i64)]);
- check_round_trip(vec![(String::new(), "some string".to_string())]);
- }
-}
fn read_f64(&mut self) -> Result<f64, Self::Error>;
fn read_f32(&mut self) -> Result<f32, Self::Error>;
fn read_char(&mut self) -> Result<char, Self::Error>;
- fn read_str(&mut self) -> Result<Cow<str>, Self::Error>;
+ fn read_str(&mut self) -> Result<Cow<'_, str>, Self::Error>;
// Compound types:
fn read_enum<T, F>(&mut self, _name: &str, f: F) -> Result<T, Self::Error>
/// Implement this trait on your `{Encodable,Decodable}::Error` types
/// to override the default panic behavior for missing specializations.
pub trait SpecializationError {
- /// Create an error for a missing method specialization.
+ /// Creates an error for a missing method specialization.
/// Defaults to panicking with type, trait & method names.
/// `S` is the encoder/decoder state type,
/// `T` is the type being encoded/decoded, and
--- /dev/null
+extern crate serialize as rustc_serialize;
+
+use rustc_serialize::{Encodable, Decodable};
+use rustc_serialize::json;
+use json::Json::*;
+use json::ErrorCode::*;
+use json::ParserError::*;
+use json::DecoderError::*;
+use json::JsonEvent::*;
+use json::{Json, from_str, DecodeResult, DecoderError, JsonEvent, Parser, StackElement,
+ Decoder, Encoder, EncoderError};
+
+use Animal::*;
+use std::{i64, u64, f32, f64};
+use std::io::prelude::*;
+use std::collections::BTreeMap;
+use std::string;
+
+#[derive(RustcDecodable, Eq, PartialEq, Debug)]
+struct OptionData {
+ opt: Option<usize>,
+}
+
+#[test]
+fn test_decode_option_none() {
+ let s ="{}";
+ let obj: OptionData = json::decode(s).unwrap();
+ assert_eq!(obj, OptionData { opt: None });
+}
+
+#[test]
+fn test_decode_option_some() {
+ let s = "{ \"opt\": 10 }";
+ let obj: OptionData = json::decode(s).unwrap();
+ assert_eq!(obj, OptionData { opt: Some(10) });
+}
+
+#[test]
+fn test_decode_option_malformed() {
+ check_err::<OptionData>("{ \"opt\": [] }",
+ ExpectedError("Number".to_string(), "[]".to_string()));
+ check_err::<OptionData>("{ \"opt\": false }",
+ ExpectedError("Number".to_string(), "false".to_string()));
+}
+
+#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
+enum Animal {
+ Dog,
+ Frog(string::String, isize)
+}
+
+#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
+struct Inner {
+ a: (),
+ b: usize,
+ c: Vec<string::String>,
+}
+
+#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
+struct Outer {
+ inner: Vec<Inner>,
+}
+
+fn mk_object(items: &[(string::String, Json)]) -> Json {
+ let mut d = BTreeMap::new();
+
+ for item in items {
+ match *item {
+ (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
+ }
+ };
+
+ Object(d)
+}
+
+#[test]
+fn test_from_str_trait() {
+ let s = "null";
+ assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
+}
+
+#[test]
+fn test_write_null() {
+ assert_eq!(Null.to_string(), "null");
+ assert_eq!(Null.pretty().to_string(), "null");
+}
+
+#[test]
+fn test_write_i64() {
+ assert_eq!(U64(0).to_string(), "0");
+ assert_eq!(U64(0).pretty().to_string(), "0");
+
+ assert_eq!(U64(1234).to_string(), "1234");
+ assert_eq!(U64(1234).pretty().to_string(), "1234");
+
+ assert_eq!(I64(-5678).to_string(), "-5678");
+ assert_eq!(I64(-5678).pretty().to_string(), "-5678");
+
+ assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
+ assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
+}
+
+#[test]
+fn test_write_f64() {
+ assert_eq!(F64(3.0).to_string(), "3.0");
+ assert_eq!(F64(3.0).pretty().to_string(), "3.0");
+
+ assert_eq!(F64(3.1).to_string(), "3.1");
+ assert_eq!(F64(3.1).pretty().to_string(), "3.1");
+
+ assert_eq!(F64(-1.5).to_string(), "-1.5");
+ assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
+
+ assert_eq!(F64(0.5).to_string(), "0.5");
+ assert_eq!(F64(0.5).pretty().to_string(), "0.5");
+
+ assert_eq!(F64(f64::NAN).to_string(), "null");
+ assert_eq!(F64(f64::NAN).pretty().to_string(), "null");
+
+ assert_eq!(F64(f64::INFINITY).to_string(), "null");
+ assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null");
+
+ assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null");
+ assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null");
+}
+
+#[test]
+fn test_write_str() {
+ assert_eq!(String("".to_string()).to_string(), "\"\"");
+ assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
+
+ assert_eq!(String("homura".to_string()).to_string(), "\"homura\"");
+ assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\"");
+}
+
+#[test]
+fn test_write_bool() {
+ assert_eq!(Boolean(true).to_string(), "true");
+ assert_eq!(Boolean(true).pretty().to_string(), "true");
+
+ assert_eq!(Boolean(false).to_string(), "false");
+ assert_eq!(Boolean(false).pretty().to_string(), "false");
+}
+
+#[test]
+fn test_write_array() {
+ assert_eq!(Array(vec![]).to_string(), "[]");
+ assert_eq!(Array(vec![]).pretty().to_string(), "[]");
+
+ assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
+ assert_eq!(
+ Array(vec![Boolean(true)]).pretty().to_string(),
+ "\
+ [\n \
+ true\n\
+ ]"
+ );
+
+ let long_test_array = Array(vec![
+ Boolean(false),
+ Null,
+ Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
+
+ assert_eq!(long_test_array.to_string(),
+ "[false,null,[\"foo\\nbar\",3.5]]");
+ assert_eq!(
+ long_test_array.pretty().to_string(),
+ "\
+ [\n \
+ false,\n \
+ null,\n \
+ [\n \
+ \"foo\\nbar\",\n \
+ 3.5\n \
+ ]\n\
+ ]"
+ );
+}
+
+#[test]
+fn test_write_object() {
+ assert_eq!(mk_object(&[]).to_string(), "{}");
+ assert_eq!(mk_object(&[]).pretty().to_string(), "{}");
+
+ assert_eq!(
+ mk_object(&[
+ ("a".to_string(), Boolean(true))
+ ]).to_string(),
+ "{\"a\":true}"
+ );
+ assert_eq!(
+ mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(),
+ "\
+ {\n \
+ \"a\": true\n\
+ }"
+ );
+
+ let complex_obj = mk_object(&[
+ ("b".to_string(), Array(vec![
+ mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
+ mk_object(&[("d".to_string(), String("".to_string()))])
+ ]))
+ ]);
+
+ assert_eq!(
+ complex_obj.to_string(),
+ "{\
+ \"b\":[\
+ {\"c\":\"\\f\\r\"},\
+ {\"d\":\"\"}\
+ ]\
+ }"
+ );
+ assert_eq!(
+ complex_obj.pretty().to_string(),
+ "\
+ {\n \
+ \"b\": [\n \
+ {\n \
+ \"c\": \"\\f\\r\"\n \
+ },\n \
+ {\n \
+ \"d\": \"\"\n \
+ }\n \
+ ]\n\
+ }"
+ );
+
+ let a = mk_object(&[
+ ("a".to_string(), Boolean(true)),
+ ("b".to_string(), Array(vec![
+ mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
+ mk_object(&[("d".to_string(), String("".to_string()))])
+ ]))
+ ]);
+
+ // We can't compare the strings directly because the object fields be
+ // printed in a different order.
+ assert_eq!(a.clone(), a.to_string().parse().unwrap());
+ assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
+}
+
+#[test]
+fn test_write_enum() {
+ let animal = Dog;
+ assert_eq!(
+ json::as_json(&animal).to_string(),
+ "\"Dog\""
+ );
+ assert_eq!(
+ json::as_pretty_json(&animal).to_string(),
+ "\"Dog\""
+ );
+
+ let animal = Frog("Henry".to_string(), 349);
+ assert_eq!(
+ json::as_json(&animal).to_string(),
+ "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
+ );
+ assert_eq!(
+ json::as_pretty_json(&animal).to_string(),
+ "{\n \
+ \"variant\": \"Frog\",\n \
+ \"fields\": [\n \
+ \"Henry\",\n \
+ 349\n \
+ ]\n\
+ }"
+ );
+}
+
+macro_rules! check_encoder_for_simple {
+ ($value:expr, $expected:expr) => ({
+ let s = json::as_json(&$value).to_string();
+ assert_eq!(s, $expected);
+
+ let s = json::as_pretty_json(&$value).to_string();
+ assert_eq!(s, $expected);
+ })
+}
+
+#[test]
+fn test_write_some() {
+ check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\"");
+}
+
+#[test]
+fn test_write_none() {
+ check_encoder_for_simple!(None::<string::String>, "null");
+}
+
+#[test]
+fn test_write_char() {
+ check_encoder_for_simple!('a', "\"a\"");
+ check_encoder_for_simple!('\t', "\"\\t\"");
+ check_encoder_for_simple!('\u{0000}', "\"\\u0000\"");
+ check_encoder_for_simple!('\u{001b}', "\"\\u001b\"");
+ check_encoder_for_simple!('\u{007f}', "\"\\u007f\"");
+ check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
+ check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
+ check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\"");
+}
+
+#[test]
+fn test_trailing_characters() {
+ assert_eq!(from_str("nulla"), Err(SyntaxError(TrailingCharacters, 1, 5)));
+ assert_eq!(from_str("truea"), Err(SyntaxError(TrailingCharacters, 1, 5)));
+ assert_eq!(from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
+ assert_eq!(from_str("1a"), Err(SyntaxError(TrailingCharacters, 1, 2)));
+ assert_eq!(from_str("[]a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
+ assert_eq!(from_str("{}a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
+}
+
+#[test]
+fn test_read_identifiers() {
+ assert_eq!(from_str("n"), Err(SyntaxError(InvalidSyntax, 1, 2)));
+ assert_eq!(from_str("nul"), Err(SyntaxError(InvalidSyntax, 1, 4)));
+ assert_eq!(from_str("t"), Err(SyntaxError(InvalidSyntax, 1, 2)));
+ assert_eq!(from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
+ assert_eq!(from_str("f"), Err(SyntaxError(InvalidSyntax, 1, 2)));
+ assert_eq!(from_str("faz"), Err(SyntaxError(InvalidSyntax, 1, 3)));
+
+ assert_eq!(from_str("null"), Ok(Null));
+ assert_eq!(from_str("true"), Ok(Boolean(true)));
+ assert_eq!(from_str("false"), Ok(Boolean(false)));
+ assert_eq!(from_str(" null "), Ok(Null));
+ assert_eq!(from_str(" true "), Ok(Boolean(true)));
+ assert_eq!(from_str(" false "), Ok(Boolean(false)));
+}
+
+#[test]
+fn test_decode_identifiers() {
+ let v: () = json::decode("null").unwrap();
+ assert_eq!(v, ());
+
+ let v: bool = json::decode("true").unwrap();
+ assert_eq!(v, true);
+
+ let v: bool = json::decode("false").unwrap();
+ assert_eq!(v, false);
+}
+
+#[test]
+fn test_read_number() {
+ assert_eq!(from_str("+"), Err(SyntaxError(InvalidSyntax, 1, 1)));
+ assert_eq!(from_str("."), Err(SyntaxError(InvalidSyntax, 1, 1)));
+ assert_eq!(from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
+ assert_eq!(from_str("-"), Err(SyntaxError(InvalidNumber, 1, 2)));
+ assert_eq!(from_str("00"), Err(SyntaxError(InvalidNumber, 1, 2)));
+ assert_eq!(from_str("1."), Err(SyntaxError(InvalidNumber, 1, 3)));
+ assert_eq!(from_str("1e"), Err(SyntaxError(InvalidNumber, 1, 3)));
+ assert_eq!(from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
+
+ assert_eq!(from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
+ assert_eq!(from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
+
+ assert_eq!(from_str("3"), Ok(U64(3)));
+ assert_eq!(from_str("3.1"), Ok(F64(3.1)));
+ assert_eq!(from_str("-1.2"), Ok(F64(-1.2)));
+ assert_eq!(from_str("0.4"), Ok(F64(0.4)));
+ assert_eq!(from_str("0.4e5"), Ok(F64(0.4e5)));
+ assert_eq!(from_str("0.4e+15"), Ok(F64(0.4e15)));
+ assert_eq!(from_str("0.4e-01"), Ok(F64(0.4e-01)));
+ assert_eq!(from_str(" 3 "), Ok(U64(3)));
+
+ assert_eq!(from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
+ assert_eq!(from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
+ assert_eq!(from_str("18446744073709551615"), Ok(U64(u64::MAX)));
+}
+
+#[test]
+fn test_decode_numbers() {
+ let v: f64 = json::decode("3").unwrap();
+ assert_eq!(v, 3.0);
+
+ let v: f64 = json::decode("3.1").unwrap();
+ assert_eq!(v, 3.1);
+
+ let v: f64 = json::decode("-1.2").unwrap();
+ assert_eq!(v, -1.2);
+
+ let v: f64 = json::decode("0.4").unwrap();
+ assert_eq!(v, 0.4);
+
+ let v: f64 = json::decode("0.4e5").unwrap();
+ assert_eq!(v, 0.4e5);
+
+ let v: f64 = json::decode("0.4e15").unwrap();
+ assert_eq!(v, 0.4e15);
+
+ let v: f64 = json::decode("0.4e-01").unwrap();
+ assert_eq!(v, 0.4e-01);
+
+ let v: u64 = json::decode("0").unwrap();
+ assert_eq!(v, 0);
+
+ let v: u64 = json::decode("18446744073709551615").unwrap();
+ assert_eq!(v, u64::MAX);
+
+ let v: i64 = json::decode("-9223372036854775808").unwrap();
+ assert_eq!(v, i64::MIN);
+
+ let v: i64 = json::decode("9223372036854775807").unwrap();
+ assert_eq!(v, i64::MAX);
+
+ let res: DecodeResult<i64> = json::decode("765.25");
+ assert_eq!(res, Err(ExpectedError("Integer".to_string(),
+ "765.25".to_string())));
+}
+
+#[test]
+fn test_read_str() {
+ assert_eq!(from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2)));
+ assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
+
+ assert_eq!(from_str("\"\""), Ok(String("".to_string())));
+ assert_eq!(from_str("\"foo\""), Ok(String("foo".to_string())));
+ assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string())));
+ assert_eq!(from_str("\"\\b\""), Ok(String("\x08".to_string())));
+ assert_eq!(from_str("\"\\n\""), Ok(String("\n".to_string())));
+ assert_eq!(from_str("\"\\r\""), Ok(String("\r".to_string())));
+ assert_eq!(from_str("\"\\t\""), Ok(String("\t".to_string())));
+ assert_eq!(from_str(" \"foo\" "), Ok(String("foo".to_string())));
+ assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string())));
+ assert_eq!(from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string())));
+}
+
+#[test]
+fn test_decode_str() {
+ let s = [("\"\"", ""),
+ ("\"foo\"", "foo"),
+ ("\"\\\"\"", "\""),
+ ("\"\\b\"", "\x08"),
+ ("\"\\n\"", "\n"),
+ ("\"\\r\"", "\r"),
+ ("\"\\t\"", "\t"),
+ ("\"\\u12ab\"", "\u{12ab}"),
+ ("\"\\uAB12\"", "\u{AB12}")];
+
+ for &(i, o) in &s {
+ let v: string::String = json::decode(i).unwrap();
+ assert_eq!(v, o);
+ }
+}
+
+#[test]
+fn test_read_array() {
+ assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
+ assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
+ assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
+ assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
+ assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
+
+ assert_eq!(from_str("[]"), Ok(Array(vec![])));
+ assert_eq!(from_str("[ ]"), Ok(Array(vec![])));
+ assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)])));
+ assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
+ assert_eq!(from_str("[null]"), Ok(Array(vec![Null])));
+ assert_eq!(from_str("[3, 1]"),
+ Ok(Array(vec![U64(3), U64(1)])));
+ assert_eq!(from_str("\n[3, 2]\n"),
+ Ok(Array(vec![U64(3), U64(2)])));
+ assert_eq!(from_str("[2, [4, 1]]"),
+ Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
+}
+
+#[test]
+fn test_decode_array() {
+ let v: Vec<()> = json::decode("[]").unwrap();
+ assert_eq!(v, []);
+
+ let v: Vec<()> = json::decode("[null]").unwrap();
+ assert_eq!(v, [()]);
+
+ let v: Vec<bool> = json::decode("[true]").unwrap();
+ assert_eq!(v, [true]);
+
+ let v: Vec<isize> = json::decode("[3, 1]").unwrap();
+ assert_eq!(v, [3, 1]);
+
+ let v: Vec<Vec<usize>> = json::decode("[[3], [1, 2]]").unwrap();
+ assert_eq!(v, [vec![3], vec![1, 2]]);
+}
+
+#[test]
+fn test_decode_tuple() {
+ let t: (usize, usize, usize) = json::decode("[1, 2, 3]").unwrap();
+ assert_eq!(t, (1, 2, 3));
+
+ let t: (usize, string::String) = json::decode("[1, \"two\"]").unwrap();
+ assert_eq!(t, (1, "two".to_string()));
+}
+
+#[test]
+fn test_decode_tuple_malformed_types() {
+ assert!(json::decode::<(usize, string::String)>("[1, 2]").is_err());
+}
+
+#[test]
+fn test_decode_tuple_malformed_length() {
+ assert!(json::decode::<(usize, usize)>("[1, 2, 3]").is_err());
+}
+
+#[test]
+fn test_read_object() {
+ assert_eq!(from_str("{"), Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
+ assert_eq!(from_str("{ "), Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
+ assert_eq!(from_str("{1"), Err(SyntaxError(KeyMustBeAString, 1, 2)));
+ assert_eq!(from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
+ assert_eq!(from_str("{\"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
+ assert_eq!(from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
+
+ assert_eq!(from_str("{\"a\" 1"), Err(SyntaxError(ExpectedColon, 1, 6)));
+ assert_eq!(from_str("{\"a\":"), Err(SyntaxError(EOFWhileParsingValue, 1, 6)));
+ assert_eq!(from_str("{\"a\":1"), Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
+ assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8)));
+ assert_eq!(from_str("{\"a\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
+
+ assert_eq!(from_str("{}").unwrap(), mk_object(&[]));
+ assert_eq!(from_str("{\"a\": 3}").unwrap(),
+ mk_object(&[("a".to_string(), U64(3))]));
+
+ assert_eq!(from_str(
+ "{ \"a\": null, \"b\" : true }").unwrap(),
+ mk_object(&[
+ ("a".to_string(), Null),
+ ("b".to_string(), Boolean(true))]));
+ assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
+ mk_object(&[
+ ("a".to_string(), Null),
+ ("b".to_string(), Boolean(true))]));
+ assert_eq!(from_str(
+ "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
+ mk_object(&[
+ ("a".to_string(), F64(1.0)),
+ ("b".to_string(), Array(vec![Boolean(true)]))
+ ]));
+ assert_eq!(from_str(
+ "{\
+ \"a\": 1.0, \
+ \"b\": [\
+ true,\
+ \"foo\\nbar\", \
+ { \"c\": {\"d\": null} } \
+ ]\
+ }").unwrap(),
+ mk_object(&[
+ ("a".to_string(), F64(1.0)),
+ ("b".to_string(), Array(vec![
+ Boolean(true),
+ String("foo\nbar".to_string()),
+ mk_object(&[
+ ("c".to_string(), mk_object(&[("d".to_string(), Null)]))
+ ])
+ ]))
+ ]));
+}
+
+#[test]
+fn test_decode_struct() {
+ let s = "{
+ \"inner\": [
+ { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
+ ]
+ }";
+
+ let v: Outer = json::decode(s).unwrap();
+ assert_eq!(
+ v,
+ Outer {
+ inner: vec![
+ Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
+ ]
+ }
+ );
+}
+
+#[derive(RustcDecodable)]
+struct FloatStruct {
+ f: f64,
+ a: Vec<f64>
+}
+#[test]
+fn test_decode_struct_with_nan() {
+ let s = "{\"f\":null,\"a\":[null,123]}";
+ let obj: FloatStruct = json::decode(s).unwrap();
+ assert!(obj.f.is_nan());
+ assert!(obj.a[0].is_nan());
+ assert_eq!(obj.a[1], 123f64);
+}
+
+#[test]
+fn test_decode_option() {
+ let value: Option<string::String> = json::decode("null").unwrap();
+ assert_eq!(value, None);
+
+ let value: Option<string::String> = json::decode("\"jodhpurs\"").unwrap();
+ assert_eq!(value, Some("jodhpurs".to_string()));
+}
+
+#[test]
+fn test_decode_enum() {
+ let value: Animal = json::decode("\"Dog\"").unwrap();
+ assert_eq!(value, Dog);
+
+ let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
+ let value: Animal = json::decode(s).unwrap();
+ assert_eq!(value, Frog("Henry".to_string(), 349));
+}
+
+#[test]
+fn test_decode_map() {
+ let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
+ \"fields\":[\"Henry\", 349]}}";
+ let mut map: BTreeMap<string::String, Animal> = json::decode(s).unwrap();
+
+ assert_eq!(map.remove(&"a".to_string()), Some(Dog));
+ assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
+}
+
+#[test]
+fn test_multiline_errors() {
+ assert_eq!(from_str("{\n \"foo\":\n \"bar\""),
+ Err(SyntaxError(EOFWhileParsingObject, 3, 8)));
+}
+
+#[derive(RustcDecodable)]
+#[allow(dead_code)]
+struct DecodeStruct {
+ x: f64,
+ y: bool,
+ z: string::String,
+ w: Vec<DecodeStruct>
+}
+#[derive(RustcDecodable)]
+enum DecodeEnum {
+ A(f64),
+ B(string::String)
+}
+fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) {
+ let res: DecodeResult<T> = match from_str(to_parse) {
+ Err(e) => Err(ParseError(e)),
+ Ok(json) => Decodable::decode(&mut Decoder::new(json))
+ };
+ match res {
+ Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`",
+ to_parse, expected),
+ Err(ParseError(e)) => panic!("`{:?}` is not valid json: {:?}",
+ to_parse, e),
+ Err(e) => {
+ assert_eq!(e, expected);
+ }
+ }
+}
+#[test]
+fn test_decode_errors_struct() {
+ check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
+ check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
+ ExpectedError("Number".to_string(), "true".to_string()));
+ check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
+ ExpectedError("Boolean".to_string(), "[]".to_string()));
+ check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
+ ExpectedError("String".to_string(), "{}".to_string()));
+ check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
+ ExpectedError("Array".to_string(), "null".to_string()));
+ check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
+ MissingFieldError("w".to_string()));
+}
+#[test]
+fn test_decode_errors_enum() {
+ check_err::<DecodeEnum>("{}",
+ MissingFieldError("variant".to_string()));
+ check_err::<DecodeEnum>("{\"variant\": 1}",
+ ExpectedError("String".to_string(), "1".to_string()));
+ check_err::<DecodeEnum>("{\"variant\": \"A\"}",
+ MissingFieldError("fields".to_string()));
+ check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
+ ExpectedError("Array".to_string(), "null".to_string()));
+ check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
+ UnknownVariantError("C".to_string()));
+}
+
+#[test]
+fn test_find(){
+ let json_value = from_str("{\"dog\" : \"cat\"}").unwrap();
+ let found_str = json_value.find("dog");
+ assert!(found_str.unwrap().as_string().unwrap() == "cat");
+}
+
+#[test]
+fn test_find_path(){
+ let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
+ let found_str = json_value.find_path(&["dog", "cat", "mouse"]);
+ assert!(found_str.unwrap().as_string().unwrap() == "cheese");
+}
+
+#[test]
+fn test_search(){
+ let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
+ let found_str = json_value.search("mouse").and_then(|j| j.as_string());
+ assert!(found_str.unwrap() == "cheese");
+}
+
+#[test]
+fn test_index(){
+ let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
+ let ref array = json_value["animals"];
+ assert_eq!(array[0].as_string().unwrap(), "dog");
+ assert_eq!(array[1].as_string().unwrap(), "cat");
+ assert_eq!(array[2].as_string().unwrap(), "mouse");
+}
+
+#[test]
+fn test_is_object(){
+ let json_value = from_str("{}").unwrap();
+ assert!(json_value.is_object());
+}
+
+#[test]
+fn test_as_object(){
+ let json_value = from_str("{}").unwrap();
+ let json_object = json_value.as_object();
+ assert!(json_object.is_some());
+}
+
+#[test]
+fn test_is_array(){
+ let json_value = from_str("[1, 2, 3]").unwrap();
+ assert!(json_value.is_array());
+}
+
+#[test]
+fn test_as_array(){
+ let json_value = from_str("[1, 2, 3]").unwrap();
+ let json_array = json_value.as_array();
+ let expected_length = 3;
+ assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
+}
+
+#[test]
+fn test_is_string(){
+ let json_value = from_str("\"dog\"").unwrap();
+ assert!(json_value.is_string());
+}
+
+#[test]
+fn test_as_string(){
+ let json_value = from_str("\"dog\"").unwrap();
+ let json_str = json_value.as_string();
+ let expected_str = "dog";
+ assert_eq!(json_str, Some(expected_str));
+}
+
+#[test]
+fn test_is_number(){
+ let json_value = from_str("12").unwrap();
+ assert!(json_value.is_number());
+}
+
+#[test]
+fn test_is_i64(){
+ let json_value = from_str("-12").unwrap();
+ assert!(json_value.is_i64());
+
+ let json_value = from_str("12").unwrap();
+ assert!(!json_value.is_i64());
+
+ let json_value = from_str("12.0").unwrap();
+ assert!(!json_value.is_i64());
+}
+
+#[test]
+fn test_is_u64(){
+ let json_value = from_str("12").unwrap();
+ assert!(json_value.is_u64());
+
+ let json_value = from_str("-12").unwrap();
+ assert!(!json_value.is_u64());
+
+ let json_value = from_str("12.0").unwrap();
+ assert!(!json_value.is_u64());
+}
+
+#[test]
+fn test_is_f64(){
+ let json_value = from_str("12").unwrap();
+ assert!(!json_value.is_f64());
+
+ let json_value = from_str("-12").unwrap();
+ assert!(!json_value.is_f64());
+
+ let json_value = from_str("12.0").unwrap();
+ assert!(json_value.is_f64());
+
+ let json_value = from_str("-12.0").unwrap();
+ assert!(json_value.is_f64());
+}
+
+#[test]
+fn test_as_i64(){
+ let json_value = from_str("-12").unwrap();
+ let json_num = json_value.as_i64();
+ assert_eq!(json_num, Some(-12));
+}
+
+#[test]
+fn test_as_u64(){
+ let json_value = from_str("12").unwrap();
+ let json_num = json_value.as_u64();
+ assert_eq!(json_num, Some(12));
+}
+
+#[test]
+fn test_as_f64(){
+ let json_value = from_str("12.0").unwrap();
+ let json_num = json_value.as_f64();
+ assert_eq!(json_num, Some(12f64));
+}
+
+#[test]
+fn test_is_boolean(){
+ let json_value = from_str("false").unwrap();
+ assert!(json_value.is_boolean());
+}
+
+#[test]
+fn test_as_boolean(){
+ let json_value = from_str("false").unwrap();
+ let json_bool = json_value.as_boolean();
+ let expected_bool = false;
+ assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
+}
+
+#[test]
+fn test_is_null(){
+ let json_value = from_str("null").unwrap();
+ assert!(json_value.is_null());
+}
+
+#[test]
+fn test_as_null(){
+ let json_value = from_str("null").unwrap();
+ let json_null = json_value.as_null();
+ let expected_null = ();
+ assert!(json_null.is_some() && json_null.unwrap() == expected_null);
+}
+
+#[test]
+fn test_encode_hashmap_with_numeric_key() {
+ use std::str::from_utf8;
+ use std::collections::HashMap;
+ let mut hm: HashMap<usize, bool> = HashMap::new();
+ hm.insert(1, true);
+ let mut mem_buf = Vec::new();
+ write!(&mut mem_buf, "{}", json::as_pretty_json(&hm)).unwrap();
+ let json_str = from_utf8(&mem_buf[..]).unwrap();
+ match from_str(json_str) {
+ Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
+ _ => {} // it parsed and we are good to go
+ }
+}
+
+#[test]
+fn test_prettyencode_hashmap_with_numeric_key() {
+ use std::str::from_utf8;
+ use std::collections::HashMap;
+ let mut hm: HashMap<usize, bool> = HashMap::new();
+ hm.insert(1, true);
+ let mut mem_buf = Vec::new();
+ write!(&mut mem_buf, "{}", json::as_pretty_json(&hm)).unwrap();
+ let json_str = from_utf8(&mem_buf[..]).unwrap();
+ match from_str(json_str) {
+ Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
+ _ => {} // it parsed and we are good to go
+ }
+}
+
+#[test]
+fn test_prettyencoder_indent_level_param() {
+ use std::str::from_utf8;
+ use std::collections::BTreeMap;
+
+ let mut tree = BTreeMap::new();
+
+ tree.insert("hello".to_string(), String("guten tag".to_string()));
+ tree.insert("goodbye".to_string(), String("sayonara".to_string()));
+
+ let json = Array(
+ // The following layout below should look a lot like
+ // the pretty-printed JSON (indent * x)
+ vec!
+ ( // 0x
+ String("greetings".to_string()), // 1x
+ Object(tree), // 1x + 2x + 2x + 1x
+ ) // 0x
+ // End JSON array (7 lines)
+ );
+
+ // Helper function for counting indents
+ fn indents(source: &str) -> usize {
+ let trimmed = source.trim_start_matches(' ');
+ source.len() - trimmed.len()
+ }
+
+ // Test up to 4 spaces of indents (more?)
+ for i in 0..4 {
+ let mut writer = Vec::new();
+ write!(&mut writer, "{}",
+ json::as_pretty_json(&json).indent(i)).unwrap();
+
+ let printed = from_utf8(&writer[..]).unwrap();
+
+ // Check for indents at each line
+ let lines: Vec<&str> = printed.lines().collect();
+ assert_eq!(lines.len(), 7); // JSON should be 7 lines
+
+ assert_eq!(indents(lines[0]), 0 * i); // [
+ assert_eq!(indents(lines[1]), 1 * i); // "greetings",
+ assert_eq!(indents(lines[2]), 1 * i); // {
+ assert_eq!(indents(lines[3]), 2 * i); // "hello": "guten tag",
+ assert_eq!(indents(lines[4]), 2 * i); // "goodbye": "sayonara"
+ assert_eq!(indents(lines[5]), 1 * i); // },
+ assert_eq!(indents(lines[6]), 0 * i); // ]
+
+ // Finally, test that the pretty-printed JSON is valid
+ from_str(printed).ok().expect("Pretty-printed JSON is invalid!");
+ }
+}
+
+#[test]
+fn test_hashmap_with_enum_key() {
+ use std::collections::HashMap;
+ #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)]
+ enum Enum {
+ Foo,
+ #[allow(dead_code)]
+ Bar,
+ }
+ let mut map = HashMap::new();
+ map.insert(Enum::Foo, 0);
+ let result = json::encode(&map).unwrap();
+ assert_eq!(&result[..], r#"{"Foo":0}"#);
+ let decoded: HashMap<Enum, _> = json::decode(&result).unwrap();
+ assert_eq!(map, decoded);
+}
+
+#[test]
+fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
+ use std::collections::HashMap;
+ let json_str = "{\"1\":true}";
+ let json_obj = match from_str(json_str) {
+ Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
+ Ok(o) => o
+ };
+ let mut decoder = Decoder::new(json_obj);
+ let _hm: HashMap<usize, bool> = Decodable::decode(&mut decoder).unwrap();
+}
+
+#[test]
+fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
+ use std::collections::HashMap;
+ let json_str = "{\"a\":true}";
+ let json_obj = match from_str(json_str) {
+ Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
+ Ok(o) => o
+ };
+ let mut decoder = Decoder::new(json_obj);
+ let result: Result<HashMap<usize, bool>, DecoderError> = Decodable::decode(&mut decoder);
+ assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
+}
+
+fn assert_stream_equal(src: &str,
+ expected: Vec<(JsonEvent, Vec<StackElement<'_>>)>) {
+ let mut parser = Parser::new(src.chars());
+ let mut i = 0;
+ loop {
+ let evt = match parser.next() {
+ Some(e) => e,
+ None => { break; }
+ };
+ let (ref expected_evt, ref expected_stack) = expected[i];
+ if !parser.stack().is_equal_to(expected_stack) {
+ panic!("Parser stack is not equal to {:?}", expected_stack);
+ }
+ assert_eq!(&evt, expected_evt);
+ i+=1;
+ }
+}
+#[test]
+fn test_streaming_parser() {
+ assert_stream_equal(
+ r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
+ vec![
+ (ObjectStart, vec![]),
+ (StringValue("bar".to_string()), vec![StackElement::Key("foo")]),
+ (ArrayStart, vec![StackElement::Key("array")]),
+ (U64Value(0), vec![StackElement::Key("array"), StackElement::Index(0)]),
+ (U64Value(1), vec![StackElement::Key("array"), StackElement::Index(1)]),
+ (U64Value(2), vec![StackElement::Key("array"), StackElement::Index(2)]),
+ (U64Value(3), vec![StackElement::Key("array"), StackElement::Index(3)]),
+ (U64Value(4), vec![StackElement::Key("array"), StackElement::Index(4)]),
+ (U64Value(5), vec![StackElement::Key("array"), StackElement::Index(5)]),
+ (ArrayEnd, vec![StackElement::Key("array")]),
+ (ArrayStart, vec![StackElement::Key("idents")]),
+ (NullValue, vec![StackElement::Key("idents"),
+ StackElement::Index(0)]),
+ (BooleanValue(true), vec![StackElement::Key("idents"),
+ StackElement::Index(1)]),
+ (BooleanValue(false), vec![StackElement::Key("idents"),
+ StackElement::Index(2)]),
+ (ArrayEnd, vec![StackElement::Key("idents")]),
+ (ObjectEnd, vec![]),
+ ]
+ );
+}
+fn last_event(src: &str) -> JsonEvent {
+ let mut parser = Parser::new(src.chars());
+ let mut evt = NullValue;
+ loop {
+ evt = match parser.next() {
+ Some(e) => e,
+ None => return evt,
+ }
+ }
+}
+
+#[test]
+fn test_read_object_streaming() {
+ assert_eq!(last_event("{ "), Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
+ assert_eq!(last_event("{1"), Error(SyntaxError(KeyMustBeAString, 1, 2)));
+ assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
+ assert_eq!(last_event("{\"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
+ assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
+
+ assert_eq!(last_event("{\"a\" 1"), Error(SyntaxError(ExpectedColon, 1, 6)));
+ assert_eq!(last_event("{\"a\":"), Error(SyntaxError(EOFWhileParsingValue, 1, 6)));
+ assert_eq!(last_event("{\"a\":1"), Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
+ assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax, 1, 8)));
+ assert_eq!(last_event("{\"a\":1,"), Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
+ assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8)));
+
+ assert_stream_equal(
+ "{}",
+ vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]
+ );
+ assert_stream_equal(
+ "{\"a\": 3}",
+ vec![
+ (ObjectStart, vec![]),
+ (U64Value(3), vec![StackElement::Key("a")]),
+ (ObjectEnd, vec![]),
+ ]
+ );
+ assert_stream_equal(
+ "{ \"a\": null, \"b\" : true }",
+ vec![
+ (ObjectStart, vec![]),
+ (NullValue, vec![StackElement::Key("a")]),
+ (BooleanValue(true), vec![StackElement::Key("b")]),
+ (ObjectEnd, vec![]),
+ ]
+ );
+ assert_stream_equal(
+ "{\"a\" : 1.0 ,\"b\": [ true ]}",
+ vec![
+ (ObjectStart, vec![]),
+ (F64Value(1.0), vec![StackElement::Key("a")]),
+ (ArrayStart, vec![StackElement::Key("b")]),
+ (BooleanValue(true),vec![StackElement::Key("b"), StackElement::Index(0)]),
+ (ArrayEnd, vec![StackElement::Key("b")]),
+ (ObjectEnd, vec![]),
+ ]
+ );
+ assert_stream_equal(
+ r#"{
+ "a": 1.0,
+ "b": [
+ true,
+ "foo\nbar",
+ { "c": {"d": null} }
+ ]
+ }"#,
+ vec![
+ (ObjectStart, vec![]),
+ (F64Value(1.0), vec![StackElement::Key("a")]),
+ (ArrayStart, vec![StackElement::Key("b")]),
+ (BooleanValue(true), vec![StackElement::Key("b"),
+ StackElement::Index(0)]),
+ (StringValue("foo\nbar".to_string()), vec![StackElement::Key("b"),
+ StackElement::Index(1)]),
+ (ObjectStart, vec![StackElement::Key("b"),
+ StackElement::Index(2)]),
+ (ObjectStart, vec![StackElement::Key("b"),
+ StackElement::Index(2),
+ StackElement::Key("c")]),
+ (NullValue, vec![StackElement::Key("b"),
+ StackElement::Index(2),
+ StackElement::Key("c"),
+ StackElement::Key("d")]),
+ (ObjectEnd, vec![StackElement::Key("b"),
+ StackElement::Index(2),
+ StackElement::Key("c")]),
+ (ObjectEnd, vec![StackElement::Key("b"),
+ StackElement::Index(2)]),
+ (ArrayEnd, vec![StackElement::Key("b")]),
+ (ObjectEnd, vec![]),
+ ]
+ );
+}
+#[test]
+fn test_read_array_streaming() {
+ assert_stream_equal(
+ "[]",
+ vec![
+ (ArrayStart, vec![]),
+ (ArrayEnd, vec![]),
+ ]
+ );
+ assert_stream_equal(
+ "[ ]",
+ vec![
+ (ArrayStart, vec![]),
+ (ArrayEnd, vec![]),
+ ]
+ );
+ assert_stream_equal(
+ "[true]",
+ vec![
+ (ArrayStart, vec![]),
+ (BooleanValue(true), vec![StackElement::Index(0)]),
+ (ArrayEnd, vec![]),
+ ]
+ );
+ assert_stream_equal(
+ "[ false ]",
+ vec![
+ (ArrayStart, vec![]),
+ (BooleanValue(false), vec![StackElement::Index(0)]),
+ (ArrayEnd, vec![]),
+ ]
+ );
+ assert_stream_equal(
+ "[null]",
+ vec![
+ (ArrayStart, vec![]),
+ (NullValue, vec![StackElement::Index(0)]),
+ (ArrayEnd, vec![]),
+ ]
+ );
+ assert_stream_equal(
+ "[3, 1]",
+ vec![
+ (ArrayStart, vec![]),
+ (U64Value(3), vec![StackElement::Index(0)]),
+ (U64Value(1), vec![StackElement::Index(1)]),
+ (ArrayEnd, vec![]),
+ ]
+ );
+ assert_stream_equal(
+ "\n[3, 2]\n",
+ vec![
+ (ArrayStart, vec![]),
+ (U64Value(3), vec![StackElement::Index(0)]),
+ (U64Value(2), vec![StackElement::Index(1)]),
+ (ArrayEnd, vec![]),
+ ]
+ );
+ assert_stream_equal(
+ "[2, [4, 1]]",
+ vec![
+ (ArrayStart, vec![]),
+ (U64Value(2), vec![StackElement::Index(0)]),
+ (ArrayStart, vec![StackElement::Index(1)]),
+ (U64Value(4), vec![StackElement::Index(1), StackElement::Index(0)]),
+ (U64Value(1), vec![StackElement::Index(1), StackElement::Index(1)]),
+ (ArrayEnd, vec![StackElement::Index(1)]),
+ (ArrayEnd, vec![]),
+ ]
+ );
+
+ assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2)));
+
+ assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
+ assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
+ assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
+ assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
+ assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
+
+}
+#[test]
+fn test_trailing_characters_streaming() {
+ assert_eq!(last_event("nulla"), Error(SyntaxError(TrailingCharacters, 1, 5)));
+ assert_eq!(last_event("truea"), Error(SyntaxError(TrailingCharacters, 1, 5)));
+ assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6)));
+ assert_eq!(last_event("1a"), Error(SyntaxError(TrailingCharacters, 1, 2)));
+ assert_eq!(last_event("[]a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
+ assert_eq!(last_event("{}a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
+}
+#[test]
+fn test_read_identifiers_streaming() {
+ assert_eq!(Parser::new("null".chars()).next(), Some(NullValue));
+ assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
+ assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
+
+ assert_eq!(last_event("n"), Error(SyntaxError(InvalidSyntax, 1, 2)));
+ assert_eq!(last_event("nul"), Error(SyntaxError(InvalidSyntax, 1, 4)));
+ assert_eq!(last_event("t"), Error(SyntaxError(InvalidSyntax, 1, 2)));
+ assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4)));
+ assert_eq!(last_event("f"), Error(SyntaxError(InvalidSyntax, 1, 2)));
+ assert_eq!(last_event("faz"), Error(SyntaxError(InvalidSyntax, 1, 3)));
+}
+
+#[test]
+fn test_to_json() {
+ use std::collections::{HashMap,BTreeMap};
+ use json::ToJson;
+
+ let array2 = Array(vec![U64(1), U64(2)]);
+ let array3 = Array(vec![U64(1), U64(2), U64(3)]);
+ let object = {
+ let mut tree_map = BTreeMap::new();
+ tree_map.insert("a".to_string(), U64(1));
+ tree_map.insert("b".to_string(), U64(2));
+ Object(tree_map)
+ };
+
+ assert_eq!(array2.to_json(), array2);
+ assert_eq!(object.to_json(), object);
+ assert_eq!(3_isize.to_json(), I64(3));
+ assert_eq!(4_i8.to_json(), I64(4));
+ assert_eq!(5_i16.to_json(), I64(5));
+ assert_eq!(6_i32.to_json(), I64(6));
+ assert_eq!(7_i64.to_json(), I64(7));
+ assert_eq!(8_usize.to_json(), U64(8));
+ assert_eq!(9_u8.to_json(), U64(9));
+ assert_eq!(10_u16.to_json(), U64(10));
+ assert_eq!(11_u32.to_json(), U64(11));
+ assert_eq!(12_u64.to_json(), U64(12));
+ assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
+ assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
+ assert_eq!(().to_json(), Null);
+ assert_eq!(f32::INFINITY.to_json(), Null);
+ assert_eq!(f64::NAN.to_json(), Null);
+ assert_eq!(true.to_json(), Boolean(true));
+ assert_eq!(false.to_json(), Boolean(false));
+ assert_eq!("abc".to_json(), String("abc".to_string()));
+ assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
+ assert_eq!((1_usize, 2_usize).to_json(), array2);
+ assert_eq!((1_usize, 2_usize, 3_usize).to_json(), array3);
+ assert_eq!([1_usize, 2_usize].to_json(), array2);
+ assert_eq!((&[1_usize, 2_usize, 3_usize]).to_json(), array3);
+ assert_eq!((vec![1_usize, 2_usize]).to_json(), array2);
+ assert_eq!(vec![1_usize, 2_usize, 3_usize].to_json(), array3);
+ let mut tree_map = BTreeMap::new();
+ tree_map.insert("a".to_string(), 1 as usize);
+ tree_map.insert("b".to_string(), 2);
+ assert_eq!(tree_map.to_json(), object);
+ let mut hash_map = HashMap::new();
+ hash_map.insert("a".to_string(), 1 as usize);
+ hash_map.insert("b".to_string(), 2);
+ assert_eq!(hash_map.to_json(), object);
+ assert_eq!(Some(15).to_json(), I64(15));
+ assert_eq!(Some(15 as usize).to_json(), U64(15));
+ assert_eq!(None::<isize>.to_json(), Null);
+}
+
+#[test]
+fn test_encode_hashmap_with_arbitrary_key() {
+ use std::collections::HashMap;
+ #[derive(PartialEq, Eq, Hash, RustcEncodable)]
+ struct ArbitraryType(usize);
+ let mut hm: HashMap<ArbitraryType, bool> = HashMap::new();
+ hm.insert(ArbitraryType(1), true);
+ let mut mem_buf = string::String::new();
+ let mut encoder = Encoder::new(&mut mem_buf);
+ let result = hm.encode(&mut encoder);
+ match result.unwrap_err() {
+ EncoderError::BadHashmapKey => (),
+ _ => panic!("expected bad hash map key")
+ }
+}
--- /dev/null
+extern crate serialize as rustc_serialize;
+
+use rustc_serialize::{Encodable, Decodable};
+use rustc_serialize::opaque::{Encoder, Decoder};
+use std::fmt::Debug;
+
+#[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)]
+struct Struct {
+ a: (),
+ b: u8,
+ c: u16,
+ d: u32,
+ e: u64,
+ f: usize,
+
+ g: i8,
+ h: i16,
+ i: i32,
+ j: i64,
+ k: isize,
+
+ l: char,
+ m: String,
+ n: f32,
+ o: f64,
+ p: bool,
+ q: Option<u32>,
+}
+
+
+fn check_round_trip<T: Encodable + Decodable + PartialEq + Debug>(values: Vec<T>) {
+ let mut encoder = Encoder::new(Vec::new());
+
+ for value in &values {
+ Encodable::encode(&value, &mut encoder).unwrap();
+ }
+
+ let data = encoder.into_inner();
+ let mut decoder = Decoder::new(&data[..], 0);
+
+ for value in values {
+ let decoded = Decodable::decode(&mut decoder).unwrap();
+ assert_eq!(value, decoded);
+ }
+}
+
+#[test]
+fn test_unit() {
+ check_round_trip(vec![(), (), (), ()]);
+}
+
+#[test]
+fn test_u8() {
+ let mut vec = vec![];
+ for i in ::std::u8::MIN..::std::u8::MAX {
+ vec.push(i);
+ }
+ check_round_trip(vec);
+}
+
+#[test]
+fn test_u16() {
+ for i in ::std::u16::MIN..::std::u16::MAX {
+ check_round_trip(vec![1, 2, 3, i, i, i]);
+ }
+}
+
+#[test]
+fn test_u32() {
+ check_round_trip(vec![1, 2, 3, ::std::u32::MIN, 0, 1, ::std::u32::MAX, 2, 1]);
+}
+
+#[test]
+fn test_u64() {
+ check_round_trip(vec![1, 2, 3, ::std::u64::MIN, 0, 1, ::std::u64::MAX, 2, 1]);
+}
+
+#[test]
+fn test_usize() {
+ check_round_trip(vec![1, 2, 3, ::std::usize::MIN, 0, 1, ::std::usize::MAX, 2, 1]);
+}
+
+#[test]
+fn test_i8() {
+ let mut vec = vec![];
+ for i in ::std::i8::MIN..::std::i8::MAX {
+ vec.push(i);
+ }
+ check_round_trip(vec);
+}
+
+#[test]
+fn test_i16() {
+ for i in ::std::i16::MIN..::std::i16::MAX {
+ check_round_trip(vec![-1, 2, -3, i, i, i, 2]);
+ }
+}
+
+#[test]
+fn test_i32() {
+ check_round_trip(vec![-1, 2, -3, ::std::i32::MIN, 0, 1, ::std::i32::MAX, 2, 1]);
+}
+
+#[test]
+fn test_i64() {
+ check_round_trip(vec![-1, 2, -3, ::std::i64::MIN, 0, 1, ::std::i64::MAX, 2, 1]);
+}
+
+#[test]
+fn test_isize() {
+ check_round_trip(vec![-1, 2, -3, ::std::isize::MIN, 0, 1, ::std::isize::MAX, 2, 1]);
+}
+
+#[test]
+fn test_bool() {
+ check_round_trip(vec![false, true, true, false, false]);
+}
+
+#[test]
+fn test_f32() {
+ let mut vec = vec![];
+ for i in -100..100 {
+ vec.push((i as f32) / 3.0);
+ }
+ check_round_trip(vec);
+}
+
+#[test]
+fn test_f64() {
+ let mut vec = vec![];
+ for i in -100..100 {
+ vec.push((i as f64) / 3.0);
+ }
+ check_round_trip(vec);
+}
+
+#[test]
+fn test_char() {
+ let vec = vec!['a', 'b', 'c', 'd', 'A', 'X', ' ', '#', 'Ö', 'Ä', 'µ', '€'];
+ check_round_trip(vec);
+}
+
+#[test]
+fn test_string() {
+ let vec = vec!["abcbuÖeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
+ "abcbuÖganeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
+ "abcbuÖganeiovÄnameÜavmpßvmea€µsbpapmaebn".to_string(),
+ "abcbuÖganeiovÄnameÜavmpßvmeabpnvapeapmaebn".to_string(),
+ "abcbuÖganeiÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
+ "abcbuÖganeiovÄnameÜavmpßvmea€µsbpmaebn".to_string(),
+ "abcbuÖganeiovÄnameÜavmpßvmea€µnvapeapmaebn".to_string()];
+
+ check_round_trip(vec);
+}
+
+#[test]
+fn test_option() {
+ check_round_trip(vec![Some(-1i8)]);
+ check_round_trip(vec![Some(-2i16)]);
+ check_round_trip(vec![Some(-3i32)]);
+ check_round_trip(vec![Some(-4i64)]);
+ check_round_trip(vec![Some(-5isize)]);
+
+ let none_i8: Option<i8> = None;
+ check_round_trip(vec![none_i8]);
+
+ let none_i16: Option<i16> = None;
+ check_round_trip(vec![none_i16]);
+
+ let none_i32: Option<i32> = None;
+ check_round_trip(vec![none_i32]);
+
+ let none_i64: Option<i64> = None;
+ check_round_trip(vec![none_i64]);
+
+ let none_isize: Option<isize> = None;
+ check_round_trip(vec![none_isize]);
+}
+
+#[test]
+fn test_struct() {
+ check_round_trip(vec![Struct {
+ a: (),
+ b: 10,
+ c: 11,
+ d: 12,
+ e: 13,
+ f: 14,
+
+ g: 15,
+ h: 16,
+ i: 17,
+ j: 18,
+ k: 19,
+
+ l: 'x',
+ m: "abc".to_string(),
+ n: 20.5,
+ o: 21.5,
+ p: false,
+ q: None,
+ }]);
+
+ check_round_trip(vec![Struct {
+ a: (),
+ b: 101,
+ c: 111,
+ d: 121,
+ e: 131,
+ f: 141,
+
+ g: -15,
+ h: -16,
+ i: -17,
+ j: -18,
+ k: -19,
+
+ l: 'y',
+ m: "def".to_string(),
+ n: -20.5,
+ o: -21.5,
+ p: true,
+ q: Some(1234567),
+ }]);
+}
+
+#[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)]
+enum Enum {
+ Variant1,
+ Variant2(usize, f32),
+ Variant3 {
+ a: i32,
+ b: char,
+ c: bool,
+ },
+}
+
+#[test]
+fn test_enum() {
+ check_round_trip(vec![Enum::Variant1,
+ Enum::Variant2(1, 2.5),
+ Enum::Variant3 {
+ a: 3,
+ b: 'b',
+ c: false,
+ },
+ Enum::Variant3 {
+ a: -4,
+ b: 'f',
+ c: true,
+ }]);
+}
+
+#[test]
+fn test_sequence() {
+ let mut vec = vec![];
+ for i in -100i64..100i64 {
+ vec.push(i * 100000);
+ }
+
+ check_round_trip(vec![vec]);
+}
+
+#[test]
+fn test_hash_map() {
+ use std::collections::HashMap;
+ let mut map = HashMap::new();
+ for i in -100i64..100i64 {
+ map.insert(i * 100000, i * 10000);
+ }
+
+ check_round_trip(vec![map]);
+}
+
+#[test]
+fn test_tuples() {
+ check_round_trip(vec![('x', (), false, 0.5f32)]);
+ check_round_trip(vec![(9i8, 10u16, 1.5f64)]);
+ check_round_trip(vec![(-12i16, 11u8, 12usize)]);
+ check_round_trip(vec![(1234567isize, 100000000000000u64, 99999999999999i64)]);
+ check_round_trip(vec![(String::new(), "some string".to_string())]);
+}
/// }
///
/// impl Viking {
-/// /// Create a new Viking.
+/// /// Creates a new Viking.
/// fn new(name: &str, country: &str) -> Viking {
/// Viking { name: name.to_string(), country: country.to_string() }
/// }
(retkey, retval, gap.into_table())
}
-/// Perform robin hood bucket stealing at the given `bucket`. You must
+/// Performs robin hood bucket stealing at the given `bucket`. You must
/// also pass that bucket's displacement so we don't have to recalculate it.
///
/// `hash`, `key`, and `val` are the elements to "robin hood" into the hashtable.
self.table.size()
}
- /// Returns true if the map contains no elements.
+ /// Returns `true` if the map contains no elements.
///
/// # Examples
///
self.search(k).map(|bucket| bucket.into_refs())
}
- /// Returns true if the map contains a value for the specified key.
+ /// Returns `true` if the map contains a value for the specified key.
///
/// The key may be any borrowed form of the map's key type, but
/// [`Hash`] and [`Eq`] on the borrowed form *must* match those for
where S: BuildHasher,
K: Eq + Hash,
{
- /// Create a `RawEntryMut` from the given key.
+ /// Creates a `RawEntryMut` from the given key.
#[unstable(feature = "hash_raw_entry", issue = "56167")]
pub fn from_key<Q: ?Sized>(self, k: &Q) -> RawEntryMut<'a, K, V, S>
where K: Borrow<Q>,
self.from_key_hashed_nocheck(hasher.finish(), k)
}
- /// Create a `RawEntryMut` from the given key and its hash.
+ /// Creates a `RawEntryMut` from the given key and its hash.
#[inline]
#[unstable(feature = "hash_raw_entry", issue = "56167")]
pub fn from_key_hashed_nocheck<Q: ?Sized>(self, hash: u64, k: &Q) -> RawEntryMut<'a, K, V, S>
}
}
}
- /// Create a `RawEntryMut` from the given hash.
+ /// Creates a `RawEntryMut` from the given hash.
#[inline]
#[unstable(feature = "hash_raw_entry", issue = "56167")]
pub fn from_hash<F>(self, hash: u64, is_match: F) -> RawEntryMut<'a, K, V, S>
self.map.len()
}
- /// Returns true if the set contains no elements.
+ /// Returns `true` if the set contains no elements.
///
/// # Examples
///
Recover::replace(&mut self.map, value)
}
- /// Removes a value from the set. Returns `true` if the value was
+ /// Removes a value from the set. Returns whether the value was
/// present in the set.
///
/// The value may be any borrowed form of the set's value type, but
pub fn into_table(self) -> M {
self.table
}
- /// Get the raw index.
+ /// Gets the raw index.
pub fn index(&self) -> usize {
self.raw.idx
}
- /// Get the raw bucket.
+ /// Gets the raw bucket.
pub fn raw(&self) -> RawBucket<K, V> {
self.raw
}
}
impl<K, V, M> Bucket<K, V, M> {
- /// Get the raw index.
+ /// Gets the raw index.
pub fn index(&self) -> usize {
self.raw.idx
}
}
}
- /// Get the distance between this bucket and the 'ideal' location
+ /// Gets the distance between this bucket and the 'ideal' location
/// as determined by the key's hash stored in it.
///
/// In the cited blog posts above, this is called the "distance to
}
}
- /// Set the table tag
+ /// Sets the table tag.
pub fn set_tag(&mut self, value: bool) {
self.hashes.set_tag(value)
}
- /// Get the table tag
+ /// Gets the table tag.
pub fn tag(&self) -> bool {
self.hashes.tag()
}
//! // A client of the bar. They have a blood alcohol level.
//! struct Person { blood_alcohol: f32 }
//!
-//! // All the orders made to the bar, by client id.
-//! let orders = vec![1,2,1,2,3,4,1,2,2,3,4,1,1,1];
+//! // All the orders made to the bar, by client ID.
+//! let orders = vec![1, 2, 1, 2, 3, 4, 1, 2, 2, 3, 4, 1, 1, 1];
//!
//! // Our clients.
//! let mut blood_alcohol = BTreeMap::new();
#[stable(feature = "error_source", since = "1.30.0")]
fn source(&self) -> Option<&(dyn Error + 'static)> { None }
- /// Get the `TypeId` of `self`
+ /// Gets the `TypeId` of `self`
#[doc(hidden)]
#[stable(feature = "error_type_id", since = "1.34.0")]
fn type_id(&self) -> TypeId where Self: 'static {
// copied from any.rs
impl dyn Error + 'static {
- /// Returns true if the boxed type is the same as `T`
+ /// Returns `true` if the boxed type is the same as `T`
#[stable(feature = "error_downcast", since = "1.3.0")]
#[inline]
pub fn is<T: Error + 'static>(&self) -> bool {
Err(self)
}
}
+
+ /// Returns an iterator starting with the current error and continuing with
+ /// recursively calling [`source`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(error_iter)]
+ /// use std::error::Error;
+ /// use std::fmt;
+ ///
+ /// #[derive(Debug)]
+ /// struct A;
+ ///
+ /// #[derive(Debug)]
+ /// struct B(Option<Box<dyn Error + 'static>>);
+ ///
+ /// impl fmt::Display for A {
+ /// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ /// write!(f, "A")
+ /// }
+ /// }
+ ///
+ /// impl fmt::Display for B {
+ /// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ /// write!(f, "B")
+ /// }
+ /// }
+ ///
+ /// impl Error for A {}
+ ///
+ /// impl Error for B {
+ /// fn source(&self) -> Option<&(dyn Error + 'static)> {
+ /// self.0.as_ref().map(|e| e.as_ref())
+ /// }
+ /// }
+ ///
+ /// let b = B(Some(Box::new(A)));
+ ///
+ /// // let err : Box<Error> = b.into(); // or
+ /// let err = &b as &(dyn Error);
+ ///
+ /// let mut iter = err.iter_chain();
+ ///
+ /// assert_eq!("B".to_string(), iter.next().unwrap().to_string());
+ /// assert_eq!("A".to_string(), iter.next().unwrap().to_string());
+ /// assert!(iter.next().is_none());
+ /// assert!(iter.next().is_none());
+ /// ```
+ ///
+ /// [`source`]: trait.Error.html#method.source
+ #[unstable(feature = "error_iter", issue = "58289")]
+ #[inline]
+ pub fn iter_chain(&self) -> ErrorIter {
+ ErrorIter {
+ current: Some(self),
+ }
+ }
+
+ /// Returns an iterator starting with the [`source`] of this error
+ /// and continuing with recursively calling [`source`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(error_iter)]
+ /// use std::error::Error;
+ /// use std::fmt;
+ ///
+ /// #[derive(Debug)]
+ /// struct A;
+ ///
+ /// #[derive(Debug)]
+ /// struct B(Option<Box<dyn Error + 'static>>);
+ ///
+ /// #[derive(Debug)]
+ /// struct C(Option<Box<dyn Error + 'static>>);
+ ///
+ /// impl fmt::Display for A {
+ /// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ /// write!(f, "A")
+ /// }
+ /// }
+ ///
+ /// impl fmt::Display for B {
+ /// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ /// write!(f, "B")
+ /// }
+ /// }
+ ///
+ /// impl fmt::Display for C {
+ /// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ /// write!(f, "C")
+ /// }
+ /// }
+ ///
+ /// impl Error for A {}
+ ///
+ /// impl Error for B {
+ /// fn source(&self) -> Option<&(dyn Error + 'static)> {
+ /// self.0.as_ref().map(|e| e.as_ref())
+ /// }
+ /// }
+ ///
+ /// impl Error for C {
+ /// fn source(&self) -> Option<&(dyn Error + 'static)> {
+ /// self.0.as_ref().map(|e| e.as_ref())
+ /// }
+ /// }
+ ///
+ /// let b = B(Some(Box::new(A)));
+ /// let c = C(Some(Box::new(b)));
+ ///
+ /// // let err : Box<Error> = c.into(); // or
+ /// let err = &c as &(dyn Error);
+ ///
+ /// let mut iter = err.iter_sources();
+ ///
+ /// assert_eq!("B".to_string(), iter.next().unwrap().to_string());
+ /// assert_eq!("A".to_string(), iter.next().unwrap().to_string());
+ /// assert!(iter.next().is_none());
+ /// assert!(iter.next().is_none());
+ /// ```
+ ///
+ /// [`source`]: trait.Error.html#method.source
+ #[inline]
+ #[unstable(feature = "error_iter", issue = "58289")]
+ pub fn iter_sources(&self) -> ErrorIter {
+ ErrorIter {
+ current: self.source(),
+ }
+ }
+}
+
+/// An iterator over [`Error`]
+///
+/// [`Error`]: trait.Error.html
+#[unstable(feature = "error_iter", issue = "58289")]
+#[derive(Copy, Clone, Debug)]
+pub struct ErrorIter<'a> {
+ current: Option<&'a (dyn Error + 'static)>,
+}
+
+#[unstable(feature = "error_iter", issue = "58289")]
+impl<'a> Iterator for ErrorIter<'a> {
+ type Item = &'a (dyn Error + 'static);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let current = self.current;
+ self.current = self.current.and_then(Error::source);
+ current
+ }
}
impl dyn Error + Send {
/// Calculates the least nonnegative remainder of `self (mod rhs)`.
///
/// In particular, the return value `r` satisfies `0.0 <= r < rhs.abs()` in
- /// most cases. However, due to a floating point round-off error it can
+ /// most cases. However, due to a floating point round-off error it can
/// result in `r == rhs.abs()`, violating the mathematical definition, if
/// `self` is much smaller than `rhs.abs()` in magnitude and `self < 0.0`.
/// This result is not an element of the function's codomain, but it is the
///
/// # Examples
///
- /// Create a `CString`, pass ownership to an `extern` function (via raw pointer), then retake
+ /// Creates a `CString`, pass ownership to an `extern` function (via raw pointer), then retake
/// ownership with `from_raw`:
///
/// ```ignore (extern-declaration)
///
/// `OsString` and [`OsStr`] bridge this gap by simultaneously representing Rust
/// and platform-native string values, and in particular allowing a Rust string
-/// to be converted into an "OS" string with no cost if possible. A consequence
+/// to be converted into an "OS" string with no cost if possible. A consequence
/// of this is that `OsString` instances are *not* `NUL` terminated; in order
/// to pass to e.g., Unix system call, you should create a [`CStr`].
///
/// already sufficient.
///
/// Note that the allocator may give the collection more space than it
- /// requests. Therefore capacity can not be relied upon to be precisely
+ /// requests. Therefore, capacity can not be relied upon to be precisely
/// minimal. Prefer reserve if future insertions are expected.
///
/// # Examples
///
/// # Examples
///
-/// Create a new file and write bytes to it:
+/// Creates a new file and write bytes to it:
///
/// ```no_run
/// use std::fs::File;
/// Read the entire contents of a file into a bytes vector.
///
/// This is a convenience function for using [`File::open`] and [`read_to_end`]
-/// with fewer imports and without an intermediate variable. It pre-allocates a
+/// with fewer imports and without an intermediate variable. It pre-allocates a
/// buffer based on the file size when available, so it is generally faster than
/// reading into a vector created with `Vec::new()`.
///
/// Read the entire contents of a file into a string.
///
/// This is a convenience function for using [`File::open`] and [`read_to_string`]
-/// with fewer imports and without an intermediate variable. It pre-allocates a
+/// with fewer imports and without an intermediate variable. It pre-allocates a
/// buffer based on the file size when available, so it is generally faster than
/// reading into a string created with `String::new()`.
///
self.inner.file_attr().map(Metadata)
}
- /// Create a new `File` instance that shares the same underlying file handle
+ /// Creates a new `File` instance that shares the same underlying file handle
/// as the existing `File` instance. Reads, writes, and seeks will affect
/// both `File` instances simultaneously.
///
/// # Examples
///
- /// Create two handles for a file named `foo.txt`:
+ /// Creates two handles for a file named `foo.txt`:
///
/// ```no_run
/// use std::fs::File;
FileType(self.0.file_type())
}
- /// Returns whether this metadata is for a directory. The
+ /// Returns `true` if this metadata is for a directory. The
/// result is mutually exclusive to the result of
/// [`is_file`], and will be false for symlink metadata
/// obtained from [`symlink_metadata`].
#[stable(feature = "rust1", since = "1.0.0")]
pub fn is_dir(&self) -> bool { self.file_type().is_dir() }
- /// Returns whether this metadata is for a regular file. The
+ /// Returns `true` if this metadata is for a regular file. The
/// result is mutually exclusive to the result of
/// [`is_dir`], and will be false for symlink metadata
/// obtained from [`symlink_metadata`].
}
impl Permissions {
- /// Returns whether these permissions describe a readonly (unwritable) file.
+ /// Returns `true` if these permissions describe a readonly (unwritable) file.
///
/// # Examples
///
}
impl FileType {
- /// Test whether this file type represents a directory. The
+ /// Tests whether this file type represents a directory. The
/// result is mutually exclusive to the results of
/// [`is_file`] and [`is_symlink`]; only zero or one of these
/// tests may pass.
#[stable(feature = "file_type", since = "1.1.0")]
pub fn is_dir(&self) -> bool { self.0.is_dir() }
- /// Test whether this file type represents a regular file.
+ /// Tests whether this file type represents a regular file.
/// The result is mutually exclusive to the results of
/// [`is_dir`] and [`is_symlink`]; only zero or one of these
/// tests may pass.
#[stable(feature = "file_type", since = "1.1.0")]
pub fn is_file(&self) -> bool { self.0.is_file() }
- /// Test whether this file type represents a symbolic link.
+ /// Tests whether this file type represents a symbolic link.
/// The result is mutually exclusive to the results of
/// [`is_dir`] and [`is_file`]; only zero or one of these
/// tests may pass.
/// with the [`fs::symlink_metadata`] function and not the
/// [`fs::metadata`] function. The [`fs::metadata`] function
/// follows symbolic links, so [`is_symlink`] would always
- /// return false for the target file.
+ /// return `false` for the target file.
///
/// [`Metadata`]: struct.Metadata.html
/// [`fs::metadata`]: fn.metadata.html
#[stable(feature = "rust1", since = "1.0.0")]
pub fn path(&self) -> PathBuf { self.0.path() }
- /// Return the metadata for the file that this entry points at.
+ /// Returns the metadata for the file that this entry points at.
///
/// This function will not traverse symlinks if this entry points at a
/// symlink.
self.0.metadata().map(Metadata)
}
- /// Return the file type for the file that this entry points at.
+ /// Returns the file type for the file that this entry points at.
///
/// This function will not traverse symlinks if this entry points at a
/// symlink.
self
}
- /// Create the specified directory with the options configured in this
+ /// Creates the specified directory with the options configured in this
/// builder.
///
/// It is considered an error if the directory already exists unless
use core::pin::Pin;
use core::option::Option;
use core::ptr::NonNull;
-use core::task::{LocalWaker, Poll};
+use core::task::{Waker, Poll};
use core::ops::{Drop, Generator, GeneratorState};
#[doc(inline)]
#[unstable(feature = "gen_future", issue = "50547")]
impl<T: Generator<Yield = ()>> Future for GenFuture<T> {
type Output = T::Return;
- fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output> {
+ fn poll(self: Pin<&mut Self>, waker: &Waker) -> Poll<Self::Output> {
// Safe because we're !Unpin + !Drop mapping to a ?Unpin value
let gen = unsafe { Pin::map_unchecked_mut(self, |s| &mut s.0) };
- set_task_waker(lw, || match gen.resume() {
+ set_task_waker(waker, || match gen.resume() {
GeneratorState::Yielded(()) => Poll::Pending,
GeneratorState::Complete(x) => Poll::Ready(x),
})
}
thread_local! {
- static TLS_WAKER: Cell<Option<NonNull<LocalWaker>>> = Cell::new(None);
+ static TLS_WAKER: Cell<Option<NonNull<Waker>>> = Cell::new(None);
}
-struct SetOnDrop(Option<NonNull<LocalWaker>>);
+struct SetOnDrop(Option<NonNull<Waker>>);
impl Drop for SetOnDrop {
fn drop(&mut self) {
#[unstable(feature = "gen_future", issue = "50547")]
/// Sets the thread-local task context used by async/await futures.
-pub fn set_task_waker<F, R>(lw: &LocalWaker, f: F) -> R
+pub fn set_task_waker<F, R>(waker: &Waker, f: F) -> R
where
F: FnOnce() -> R
{
let old_waker = TLS_WAKER.with(|tls_waker| {
- tls_waker.replace(Some(NonNull::from(lw)))
+ tls_waker.replace(Some(NonNull::from(waker)))
});
let _reset_waker = SetOnDrop(old_waker);
f()
/// retrieved by a surrounding call to get_task_waker.
pub fn get_task_waker<F, R>(f: F) -> R
where
- F: FnOnce(&LocalWaker) -> R
+ F: FnOnce(&Waker) -> R
{
let waker_ptr = TLS_WAKER.with(|tls_waker| {
// Clear the entry so that nested `get_task_waker` calls
let _reset_waker = SetOnDrop(waker_ptr);
let waker_ptr = waker_ptr.expect(
- "TLS LocalWaker not set. This is a rustc bug. \
+ "TLS Waker not set. This is a rustc bug. \
Please file an issue on https://github.com/rust-lang/rust.");
unsafe { f(waker_ptr.as_ref()) }
}
where
F: Future
{
- get_task_waker(|lw| F::poll(f, lw))
+ get_task_waker(|waker| F::poll(f, waker))
}
/// the underlying [`Read`] and maintains an in-memory buffer of the results.
///
/// `BufReader` can improve the speed of programs that make *small* and
-/// *repeated* read calls to the same file or network socket. It does not
+/// *repeated* read calls to the same file or network socket. It does not
/// help when reading very large amounts at once, or reading just one or a few
-/// times. It also provides no advantage when reading from a source that is
+/// times. It also provides no advantage when reading from a source that is
/// already in memory, like a `Vec<u8>`.
///
/// [`Read`]: ../../std/io/trait.Read.html
/// writer in large, infrequent batches.
///
/// `BufWriter` can improve the speed of programs that make *small* and
-/// *repeated* write calls to the same file or network socket. It does not
+/// *repeated* write calls to the same file or network socket. It does not
/// help when writing very large amounts at once, or writing just one or a few
-/// times. It also provides no advantage when writing to a destination that is
+/// times. It also provides no advantage when writing to a destination that is
/// in memory, like a `Vec<u8>`.
///
/// When the `BufWriter` is dropped, the contents of its buffer will be written
#[derive(Copy, PartialEq, Eq, Clone, Debug)]
#[stable(feature = "rust1", since = "1.0.0")]
pub enum SeekFrom {
- /// Set the offset to the provided number of bytes.
+ /// Sets the offset to the provided number of bytes.
#[stable(feature = "rust1", since = "1.0.0")]
Start(#[stable(feature = "rust1", since = "1.0.0")] u64),
- /// Set the offset to the size of this object plus the specified number of
+ /// Sets the offset to the size of this object plus the specified number of
/// bytes.
///
/// It is possible to seek beyond the end of an object, but it's an error to
#[stable(feature = "rust1", since = "1.0.0")]
End(#[stable(feature = "rust1", since = "1.0.0")] i64),
- /// Set the offset to the current position plus the specified number of
+ /// Sets the offset to the current position plus the specified number of
/// bytes.
///
/// It is possible to seek beyond the end of an object, but it's an error to
/// }
///
/// fn generic_where<T>(x: T) -> T
-/// where T: std::ops::Add<Output=T> + Copy
+/// where T: std::ops::Add<Output = T> + Copy
/// {
/// x + x + x
/// }
/// `for` is primarily used in for-in-loops, but it has a few other pieces of syntactic uses such as
/// `impl Trait for Type` (see [`impl`] for more info on that). for-in-loops, or to be more
/// precise, iterator loops, are a simple syntactic sugar over an exceedingly common practice
-/// within Rust, which is to loop over an iterator until that iterator returns None (or `break`
+/// within Rust, which is to loop over an iterator until that iterator returns `None` (or `break`
/// is called).
///
/// ```rust
/// directly accessed and modified.
///
/// Tuple structs are similar to regular structs, but its fields have no names. They are used like
-/// tuples, with deconstruction possible via `let TupleStruct(x, y) = foo;` syntax. For accessing
+/// tuples, with deconstruction possible via `let TupleStruct(x, y) = foo;` syntax. For accessing
/// individual variables, the same syntax is used as with regular tuples, namely `foo.0`, `foo.1`,
/// etc, starting at zero.
///
//! primitives](#primitives), [standard macros](#macros), [I/O] and
//! [multithreading], among [many other things][other].
//!
-//! `std` is available to all Rust crates by default. Therefore the
+//! `std` is available to all Rust crates by default. Therefore, the
//! standard library can be accessed in [`use`] statements through the path
//! `std`, as in [`use std::env`].
//!
#[cfg(test)] extern crate std as realstd;
#[cfg(all(target_vendor = "fortanix", target_env = "sgx"))]
-#[macro_use]
-#[allow(unused_imports)] // FIXME: without `#[macro_use]`, get error: “cannot
- // determine resolution for the macro `usercalls_asm`”
extern crate fortanix_sgx_abi;
// The standard macros that are not built-in to the compiler.
//! Types and Traits for working with asynchronous tasks.
#[doc(inline)]
pub use core::task::*;
- #[doc(inline)]
- pub use alloc_crate::task::*;
}
#[unstable(feature = "futures_api",
///
/// This allows a program to terminate immediately and provide feedback
/// to the caller of the program. `panic!` should be used when a program reaches
-/// an unrecoverable problem.
+/// an unrecoverable state.
///
/// This macro is the perfect way to assert conditions in example code and in
-/// tests. `panic!` is closely tied with the `unwrap` method of both [`Option`]
-/// and [`Result`][runwrap] enums. Both implementations call `panic!` when they are set
+/// tests. `panic!` is closely tied with the `unwrap` method of both [`Option`]
+/// and [`Result`][runwrap] enums. Both implementations call `panic!` when they are set
/// to None or Err variants.
///
/// This macro is used to inject panic into a Rust thread, causing the thread to
/// is transmitted.
///
/// [`Result`] enum is often a better solution for recovering from errors than
-/// using the `panic!` macro. This macro should be used to avoid proceeding using
+/// using the `panic!` macro. This macro should be used to avoid proceeding using
/// incorrect values, such as from external sources. Detailed information about
/// error handling is found in the [book].
///
/// ```
#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow_internal_unstable]
+#[cfg_attr(stage0, allow_internal_unstable)]
+#[cfg_attr(not(stage0), allow_internal_unstable(__rust_unstable_column, libstd_sys_internals))]
macro_rules! panic {
() => ({
panic!("explicit panic")
/// necessary to use [`io::stdout().flush()`][flush] to ensure the output is emitted
/// immediately.
///
-/// Use `print!` only for the primary output of your program. Use
+/// Use `print!` only for the primary output of your program. Use
/// [`eprint!`] instead to print error and progress messages.
///
/// [`println!`]: ../std/macro.println.html
/// ```
#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow_internal_unstable]
+#[cfg_attr(stage0, allow_internal_unstable)]
+#[cfg_attr(not(stage0), allow_internal_unstable(print_internals))]
macro_rules! print {
($($arg:tt)*) => ($crate::io::_print(format_args!($($arg)*)));
}
/// Use the [`format!`] syntax to write data to the standard output.
/// See [`std::fmt`] for more information.
///
-/// Use `println!` only for the primary output of your program. Use
+/// Use `println!` only for the primary output of your program. Use
/// [`eprintln!`] instead to print error and progress messages.
///
/// [`format!`]: ../std/macro.format.html
/// ```
#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow_internal_unstable]
+#[cfg_attr(stage0, allow_internal_unstable)]
+#[cfg_attr(not(stage0), allow_internal_unstable(print_internals, format_args_nl))]
macro_rules! println {
() => (print!("\n"));
($($arg:tt)*) => ({
/// Macro for printing to the standard error.
///
/// Equivalent to the [`print!`] macro, except that output goes to
-/// [`io::stderr`] instead of `io::stdout`. See [`print!`] for
+/// [`io::stderr`] instead of `io::stdout`. See [`print!`] for
/// example usage.
///
-/// Use `eprint!` only for error and progress messages. Use `print!`
+/// Use `eprint!` only for error and progress messages. Use `print!`
/// instead for the primary output of your program.
///
/// [`io::stderr`]: ../std/io/struct.Stderr.html
/// ```
#[macro_export]
#[stable(feature = "eprint", since = "1.19.0")]
-#[allow_internal_unstable]
+#[cfg_attr(stage0, allow_internal_unstable)]
+#[cfg_attr(not(stage0), allow_internal_unstable(print_internals))]
macro_rules! eprint {
($($arg:tt)*) => ($crate::io::_eprint(format_args!($($arg)*)));
}
/// Macro for printing to the standard error, with a newline.
///
/// Equivalent to the [`println!`] macro, except that output goes to
-/// [`io::stderr`] instead of `io::stdout`. See [`println!`] for
+/// [`io::stderr`] instead of `io::stdout`. See [`println!`] for
/// example usage.
///
-/// Use `eprintln!` only for error and progress messages. Use `println!`
+/// Use `eprintln!` only for error and progress messages. Use `println!`
/// instead for the primary output of your program.
///
/// [`io::stderr`]: ../std/io/struct.Stderr.html
/// ```
#[macro_export]
#[stable(feature = "eprint", since = "1.19.0")]
-#[allow_internal_unstable]
+#[cfg_attr(stage0, allow_internal_unstable)]
+#[cfg_attr(not(stage0), allow_internal_unstable(print_internals, format_args_nl))]
macro_rules! eprintln {
() => (eprint!("\n"));
($($arg:tt)*) => ({
/// A macro to await on an async call.
#[macro_export]
#[unstable(feature = "await_macro", issue = "50547")]
-#[allow_internal_unstable]
+#[cfg_attr(stage0, allow_internal_unstable)]
+#[cfg_attr(not(stage0), allow_internal_unstable(gen_future, generators))]
#[allow_internal_unsafe]
macro_rules! await {
($e:expr) => { {
/// The core macro for formatted string creation & output.
///
/// This macro functions by taking a formatting string literal containing
- /// `{}` for each additional argument passed. `format_args!` prepares the
+ /// `{}` for each additional argument passed. `format_args!` prepares the
/// additional parameters to ensure the output can be interpreted as a string
- /// and canonicalizes the arguments into a single type. Any value that implements
+ /// and canonicalizes the arguments into a single type. Any value that implements
/// the [`Display`] trait can be passed to `format_args!`, as can any
/// [`Debug`] implementation be passed to a `{:?}` within the formatting string.
///
/// This macro produces a value of type [`fmt::Arguments`]. This value can be
/// passed to the macros within [`std::fmt`] for performing useful redirection.
/// All other formatting macros ([`format!`], [`write!`], [`println!`], etc) are
- /// proxied through this one. `format_args!`, unlike its derived macros, avoids
+ /// proxied through this one. `format_args!`, unlike its derived macros, avoids
/// heap allocations.
///
/// You can use the [`fmt::Arguments`] value that `format_args!` returns
/// If the named environment variable is present at compile time, this will
/// expand into an expression of type `Option<&'static str>` whose value is
/// `Some` of the value of the environment variable. If the environment
- /// variable is not present, then this will expand to `None`. See
+ /// variable is not present, then this will expand to `None`. See
/// [`Option<T>`][option] for more information on this type.
///
/// A compile time error is never emitted when using this macro regardless
/// # Custom Messages
///
/// This macro has a second form, where a custom panic message can
- /// be provided with or without arguments for formatting. See [`std::fmt`]
+ /// be provided with or without arguments for formatting. See [`std::fmt`]
/// for syntax for this form.
///
/// [`panic!`]: macro.panic.html
self.inner.sin6_scope_id
}
- /// Change the scope ID associated with this socket address.
+ /// Changes the scope ID associated with this socket address.
///
/// See the [`scope_id`] method's documentation for more details.
///
/// [`SocketAddr`] values.
///
/// This trait is used for generic address resolution when constructing network
-/// objects. By default it is implemented for the following types:
+/// objects. By default it is implemented for the following types:
///
/// * [`SocketAddr`]: [`to_socket_addrs`] is the identity function.
///
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn octets(&self) -> [u8; 4] {
- let bits = u32::from_be(self.inner.s_addr);
- [(bits >> 24) as u8, (bits >> 16) as u8, (bits >> 8) as u8, bits as u8]
+ self.inner.s_addr.to_ne_bytes()
}
/// Returns [`true`] for the special 'unspecified' address (0.0.0.0).
#[stable(feature = "ip_u32", since = "1.1.0")]
impl From<Ipv4Addr> for u32 {
- /// Convert an `Ipv4Addr` into a host byte order `u32`.
+ /// Converts an `Ipv4Addr` into a host byte order `u32`.
///
/// # Examples
///
#[stable(feature = "ip_u32", since = "1.1.0")]
impl From<u32> for Ipv4Addr {
- /// Convert a host byte order `u32` into an `Ipv4Addr`.
+ /// Converts a host byte order `u32` into an `Ipv4Addr`.
///
/// # Examples
///
#[stable(feature = "ip_from_slice", since = "1.17.0")]
impl From<[u8; 4]> for IpAddr {
- /// Create an `IpAddr::V4` from a four element byte array.
+ /// Creates an `IpAddr::V4` from a four element byte array.
///
/// # Examples
///
#[stable(feature = "ip_from_slice", since = "1.17.0")]
impl From<[u8; 16]> for IpAddr {
- /// Create an `IpAddr::V6` from a sixteen element byte array.
+ /// Creates an `IpAddr::V6` from a sixteen element byte array.
///
/// # Examples
///
#[stable(feature = "ip_from_slice", since = "1.17.0")]
impl From<[u16; 8]> for IpAddr {
- /// Create an `IpAddr::V6` from an eight element 16-bit array.
+ /// Creates an `IpAddr::V6` from an eight element 16-bit array.
///
/// # Examples
///
self.0.ttl()
}
- /// Get the value of the `SO_ERROR` option on this socket.
+ /// Gets the value of the `SO_ERROR` option on this socket.
///
/// This will retrieve the stored error in the underlying socket, clearing
/// the field in the process. This can be useful for checking errors between
///
/// # Examples
///
- /// Create a TCP listener bound to `127.0.0.1:80`:
+ /// Creates a TCP listener bound to `127.0.0.1:80`:
///
/// ```no_run
/// use std::net::TcpListener;
/// let listener = TcpListener::bind("127.0.0.1:80").unwrap();
/// ```
///
- /// Create a TCP listener bound to `127.0.0.1:80`. If that fails, create a
+ /// Creates a TCP listener bound to `127.0.0.1:80`. If that fails, create a
/// TCP listener bound to `127.0.0.1:443`:
///
/// ```no_run
self.0.only_v6()
}
- /// Get the value of the `SO_ERROR` option on this socket.
+ /// Gets the value of the `SO_ERROR` option on this socket.
///
/// This will retrieve the stored error in the underlying socket, clearing
/// the field in the process. This can be useful for checking errors between
///
/// # Examples
///
- /// Create a UDP socket bound to `127.0.0.1:3400`:
+ /// Creates a UDP socket bound to `127.0.0.1:3400`:
///
/// ```no_run
/// use std::net::UdpSocket;
/// let socket = UdpSocket::bind("127.0.0.1:3400").expect("couldn't bind to address");
/// ```
///
- /// Create a UDP socket bound to `127.0.0.1:3400`. If the socket cannot be
+ /// Creates a UDP socket bound to `127.0.0.1:3400`. If the socket cannot be
/// bound to that address, create a UDP socket bound to `127.0.0.1:3401`:
///
/// ```no_run
/// This will return an error when the IP version of the local socket
/// does not match that returned from [`ToSocketAddrs`].
///
- /// See <https://github.com/rust-lang/rust/issues/34202> for more details.
+ /// See issue #34202 for more details.
///
/// [`ToSocketAddrs`]: ../../std/net/trait.ToSocketAddrs.html
///
self.0.leave_multicast_v6(multiaddr, interface)
}
- /// Get the value of the `SO_ERROR` option on this socket.
+ /// Gets the value of the `SO_ERROR` option on this socket.
///
/// This will retrieve the stored error in the underlying socket, clearing
/// the field in the process. This can be useful for checking errors between
///
/// # Examples
///
- /// Create a UDP socket bound to `127.0.0.1:3400` and connect the socket to
+ /// Creates a UDP socket bound to `127.0.0.1:3400` and connect the socket to
/// `127.0.0.1:8080`:
///
/// ```no_run
///
/// # Examples
///
- /// Create a UDP socket bound to `127.0.0.1:7878` and read bytes in
+ /// Creates a UDP socket bound to `127.0.0.1:7878` and read bytes in
/// nonblocking mode:
///
/// ```no_run
use ptr::{Unique, NonNull};
use rc::Rc;
use sync::{Arc, Mutex, RwLock, atomic};
-use task::{LocalWaker, Poll};
+use task::{Waker, Poll};
use thread::Result;
#[stable(feature = "panic_hooks", since = "1.10.0")]
impl<'a, F: Future> Future for AssertUnwindSafe<F> {
type Output = F::Output;
- fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output> {
+ fn poll(self: Pin<&mut Self>, waker: &Waker) -> Poll<Self::Output> {
let pinned_field = unsafe { Pin::map_unchecked_mut(self, |x| &mut x.0) };
- F::poll(pinned_field, lw)
+ F::poll(pinned_field, waker)
}
}
fs::read_dir(self)
}
- /// Returns whether the path points at an existing entity.
+ /// Returns `true` if the path points at an existing entity.
///
/// This function will traverse symbolic links to query information about the
/// destination file. In case of broken symbolic links this will return `false`.
fs::metadata(self).is_ok()
}
- /// Returns whether the path exists on disk and is pointing at a regular file.
+ /// Returns `true` if the path exists on disk and is pointing at a regular file.
///
/// This function will traverse symbolic links to query information about the
/// destination file. In case of broken symbolic links this will return `false`.
fs::metadata(self).map(|m| m.is_file()).unwrap_or(false)
}
- /// Returns whether the path exists on disk and is pointing at a directory.
+ /// Returns `true` if the path exists on disk and is pointing at a directory.
///
/// This function will traverse symbolic links to query information about the
/// destination file. In case of broken symbolic links this will return `false`.
//! [`std::string`]: ../string/index.html
//! [`std::vec`]: ../vec/index.html
//! [`to_owned`]: ../borrow/trait.ToOwned.html#tymethod.to_owned
-//! [book-closures]: ../../book/first-edition/closures.html
-//! [book-dtor]: ../../book/first-edition/drop.html
-//! [book-enums]: ../../book/first-edition/enums.html
-//! [book-iter]: ../../book/first-edition/iterators.html
+//! [book-closures]: ../../book/ch13-01-closures.html
+//! [book-dtor]: ../../book/ch15-03-drop.html
+//! [book-enums]: ../../book/ch06-01-defining-an-enum.html
+//! [book-iter]: ../../book/ch13-02-iterators.html
#![stable(feature = "rust1", since = "1.0.0")]
///
/// ```ignore (string-from-str-error-type-is-not-never-yet)
/// #[feature(exhaustive_patterns)]
-/// // NOTE: This does not work today!
+/// // NOTE: this does not work today!
/// let Ok(s) = String::from_str("hello");
/// ```
///
/// On top of that, function pointers can vary based on what ABI they use. This is achieved by
/// adding the `extern` keyword to the type name, followed by the ABI in question. For example,
/// `fn()` is different from `extern "C" fn()`, which itself is different from `extern "stdcall"
-/// fn()`, and so on for the various ABIs that Rust supports. Non-`extern` functions have an ABI
+/// fn()`, and so on for the various ABIs that Rust supports. Non-`extern` functions have an ABI
/// of `"Rust"`, and `extern` functions without an explicit ABI have an ABI of `"C"`. For more
/// information, see [the nomicon's section on foreign calling conventions][nomicon-abi].
///
/// The search path to be used may be controlled by setting the
/// `PATH` environment variable on the Command,
/// but this has some implementation limitations on Windows
- /// (see <https://github.com/rust-lang/rust/issues/37519>).
+ /// (see issue #37519).
///
/// # Examples
///
Command { inner: imp::Command::new(program.as_ref()) }
}
- /// Add an argument to pass to the program.
+ /// Adds an argument to pass to the program.
///
/// Only one argument can be passed per use. So instead of:
///
self
}
- /// Add multiple arguments to pass to the program.
+ /// Adds multiple arguments to pass to the program.
///
/// To pass a single argument see [`arg`].
///
self
}
- /// Add or update multiple environment variable mappings.
+ /// Adds or updates multiple environment variable mappings.
///
/// # Examples
///
///
/// let mut command = Command::new("ls");
/// if let Ok(child) = command.spawn() {
- /// println!("Child's id is {}", child.id());
+ /// println!("Child's ID is {}", child.id());
/// } else {
/// println!("ls command didn't start");
/// }
///
/// This function will not block the calling thread and will only
/// check to see if the child process has exited or not. If the child has
- /// exited then on Unix the process id is reaped. This function is
+ /// exited then on Unix the process ID is reaped. This function is
/// guaranteed to repeatedly return a successful exit status so long as the
/// child has already exited.
///
}
}
- /// Test that process creation flags work by debugging a process.
+ /// Tests that process creation flags work by debugging a process.
/// Other creation flags make it hard or impossible to detect
/// behavioral changes in the process.
#[test]
}
impl BarrierWaitResult {
- /// Returns whether this thread from [`wait`] is the "leader thread".
+ /// Returns `true` if this thread from [`wait`] is the "leader thread".
///
/// Only one thread will have `true` returned from their result, all other
/// threads will have `false` returned.
pub struct WaitTimeoutResult(bool);
impl WaitTimeoutResult {
- /// Returns whether the wait was known to have timed out.
+ /// Returns `true` if the wait was known to have timed out.
///
/// # Examples
///
///
/// Note that the best effort is made to ensure that the time waited is
/// measured with a monotonic clock, and not affected by the changes made to
- /// the system time. This function is susceptible to spurious wakeups.
+ /// the system time. This function is susceptible to spurious wakeups.
/// Condition variables normally have a boolean predicate associated with
/// them, and the predicate must always be checked each time this function
- /// returns to protect against spurious wakeups. Additionally, it is
+ /// returns to protect against spurious wakeups. Additionally, it is
/// typically desirable for the time-out to not exceed some duration in
/// spite of spurious wakes, thus the sleep-duration is decremented by the
- /// amount slept. Alternatively, use the `wait_timeout_until` method
+ /// amount slept. Alternatively, use the `wait_timeout_until` method
/// to wait until a condition is met with a total time-out regardless
/// of spurious wakes.
///
}
/// Waits on this condition variable for a notification, timing out after a
- /// specified duration. Spurious wakes will not cause this function to
+ /// specified duration. Spurious wakes will not cause this function to
/// return.
///
/// The semantics of this function are equivalent to [`wait_until`] except
wake
}
- /// Convert to an unsafe usize value. Useful for storing in a pipe's state
+ /// Converts to an unsafe usize value. Useful for storing in a pipe's state
/// flag.
#[inline]
pub unsafe fn cast_to_usize(self) -> usize {
mem::transmute(self.inner)
}
- /// Convert from an unsafe usize value. Useful for retrieving a pipe's state
+ /// Converts from an unsafe usize value. Useful for retrieving a pipe's state
/// flag.
#[inline]
pub unsafe fn cast_from_usize(signal_ptr: usize) -> SignalToken {
}
}
- /// Returns true if we wake up normally, false otherwise.
+ /// Returns `true` if we wake up normally.
pub fn wait_max_until(self, end: Instant) -> bool {
while !self.inner.woken.load(Ordering::SeqCst) {
let now = Instant::now();
use self::select::StartResult::*;
use self::blocking::SignalToken;
+#[cfg(all(test, not(target_os = "emscripten")))]
+mod select_tests;
+
mod blocking;
mod oneshot;
mod select;
/// where the corresponding receiver has already been deallocated. Note
/// that a return value of [`Err`] means that the data will never be
/// received, but a return value of [`Ok`] does *not* mean that the data
- /// will be received. It is possible for the corresponding receiver to
+ /// will be received. It is possible for the corresponding receiver to
/// hang up immediately after this function returns [`Ok`].
///
/// [`Err`]: ../../../std/result/enum.Result.html#variant.Err
impl !marker::Send for Select {}
/// A handle to a receiver which is currently a member of a `Select` set of
-/// receivers. This handle is used to keep the receiver in the set as well as
+/// receivers. This handle is used to keep the receiver in the set as well as
/// interact with the underlying receiver.
pub struct Handle<'rx, T:Send+'rx> {
/// The ID of this handle, used to compare against the return value of
- /// `Select::wait()`
+ /// `Select::wait()`.
id: usize,
selector: *mut SelectInner,
next: *mut Handle<'static, ()>,
}
/// Waits for an event on this receiver set. The returned value is *not* an
- /// index, but rather an id. This id can be queried against any active
+ /// index, but rather an ID. This ID can be queried against any active
/// `Handle` structures (each one has an `id` method). The handle with
/// the matching `id` will have some sort of event available on it. The
/// event could either be that data is available or the corresponding
}
/// Helper method for skipping the preflight checks during testing
- fn wait2(&self, do_preflight_checks: bool) -> usize {
+ pub(super) fn wait2(&self, do_preflight_checks: bool) -> usize {
// Note that this is currently an inefficient implementation. We in
// theory have knowledge about all receivers in the set ahead of time,
// so this method shouldn't really have to iterate over all of them yet
}
impl<'rx, T: Send> Handle<'rx, T> {
- /// Retrieves the id of this handle.
+ /// Retrieves the ID of this handle.
#[inline]
pub fn id(&self) -> usize { self.id }
f.debug_struct("Handle").finish()
}
}
-
-#[allow(unused_imports)]
-#[cfg(all(test, not(target_os = "emscripten")))]
-mod tests {
- use thread;
- use sync::mpsc::*;
-
- // Don't use the libstd version so we can pull in the right Select structure
- // (std::comm points at the wrong one)
- macro_rules! select {
- (
- $($name:pat = $rx:ident.$meth:ident() => $code:expr),+
- ) => ({
- let sel = Select::new();
- $( let mut $rx = sel.handle(&$rx); )+
- unsafe {
- $( $rx.add(); )+
- }
- let ret = sel.wait();
- $( if ret == $rx.id() { let $name = $rx.$meth(); $code } else )+
- { unreachable!() }
- })
- }
-
- #[test]
- fn smoke() {
- let (tx1, rx1) = channel::<i32>();
- let (tx2, rx2) = channel::<i32>();
- tx1.send(1).unwrap();
- select! {
- foo = rx1.recv() => { assert_eq!(foo.unwrap(), 1); },
- _bar = rx2.recv() => { panic!() }
- }
- tx2.send(2).unwrap();
- select! {
- _foo = rx1.recv() => { panic!() },
- bar = rx2.recv() => { assert_eq!(bar.unwrap(), 2) }
- }
- drop(tx1);
- select! {
- foo = rx1.recv() => { assert!(foo.is_err()); },
- _bar = rx2.recv() => { panic!() }
- }
- drop(tx2);
- select! {
- bar = rx2.recv() => { assert!(bar.is_err()); }
- }
- }
-
- #[test]
- fn smoke2() {
- let (_tx1, rx1) = channel::<i32>();
- let (_tx2, rx2) = channel::<i32>();
- let (_tx3, rx3) = channel::<i32>();
- let (_tx4, rx4) = channel::<i32>();
- let (tx5, rx5) = channel::<i32>();
- tx5.send(4).unwrap();
- select! {
- _foo = rx1.recv() => { panic!("1") },
- _foo = rx2.recv() => { panic!("2") },
- _foo = rx3.recv() => { panic!("3") },
- _foo = rx4.recv() => { panic!("4") },
- foo = rx5.recv() => { assert_eq!(foo.unwrap(), 4); }
- }
- }
-
- #[test]
- fn closed() {
- let (_tx1, rx1) = channel::<i32>();
- let (tx2, rx2) = channel::<i32>();
- drop(tx2);
-
- select! {
- _a1 = rx1.recv() => { panic!() },
- a2 = rx2.recv() => { assert!(a2.is_err()); }
- }
- }
-
- #[test]
- fn unblocks() {
- let (tx1, rx1) = channel::<i32>();
- let (_tx2, rx2) = channel::<i32>();
- let (tx3, rx3) = channel::<i32>();
-
- let _t = thread::spawn(move|| {
- for _ in 0..20 { thread::yield_now(); }
- tx1.send(1).unwrap();
- rx3.recv().unwrap();
- for _ in 0..20 { thread::yield_now(); }
- });
-
- select! {
- a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
- _b = rx2.recv() => { panic!() }
- }
- tx3.send(1).unwrap();
- select! {
- a = rx1.recv() => { assert!(a.is_err()) },
- _b = rx2.recv() => { panic!() }
- }
- }
-
- #[test]
- fn both_ready() {
- let (tx1, rx1) = channel::<i32>();
- let (tx2, rx2) = channel::<i32>();
- let (tx3, rx3) = channel::<()>();
-
- let _t = thread::spawn(move|| {
- for _ in 0..20 { thread::yield_now(); }
- tx1.send(1).unwrap();
- tx2.send(2).unwrap();
- rx3.recv().unwrap();
- });
-
- select! {
- a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
- a = rx2.recv() => { assert_eq!(a.unwrap(), 2); }
- }
- select! {
- a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
- a = rx2.recv() => { assert_eq!(a.unwrap(), 2); }
- }
- assert_eq!(rx1.try_recv(), Err(TryRecvError::Empty));
- assert_eq!(rx2.try_recv(), Err(TryRecvError::Empty));
- tx3.send(()).unwrap();
- }
-
- #[test]
- fn stress() {
- const AMT: i32 = 10000;
- let (tx1, rx1) = channel::<i32>();
- let (tx2, rx2) = channel::<i32>();
- let (tx3, rx3) = channel::<()>();
-
- let _t = thread::spawn(move|| {
- for i in 0..AMT {
- if i % 2 == 0 {
- tx1.send(i).unwrap();
- } else {
- tx2.send(i).unwrap();
- }
- rx3.recv().unwrap();
- }
- });
-
- for i in 0..AMT {
- select! {
- i1 = rx1.recv() => { assert!(i % 2 == 0 && i == i1.unwrap()); },
- i2 = rx2.recv() => { assert!(i % 2 == 1 && i == i2.unwrap()); }
- }
- tx3.send(()).unwrap();
- }
- }
-
- #[allow(unused_must_use)]
- #[test]
- fn cloning() {
- let (tx1, rx1) = channel::<i32>();
- let (_tx2, rx2) = channel::<i32>();
- let (tx3, rx3) = channel::<()>();
-
- let _t = thread::spawn(move|| {
- rx3.recv().unwrap();
- tx1.clone();
- assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
- tx1.send(2).unwrap();
- rx3.recv().unwrap();
- });
-
- tx3.send(()).unwrap();
- select! {
- _i1 = rx1.recv() => {},
- _i2 = rx2.recv() => panic!()
- }
- tx3.send(()).unwrap();
- }
-
- #[allow(unused_must_use)]
- #[test]
- fn cloning2() {
- let (tx1, rx1) = channel::<i32>();
- let (_tx2, rx2) = channel::<i32>();
- let (tx3, rx3) = channel::<()>();
-
- let _t = thread::spawn(move|| {
- rx3.recv().unwrap();
- tx1.clone();
- assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
- tx1.send(2).unwrap();
- rx3.recv().unwrap();
- });
-
- tx3.send(()).unwrap();
- select! {
- _i1 = rx1.recv() => {},
- _i2 = rx2.recv() => panic!()
- }
- tx3.send(()).unwrap();
- }
-
- #[test]
- fn cloning3() {
- let (tx1, rx1) = channel::<()>();
- let (tx2, rx2) = channel::<()>();
- let (tx3, rx3) = channel::<()>();
- let _t = thread::spawn(move|| {
- let s = Select::new();
- let mut h1 = s.handle(&rx1);
- let mut h2 = s.handle(&rx2);
- unsafe { h2.add(); }
- unsafe { h1.add(); }
- assert_eq!(s.wait(), h2.id);
- tx3.send(()).unwrap();
- });
-
- for _ in 0..1000 { thread::yield_now(); }
- drop(tx1.clone());
- tx2.send(()).unwrap();
- rx3.recv().unwrap();
- }
-
- #[test]
- fn preflight1() {
- let (tx, rx) = channel();
- tx.send(()).unwrap();
- select! {
- _n = rx.recv() => {}
- }
- }
-
- #[test]
- fn preflight2() {
- let (tx, rx) = channel();
- tx.send(()).unwrap();
- tx.send(()).unwrap();
- select! {
- _n = rx.recv() => {}
- }
- }
-
- #[test]
- fn preflight3() {
- let (tx, rx) = channel();
- drop(tx.clone());
- tx.send(()).unwrap();
- select! {
- _n = rx.recv() => {}
- }
- }
-
- #[test]
- fn preflight4() {
- let (tx, rx) = channel();
- tx.send(()).unwrap();
- let s = Select::new();
- let mut h = s.handle(&rx);
- unsafe { h.add(); }
- assert_eq!(s.wait2(false), h.id);
- }
-
- #[test]
- fn preflight5() {
- let (tx, rx) = channel();
- tx.send(()).unwrap();
- tx.send(()).unwrap();
- let s = Select::new();
- let mut h = s.handle(&rx);
- unsafe { h.add(); }
- assert_eq!(s.wait2(false), h.id);
- }
-
- #[test]
- fn preflight6() {
- let (tx, rx) = channel();
- drop(tx.clone());
- tx.send(()).unwrap();
- let s = Select::new();
- let mut h = s.handle(&rx);
- unsafe { h.add(); }
- assert_eq!(s.wait2(false), h.id);
- }
-
- #[test]
- fn preflight7() {
- let (tx, rx) = channel::<()>();
- drop(tx);
- let s = Select::new();
- let mut h = s.handle(&rx);
- unsafe { h.add(); }
- assert_eq!(s.wait2(false), h.id);
- }
-
- #[test]
- fn preflight8() {
- let (tx, rx) = channel();
- tx.send(()).unwrap();
- drop(tx);
- rx.recv().unwrap();
- let s = Select::new();
- let mut h = s.handle(&rx);
- unsafe { h.add(); }
- assert_eq!(s.wait2(false), h.id);
- }
-
- #[test]
- fn preflight9() {
- let (tx, rx) = channel();
- drop(tx.clone());
- tx.send(()).unwrap();
- drop(tx);
- rx.recv().unwrap();
- let s = Select::new();
- let mut h = s.handle(&rx);
- unsafe { h.add(); }
- assert_eq!(s.wait2(false), h.id);
- }
-
- #[test]
- fn oneshot_data_waiting() {
- let (tx1, rx1) = channel();
- let (tx2, rx2) = channel();
- let _t = thread::spawn(move|| {
- select! {
- _n = rx1.recv() => {}
- }
- tx2.send(()).unwrap();
- });
-
- for _ in 0..100 { thread::yield_now() }
- tx1.send(()).unwrap();
- rx2.recv().unwrap();
- }
-
- #[test]
- fn stream_data_waiting() {
- let (tx1, rx1) = channel();
- let (tx2, rx2) = channel();
- tx1.send(()).unwrap();
- tx1.send(()).unwrap();
- rx1.recv().unwrap();
- rx1.recv().unwrap();
- let _t = thread::spawn(move|| {
- select! {
- _n = rx1.recv() => {}
- }
- tx2.send(()).unwrap();
- });
-
- for _ in 0..100 { thread::yield_now() }
- tx1.send(()).unwrap();
- rx2.recv().unwrap();
- }
-
- #[test]
- fn shared_data_waiting() {
- let (tx1, rx1) = channel();
- let (tx2, rx2) = channel();
- drop(tx1.clone());
- tx1.send(()).unwrap();
- rx1.recv().unwrap();
- let _t = thread::spawn(move|| {
- select! {
- _n = rx1.recv() => {}
- }
- tx2.send(()).unwrap();
- });
-
- for _ in 0..100 { thread::yield_now() }
- tx1.send(()).unwrap();
- rx2.recv().unwrap();
- }
-
- #[test]
- fn sync1() {
- let (tx, rx) = sync_channel::<i32>(1);
- tx.send(1).unwrap();
- select! {
- n = rx.recv() => { assert_eq!(n.unwrap(), 1); }
- }
- }
-
- #[test]
- fn sync2() {
- let (tx, rx) = sync_channel::<i32>(0);
- let _t = thread::spawn(move|| {
- for _ in 0..100 { thread::yield_now() }
- tx.send(1).unwrap();
- });
- select! {
- n = rx.recv() => { assert_eq!(n.unwrap(), 1); }
- }
- }
-
- #[test]
- fn sync3() {
- let (tx1, rx1) = sync_channel::<i32>(0);
- let (tx2, rx2): (Sender<i32>, Receiver<i32>) = channel();
- let _t = thread::spawn(move|| { tx1.send(1).unwrap(); });
- let _t = thread::spawn(move|| { tx2.send(2).unwrap(); });
- select! {
- n = rx1.recv() => {
- let n = n.unwrap();
- assert_eq!(n, 1);
- assert_eq!(rx2.recv().unwrap(), 2);
- },
- n = rx2.recv() => {
- let n = n.unwrap();
- assert_eq!(n, 2);
- assert_eq!(rx1.recv().unwrap(), 1);
- }
- }
- }
-}
--- /dev/null
+#![allow(unused_imports)]
+
+/// This file exists to hack around https://github.com/rust-lang/rust/issues/47238
+
+use thread;
+use sync::mpsc::*;
+
+// Don't use the libstd version so we can pull in the right Select structure
+// (std::comm points at the wrong one)
+macro_rules! select {
+ (
+ $($name:pat = $rx:ident.$meth:ident() => $code:expr),+
+ ) => ({
+ let sel = Select::new();
+ $( let mut $rx = sel.handle(&$rx); )+
+ unsafe {
+ $( $rx.add(); )+
+ }
+ let ret = sel.wait();
+ $( if ret == $rx.id() { let $name = $rx.$meth(); $code } else )+
+ { unreachable!() }
+ })
+}
+
+#[test]
+fn smoke() {
+ let (tx1, rx1) = channel::<i32>();
+ let (tx2, rx2) = channel::<i32>();
+ tx1.send(1).unwrap();
+ select! {
+ foo = rx1.recv() => { assert_eq!(foo.unwrap(), 1); },
+ _bar = rx2.recv() => { panic!() }
+ }
+ tx2.send(2).unwrap();
+ select! {
+ _foo = rx1.recv() => { panic!() },
+ bar = rx2.recv() => { assert_eq!(bar.unwrap(), 2) }
+ }
+ drop(tx1);
+ select! {
+ foo = rx1.recv() => { assert!(foo.is_err()); },
+ _bar = rx2.recv() => { panic!() }
+ }
+ drop(tx2);
+ select! {
+ bar = rx2.recv() => { assert!(bar.is_err()); }
+ }
+}
+
+#[test]
+fn smoke2() {
+ let (_tx1, rx1) = channel::<i32>();
+ let (_tx2, rx2) = channel::<i32>();
+ let (_tx3, rx3) = channel::<i32>();
+ let (_tx4, rx4) = channel::<i32>();
+ let (tx5, rx5) = channel::<i32>();
+ tx5.send(4).unwrap();
+ select! {
+ _foo = rx1.recv() => { panic!("1") },
+ _foo = rx2.recv() => { panic!("2") },
+ _foo = rx3.recv() => { panic!("3") },
+ _foo = rx4.recv() => { panic!("4") },
+ foo = rx5.recv() => { assert_eq!(foo.unwrap(), 4); }
+ }
+}
+
+#[test]
+fn closed() {
+ let (_tx1, rx1) = channel::<i32>();
+ let (tx2, rx2) = channel::<i32>();
+ drop(tx2);
+
+ select! {
+ _a1 = rx1.recv() => { panic!() },
+ a2 = rx2.recv() => { assert!(a2.is_err()); }
+ }
+}
+
+#[test]
+fn unblocks() {
+ let (tx1, rx1) = channel::<i32>();
+ let (_tx2, rx2) = channel::<i32>();
+ let (tx3, rx3) = channel::<i32>();
+
+ let _t = thread::spawn(move|| {
+ for _ in 0..20 { thread::yield_now(); }
+ tx1.send(1).unwrap();
+ rx3.recv().unwrap();
+ for _ in 0..20 { thread::yield_now(); }
+ });
+
+ select! {
+ a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
+ _b = rx2.recv() => { panic!() }
+ }
+ tx3.send(1).unwrap();
+ select! {
+ a = rx1.recv() => { assert!(a.is_err()) },
+ _b = rx2.recv() => { panic!() }
+ }
+}
+
+#[test]
+fn both_ready() {
+ let (tx1, rx1) = channel::<i32>();
+ let (tx2, rx2) = channel::<i32>();
+ let (tx3, rx3) = channel::<()>();
+
+ let _t = thread::spawn(move|| {
+ for _ in 0..20 { thread::yield_now(); }
+ tx1.send(1).unwrap();
+ tx2.send(2).unwrap();
+ rx3.recv().unwrap();
+ });
+
+ select! {
+ a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
+ a = rx2.recv() => { assert_eq!(a.unwrap(), 2); }
+ }
+ select! {
+ a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
+ a = rx2.recv() => { assert_eq!(a.unwrap(), 2); }
+ }
+ assert_eq!(rx1.try_recv(), Err(TryRecvError::Empty));
+ assert_eq!(rx2.try_recv(), Err(TryRecvError::Empty));
+ tx3.send(()).unwrap();
+}
+
+#[test]
+fn stress() {
+ const AMT: i32 = 10000;
+ let (tx1, rx1) = channel::<i32>();
+ let (tx2, rx2) = channel::<i32>();
+ let (tx3, rx3) = channel::<()>();
+
+ let _t = thread::spawn(move|| {
+ for i in 0..AMT {
+ if i % 2 == 0 {
+ tx1.send(i).unwrap();
+ } else {
+ tx2.send(i).unwrap();
+ }
+ rx3.recv().unwrap();
+ }
+ });
+
+ for i in 0..AMT {
+ select! {
+ i1 = rx1.recv() => { assert!(i % 2 == 0 && i == i1.unwrap()); },
+ i2 = rx2.recv() => { assert!(i % 2 == 1 && i == i2.unwrap()); }
+ }
+ tx3.send(()).unwrap();
+ }
+}
+
+#[allow(unused_must_use)]
+#[test]
+fn cloning() {
+ let (tx1, rx1) = channel::<i32>();
+ let (_tx2, rx2) = channel::<i32>();
+ let (tx3, rx3) = channel::<()>();
+
+ let _t = thread::spawn(move|| {
+ rx3.recv().unwrap();
+ tx1.clone();
+ assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
+ tx1.send(2).unwrap();
+ rx3.recv().unwrap();
+ });
+
+ tx3.send(()).unwrap();
+ select! {
+ _i1 = rx1.recv() => {},
+ _i2 = rx2.recv() => panic!()
+ }
+ tx3.send(()).unwrap();
+}
+
+#[allow(unused_must_use)]
+#[test]
+fn cloning2() {
+ let (tx1, rx1) = channel::<i32>();
+ let (_tx2, rx2) = channel::<i32>();
+ let (tx3, rx3) = channel::<()>();
+
+ let _t = thread::spawn(move|| {
+ rx3.recv().unwrap();
+ tx1.clone();
+ assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
+ tx1.send(2).unwrap();
+ rx3.recv().unwrap();
+ });
+
+ tx3.send(()).unwrap();
+ select! {
+ _i1 = rx1.recv() => {},
+ _i2 = rx2.recv() => panic!()
+ }
+ tx3.send(()).unwrap();
+}
+
+#[test]
+fn cloning3() {
+ let (tx1, rx1) = channel::<()>();
+ let (tx2, rx2) = channel::<()>();
+ let (tx3, rx3) = channel::<()>();
+ let _t = thread::spawn(move|| {
+ let s = Select::new();
+ let mut h1 = s.handle(&rx1);
+ let mut h2 = s.handle(&rx2);
+ unsafe { h2.add(); }
+ unsafe { h1.add(); }
+ assert_eq!(s.wait(), h2.id());
+ tx3.send(()).unwrap();
+ });
+
+ for _ in 0..1000 { thread::yield_now(); }
+ drop(tx1.clone());
+ tx2.send(()).unwrap();
+ rx3.recv().unwrap();
+}
+
+#[test]
+fn preflight1() {
+ let (tx, rx) = channel();
+ tx.send(()).unwrap();
+ select! {
+ _n = rx.recv() => {}
+ }
+}
+
+#[test]
+fn preflight2() {
+ let (tx, rx) = channel();
+ tx.send(()).unwrap();
+ tx.send(()).unwrap();
+ select! {
+ _n = rx.recv() => {}
+ }
+}
+
+#[test]
+fn preflight3() {
+ let (tx, rx) = channel();
+ drop(tx.clone());
+ tx.send(()).unwrap();
+ select! {
+ _n = rx.recv() => {}
+ }
+}
+
+#[test]
+fn preflight4() {
+ let (tx, rx) = channel();
+ tx.send(()).unwrap();
+ let s = Select::new();
+ let mut h = s.handle(&rx);
+ unsafe { h.add(); }
+ assert_eq!(s.wait2(false), h.id());
+}
+
+#[test]
+fn preflight5() {
+ let (tx, rx) = channel();
+ tx.send(()).unwrap();
+ tx.send(()).unwrap();
+ let s = Select::new();
+ let mut h = s.handle(&rx);
+ unsafe { h.add(); }
+ assert_eq!(s.wait2(false), h.id());
+}
+
+#[test]
+fn preflight6() {
+ let (tx, rx) = channel();
+ drop(tx.clone());
+ tx.send(()).unwrap();
+ let s = Select::new();
+ let mut h = s.handle(&rx);
+ unsafe { h.add(); }
+ assert_eq!(s.wait2(false), h.id());
+}
+
+#[test]
+fn preflight7() {
+ let (tx, rx) = channel::<()>();
+ drop(tx);
+ let s = Select::new();
+ let mut h = s.handle(&rx);
+ unsafe { h.add(); }
+ assert_eq!(s.wait2(false), h.id());
+}
+
+#[test]
+fn preflight8() {
+ let (tx, rx) = channel();
+ tx.send(()).unwrap();
+ drop(tx);
+ rx.recv().unwrap();
+ let s = Select::new();
+ let mut h = s.handle(&rx);
+ unsafe { h.add(); }
+ assert_eq!(s.wait2(false), h.id());
+}
+
+#[test]
+fn preflight9() {
+ let (tx, rx) = channel();
+ drop(tx.clone());
+ tx.send(()).unwrap();
+ drop(tx);
+ rx.recv().unwrap();
+ let s = Select::new();
+ let mut h = s.handle(&rx);
+ unsafe { h.add(); }
+ assert_eq!(s.wait2(false), h.id());
+}
+
+#[test]
+fn oneshot_data_waiting() {
+ let (tx1, rx1) = channel();
+ let (tx2, rx2) = channel();
+ let _t = thread::spawn(move|| {
+ select! {
+ _n = rx1.recv() => {}
+ }
+ tx2.send(()).unwrap();
+ });
+
+ for _ in 0..100 { thread::yield_now() }
+ tx1.send(()).unwrap();
+ rx2.recv().unwrap();
+}
+
+#[test]
+fn stream_data_waiting() {
+ let (tx1, rx1) = channel();
+ let (tx2, rx2) = channel();
+ tx1.send(()).unwrap();
+ tx1.send(()).unwrap();
+ rx1.recv().unwrap();
+ rx1.recv().unwrap();
+ let _t = thread::spawn(move|| {
+ select! {
+ _n = rx1.recv() => {}
+ }
+ tx2.send(()).unwrap();
+ });
+
+ for _ in 0..100 { thread::yield_now() }
+ tx1.send(()).unwrap();
+ rx2.recv().unwrap();
+}
+
+#[test]
+fn shared_data_waiting() {
+ let (tx1, rx1) = channel();
+ let (tx2, rx2) = channel();
+ drop(tx1.clone());
+ tx1.send(()).unwrap();
+ rx1.recv().unwrap();
+ let _t = thread::spawn(move|| {
+ select! {
+ _n = rx1.recv() => {}
+ }
+ tx2.send(()).unwrap();
+ });
+
+ for _ in 0..100 { thread::yield_now() }
+ tx1.send(()).unwrap();
+ rx2.recv().unwrap();
+}
+
+#[test]
+fn sync1() {
+ let (tx, rx) = sync_channel::<i32>(1);
+ tx.send(1).unwrap();
+ select! {
+ n = rx.recv() => { assert_eq!(n.unwrap(), 1); }
+ }
+}
+
+#[test]
+fn sync2() {
+ let (tx, rx) = sync_channel::<i32>(0);
+ let _t = thread::spawn(move|| {
+ for _ in 0..100 { thread::yield_now() }
+ tx.send(1).unwrap();
+ });
+ select! {
+ n = rx.recv() => { assert_eq!(n.unwrap(), 1); }
+ }
+}
+
+#[test]
+fn sync3() {
+ let (tx1, rx1) = sync_channel::<i32>(0);
+ let (tx2, rx2): (Sender<i32>, Receiver<i32>) = channel();
+ let _t = thread::spawn(move|| { tx1.send(1).unwrap(); });
+ let _t = thread::spawn(move|| { tx2.send(2).unwrap(); });
+ select! {
+ n = rx1.recv() => {
+ let n = n.unwrap();
+ assert_eq!(n, 1);
+ assert_eq!(rx2.recv().unwrap(), 2);
+ },
+ n = rx2.recv() => {
+ let n = n.unwrap();
+ assert_eq!(n, 2);
+ assert_eq!(rx1.recv().unwrap(), 1);
+ }
+ }
+}
-/// Shared channels
+/// Shared channels.
///
/// This is the flavor of channels which are not necessarily optimized for any
/// particular use case, but are the most general in how they are used. Shared
/// Returns a mutable reference to the underlying data.
///
/// Since this call borrows the `Mutex` mutably, no actual locking needs to
- /// take place---the mutable borrow statically guarantees no locks exist.
+ /// take place -- the mutable borrow statically guarantees no locks exist.
///
/// # Errors
///
/// result in an immediate panic. If `f` panics, the `Once` will remain
/// in a poison state. If `f` does _not_ panic, the `Once` will no
/// longer be in a poison state and all future calls to `call_once` or
- /// `call_one_force` will no-op.
+ /// `call_one_force` will be no-ops.
///
/// The closure `f` is yielded a [`OnceState`] structure which can be used
/// to query the poison status of the `Once`.
});
}
- /// Returns true if some `call_once` call has completed
+ /// Returns `true` if some `call_once` call has completed
/// successfully. Specifically, `is_completed` will return false in
/// the following situations:
/// * `call_once` was not called at all,
}
impl OnceState {
- /// Returns whether the associated [`Once`] was poisoned prior to the
+ /// Returns `true` if the associated [`Once`] was poisoned prior to the
/// invocation of the closure passed to [`call_once_force`].
///
/// [`call_once_force`]: struct.Once.html#method.call_once_force
/// Determines whether the lock is poisoned.
///
/// If another thread is active, the lock can still become poisoned at any
- /// time. You should not trust a `false` value for program correctness
+ /// time. You should not trust a `false` value for program correctness
/// without additional synchronization.
///
/// # Examples
/// Returns a mutable reference to the underlying data.
///
/// Since this call borrows the `RwLock` mutably, no actual locking needs to
- /// take place---the mutable borrow statically guarantees no locks exist.
+ /// take place -- the mutable borrow statically guarantees no locks exist.
///
/// # Errors
///
/// Methods of synchronizing memory with physical storage.
#[repr(C)]
pub struct msflags: u8 {
- /// Perform asynchronous writes.
+ /// Performs asynchronous writes.
const ASYNC = 0x01;
- /// Invalidate cached data.
+ /// Invalidates cached data.
const INVALIDATE = 0x02;
- /// Perform synchronous writes.
+ /// Performs synchronous writes.
const SYNC = 0x04;
}
}
/// Entry point for additionally created threads.
///
-/// **tid**:
-/// Thread ID of the current thread.
+/// `tid`: thread ID of the current thread.
///
-/// **aux**:
-/// Copy of the value stored in
+/// `aux`: copy of the value stored in
/// [`threadattr.argument`](struct.threadattr.html#structfield.argument).
pub type threadentry = unsafe extern "C" fn(
tid: tid,
cloudabi_sys_mem_map(addr_, len_, prot_, flags_, fd_, off_, mem_)
}
-/// Change the protection of a memory mapping.
+/// Changes the protection of a memory mapping.
///
/// ## Parameters
///
cloudabi_sys_mem_protect(mapping_.as_mut_ptr() as *mut (), mapping_.len(), prot_)
}
-/// Synchronize a region of memory with its physical storage.
+/// Synchronizes a region of memory with its physical storage.
///
/// ## Parameters
///
-//! Platform-dependent platform abstraction
+//! Platform-dependent platform abstraction.
//!
//! The `std::sys` module is the abstracted interface through which
//! `std` talks to the underlying operating system. It has different
#[stable(feature = "fs_ext", since = "1.1.0")]
fn mode(&mut self, mode: u32) -> &mut Self;
- /// Pass custom flags to the `flags` argument of `open`.
+ /// Passes custom flags to the `flags` argument of `open`.
///
/// The bits that define the access mode are masked out with `O_ACCMODE`, to
/// ensure they do not interfere with the access mode set by Rusts options.
/// # Note
///
/// On Windows, you must specify whether a symbolic link points to a file
-/// or directory. Use `os::windows::fs::symlink_file` to create a
+/// or directory. Use `os::windows::fs::symlink_file` to create a
/// symbolic link to a file, or `os::windows::fs::symlink_dir` to create a
-/// symbolic link to a directory. Additionally, the process must have
+/// symbolic link to a directory. Additionally, the process must have
/// `SeCreateSymbolicLinkPrivilege` in order to be able to create a
/// symbolic link.
///
None
}
- /// Returns true if and only if the address is unnamed.
+ /// Returns `true` if the address is unnamed.
///
/// # Examples
///
/// ```
///
/// # Platform specific
- /// On Redox this always returns None.
+ /// On Redox this always returns `None`.
#[stable(feature = "unix_socket_redox", since = "1.29")]
pub fn take_error(&self) -> io::Result<Option<io::Error>> {
Ok(None)
/// ```
///
/// # Platform specific
- /// On Redox this always returns None.
+ /// On Redox this always returns `None`.
#[stable(feature = "unix_socket_redox", since = "1.29")]
pub fn take_error(&self) -> io::Result<Option<io::Error>> {
Ok(None)
/// [`process::Command`]: ../../../../std/process/struct.Command.html
#[stable(feature = "rust1", since = "1.0.0")]
pub trait CommandExt {
- /// Sets the child process's user id. This translates to a
+ /// Sets the child process's user ID. This translates to a
/// `setuid` call in the child process. Failure in the `setuid`
/// call will cause the spawn to fail.
#[stable(feature = "rust1", since = "1.0.0")]
fn uid(&mut self, id: u32) -> &mut process::Command;
- /// Similar to `uid`, but sets the group id of the child process. This has
+ /// Similar to `uid`, but sets the group ID of the child process. This has
/// the same semantics as the `uid` field.
#[stable(feature = "rust1", since = "1.0.0")]
fn gid(&mut self, id: u32) -> &mut process::Command;
}
impl Mutex {
- /// Create a new mutex.
+ /// Creates a new mutex.
pub const fn new() -> Self {
Mutex {
lock: UnsafeCell::new(0),
}
}
-/// The unique id of the process (this should never be negative).
+/// The unique ID of the process (this should never be negative).
pub struct Process {
pid: usize,
status: Option<ExitStatus>,
syscall1(SYS_BRK, addr)
}
-/// Change the process's working directory
+/// Changes the process's working directory.
///
/// This function will attempt to set the process's working directory to `path`, which can be
/// either a relative, scheme relative, or absolute path.
unsafe { syscall3(SYS_CHMOD, path.as_ref().as_ptr() as usize, path.as_ref().len(), mode) }
}
-/// Produce a fork of the current process, or a new process thread
+/// Produces a fork of the current process, or a new process thread.
pub unsafe fn clone(flags: usize) -> Result<usize> {
syscall1_clobber(SYS_CLONE, flags)
}
-/// Close a file
+/// Closes a file.
pub fn close(fd: usize) -> Result<usize> {
unsafe { syscall1(SYS_CLOSE, fd) }
}
-/// Get the current system time
+/// Gets the current system time.
pub fn clock_gettime(clock: usize, tp: &mut TimeSpec) -> Result<usize> {
unsafe { syscall2(SYS_CLOCK_GETTIME, clock, tp as *mut TimeSpec as usize) }
}
-/// Copy and transform a file descriptor
+/// Copies and transforms a file descriptor.
pub fn dup(fd: usize, buf: &[u8]) -> Result<usize> {
unsafe { syscall3(SYS_DUP, fd, buf.as_ptr() as usize, buf.len()) }
}
-/// Copy and transform a file descriptor
+/// Copies and transforms a file descriptor.
pub fn dup2(fd: usize, newfd: usize, buf: &[u8]) -> Result<usize> {
unsafe { syscall4(SYS_DUP2, fd, newfd, buf.as_ptr() as usize, buf.len()) }
}
-/// Exit the current process
+/// Exits the current process.
pub fn exit(status: usize) -> Result<usize> {
unsafe { syscall1(SYS_EXIT, status) }
}
-/// Change file permissions
+/// Changes file permissions.
pub fn fchmod(fd: usize, mode: u16) -> Result<usize> {
unsafe { syscall2(SYS_FCHMOD, fd, mode as usize) }
}
-/// Change file ownership
+/// Changes file ownership.
pub fn fchown(fd: usize, uid: u32, gid: u32) -> Result<usize> {
unsafe { syscall3(SYS_FCHOWN, fd, uid as usize, gid as usize) }
}
-/// Change file descriptor flags
+/// Changes file descriptor flags.
pub fn fcntl(fd: usize, cmd: usize, arg: usize) -> Result<usize> {
unsafe { syscall3(SYS_FCNTL, fd, cmd, arg) }
}
-/// Replace the current process with a new executable
+/// Replaces the current process with a new executable.
pub fn fexec(fd: usize, args: &[[usize; 2]], vars: &[[usize; 2]]) -> Result<usize> {
unsafe { syscall5(SYS_FEXEC, fd, args.as_ptr() as usize, args.len(),
vars.as_ptr() as usize, vars.len()) }
}
-/// Map a file into memory
+/// Maps a file into memory.
pub unsafe fn fmap(fd: usize, offset: usize, size: usize) -> Result<usize> {
syscall3(SYS_FMAP, fd, offset, size)
}
-/// Unmap a memory-mapped file
+/// Unmaps a memory-mapped file.
pub unsafe fn funmap(addr: usize) -> Result<usize> {
syscall1(SYS_FUNMAP, addr)
}
-/// Retrieve the canonical path of a file
+/// Retrieves the canonical path of a file.
pub fn fpath(fd: usize, buf: &mut [u8]) -> Result<usize> {
unsafe { syscall3(SYS_FPATH, fd, buf.as_mut_ptr() as usize, buf.len()) }
}
-/// Rename a file
+/// Renames a file.
pub fn frename<T: AsRef<[u8]>>(fd: usize, path: T) -> Result<usize> {
unsafe { syscall3(SYS_FRENAME, fd, path.as_ref().as_ptr() as usize, path.as_ref().len()) }
}
-/// Get metadata about a file
+/// Gets metadata about a file.
pub fn fstat(fd: usize, stat: &mut Stat) -> Result<usize> {
unsafe { syscall3(SYS_FSTAT, fd, stat as *mut Stat as usize, mem::size_of::<Stat>()) }
}
-/// Get metadata about a filesystem
+/// Gets metadata about a filesystem.
pub fn fstatvfs(fd: usize, stat: &mut StatVfs) -> Result<usize> {
unsafe { syscall3(SYS_FSTATVFS, fd, stat as *mut StatVfs as usize, mem::size_of::<StatVfs>()) }
}
-/// Sync a file descriptor to its underlying medium
+/// Syncs a file descriptor to its underlying medium.
pub fn fsync(fd: usize) -> Result<usize> {
unsafe { syscall1(SYS_FSYNC, fd) }
}
syscall5(SYS_FUTEX, addr as usize, op, (val as isize) as usize, val2, addr2 as usize)
}
-/// Get the current working directory
+/// Gets the current working directory.
pub fn getcwd(buf: &mut [u8]) -> Result<usize> {
unsafe { syscall2(SYS_GETCWD, buf.as_mut_ptr() as usize, buf.len()) }
}
-/// Get the effective group ID
+/// Gets the effective group ID.
pub fn getegid() -> Result<usize> {
unsafe { syscall0(SYS_GETEGID) }
}
-/// Get the effective namespace
+/// Gets the effective namespace.
pub fn getens() -> Result<usize> {
unsafe { syscall0(SYS_GETENS) }
}
-/// Get the effective user ID
+/// Gets the effective user ID.
pub fn geteuid() -> Result<usize> {
unsafe { syscall0(SYS_GETEUID) }
}
-/// Get the current group ID
+/// Gets the current group ID.
pub fn getgid() -> Result<usize> {
unsafe { syscall0(SYS_GETGID) }
}
-/// Get the current namespace
+/// Gets the current namespace.
pub fn getns() -> Result<usize> {
unsafe { syscall0(SYS_GETNS) }
}
-/// Get the current process ID
+/// Gets the current process ID.
pub fn getpid() -> Result<usize> {
unsafe { syscall0(SYS_GETPID) }
}
-/// Get the process group ID
+/// Gets the process group ID.
pub fn getpgid(pid: usize) -> Result<usize> {
unsafe { syscall1(SYS_GETPGID, pid) }
}
-/// Get the parent process ID
+/// Gets the parent process ID.
pub fn getppid() -> Result<usize> {
unsafe { syscall0(SYS_GETPPID) }
}
-/// Get the current user ID
+/// Gets the current user ID.
pub fn getuid() -> Result<usize> {
unsafe { syscall0(SYS_GETUID) }
}
-/// Set the I/O privilege level
+/// Sets the I/O privilege level
pub unsafe fn iopl(level: usize) -> Result<usize> {
syscall1(SYS_IOPL, level)
}
-/// Send a signal `sig` to the process identified by `pid`
+/// Sends a signal `sig` to the process identified by `pid`.
pub fn kill(pid: usize, sig: usize) -> Result<usize> {
unsafe { syscall2(SYS_KILL, pid, sig) }
}
-/// Create a link to a file
+/// Creates a link to a file.
pub unsafe fn link(old: *const u8, new: *const u8) -> Result<usize> {
syscall2(SYS_LINK, old as usize, new as usize)
}
-/// Seek to `offset` bytes in a file descriptor
+/// Seeks to `offset` bytes in a file descriptor.
pub fn lseek(fd: usize, offset: isize, whence: usize) -> Result<usize> {
unsafe { syscall3(SYS_LSEEK, fd, offset as usize, whence) }
}
-/// Make a new scheme namespace
+/// Makes a new scheme namespace.
pub fn mkns(schemes: &[[usize; 2]]) -> Result<usize> {
unsafe { syscall2(SYS_MKNS, schemes.as_ptr() as usize, schemes.len()) }
}
-/// Sleep for the time specified in `req`
+/// Sleeps for the time specified in `req`.
pub fn nanosleep(req: &TimeSpec, rem: &mut TimeSpec) -> Result<usize> {
unsafe { syscall2(SYS_NANOSLEEP, req as *const TimeSpec as usize,
rem as *mut TimeSpec as usize) }
}
-/// Open a file
+/// Opens a file.
pub fn open<T: AsRef<[u8]>>(path: T, flags: usize) -> Result<usize> {
unsafe { syscall3(SYS_OPEN, path.as_ref().as_ptr() as usize, path.as_ref().len(), flags) }
}
-/// Allocate pages, linearly in physical memory
+/// Allocates pages, linearly in physical memory.
pub unsafe fn physalloc(size: usize) -> Result<usize> {
syscall1(SYS_PHYSALLOC, size)
}
-/// Free physically allocated pages
+/// Frees physically allocated pages.
pub unsafe fn physfree(physical_address: usize, size: usize) -> Result<usize> {
syscall2(SYS_PHYSFREE, physical_address, size)
}
-/// Map physical memory to virtual memory
+/// Maps physical memory to virtual memory.
pub unsafe fn physmap(physical_address: usize, size: usize, flags: usize) -> Result<usize> {
syscall3(SYS_PHYSMAP, physical_address, size, flags)
}
-/// Unmap previously mapped physical memory
+/// Unmaps previously mapped physical memory.
pub unsafe fn physunmap(virtual_address: usize) -> Result<usize> {
syscall1(SYS_PHYSUNMAP, virtual_address)
}
-/// Create a pair of file descriptors referencing the read and write ends of a pipe
+/// Creates a pair of file descriptors referencing the read and write ends of a pipe.
pub fn pipe2(fds: &mut [usize; 2], flags: usize) -> Result<usize> {
unsafe { syscall2(SYS_PIPE2, fds.as_ptr() as usize, flags) }
}
unsafe { syscall3(SYS_READ, fd, buf.as_mut_ptr() as usize, buf.len()) }
}
-/// Remove a directory
+/// Removes a directory.
pub fn rmdir<T: AsRef<[u8]>>(path: T) -> Result<usize> {
unsafe { syscall2(SYS_RMDIR, path.as_ref().as_ptr() as usize, path.as_ref().len()) }
}
-/// Set the process group ID
+/// Sets the process group ID.
pub fn setpgid(pid: usize, pgid: usize) -> Result<usize> {
unsafe { syscall2(SYS_SETPGID, pid, pgid) }
}
-/// Set the current process group IDs
+/// Sets the current process group IDs.
pub fn setregid(rgid: usize, egid: usize) -> Result<usize> {
unsafe { syscall2(SYS_SETREGID, rgid, egid) }
}
-/// Make a new scheme namespace
+/// Makes a new scheme namespace.
pub fn setrens(rns: usize, ens: usize) -> Result<usize> {
unsafe { syscall2(SYS_SETRENS, rns, ens) }
}
-/// Set the current process user IDs
+/// Sets the current process user IDs.
pub fn setreuid(ruid: usize, euid: usize) -> Result<usize> {
unsafe { syscall2(SYS_SETREUID, ruid, euid) }
}
-/// Set up a signal handler
+/// Sets up a signal handler.
pub fn sigaction(sig: usize, act: Option<&SigAction>, oldact: Option<&mut SigAction>)
-> Result<usize> {
unsafe { syscall4(SYS_SIGACTION, sig,
restorer as usize) }
}
-// Return from signal handler
+/// Returns from signal handler.
pub fn sigreturn() -> Result<usize> {
unsafe { syscall0(SYS_SIGRETURN) }
}
-/// Remove a file
+/// Removes a file.
pub fn unlink<T: AsRef<[u8]>>(path: T) -> Result<usize> {
unsafe { syscall2(SYS_UNLINK, path.as_ref().as_ptr() as usize, path.as_ref().len()) }
}
-/// Convert a virtual address to a physical one
+/// Converts a virtual address to a physical one.
pub unsafe fn virttophys(virtual_address: usize) -> Result<usize> {
syscall1(SYS_VIRTTOPHYS, virtual_address)
}
-/// Check if a child process has exited or received a signal
+/// Checks if a child process has exited or received a signal.
pub fn waitpid(pid: usize, status: &mut usize, options: usize) -> Result<usize> {
unsafe { syscall3(SYS_WAITPID, pid, status as *mut usize as usize, options) }
}
-/// Write a buffer to a file descriptor
+/// Writes a buffer to a file descriptor.
///
/// The kernel will attempt to write the bytes in `buf` to the file descriptor `fd`, returning
/// either an `Err`, explained below, or `Ok(count)` where `count` is the number of bytes which
unsafe { syscall3(SYS_WRITE, fd, buf.as_ptr() as usize, buf.len()) }
}
-/// Yield the process's time slice to the kernel
+/// Yields the process's time slice to the kernel.
///
/// This function will return Ok(0) on success
pub fn sched_yield() -> Result<usize> {
pub const WUNTRACED: usize = 0x02;
pub const WCONTINUED: usize = 0x08;
-/// True if status indicates the child is stopped.
+/// Returns `true` if status indicates the child is stopped.
pub fn wifstopped(status: usize) -> bool {
(status & 0xff) == 0x7f
}
-/// If wifstopped(status), the signal that stopped the child.
+/// If wifstopped(status), returns the signal that stopped the child.
pub fn wstopsig(status: usize) -> usize {
(status >> 8) & 0xff
}
-/// True if status indicates the child continued after a stop.
+/// Returns `true` if status indicates the child continued after a stop.
pub fn wifcontinued(status: usize) -> bool {
status == 0xffff
}
-/// True if STATUS indicates termination by a signal.
+/// Returns `true` if status indicates termination by a signal.
pub fn wifsignaled(status: usize) -> bool {
((status & 0x7f) + 1) as i8 >= 2
}
-/// If wifsignaled(status), the terminating signal.
+/// If wifsignaled(status), returns the terminating signal.
pub fn wtermsig(status: usize) -> usize {
status & 0x7f
}
-/// True if status indicates normal termination.
+/// Returns `true` if status indicates normal termination.
pub fn wifexited(status: usize) -> bool {
wtermsig(status) == 0
}
-/// If wifexited(status), the exit status.
+/// If wifexited(status), returns the exit status.
pub fn wexitstatus(status: usize) -> usize {
(status >> 8) & 0xff
}
-/// True if status indicates a core dump was created.
+/// Returns `true` if status indicates a core dump was created.
pub fn wcoredump(status: usize) -> bool {
(status & 0x80) != 0
}
.asciz "Re-entered aborted enclave!"
.Lreentry_panic_msg_end:
-.Lusercall_panic_msg:
- .asciz "Invalid usercall#!"
-.Lusercall_panic_msg_end:
-
.org .Lxsave_clear+512
.Lxsave_header:
.int 0, 0 /* XSTATE_BV */
orq $8,%rsp
jmp panic_msg
-.Lusercall_panic:
- lea .Lusercall_panic_msg(%rip),%rdi
- mov $.Lusercall_panic_msg_end-.Lusercall_panic_msg,%esi
- orq $8,%rsp
- jmp panic_msg
-
-.macro push_callee_saved_registers
+/* This *MUST* be called with 6 parameters, otherwise register information */
+/* might leak! */
+.global usercall
+usercall:
+ test %rcx,%rcx /* check `abort` function argument */
+ jnz .Lusercall_abort /* abort is set, jump to abort code (unlikely forward conditional) */
+ jmp .Lusercall_save_state /* non-aborting usercall */
+.Lusercall_abort:
+/* set aborted bit */
+ movb $1,.Laborted(%rip)
+/* save registers in DEBUG mode, so that debugger can reconstruct the stack */
+ testb $0xff,DEBUG(%rip)
+ jz .Lusercall_noreturn
+.Lusercall_save_state:
+/* save callee-saved state */
push %r15
push %r14
push %r13
sub $8, %rsp
fstcw 4(%rsp)
stmxcsr (%rsp)
-.endm
-
-.global usercall_exit
-usercall_exit:
-/* save registers in DEBUG mode, so that debugger can reconstruct the stack */
- testb $0xff,DEBUG(%rip)
- jz .Lskip_save_registers
- push_callee_saved_registers
- movq %rsp,%gs:tcsls_panic_last_rsp
-.Lskip_save_registers:
-/* set aborted bit */
- movb $1,.Laborted(%rip)
-/* call usercall exit(true) */
- /* NOP: mov %rsi,%rsi */ /* RSI = usercall() argument: panic */
- xor %rdx,%rdx /* RDX cleared */
- movq $usercall_nr_exit,%rdi /* RDI = usercall exit */
- jmp .Lexit
-
-/* This *MUST* be called with 6 parameters, otherwise register information */
-/* might leak! */
-.global usercall
-usercall:
- test %rdi,%rdi
- jle .Lusercall_panic
-/* save callee-saved state */
- push_callee_saved_registers
movq %rsp,%gs:tcsls_last_rsp
+.Lusercall_noreturn:
/* clear general purpose register state */
/* RAX overwritten by ENCLU */
/* RBX set by sgx_exit */
jmp .Lsgx_exit
.Lusercall_ret:
movq $0,%gs:tcsls_last_rsp
-/* restore callee-saved state, cf. push_callee_saved_registers */
+/* restore callee-saved state, cf. "save" above */
mov %r11,%rsp
ldmxcsr (%rsp)
fldcw 4(%rsp)
#[macro_use]
pub mod usercalls;
-global_asm!(concat!(usercalls_asm!(), include_str!("entry.S")));
+global_asm!(include_str!("entry.S"));
#[no_mangle]
unsafe extern "C" fn tcs_init(secondary: bool) {
-use super::usercalls::alloc::UserRef;
+use super::usercalls::{alloc::UserRef, self};
use cmp;
use io::{self, Write};
use mem;
#[no_mangle]
pub extern "C" fn panic_msg(msg: &str) -> ! {
let _ = SgxPanicOutput::new().map(|mut out| out.write(msg.as_bytes()));
- unsafe { usercall_exit(true); }
+ usercalls::exit(true)
}
-
-extern "C" { pub fn usercall_exit(panic: bool) -> !; }
use fortanix_sgx_abi::Tcs;
-/// Get the ID for the current thread. The ID is guaranteed to be unique among
+/// Gets the ID for the current thread. The ID is guaranteed to be unique among
/// all currently running threads in the enclave, and it is guaranteed to be
/// constant for the lifetime of the thread. More specifically for SGX, there
/// is a one-to-one correspondence of the ID to the address of the TCS.
self.0[hi].fetch_and(!lo, Ordering::Relaxed);
}
- /// Set any unset bit. Not atomic. Returns `None` if all bits were
+ /// Sets any unset bit. Not atomic. Returns `None` if all bits were
/// observed to be set.
pub fn set(&self) -> Option<usize> {
'elems: for (idx, elem) in self.0.iter().enumerate() {
/// Construct a pointer to `Self` given a memory range in user space.
///
- /// NB. This takes a size, not a length!
+ /// N.B., this takes a size, not a length!
///
/// # Safety
+ ///
/// The caller must ensure the memory range is in user memory, is the
/// correct size and is correctly aligned and points to the right type.
unsafe fn from_raw_sized_unchecked(ptr: *mut u8, size: usize) -> *mut Self;
/// Construct a pointer to `Self` given a memory range.
///
- /// NB. This takes a size, not a length!
+ /// N.B., this takes a size, not a length!
///
/// # Safety
+ ///
/// The caller must ensure the memory range points to the correct type.
///
/// # Panics
+ ///
/// This function panics if:
///
- /// * The pointer is not aligned
- /// * The pointer is null
- /// * The pointed-to range is not in user memory
+ /// * the pointer is not aligned.
+ /// * the pointer is null.
+ /// * the pointed-to range is not in user memory.
unsafe fn from_raw_sized(ptr: *mut u8, size: usize) -> NonNull<Self> {
let ret = Self::from_raw_sized_unchecked(ptr, size);
Self::check_ptr(ret);
NonNull::new_unchecked(ret as _)
}
- /// Check if a pointer may point to Self in user memory.
+ /// Checks if a pointer may point to `Self` in user memory.
///
/// # Safety
+ ///
/// The caller must ensure the memory range points to the correct type and
/// length (if this is a slice).
///
/// # Panics
+ ///
/// This function panics if:
///
- /// * The pointer is not aligned
- /// * The pointer is null
- /// * The pointed-to range is not in user memory
+ /// * the pointer is not aligned.
+ /// * the pointer is null.
+ /// * the pointed-to range is not in user memory.
unsafe fn check_ptr(ptr: *const Self) {
let is_aligned = |p| -> bool {
0 == (p as usize) & (Self::align_of() - 1)
}
}
- /// Copy `val` into freshly allocated space in user memory.
+ /// Copies `val` into freshly allocated space in user memory.
pub fn new_from_enclave(val: &T) -> Self {
unsafe {
let ret = Self::new_uninit_bytes(mem::size_of_val(val));
}
}
- /// Create an owned `User<T>` from a raw pointer.
+ /// Creates an owned `User<T>` from a raw pointer.
///
/// # Safety
/// The caller must ensure `ptr` points to `T`, is freeable with the `free`
User(NonNull::new_userref(ptr))
}
- /// Convert this value into a raw pointer. The value will no longer be
+ /// Converts this value into a raw pointer. The value will no longer be
/// automatically freed.
pub fn into_raw(self) -> *mut T {
let ret = self.0;
Self::new_uninit_bytes(n * mem::size_of::<T>())
}
- /// Create an owned `User<[T]>` from a raw thin pointer and a slice length.
+ /// Creates an owned `User<[T]>` from a raw thin pointer and a slice length.
///
/// # Safety
/// The caller must ensure `ptr` points to `len` elements of `T`, is
#[unstable(feature = "sgx_platform", issue = "56975")]
impl<T: ?Sized> UserRef<T> where T: UserSafe {
- /// Create a `&UserRef<[T]>` from a raw pointer.
+ /// Creates a `&UserRef<[T]>` from a raw pointer.
///
/// # Safety
/// The caller must ensure `ptr` points to `T`.
&*(ptr as *const Self)
}
- /// Create a `&mut UserRef<[T]>` from a raw pointer. See the struct
+ /// Creates a `&mut UserRef<[T]>` from a raw pointer. See the struct
/// documentation for the nuances regarding a `&mut UserRef<T>`.
///
/// # Safety
&mut*(ptr as *mut Self)
}
- /// Copy `val` into user memory.
+ /// Copies `val` into user memory.
///
/// # Panics
/// This function panics if the destination doesn't have the same size as
}
}
- /// Copy the value from user memory and place it into `dest`.
+ /// Copies the value from user memory and place it into `dest`.
///
/// # Panics
/// This function panics if the destination doesn't have the same size as
#[unstable(feature = "sgx_platform", issue = "56975")]
impl<T> UserRef<T> where T: UserSafe {
- /// Copy the value from user memory into enclave memory.
+ /// Copies the value from user memory into enclave memory.
pub fn to_enclave(&self) -> T {
unsafe { ptr::read(self.0.get()) }
}
#[unstable(feature = "sgx_platform", issue = "56975")]
impl<T> UserRef<[T]> where [T]: UserSafe {
- /// Create a `&UserRef<[T]>` from a raw thin pointer and a slice length.
+ /// Creates a `&UserRef<[T]>` from a raw thin pointer and a slice length.
///
/// # Safety
/// The caller must ensure `ptr` points to `n` elements of `T`.
&*(<[T]>::from_raw_sized(ptr as _, len * mem::size_of::<T>()).as_ptr() as *const Self)
}
- /// Create a `&mut UserRef<[T]>` from a raw thin pointer and a slice length.
+ /// Creates a `&mut UserRef<[T]>` from a raw thin pointer and a slice length.
/// See the struct documentation for the nuances regarding a
/// `&mut UserRef<T>`.
///
unsafe { (*self.0.get()).len() }
}
- /// Copy the value from user memory and place it into `dest`. Afterwards,
+ /// Copies the value from user memory and place it into `dest`. Afterwards,
/// `dest` will contain exactly `self.len()` elements.
///
/// # Panics
}
}
- /// Copy the value from user memory into a vector in enclave memory.
+ /// Copies the value from user memory into a vector in enclave memory.
pub fn to_enclave(&self) -> Vec<T> {
let mut ret = Vec::with_capacity(self.len());
self.copy_to_enclave_vec(&mut ret);
#[unstable(feature = "sgx_platform", issue = "56975")]
impl UserRef<super::raw::ByteBuffer> {
- /// Copy the user memory range pointed to by the user `ByteBuffer` to
+ /// Copies the user memory range pointed to by the user `ByteBuffer` to
/// enclave memory.
///
/// # Panics
/// Usercall `exit`. See the ABI documentation for more information.
#[unstable(feature = "sgx_platform", issue = "56975")]
pub fn exit(panic: bool) -> ! {
- unsafe { super::panic::usercall_exit(panic) }
+ unsafe { raw::exit(panic) }
}
/// Usercall `wait`. See the ABI documentation for more information.
pub use fortanix_sgx_abi::*;
use ptr::NonNull;
+use num::NonZeroU64;
#[repr(C)]
struct UsercallReturn(u64, u64);
extern "C" {
- fn usercall(nr: u64, p1: u64, p2: u64, _ignore: u64, p3: u64, p4: u64) -> UsercallReturn;
+ fn usercall(nr: NonZeroU64, p1: u64, p2: u64, abort: u64, p3: u64, p4: u64) -> UsercallReturn;
}
-/// Perform the raw usercall operation as defined in the ABI calling convention.
+/// Performs the raw usercall operation as defined in the ABI calling convention.
///
/// # Safety
+///
/// The caller must ensure to pass parameters appropriate for the usercall `nr`
/// and to observe all requirements specified in the ABI.
///
/// # Panics
-/// Panics if `nr` is 0.
+///
+/// Panics if `nr` is `0`.
#[unstable(feature = "sgx_platform", issue = "56975")]
-pub unsafe fn do_usercall(nr: u64, p1: u64, p2: u64, p3: u64, p4: u64) -> (u64, u64) {
- if nr==0 { panic!("Invalid usercall number {}",nr) }
- let UsercallReturn(a, b) = usercall(nr,p1,p2,0,p3,p4);
+#[inline]
+pub unsafe fn do_usercall(nr: NonZeroU64, p1: u64, p2: u64, p3: u64, p4: u64, abort: bool)
+ -> (u64, u64)
+{
+ let UsercallReturn(a, b) = usercall(nr, p1, p2, abort as _, p3, p4);
(a, b)
}
}
macro_rules! define_usercalls {
- // Using `$r:tt` because `$r:ty` doesn't match ! in `clobber_diverging`
($(fn $f:ident($($n:ident: $t:ty),*) $(-> $r:tt)*; )*) => {
/// Usercall numbers as per the ABI.
#[repr(u64)]
};
}
-macro_rules! define_usercalls_asm {
- ($(fn $f:ident($($n:ident: $t:ty),*) $(-> $r:ty)*; )*) => {
- macro_rules! usercalls_asm {
- () => {
- concat!(
- ".equ usercall_nr_LAST, 0\n",
- $(
- ".equ usercall_nr_", stringify!($f), ", usercall_nr_LAST+1\n",
- ".equ usercall_nr_LAST, usercall_nr_", stringify!($f), "\n"
- ),*
- )
- }
- }
- };
-}
-
macro_rules! define_ra {
(< $i:ident > $t:ty) => {
impl<$i> RegisterArgument for $t {
}
}
+macro_rules! return_type_is_abort {
+ (!) => { true };
+ ($r:ty) => { false };
+}
+
+// In this macro: using `$r:tt` because `$r:ty` doesn't match ! in `return_type_is_abort`
macro_rules! enclave_usercalls_internal_define_usercalls {
(def fn $f:ident($n1:ident: $t1:ty, $n2:ident: $t2:ty,
- $n3:ident: $t3:ty, $n4:ident: $t4:ty) -> $r:ty) => (
+ $n3:ident: $t3:ty, $n4:ident: $t4:ty) -> $r:tt) => (
/// This is the raw function definition, see the ABI documentation for
/// more information.
#[unstable(feature = "sgx_platform", issue = "56975")]
#[inline(always)]
pub unsafe fn $f($n1: $t1, $n2: $t2, $n3: $t3, $n4: $t4) -> $r {
ReturnValue::from_registers(stringify!($f), do_usercall(
- Usercalls::$f as Register,
+ NonZeroU64::new(Usercalls::$f as Register)
+ .expect("Usercall number must be non-zero"),
RegisterArgument::into_register($n1),
RegisterArgument::into_register($n2),
RegisterArgument::into_register($n3),
RegisterArgument::into_register($n4),
+ return_type_is_abort!($r)
))
}
);
- (def fn $f:ident($n1:ident: $t1:ty, $n2:ident: $t2:ty, $n3:ident: $t3:ty) -> $r:ty) => (
+ (def fn $f:ident($n1:ident: $t1:ty, $n2:ident: $t2:ty, $n3:ident: $t3:ty) -> $r:tt) => (
/// This is the raw function definition, see the ABI documentation for
/// more information.
#[unstable(feature = "sgx_platform", issue = "56975")]
#[inline(always)]
pub unsafe fn $f($n1: $t1, $n2: $t2, $n3: $t3) -> $r {
ReturnValue::from_registers(stringify!($f), do_usercall(
- Usercalls::$f as Register,
+ NonZeroU64::new(Usercalls::$f as Register)
+ .expect("Usercall number must be non-zero"),
RegisterArgument::into_register($n1),
RegisterArgument::into_register($n2),
RegisterArgument::into_register($n3),
- 0
+ 0,
+ return_type_is_abort!($r)
))
}
);
- (def fn $f:ident($n1:ident: $t1:ty, $n2:ident: $t2:ty) -> $r:ty) => (
+ (def fn $f:ident($n1:ident: $t1:ty, $n2:ident: $t2:ty) -> $r:tt) => (
/// This is the raw function definition, see the ABI documentation for
/// more information.
#[unstable(feature = "sgx_platform", issue = "56975")]
#[inline(always)]
pub unsafe fn $f($n1: $t1, $n2: $t2) -> $r {
ReturnValue::from_registers(stringify!($f), do_usercall(
- Usercalls::$f as Register,
+ NonZeroU64::new(Usercalls::$f as Register)
+ .expect("Usercall number must be non-zero"),
RegisterArgument::into_register($n1),
RegisterArgument::into_register($n2),
- 0,0
+ 0,0,
+ return_type_is_abort!($r)
))
}
);
- (def fn $f:ident($n1:ident: $t1:ty) -> $r:ty) => (
+ (def fn $f:ident($n1:ident: $t1:ty) -> $r:tt) => (
/// This is the raw function definition, see the ABI documentation for
/// more information.
#[unstable(feature = "sgx_platform", issue = "56975")]
#[inline(always)]
pub unsafe fn $f($n1: $t1) -> $r {
ReturnValue::from_registers(stringify!($f), do_usercall(
- Usercalls::$f as Register,
+ NonZeroU64::new(Usercalls::$f as Register)
+ .expect("Usercall number must be non-zero"),
RegisterArgument::into_register($n1),
- 0,0,0
+ 0,0,0,
+ return_type_is_abort!($r)
))
}
);
- (def fn $f:ident() -> $r:ty) => (
+ (def fn $f:ident() -> $r:tt) => (
/// This is the raw function definition, see the ABI documentation for
/// more information.
#[unstable(feature = "sgx_platform", issue = "56975")]
#[inline(always)]
pub unsafe fn $f() -> $r {
ReturnValue::from_registers(stringify!($f), do_usercall(
- Usercalls::$f as Register,
- 0,0,0,0
+ NonZeroU64::new(Usercalls::$f as Register)
+ .expect("Usercall number must be non-zero"),
+ 0,0,0,0,
+ return_type_is_abort!($r)
))
}
);
}
invoke_with_usercalls!(define_usercalls);
-invoke_with_usercalls!(define_usercalls_asm);
);
match error {
- 0 => Ok(out.into_inner()),
+ 0 => Ok(out.into_initialized()),
err => Err(err),
}
}
"{rdx}"(report.as_mut_ptr())
);
- report.into_inner()
+ report.into_initialized()
}
}
}
pub unsafe fn abort_internal() -> ! {
- abi::panic::usercall_exit(true)
+ abi::usercalls::exit(true)
}
pub fn hashmap_random_keys() -> (u64, u64) {
/// This queue is used to implement condition variable and mutexes.
///
/// Users of this API are expected to use the `WaitVariable<T>` type. Since
-/// that type is not `Sync`, it needs to be protected by e.g. a `SpinMutex` to
+/// that type is not `Sync`, it needs to be protected by e.g., a `SpinMutex` to
/// allow shared access.
///
/// Since userspace may send spurious wake-ups, the wakeup event state is
self.inner.is_empty()
}
- /// Add the calling thread to the WaitVariable's wait queue, then wait
+ /// Adds the calling thread to the `WaitVariable`'s wait queue, then wait
/// until a wakeup event.
///
/// This function does not return until this thread has been awoken.
/// [`FileType`]: ../../../../std/fs/struct.FileType.html
#[stable(feature = "file_type_ext", since = "1.5.0")]
pub trait FileTypeExt {
- /// Returns whether this file type is a block device.
+ /// Returns `true` if this file type is a block device.
///
/// # Examples
///
/// ```
#[stable(feature = "file_type_ext", since = "1.5.0")]
fn is_block_device(&self) -> bool;
- /// Returns whether this file type is a char device.
+ /// Returns `true` if this file type is a char device.
///
/// # Examples
///
/// ```
#[stable(feature = "file_type_ext", since = "1.5.0")]
fn is_char_device(&self) -> bool;
- /// Returns whether this file type is a fifo.
+ /// Returns `true` if this file type is a fifo.
///
/// # Examples
///
/// ```
#[stable(feature = "file_type_ext", since = "1.5.0")]
fn is_fifo(&self) -> bool;
- /// Returns whether this file type is a socket.
+ /// Returns `true` if this file type is a socket.
///
/// # Examples
///
/// # Note
///
/// On Windows, you must specify whether a symbolic link points to a file
-/// or directory. Use `os::windows::fs::symlink_file` to create a
+/// or directory. Use `os::windows::fs::symlink_file` to create a
/// symbolic link to a file, or `os::windows::fs::symlink_dir` to create a
-/// symbolic link to a directory. Additionally, the process must have
+/// symbolic link to a directory. Additionally, the process must have
/// `SeCreateSymbolicLinkPrivilege` in order to be able to create a
/// symbolic link.
///
-//! Experimental extensions to `std` for Unix platforms.
+//! Platform-specific extensions to `std` for Unix platforms.
//!
//! Provides access to platform-level information on Unix platforms, and
//! exposes Unix-specific functions that would otherwise be inappropriate as
})
}
- /// Returns true if and only if the address is unnamed.
+ /// Returns `true` if the address is unnamed.
///
/// # Examples
///
/// ```
///
/// # Platform specific
- /// On Redox this always returns None.
+ /// On Redox this always returns `None`.
#[stable(feature = "unix_socket", since = "1.10.0")]
pub fn take_error(&self) -> io::Result<Option<io::Error>> {
self.0.take_error()
/// ```
///
/// # Platform specific
- /// On Redox this always returns None.
+ /// On Redox this always returns `None`.
#[stable(feature = "unix_socket", since = "1.10.0")]
pub fn take_error(&self) -> io::Result<Option<io::Error>> {
self.0.take_error()
Ok(UnixDatagram(inner))
}
- /// Create an unnamed pair of connected sockets.
+ /// Creates an unnamed pair of connected sockets.
///
/// Returns two `UnixDatagrams`s which are connected to each other.
///
/// [`process::Command`]: ../../../../std/process/struct.Command.html
#[stable(feature = "rust1", since = "1.0.0")]
pub trait CommandExt {
- /// Sets the child process's user id. This translates to a
+ /// Sets the child process's user ID. This translates to a
/// `setuid` call in the child process. Failure in the `setuid`
/// call will cause the spawn to fail.
#[stable(feature = "rust1", since = "1.0.0")]
fn uid(&mut self, id: u32) -> &mut process::Command;
- /// Similar to `uid`, but sets the group id of the child process. This has
+ /// Similar to `uid`, but sets the group ID of the child process. This has
/// the same semantics as the `uid` field.
#[stable(feature = "rust1", since = "1.0.0")]
fn gid(&mut self, id: u32) -> &mut process::Command;
// Processes
////////////////////////////////////////////////////////////////////////////////
-/// The unique id of the process (this should never be negative).
+/// The unique ID of the process (this should never be negative).
pub struct Process {
pid: pid_t,
status: Option<ExitStatus>,
pub fn read(&self, data: &mut [u8]) -> io::Result<usize> {
let fd = FileDesc::new(libc::STDIN_FILENO);
let ret = fd.read(data);
- fd.into_raw();
+ fd.into_raw(); // do not close this FD
ret
}
}
pub fn write(&self, data: &[u8]) -> io::Result<usize> {
let fd = FileDesc::new(libc::STDOUT_FILENO);
let ret = fd.write(data);
- fd.into_raw();
+ fd.into_raw(); // do not close this FD
ret
}
pub fn write(&self, data: &[u8]) -> io::Result<usize> {
let fd = FileDesc::new(libc::STDERR_FILENO);
let ret = fd.write(data);
- fd.into_raw();
+ fd.into_raw(); // do not close this FD
ret
}
//! # Overview
//!
//! For historical reasons, the Windows API uses a form of potentially
-//! ill-formed UTF-16 encoding for strings. Specifically, the 16-bit
+//! ill-formed UTF-16 encoding for strings. Specifically, the 16-bit
//! code units in Windows strings may contain [isolated surrogate code
-//! points which are not paired together][ill-formed-utf-16]. The
+//! points which are not paired together][ill-formed-utf-16]. The
//! Unicode standard requires that surrogate code points (those in the
//! range U+D800 to U+DFFF) always be *paired*, because in the UTF-16
//! encoding a *surrogate code unit pair* is used to encode a single
-//! character. For compatibility with code that does not enforce
+//! character. For compatibility with code that does not enforce
//! these pairings, Windows does not enforce them, either.
//!
//! While it is not always possible to convert such a string losslessly into
//! a valid UTF-16 string (or even UTF-8), it is often desirable to be
//! able to round-trip such a string from and to Windows APIs
-//! losslessly. For example, some Rust code may be "bridging" some
+//! losslessly. For example, some Rust code may be "bridging" some
//! Windows APIs together, just passing `WCHAR` strings among those
//! APIs without ever really looking into the strings.
//!
//! # `OsStringExt` and `OsStrExt`
//!
//! [`OsString`] is the Rust wrapper for owned strings in the
-//! preferred representation of the operating system. On Windows,
+//! preferred representation of the operating system. On Windows,
//! this struct gets augmented with an implementation of the
-//! [`OsStringExt`] trait, which has a [`from_wide`] method. This
+//! [`OsStringExt`] trait, which has a [`from_wide`] method. This
//! lets you create an [`OsString`] from a `&[u16]` slice; presumably
//! you get such a slice out of a `WCHAR` Windows API.
//!
//! Similarly, [`OsStr`] is the Rust wrapper for borrowed strings from
-//! preferred representation of the operating system. On Windows, the
+//! preferred representation of the operating system. On Windows, the
//! [`OsStrExt`] trait provides the [`encode_wide`] method, which
-//! outputs an [`EncodeWide`] iterator. You can [`collect`] this
+//! outputs an [`EncodeWide`] iterator. You can [`collect`] this
//! iterator, for example, to obtain a `Vec<u16>`; you can later get a
//! pointer to this vector's contents and feed it to Windows APIs.
//!
/// [`FileType`]: ../../../../std/fs/struct.FileType.html
#[unstable(feature = "windows_file_type_ext", issue = "0")]
pub trait FileTypeExt {
- /// Returns whether this file type is a symbolic link that is also a directory.
+ /// Returns `true` if this file type is a symbolic link that is also a directory.
#[unstable(feature = "windows_file_type_ext", issue = "0")]
fn is_symlink_dir(&self) -> bool;
- /// Returns whether this file type is a symbolic link that is also a file.
+ /// Returns `true` if this file type is a symbolic link that is also a file.
#[unstable(feature = "windows_file_type_ext", issue = "0")]
fn is_symlink_file(&self) -> bool;
}
#[stable(feature = "rust1", since = "1.0.0")]
pub type RawSocket = raw::SOCKET;
-/// Extract raw handles.
+/// Extracts raw handles.
#[stable(feature = "rust1", since = "1.0.0")]
pub trait AsRawHandle {
/// Extracts the raw handle, without taking any ownership.
}
}
-/// Extract raw sockets.
+/// Extracts raw sockets.
#[stable(feature = "rust1", since = "1.0.0")]
pub trait AsRawSocket {
/// Extracts the underlying raw socket from this object.
fn as_raw_socket(&self) -> RawSocket;
}
-/// Create I/O objects from raw sockets.
+/// Creates I/O objects from raw sockets.
#[stable(feature = "from_raw_os", since = "1.1.0")]
pub trait FromRawSocket {
/// Creates a new I/O object from the given raw socket.
-//! Implementation of `std::os` functionality for Windows
+//! Implementation of `std::os` functionality for Windows.
#![allow(nonstandard_style)]
/// Takes a parameter `wait` which indicates if this pipe is currently being
/// read whether the function should block waiting for the read to complete.
///
- /// Return values:
+ /// Returns values:
///
/// * `true` - finished any pending read and the pipe is not at EOF (keep
/// going)
val
}
-/// Print the symbol of the backtrace frame.
+/// Prints the symbol of the backtrace frame.
///
/// These output functions should now be used everywhere to ensure consistency.
/// You may want to also use `output_fileline`.
w.write_all(b"\n")
}
-/// Print the filename and line number of the backtrace frame.
+/// Prints the filename and line number of the backtrace frame.
///
/// See also `output`.
#[allow(dead_code)]
/// A Unicode code point: from U+0000 to U+10FFFF.
///
-/// Compare with the `char` type,
+/// Compares with the `char` type,
/// which represents a Unicode scalar value:
/// a code point that is not a surrogate (U+D800 to U+DFFF).
#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy)]
}
}
-/// Create a new WTF-8 string from an iterator of code points.
+/// Creates a new WTF-8 string from an iterator of code points.
///
/// This replaces surrogate code point pairs with supplementary code points,
/// like concatenating ill-formed UTF-16 strings effectively would.
}
-/// Return a slice of the given string for the byte range [`begin`..`end`).
+/// Returns a slice of the given string for the byte range [`begin`..`end`).
///
/// # Panics
///
}
}
-/// Return a slice of the given string from byte `begin` to its end.
+/// Returns a slice of the given string from byte `begin` to its end.
///
/// # Panics
///
}
}
-/// Return a slice of the given string from its beginning to byte `end`.
+/// Returns a slice of the given string from its beginning to byte `end`.
///
/// # Panics
///
/// [`std::thread::LocalKey`]: ../std/thread/struct.LocalKey.html
#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow_internal_unstable]
+#[cfg_attr(stage0, allow_internal_unstable)]
+#[cfg_attr(not(stage0), allow_internal_unstable(thread_local_internals))]
macro_rules! thread_local {
// empty (base case for the recursion)
() => {};
reason = "should not be necessary",
issue = "0")]
#[macro_export]
-#[allow_internal_unstable]
+#[cfg_attr(stage0, allow_internal_unstable)]
+#[cfg_attr(not(stage0), allow_internal_unstable(
+ thread_local_internals, cfg_target_thread_local, thread_local,
+))]
#[allow_internal_unsafe]
macro_rules! __thread_local_inner {
(@key $(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $init:expr) => {
/// let flag2 = Arc::clone(&flag);
///
/// let parked_thread = thread::spawn(move || {
-/// // We want to wait until the flag is set. We *could* just spin, but using
+/// // We want to wait until the flag is set. We *could* just spin, but using
/// // park/unpark is more efficient.
/// while !flag2.load(Ordering::Acquire) {
/// println!("Parking thread");
/// instant when created, and are often useful for tasks such as measuring
/// benchmarks or timing how long an operation takes.
///
-/// Note, however, that instants are not guaranteed to be **steady**. In other
+/// Note, however, that instants are not guaranteed to be **steady**. In other
/// words, each tick of the underlying clock may not be the same length (e.g.
/// some seconds may be longer than others). An instant may jump forwards or
/// experience time dilation (slow down or speed up), but it will never go
/// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be represented as
/// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
/// otherwise.
- #[unstable(feature = "time_checked_add", issue = "55940")]
+ #[stable(feature = "time_checked_add", since = "1.34.0")]
pub fn checked_add(&self, duration: Duration) -> Option<Instant> {
- self.0.checked_add_duration(&duration).map(|t| Instant(t))
+ self.0.checked_add_duration(&duration).map(Instant)
}
/// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as
/// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
/// otherwise.
- #[unstable(feature = "time_checked_add", issue = "55940")]
+ #[stable(feature = "time_checked_add", since = "1.34.0")]
pub fn checked_sub(&self, duration: Duration) -> Option<Instant> {
- self.0.checked_sub_duration(&duration).map(|t| Instant(t))
+ self.0.checked_sub_duration(&duration).map(Instant)
}
}
/// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be represented as
/// `SystemTime` (which means it's inside the bounds of the underlying data structure), `None`
/// otherwise.
- #[unstable(feature = "time_checked_add", issue = "55940")]
+ #[stable(feature = "time_checked_add", since = "1.34.0")]
pub fn checked_add(&self, duration: Duration) -> Option<SystemTime> {
- self.0.checked_add_duration(&duration).map(|t| SystemTime(t))
+ self.0.checked_add_duration(&duration).map(SystemTime)
}
/// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as
/// `SystemTime` (which means it's inside the bounds of the underlying data structure), `None`
/// otherwise.
- #[unstable(feature = "time_checked_add", issue = "55940")]
+ #[stable(feature = "time_checked_add", since = "1.34.0")]
pub fn checked_sub(&self, duration: Duration) -> Option<SystemTime> {
- self.0.checked_sub_duration(&duration).map(|t| SystemTime(t))
+ self.0.checked_sub_duration(&duration).map(SystemTime)
}
}
log = "0.4"
scoped-tls = "0.1"
syntax_pos = { path = "../libsyntax_pos" }
-rustc_errors = { path = "../librustc_errors" }
+errors = { path = "../librustc_errors", package = "rustc_errors" }
rustc_data_structures = { path = "../librustc_data_structures" }
rustc_target = { path = "../librustc_target" }
smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
}
}
-/// Arguments of a path segment.
+/// The arguments of a path segment.
///
/// E.g., `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)`.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub enum GenericArgs {
- /// The `<'a, A,B,C>` in `foo::bar::baz::<'a, A,B,C>`
+ /// The `<'a, A, B, C>` in `foo::bar::baz::<'a, A, B, C>`.
AngleBracketed(AngleBracketedArgs),
- /// The `(A,B)` and `C` in `Foo(A,B) -> C`
+ /// The `(A, B)` and `C` in `Foo(A, B) -> C`.
Parenthesized(ParenthesizedArgs),
}
}
}
-/// A path like `Foo<'a, T>`
+/// A path like `Foo<'a, T>`.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Default)]
pub struct AngleBracketedArgs {
- /// Overall span
+ /// The overall span.
pub span: Span,
/// The arguments for this path segment.
pub args: Vec<GenericArg>,
/// Bindings (equality constraints) on associated types, if present.
- ///
- /// E.g., `Foo<A=Bar>`.
+ /// E.g., `Foo<A = Bar>`.
pub bindings: Vec<TypeBinding>,
}
}
}
-/// A path like `Foo(A,B) -> C`
+/// A path like `Foo(A, B) -> C`.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct ParenthesizedArgs {
/// Overall span
}
}
-/// Node id used to represent the root of the crate.
+/// `NodeId` used to represent the root of the crate.
pub const CRATE_NODE_ID: NodeId = NodeId::from_u32_const(0);
/// When parsing and doing expansions, we initially give all AST nodes this AST
}
}
-/// A `where` clause in a definition
+/// A where-clause in a definition.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct WhereClause {
pub id: NodeId,
pub span: Span,
}
-/// A single predicate in a `where` clause
+/// A single predicate in a where-clause.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub enum WherePredicate {
/// A type binding (e.g., `for<'c> Foo: Send + Clone + 'c`).
pub decl: P<FnDecl>,
}
-/// The different kinds of types recognized by the compiler.
+/// The various kinds of type recognized by the compiler.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub enum TyKind {
/// A variable-length slice (`[T]`).
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub enum FunctionRetTy {
- /// Return type is not specified.
+ /// Returns type is not specified.
///
/// Functions default to `()` and closures default to inference.
/// Span points to where return type would be inserted.
/// `TraitRef`s appear in impls.
///
-/// Resolve maps each `TraitRef`'s `ref_id` to its defining trait; that's all
+/// Resolution maps each `TraitRef`'s `ref_id` to its defining trait; that's all
/// that the `ref_id` is for. The `impl_id` maps to the "self type" of this impl.
/// If this impl is an `ItemKind::Impl`, the `impl_id` is redundant (it could be the
-/// same as the impl's node-id).
+/// same as the impl's `NodeId`).
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct TraitRef {
pub path: Path,
//! Parsing and validation of builtin attributes
use crate::ast::{self, Attribute, MetaItem, Name, NestedMetaItemKind};
-use crate::errors::{Applicability, Handler};
use crate::feature_gate::{Features, GatedCfg};
use crate::parse::ParseSess;
+use errors::{Applicability, Handler};
use syntax_pos::{symbol::Symbol, Span};
use super::{list_contains_name, mark_used, MetaItemKind};
pub suggestion: Option<Symbol>,
}
-/// Check if `attrs` contains an attribute like `#![feature(feature_name)]`.
+/// Checks if `attrs` contains an attribute like `#![feature(feature_name)]`.
/// This will not perform any "sanity checks" on the form of the attributes.
pub fn contains_feature_attr(attrs: &[Attribute], feature_name: &str) -> bool {
attrs.iter().any(|item| {
})
}
-/// Find the first stability attribute. `None` if none exists.
+/// Finds the first stability attribute. `None` if none exists.
pub fn find_stability(sess: &ParseSess, attrs: &[Attribute],
item_sp: Span) -> Option<Stability> {
find_stability_generic(sess, attrs.iter(), item_sp)
pub note: Option<Symbol>,
}
-/// Find the deprecation attribute. `None` if none exists.
+/// Finds the deprecation attribute. `None` if none exists.
pub fn find_deprecation(sess: &ParseSess, attrs: &[Attribute],
item_sp: Span) -> Option<Deprecation> {
find_deprecation_generic(sess, attrs.iter(), item_sp)
let diagnostic = &sess.span_diagnostic;
'outer: for attr in attrs_iter {
- if attr.path != "deprecated" {
- continue
+ if !attr.check_name("deprecated") {
+ continue;
}
- mark_used(attr);
-
if depr.is_some() {
span_err!(diagnostic, item_sp, E0550, "multiple deprecated attributes");
break
}
- depr = if let Some(metas) = attr.meta_item_list() {
- let get = |meta: &MetaItem, item: &mut Option<Symbol>| {
- if item.is_some() {
- handle_errors(sess, meta.span, AttrError::MultipleItem(meta.name()));
- return false
- }
- if let Some(v) = meta.value_str() {
- *item = Some(v);
- true
- } else {
- if let Some(lit) = meta.name_value_literal() {
- handle_errors(
- sess,
- lit.span,
- AttrError::UnsupportedLiteral(
- "literal in `deprecated` \
- value must be a string",
- lit.node.is_bytestr()
- ),
- );
- } else {
- span_err!(diagnostic, meta.span, E0551, "incorrect meta item");
+ let meta = attr.meta().unwrap();
+ depr = match &meta.node {
+ MetaItemKind::Word => Some(Deprecation { since: None, note: None }),
+ MetaItemKind::NameValue(..) => {
+ meta.value_str().map(|note| {
+ Deprecation { since: None, note: Some(note) }
+ })
+ }
+ MetaItemKind::List(list) => {
+ let get = |meta: &MetaItem, item: &mut Option<Symbol>| {
+ if item.is_some() {
+ handle_errors(sess, meta.span, AttrError::MultipleItem(meta.name()));
+ return false
}
+ if let Some(v) = meta.value_str() {
+ *item = Some(v);
+ true
+ } else {
+ if let Some(lit) = meta.name_value_literal() {
+ handle_errors(
+ sess,
+ lit.span,
+ AttrError::UnsupportedLiteral(
+ "literal in `deprecated` \
+ value must be a string",
+ lit.node.is_bytestr()
+ ),
+ );
+ } else {
+ span_err!(diagnostic, meta.span, E0551, "incorrect meta item");
+ }
- false
- }
- };
+ false
+ }
+ };
- let mut since = None;
- let mut note = None;
- for meta in metas {
- match &meta.node {
- NestedMetaItemKind::MetaItem(mi) => {
- match &*mi.name().as_str() {
- "since" => if !get(mi, &mut since) { continue 'outer },
- "note" => if !get(mi, &mut note) { continue 'outer },
- _ => {
- handle_errors(
- sess,
- meta.span,
- AttrError::UnknownMetaItem(mi.name(), &["since", "note"]),
- );
- continue 'outer
+ let mut since = None;
+ let mut note = None;
+ for meta in list {
+ match &meta.node {
+ NestedMetaItemKind::MetaItem(mi) => {
+ match &*mi.name().as_str() {
+ "since" => if !get(mi, &mut since) { continue 'outer },
+ "note" => if !get(mi, &mut note) { continue 'outer },
+ _ => {
+ handle_errors(
+ sess,
+ meta.span,
+ AttrError::UnknownMetaItem(mi.name(), &["since", "note"]),
+ );
+ continue 'outer
+ }
}
}
- }
- NestedMetaItemKind::Literal(lit) => {
- handle_errors(
- sess,
- lit.span,
- AttrError::UnsupportedLiteral(
- "item in `deprecated` must be a key/value pair",
- false,
- ),
- );
- continue 'outer
+ NestedMetaItemKind::Literal(lit) => {
+ handle_errors(
+ sess,
+ lit.span,
+ AttrError::UnsupportedLiteral(
+ "item in `deprecated` must be a key/value pair",
+ false,
+ ),
+ );
+ continue 'outer
+ }
}
}
- }
- Some(Deprecation {since: since, note: note})
- } else {
- Some(Deprecation{since: None, note: None})
- }
+ Some(Deprecation { since, note })
+ }
+ };
}
depr
self.span
}
- /// Returns true if this list item is a MetaItem with a name of `name`.
+ /// Returns `true` if this list item is a MetaItem with a name of `name`.
pub fn check_name(&self, name: &str) -> bool {
self.meta_item().map_or(false, |meta_item| meta_item.check_name(name))
}
}
impl Attribute {
+ /// Returns `true` if the attribute's path matches the argument. If it matches, then the
+ /// attribute is marked as used.
+ ///
+ /// To check the attribute name without marking it used, use the `path` field directly.
pub fn check_name(&self, name: &str) -> bool {
let matches = self.path == name;
if matches {
}
impl Attribute {
- /// Extract the MetaItem from inside this Attribute.
+ /// Extracts the MetaItem from inside this Attribute.
pub fn meta(&self) -> Option<MetaItem> {
let mut tokens = self.tokens.trees().peekable();
Some(MetaItem {
})
}
- /// Convert self to a normal #[doc="foo"] comment, if it is a
+ /// Converts self to a normal #[doc="foo"] comment, if it is a
/// comment like `///` or `/** */`. (Returns self unchanged for
/// non-sugared doc attributes.)
pub fn with_desugared_doc<T, F>(&self, f: F) -> T where
match *self {
LitKind::Str(string, ast::StrStyle::Cooked) => {
- let escaped = string.as_str().escape_default();
+ let escaped = string.as_str().escape_default().to_string();
Token::Literal(token::Lit::Str_(Symbol::intern(&escaped)), None)
}
LitKind::Str(string, ast::StrStyle::Raw(n)) => {
use crate::attr;
use crate::ast;
use crate::edition::Edition;
-use crate::errors::Applicability;
use crate::mut_visit::*;
use crate::parse::{token, ParseSess};
use crate::ptr::P;
use crate::util::map_in_place::MapInPlace;
+use errors::Applicability;
use smallvec::SmallVec;
/// A folder that strips out items that do not belong in the current configuration.
///
/// Gives a compiler warning when the `cfg_attr` contains no attributes and
/// is in the original source file. Gives a compiler error if the syntax of
- /// the attribute is incorrect
+ /// the attribute is incorrect.
fn process_cfg_attr(&mut self, attr: ast::Attribute) -> Vec<ast::Attribute> {
if !attr.check_name("cfg_attr") {
return vec![attr];
}
}
- /// Determine if a node with the given attributes should be included in this configuration.
+ /// Determines if a node with the given attributes should be included in this configuration.
pub fn in_cfg(&mut self, attrs: &[ast::Attribute]) -> bool {
attrs.iter().all(|attr| {
if !is_cfg(attr) {
}
}
- // deny #[cfg] on generic parameters until we decide what to do with it.
- // see issue #51279.
+ /// Denies `#[cfg]` on generic parameters until we decide what to do with it.
+ /// See issue #51279.
pub fn disallow_cfg_on_generic_param(&mut self, param: &ast::GenericParam) {
for attr in param.attrs() {
let offending_attr = if attr.check_name("cfg") {
}
impl ErrorLocation {
- /// Create an error location from a span.
+ /// Creates an error location from a span.
pub fn from_span(ecx: &ExtCtxt<'_>, sp: Span) -> ErrorLocation {
let loc = ecx.source_map().lookup_char_pos_adj(sp.lo());
ErrorLocation {
}
}
-/// Get the directory where metadata for a given `prefix` should be stored.
+/// Gets the directory where metadata for a given `prefix` should be stored.
///
/// See `output_metadata`.
pub fn get_metadata_dir(prefix: &str) -> PathBuf {
use crate::diagnostics::metadata::output_metadata;
-pub use crate::errors::*;
+pub use errors::*;
// Maximum width of any line in an extended error description (inclusive).
const MAX_DESCRIPTION_WIDTH: usize = 80;
/// Usage of `?` as a macro separator is deprecated.
QuestionMarkMacroSep,
IllFormedAttributeInput,
+ /// Usage of a duplicate macro matcher binding name.
+ DuplicateMacroMatcherBindingName,
}
/// Stores buffered lint info which can later be passed to `librustc`.
use crate::attr::HasAttrs;
use crate::source_map::{SourceMap, Spanned, respan};
use crate::edition::Edition;
-use crate::errors::{DiagnosticBuilder, DiagnosticId};
use crate::ext::expand::{self, AstFragment, Invocation};
use crate::ext::hygiene::{self, Mark, SyntaxContext, Transparency};
use crate::mut_visit::{self, MutVisitor};
use crate::ThinVec;
use crate::tokenstream::{self, TokenStream};
+use errors::{DiagnosticBuilder, DiagnosticId};
use smallvec::{smallvec, SmallVec};
use syntax_pos::{Span, MultiSpan, DUMMY_SP};
/// The result of a macro expansion. The return values of the various
/// methods are spliced into the AST at the callsite of the macro.
pub trait MacResult {
- /// Create an expression.
+ /// Creates an expression.
fn make_expr(self: Box<Self>) -> Option<P<ast::Expr>> {
None
}
- /// Create zero or more items.
+ /// Creates zero or more items.
fn make_items(self: Box<Self>) -> Option<SmallVec<[P<ast::Item>; 1]>> {
None
}
- /// Create zero or more impl items.
+ /// Creates zero or more impl items.
fn make_impl_items(self: Box<Self>) -> Option<SmallVec<[ast::ImplItem; 1]>> {
None
}
- /// Create zero or more trait items.
+ /// Creates zero or more trait items.
fn make_trait_items(self: Box<Self>) -> Option<SmallVec<[ast::TraitItem; 1]>> {
None
}
- /// Create zero or more items in an `extern {}` block
+ /// Creates zero or more items in an `extern {}` block
fn make_foreign_items(self: Box<Self>) -> Option<SmallVec<[ast::ForeignItem; 1]>> { None }
- /// Create a pattern.
+ /// Creates a pattern.
fn make_pat(self: Box<Self>) -> Option<P<ast::Pat>> {
None
}
- /// Create zero or more statements.
+ /// Creates zero or more statements.
///
/// By default this attempts to create an expression statement,
/// returning None if that fails.
}
impl DummyResult {
- /// Create a default MacResult that can be anything.
+ /// Creates a default MacResult that can be anything.
///
/// Use this as a return value after hitting any errors and
/// calling `span_err`.
Box::new(DummyResult { expr_only: false, is_error: false, span })
}
- /// Create a default MacResult that can only be an expression.
+ /// Creates a default MacResult that can only be an expression.
///
/// Use this for macros that must expand to an expression, so even
/// if an error is encountered internally, the user will receive
/// A function-like procedural macro. TokenStream -> TokenStream.
ProcMacro {
expander: Box<dyn ProcMacro + sync::Sync + sync::Send>,
- allow_internal_unstable: bool,
+ /// Whitelist of unstable features that are treated as stable inside this macro
+ allow_internal_unstable: Option<Lrc<[Symbol]>>,
edition: Edition,
},
expander: Box<dyn TTMacroExpander + sync::Sync + sync::Send>,
def_info: Option<(ast::NodeId, Span)>,
/// Whether the contents of the macro can
- /// directly use `#[unstable]` things (true == yes).
- allow_internal_unstable: bool,
+ /// directly use `#[unstable]` things.
+ ///
+ /// Only allows things that require a feature gate in the given whitelist
+ allow_internal_unstable: Option<Lrc<[Symbol]>>,
/// Whether the contents of the macro can use `unsafe`
/// without triggering the `unsafe_code` lint.
allow_internal_unsafe: bool,
/// A function-like syntax extension that has an extra ident before
/// the block.
- ///
- IdentTT(Box<dyn IdentMacroExpander + sync::Sync + sync::Send>, Option<Span>, bool),
+ IdentTT {
+ expander: Box<dyn IdentMacroExpander + sync::Sync + sync::Send>,
+ span: Option<Span>,
+ allow_internal_unstable: Option<Lrc<[Symbol]>>,
+ },
/// An attribute-like procedural macro. TokenStream -> TokenStream.
/// The input is the annotated item.
}
impl SyntaxExtension {
- /// Return which kind of macro calls this syntax extension.
+ /// Returns which kind of macro calls this syntax extension.
pub fn kind(&self) -> MacroKind {
match *self {
SyntaxExtension::DeclMacro { .. } |
SyntaxExtension::NormalTT { .. } |
- SyntaxExtension::IdentTT(..) |
+ SyntaxExtension::IdentTT { .. } |
SyntaxExtension::ProcMacro { .. } =>
MacroKind::Bang,
SyntaxExtension::NonMacroAttr { .. } |
SyntaxExtension::ProcMacroDerive(.., edition) => edition,
// Unstable legacy stuff
SyntaxExtension::NonMacroAttr { .. } |
- SyntaxExtension::IdentTT(..) |
+ SyntaxExtension::IdentTT { .. } |
SyntaxExtension::MultiDecorator(..) |
SyntaxExtension::MultiModifier(..) |
SyntaxExtension::BuiltinDerive(..) => hygiene::default_edition(),
expand::MacroExpander::new(self, false)
}
- /// Returns a `Folder` that deeply expands all macros and assigns all node ids in an AST node.
- /// Once node ids are assigned, the node may not be expanded, removed, or otherwise modified.
+ /// Returns a `Folder` that deeply expands all macros and assigns all `NodeId`s in an AST node.
+ /// Once `NodeId`s are assigned, the node may not be expanded, removed, or otherwise modified.
pub fn monotonic_expander<'b>(&'b mut self) -> expand::MacroExpander<'b, 'a> {
expand::MacroExpander::new(self, true)
}
}
}
-/// Extract a string literal from the macro expanded version of `expr`,
+/// Extracts a string literal from the macro expanded version of `expr`,
/// emitting `err_msg` if `expr` is not a string literal. This does not stop
-/// compilation on error, merely emits a non-fatal error and returns None.
+/// compilation on error, merely emits a non-fatal error and returns `None`.
pub fn expr_to_spanned_string<'a>(
cx: &'a mut ExtCtxt<'_>,
mut expr: P<ast::Expr>,
}
/// Interpreting `tts` as a comma-separated sequence of expressions,
-/// expect exactly one string literal, or emit an error and return None.
+/// expect exactly one string literal, or emit an error and return `None`.
pub fn get_single_str_from_tts(cx: &mut ExtCtxt<'_>,
sp: Span,
tts: &[tokenstream::TokenTree],
})
}
-/// Extract comma-separated expressions from `tts`. If there is a
-/// parsing error, emit a non-fatal error and return None.
+/// Extracts comma-separated expressions from `tts`. If there is a
+/// parsing error, emit a non-fatal error and return `None`.
pub fn get_exprs_from_tts(cx: &mut ExtCtxt<'_>,
sp: Span,
tts: &[tokenstream::TokenTree]) -> Option<Vec<P<ast::Expr>>> {
/// Constructs a qualified path.
///
- /// Constructs a path like `<self_type as trait_path>::ident<'a, T, A=Bar>`.
+ /// Constructs a path like `<self_type as trait_path>::ident<'a, T, A = Bar>`.
fn qpath_all(&self,
self_type: P<ast::Ty>,
trait_path: ast::Path,
call_site: span,
def_site: None,
format: ExpnFormat::MacroAttribute(Symbol::intern(&pretty_name)),
- allow_internal_unstable: true,
+ allow_internal_unstable: Some(vec![
+ Symbol::intern("rustc_attrs"),
+ Symbol::intern("structural_match"),
+ ].into()),
allow_internal_unsafe: false,
local_inner_macros: false,
edition: hygiene::default_edition(),
use crate::attr::{self, HasAttrs};
use crate::source_map::{ExpnInfo, MacroBang, MacroAttribute, dummy_spanned, respan};
use crate::config::StripUnconfigured;
-use crate::errors::{Applicability, FatalError};
use crate::ext::base::*;
use crate::ext::derive::{add_derived_markers, collect_derives};
use crate::ext::hygiene::{self, Mark, SyntaxContext};
use crate::visit::{self, Visitor};
use crate::util::map_in_place::MapInPlace;
+use errors::{Applicability, FatalError};
use smallvec::{smallvec, SmallVec};
use syntax_pos::{Span, DUMMY_SP, FileName};
use syntax_pos::hygiene::ExpnFormat;
}
}
- /// Collect all macro invocations reachable at this time in this AST fragment, and replace
+ /// Collects all macro invocations reachable at this time in this AST fragment, and replace
/// them with "placeholders" - dummy macro invocations with specially crafted `NodeId`s.
/// Then call into resolver that builds a skeleton ("reduced graph") of the fragment and
/// prepares data for resolving paths of macro invocations.
call_site: attr.span,
def_site: None,
format: MacroAttribute(Symbol::intern(&attr.path.to_string())),
- allow_internal_unstable: false,
+ allow_internal_unstable: None,
allow_internal_unsafe: false,
local_inner_macros: false,
edition: ext.edition(),
// don't stability-check macros in the same crate
// (the only time this is null is for syntax extensions registered as macros)
if def_site_span.map_or(false, |def_span| !crate_span.contains(def_span))
- && !span.allows_unstable() && this.cx.ecfg.features.map_or(true, |feats| {
+ && !span.allows_unstable(&feature.as_str())
+ && this.cx.ecfg.features.map_or(true, |feats| {
// macro features will count as lib features
!feats.declared_lib_features.iter().any(|&(feat, _)| feat == feature)
}) {
let opt_expanded = match *ext {
DeclMacro { ref expander, def_info, edition, .. } => {
if let Err(dummy_span) = validate_and_set_expn_info(self, def_info.map(|(_, s)| s),
- false, false, false, None,
+ None, false, false, None,
edition) {
dummy_span
} else {
NormalTT {
ref expander,
def_info,
- allow_internal_unstable,
+ ref allow_internal_unstable,
allow_internal_unsafe,
local_inner_macros,
unstable_feature,
edition,
} => {
if let Err(dummy_span) = validate_and_set_expn_info(self, def_info.map(|(_, s)| s),
- allow_internal_unstable,
+ allow_internal_unstable.clone(),
allow_internal_unsafe,
local_inner_macros,
unstable_feature,
}
}
- IdentTT(ref expander, tt_span, allow_internal_unstable) => {
+ IdentTT { ref expander, span: tt_span, ref allow_internal_unstable } => {
if ident.name == keywords::Invalid.name() {
self.cx.span_err(path.span,
&format!("macro {}! expects an ident argument", path));
call_site: span,
def_site: tt_span,
format: macro_bang_format(path),
- allow_internal_unstable,
+ allow_internal_unstable: allow_internal_unstable.clone(),
allow_internal_unsafe: false,
local_inner_macros: false,
edition: hygiene::default_edition(),
kind.dummy(span)
}
- SyntaxExtension::ProcMacro { ref expander, allow_internal_unstable, edition } => {
+ SyntaxExtension::ProcMacro { ref expander, ref allow_internal_unstable, edition } => {
if ident.name != keywords::Invalid.name() {
let msg =
format!("macro {}! expects no ident argument, given '{}'", path, ident);
def_site: None,
format: macro_bang_format(path),
// FIXME probably want to follow macro_rules macros here.
- allow_internal_unstable,
+ allow_internal_unstable: allow_internal_unstable.clone(),
allow_internal_unsafe: false,
local_inner_macros: false,
edition,
call_site: span,
def_site: None,
format: MacroAttribute(pretty_name),
- allow_internal_unstable: false,
+ allow_internal_unstable: None,
allow_internal_unsafe: false,
local_inner_macros: false,
edition: ext.edition(),
Some(invoc.fragment_kind.expect_from_annotatables(items))
}
BuiltinDerive(func) => {
- expn_info.allow_internal_unstable = true;
+ expn_info.allow_internal_unstable = Some(vec![
+ Symbol::intern("rustc_attrs"),
+ Symbol::intern("derive_clone_copy"),
+ Symbol::intern("derive_eq"),
+ Symbol::intern("libstd_sys_internals"), // RustcDeserialize and RustcSerialize
+ ].into());
invoc.expansion_data.mark.set_expn_info(expn_info);
let span = span.with_ctxt(self.cx.backtrace());
let mut items = Vec::new();
/* __rust_unstable_column!(): expands to the current column number */
pub fn expand_column_gated(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree])
-> Box<dyn base::MacResult+'static> {
- if sp.allows_unstable() {
+ if sp.allows_unstable("__rust_unstable_column") {
expand_column(cx, sp, tts)
} else {
cx.span_fatal(sp, "the __rust_unstable_column macro is unstable");
-//! This is an NFA-based parser, which calls out to the main rust parser for named nonterminals
+//! This is an NFA-based parser, which calls out to the main rust parser for named non-terminals
//! (which it commits to fully when it hits one in a grammar). There's a set of current NFA threads
//! and a set of next ones. Instead of NTs, we have a special case for Kleene star. The big-O, in
//! pathological cases, is worse than traditional use of NFA or Earley parsing, but it's an easier
//!
//! As it processes them, it fills up `eof_items` with threads that would be valid if
//! the macro invocation is now over, `bb_items` with threads that are waiting on
-//! a Rust nonterminal like `$e:expr`, and `next_items` with threads that are waiting
+//! a Rust non-terminal like `$e:expr`, and `next_items` with threads that are waiting
//! on a particular token. Most of the logic concerns moving the · through the
//! repetitions indicated by Kleene stars. The rules for moving the · without
//! consuming any input are called epsilon transitions. It only advances or calls
use TokenTreeOrTokenTreeSlice::*;
use crate::ast::Ident;
-use crate::errors::FatalError;
use crate::ext::tt::quoted::{self, TokenTree};
use crate::parse::{Directory, ParseSess};
use crate::parse::parser::{Parser, PathStyle};
use crate::symbol::keywords;
use crate::tokenstream::{DelimSpan, TokenStream};
+use errors::FatalError;
use smallvec::{smallvec, SmallVec};
-use syntax_pos::{self, Span};
+use syntax_pos::Span;
use rustc_data_structures::fx::FxHashMap;
use std::collections::hash_map::Entry::{Occupied, Vacant};
}
impl<'root, 'tt> MatcherPos<'root, 'tt> {
- /// Add `m` as a named match for the `idx`-th metavar.
+ /// Adds `m` as a named match for the `idx`-th metavar.
fn push_match(&mut self, idx: usize, m: NamedMatch) {
let matches = Rc::make_mut(&mut self.matches[idx]);
matches.push(m);
}.into_boxed_slice()
}
-/// Generate the top-level matcher position in which the "dot" is before the first token of the
+/// Generates the top-level matcher position in which the "dot" is before the first token of the
/// matcher `ms` and we are going to start matching at the span `open` in the source.
fn initial_matcher_pos<'root, 'tt>(ms: &'tt [TokenTree], open: Span) -> MatcherPos<'root, 'tt> {
let match_idx_hi = count_names(ms);
/// `NamedMatch` is a pattern-match result for a single `token::MATCH_NONTERMINAL`:
/// so it is associated with a single ident in a parse, and all
-/// `MatchedNonterminal`s in the `NamedMatch` have the same nonterminal type
+/// `MatchedNonterminal`s in the `NamedMatch` have the same non-terminal type
/// (expr, item, etc). Each leaf in a single `NamedMatch` corresponds to a
/// single `token::MATCH_NONTERMINAL` in the `TokenTree` that produced it.
///
Success(ret_val)
}
-/// Generate an appropriate parsing failure message. For EOF, this is "unexpected end...". For
+/// Generates an appropriate parsing failure message. For EOF, this is "unexpected end...". For
/// other tokens, this is "unexpected token...".
pub fn parse_failure_msg(tok: Token) -> String {
match tok {
}
}
-/// Perform a token equality check, ignoring syntax context (that is, an unhygienic comparison)
+/// Performs a token equality check, ignoring syntax context (that is, an unhygienic comparison)
fn token_name_eq(t1: &Token, t2: &Token) -> bool {
if let (Some((id1, is_raw1)), Some((id2, is_raw2))) = (t1.ident(), t2.ident()) {
id1.name == id2.name && is_raw1 == is_raw2
}
}
-/// A call to the "black-box" parser to parse some rust nonterminal.
+/// A call to the "black-box" parser to parse some Rust non-terminal.
///
/// # Parameters
///
///
/// # Returns
///
-/// The parsed nonterminal.
+/// The parsed non-terminal.
fn parse_nt<'a>(p: &mut Parser<'a>, sp: Span, name: &str) -> Nonterminal {
if name == "tt" {
return token::NtTT(p.parse_token_tree());
use crate::{ast, attr};
use crate::edition::Edition;
-use crate::errors::FatalError;
use crate::ext::base::{DummyResult, ExtCtxt, MacResult, SyntaxExtension};
use crate::ext::base::{NormalTT, TTMacroExpander};
use crate::ext::expand::{AstFragment, AstFragmentKind};
use crate::symbol::Symbol;
use crate::tokenstream::{DelimSpan, TokenStream, TokenTree};
-use syntax_pos::{Span, DUMMY_SP};
+use errors::FatalError;
+use syntax_pos::{Span, DUMMY_SP, symbol::Ident};
use log::debug;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap};
use std::borrow::Cow;
use std::collections::hash_map::Entry;
use rustc_data_structures::sync::Lrc;
-use crate::errors::Applicability;
+use errors::Applicability;
const VALID_FRAGMENT_NAMES_MSG: &str = "valid fragment specifiers are \
`ident`, `block`, `stmt`, `expr`, `pat`, `ty`, `lifetime`, `literal`, \
// Holy self-referential!
/// Converts a `macro_rules!` invocation into a syntax extension.
-pub fn compile(sess: &ParseSess, features: &Features, def: &ast::Item, edition: Edition)
- -> SyntaxExtension {
+pub fn compile(
+ sess: &ParseSess,
+ features: &Features,
+ def: &ast::Item,
+ edition: Edition
+) -> SyntaxExtension {
let lhs_nm = ast::Ident::with_empty_ctxt(Symbol::gensym("lhs"));
let rhs_nm = ast::Ident::with_empty_ctxt(Symbol::gensym("rhs"));
// don't abort iteration early, so that errors for multiple lhses can be reported
for lhs in &lhses {
- valid &= check_lhs_no_empty_seq(sess, &[lhs.clone()])
+ valid &= check_lhs_no_empty_seq(sess, &[lhs.clone()]);
+ valid &= check_lhs_duplicate_matcher_bindings(
+ sess,
+ &[lhs.clone()],
+ &mut FxHashMap::default(),
+ def.id
+ );
}
let expander: Box<_> = Box::new(MacroRulesMacroExpander {
});
if body.legacy {
- let allow_internal_unstable = attr::contains_name(&def.attrs, "allow_internal_unstable");
+ let allow_internal_unstable = attr::find_by_name(&def.attrs, "allow_internal_unstable")
+ .map(|attr| attr
+ .meta_item_list()
+ .map(|list| list.iter()
+ .map(|it| it.name().unwrap_or_else(|| sess.span_diagnostic.span_bug(
+ it.span, "allow internal unstable expects feature names",
+ )))
+ .collect::<Vec<Symbol>>().into()
+ )
+ .unwrap_or_else(|| {
+ sess.span_diagnostic.span_warn(
+ attr.span, "allow_internal_unstable expects list of feature names. In the \
+ future this will become a hard error. Please use `allow_internal_unstable(\
+ foo, bar)` to only allow the `foo` and `bar` features",
+ );
+ vec![Symbol::intern("allow_internal_unstable_backcompat_hack")].into()
+ })
+ );
let allow_internal_unsafe = attr::contains_name(&def.attrs, "allow_internal_unsafe");
let mut local_inner_macros = false;
if let Some(macro_export) = attr::find_by_name(&def.attrs, "macro_export") {
// after parsing/expansion. we can report every error in every macro this way.
}
-/// Check that the lhs contains no repetition which could match an empty token
+/// Checks that the lhs contains no repetition which could match an empty token
/// tree, because then the matcher would hang indefinitely.
fn check_lhs_no_empty_seq(sess: &ParseSess, tts: &[quoted::TokenTree]) -> bool {
use quoted::TokenTree;
true
}
+/// Check that the LHS contains no duplicate matcher bindings. e.g. `$a:expr, $a:expr` would be
+/// illegal, since it would be ambiguous which `$a` to use if we ever needed to.
+fn check_lhs_duplicate_matcher_bindings(
+ sess: &ParseSess,
+ tts: &[quoted::TokenTree],
+ metavar_names: &mut FxHashMap<Ident, Span>,
+ node_id: ast::NodeId,
+) -> bool {
+ use self::quoted::TokenTree;
+ use crate::early_buffered_lints::BufferedEarlyLintId;
+ for tt in tts {
+ match *tt {
+ TokenTree::MetaVarDecl(span, name, _kind) => {
+ if let Some(&prev_span) = metavar_names.get(&name) {
+ // FIXME(mark-i-m): in a few cycles, make this a hard error.
+ // sess.span_diagnostic
+ // .struct_span_err(span, "duplicate matcher binding")
+ // .span_note(prev_span, "previous declaration was here")
+ // .emit();
+ sess.buffer_lint(
+ BufferedEarlyLintId::DuplicateMacroMatcherBindingName,
+ crate::source_map::MultiSpan::from(vec![prev_span, span]),
+ node_id,
+ "duplicate matcher binding"
+ );
+ return false;
+ } else {
+ metavar_names.insert(name, span);
+ }
+ }
+ TokenTree::Delimited(_, ref del) => {
+ if !check_lhs_duplicate_matcher_bindings(sess, &del.tts, metavar_names, node_id) {
+ return false;
+ }
+ },
+ TokenTree::Sequence(_, ref seq) => {
+ if !check_lhs_duplicate_matcher_bindings(sess, &seq.tts, metavar_names, node_id) {
+ return false;
+ }
+ }
+ _ => {}
+ }
+ }
+
+ true
+}
+
fn check_rhs(sess: &ParseSess, rhs: "ed::TokenTree) -> bool {
match *rhs {
quoted::TokenTree::Delimited(..) => return true,
}
}
-/// True if a fragment of type `frag` can be followed by any sort of
-/// token. We use this (among other things) as a useful approximation
+/// Returns `true` if a fragment of type `frag` can be followed by any sort of
+/// token. We use this (among other things) as a useful approximation
/// for when `frag` can be followed by a repetition like `$(...)*` or
/// `$(...)+`. In general, these can be a bit tricky to reason about,
/// so we adopt a conservative position that says that any fragment
Invalid(String, &'static str),
}
-/// True if `frag` can legally be followed by the token `tok`. For
+/// Returns `true` if `frag` can legally be followed by the token `tok`. For
/// fragments that can consume an unbounded number of tokens, `tok`
/// must be within a well-defined follow set. This is intended to
/// guarantee future compatibility: for example, without this rule, if
}
impl Delimited {
- /// Return the opening delimiter (possibly `NoDelim`).
+ /// Returns the opening delimiter (possibly `NoDelim`).
pub fn open_token(&self) -> token::Token {
token::OpenDelim(self.delim)
}
- /// Return the closing delimiter (possibly `NoDelim`).
+ /// Returns the closing delimiter (possibly `NoDelim`).
pub fn close_token(&self) -> token::Token {
token::CloseDelim(self.delim)
}
- /// Return a `self::TokenTree` with a `Span` corresponding to the opening delimiter.
+ /// Returns a `self::TokenTree` with a `Span` corresponding to the opening delimiter.
pub fn open_tt(&self, span: Span) -> TokenTree {
let open_span = if span.is_dummy() {
span
TokenTree::Token(open_span, self.open_token())
}
- /// Return a `self::TokenTree` with a `Span` corresponding to the closing delimiter.
+ /// Returns a `self::TokenTree` with a `Span` corresponding to the closing delimiter.
pub fn close_tt(&self, span: Span) -> TokenTree {
let close_span = if span.is_dummy() {
span
}
}
- /// Returns true if the given token tree contains no other tokens. This is vacuously true for
+ /// Returns `true` if the given token tree contains no other tokens. This is vacuously true for
/// single tokens or metavar/decls, but may be false for delimited trees or sequences.
pub fn is_empty(&self) -> bool {
match *self {
}
}
- /// Get the `index`-th sub-token-tree. This only makes sense for delimited trees and sequences.
+ /// Gets the `index`-th sub-token-tree. This only makes sense for delimited trees and sequences.
pub fn get_tt(&self, index: usize) -> TokenTree {
match (self, index) {
(&TokenTree::Delimited(_, ref delimed), _) if delimed.delim == token::NoDelim => {
}
}
- /// Retrieve the `TokenTree`'s span.
+ /// Retrieves the `TokenTree`'s span.
pub fn span(&self) -> Span {
match *self {
TokenTree::Token(sp, _)
/// operator and separator, then a tuple with `(separator, KleeneOp)` is returned. Otherwise, an
/// error with the appropriate span is emitted to `sess` and a dummy value is returned.
///
-/// NOTE: In 2015 edition, * and + are the only Kleene operators and `?` is a separator. In 2018,
-/// `?` is a Kleene op and not a separator.
+/// N.B., in the 2015 edition, `*` and `+` are the only Kleene operators, and `?` is a separator.
+/// In the 2018 edition however, `?` is a Kleene operator, and not a separator.
fn parse_sep_and_kleene_op<I>(
input: &mut Peekable<I>,
span: Span,
use crate::early_buffered_lints::BufferedEarlyLintId;
use crate::source_map::Spanned;
use crate::edition::{ALL_EDITIONS, Edition};
-use crate::errors::{DiagnosticBuilder, Handler};
use crate::visit::{self, FnKind, Visitor};
use crate::parse::ParseSess;
use crate::symbol::Symbol;
+use errors::{DiagnosticBuilder, Handler};
use rustc_data_structures::fx::FxHashMap;
use rustc_target::spec::abi::Abi;
use syntax_pos::{Span, DUMMY_SP};
}
impl AttributeTemplate {
- /// Check that the given meta-item is compatible with this template.
+ /// Checks that the given meta-item is compatible with this template.
fn compatible(&self, meta_item_kind: &ast::MetaItemKind) -> bool {
match meta_item_kind {
ast::MetaItemKind::Word => self.word,
}
/// A convenience macro for constructing attribute templates.
-/// E.g. `template!(Word, List: "description")` means that the attribute
+/// E.g., `template!(Word, List: "description")` means that the attribute
/// supports forms `#[attr]` and `#[attr(description)]`.
macro_rules! template {
(Word) => { template!(@ true, None, None) };
stable",
cfg_fn!(profiler_runtime))),
- ("allow_internal_unstable", Normal, template!(Word), Gated(Stability::Unstable,
+ ("allow_internal_unstable", Normal, template!(Word, List: "feat1, feat2, ..."),
+ Gated(Stability::Unstable,
"allow_internal_unstable",
EXPLAIN_ALLOW_INTERNAL_UNSTABLE,
cfg_fn!(allow_internal_unstable))),
("stable", Whitelisted, template!(List: r#"feature = "name", since = "version""#), Ungated),
("unstable", Whitelisted, template!(List: r#"feature = "name", reason = "...", issue = "N""#),
Ungated),
- ("deprecated", Normal, template!(Word, List: r#"/*opt*/ since = "version",
- /*opt*/ note = "reason"#,
- NameValueStr: "reason"), Ungated),
+ ("deprecated",
+ Normal,
+ template!(
+ Word,
+ List: r#"/*opt*/ since = "version", /*opt*/ note = "reason"#,
+ NameValueStr: "reason"
+ ),
+ Ungated
+ ),
("rustc_paren_sugar", Normal, template!(Word), Gated(Stability::Unstable,
"unboxed_closures",
("proc_macro", Normal, template!(Word), Ungated),
("rustc_proc_macro_decls", Normal, template!(Word), Gated(Stability::Unstable,
- "rustc_proc_macro_decls",
+ "rustc_attrs",
"used internally by rustc",
cfg_fn!(rustc_attrs))),
pub fn check_and_emit(&self, sess: &ParseSess, features: &Features) {
let (cfg, feature, has_feature) = GATED_CFGS[self.index];
- if !has_feature(features) && !self.span.allows_unstable() {
+ if !has_feature(features) && !self.span.allows_unstable(feature) {
let explain = format!("`cfg({})` is experimental and subject to change", cfg);
emit_feature_err(sess, feature, self.span, GateIssue::Language, &explain);
}
name, explain, level) = ($cx, $has_feature, $span, $name, $explain, $level);
let has_feature: bool = has_feature(&$cx.features);
debug!("gate_feature(feature = {:?}, span = {:?}); has? {}", name, span, has_feature);
- if !has_feature && !span.allows_unstable() {
+ if !has_feature && !span.allows_unstable($name) {
leveled_feature_err(cx.parse_sess, name, span, GateIssue::Language, explain, level)
.emit();
}
for &(n, ty, _template, ref gateage) in BUILTIN_ATTRIBUTES {
if name == n {
if let Gated(_, name, desc, ref has_feature) = *gateage {
- gate_feature_fn!(self, has_feature, attr.span, name, desc, GateStrength::Hard);
+ if !attr.span.allows_unstable(name) {
+ gate_feature_fn!(
+ self, has_feature, attr.span, name, desc, GateStrength::Hard
+ );
+ }
} else if name == "doc" {
if let Some(content) = attr.meta_item_list() {
if content.iter().any(|c| c.check_name("include")) {
macro_rules! gate_feature_post {
($cx: expr, $feature: ident, $span: expr, $explain: expr) => {{
let (cx, span) = ($cx, $span);
- if !span.allows_unstable() {
+ if !span.allows_unstable(stringify!($feature)) {
gate_feature!(cx.context, $feature, span, $explain)
}
}};
($cx: expr, $feature: ident, $span: expr, $explain: expr, $level: expr) => {{
let (cx, span) = ($cx, $span);
- if !span.allows_unstable() {
+ if !span.allows_unstable(stringify!($feature)) {
gate_feature!(cx.context, $feature, span, $explain, $level)
}
}}
impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
fn visit_attribute(&mut self, attr: &ast::Attribute) {
- if !attr.span.allows_unstable() {
- // check for gated attributes
- self.context.check_attribute(attr, false);
- }
+ // check for gated attributes
+ self.context.check_attribute(attr, false);
if attr.check_name("doc") {
if let Some(content) = attr.meta_item_list() {
#[derive(Clone, Copy, Hash)]
pub enum UnstableFeatures {
- /// Hard errors for unstable features are active, as on
- /// beta/stable channels.
+ /// Hard errors for unstable features are active, as on beta/stable channels.
Disallow,
/// Allow features to be activated, as on nightly.
Allow,
// FIXME: spec the JSON output properly.
use crate::source_map::{SourceMap, FilePathMapping};
-use crate::errors::registry::Registry;
-use crate::errors::{DiagnosticBuilder, SubDiagnostic, CodeSuggestion, SourceMapper};
-use crate::errors::{DiagnosticId, Applicability};
-use crate::errors::emitter::{Emitter, EmitterWriter};
-use syntax_pos::{self, MacroBacktrace, Span, SpanLabel, MultiSpan};
+use errors::registry::Registry;
+use errors::{DiagnosticBuilder, SubDiagnostic, CodeSuggestion, SourceMapper};
+use errors::{DiagnosticId, Applicability};
+use errors::emitter::{Emitter, EmitterWriter};
+
+use syntax_pos::{MacroBacktrace, Span, SpanLabel, MultiSpan};
use rustc_data_structures::sync::{self, Lrc};
use std::io::{self, Write};
use std::vec;
}
}
- /// Create a list of DiagnosticSpanLines from span - each line with any part
+ /// Creates a list of DiagnosticSpanLines from span - each line with any part
/// of `span` gets a DiagnosticSpanLine, with the highlight indicating the
/// `span` within the line.
fn from_span(span: Span, je: &JsonEmitter) -> Vec<DiagnosticSpanLine> {
#![feature(crate_visibility_modifier)]
#![feature(label_break_value)]
+#![feature(nll)]
#![feature(rustc_attrs)]
#![feature(rustc_diagnostic_macros)]
-#![feature(slice_sort_by_cached_key)]
-#![feature(str_escape)]
#![feature(step_trait)]
#![feature(try_trait)]
#![feature(unicode_internals)]
#[allow(unused_extern_crates)]
extern crate serialize as rustc_serialize; // used by deriving
-pub use rustc_errors as errors;
+pub use errors;
use rustc_data_structures::sync::Lock;
use rustc_data_structures::bit_set::GrowableBitSet;
pub use rustc_data_structures::thin_vec::ThinVec;
macro_rules! panictry {
($e:expr) => ({
use std::result::Result::{Ok, Err};
- use crate::errors::FatalError;
+ use errors::FatalError;
match $e {
Ok(e) => e,
Err(mut e) => {
macro_rules! panictry_buffer {
($handler:expr, $e:expr) => ({
use std::result::Result::{Ok, Err};
- use crate::errors::{FatalError, DiagnosticBuilder};
+ use errors::{FatalError, DiagnosticBuilder};
match $e {
Ok(e) => e,
Err(errs) => {
}
}
-/// Returns None if the first col chars of s contain a non-whitespace char.
-/// Otherwise returns Some(k) where k is first char offset after that leading
-/// whitespace. Note k may be outside bounds of s.
+/// Returns `None` if the first `col` chars of `s` contain a non-whitespace char.
+/// Otherwise returns `Some(k)` where `k` is first char offset after that leading
+/// whitespace. Note that `k` may be outside bounds of `s`.
fn all_whitespace(s: &str, col: CharPos) -> Option<usize> {
let mut idx = 0;
for (i, ch) in s.char_indices().take(col.to_usize()) {
use crate::ast::{self, Ident};
use crate::source_map::{SourceMap, FilePathMapping};
-use crate::errors::{Applicability, FatalError, Diagnostic, DiagnosticBuilder};
use crate::parse::{token, ParseSess};
use crate::symbol::{Symbol, keywords};
-use syntax_pos::{self, BytePos, CharPos, Pos, Span, NO_EXPANSION};
+use errors::{Applicability, FatalError, Diagnostic, DiagnosticBuilder};
+use syntax_pos::{BytePos, CharPos, Pos, Span, NO_EXPANSION};
use core::unicode::property::Pattern_White_Space;
use std::borrow::Cow;
}
}
+#[derive(Clone, Debug)]
+pub struct UnmatchedBrace {
+ pub expected_delim: token::DelimToken,
+ pub found_delim: token::DelimToken,
+ pub found_span: Span,
+ pub unclosed_span: Option<Span>,
+ pub candidate_span: Option<Span>,
+}
+
pub struct StringReader<'a> {
pub sess: &'a ParseSess,
/// The absolute offset within the source_map of the next character to read
span_src_raw: Span,
/// Stack of open delimiters and their spans. Used for error message.
open_braces: Vec<(token::DelimToken, Span)>,
+ crate unmatched_braces: Vec<UnmatchedBrace>,
/// The type and spans for all braces
///
/// Used only for error recovery when arriving to EOF with mismatched braces.
self.unwrap_or_abort(res)
}
- /// Return the next token. EFFECT: advances the string_reader.
+ /// Returns the next token. EFFECT: advances the string_reader.
pub fn try_next_token(&mut self) -> Result<TokenAndSpan, ()> {
assert!(self.fatal_errs.is_empty());
let ret_val = TokenAndSpan {
span: syntax_pos::DUMMY_SP,
span_src_raw: syntax_pos::DUMMY_SP,
open_braces: Vec::new(),
+ unmatched_braces: Vec::new(),
matching_delim_spans: Vec::new(),
override_span,
last_unclosed_found_span: None,
self.with_str_from_to(start, self.pos, f)
}
- /// Create a Name from a given offset to the current offset, each
+ /// Creates a Name from a given offset to the current offset, each
/// adjusted 1 towards each other (assumes that on either side there is a
/// single-byte delimiter).
fn name_from(&self, start: BytePos) -> ast::Name {
}
/// If there is whitespace, shebang, or a comment, scan it. Otherwise,
- /// return None.
+ /// return `None`.
fn scan_whitespace_or_comment(&mut self) -> Option<TokenAndSpan> {
match self.ch.unwrap_or('\0') {
// # to handle shebang at start of file -- this is the entry point
/// in a byte, (non-raw) byte string, char, or (non-raw) string literal.
/// `start` is the position of `first_source_char`, which is already consumed.
///
- /// Returns true if there was a valid char/byte, false otherwise.
+ /// Returns `true` if there was a valid char/byte.
fn scan_char_or_byte(&mut self,
start: BytePos,
first_source_char: char,
}
}
- /// Check that a base is valid for a floating literal, emitting a nice
+ /// Checks that a base is valid for a floating literal, emitting a nice
/// error if it isn't.
fn check_float_base(&mut self, start_bpos: BytePos, last_bpos: BytePos, base: usize) {
match base {
}
}
- /// Return the next token from the string, advances the input past that
+ /// Returns the next token from the string, advances the input past that
/// token, and updates the interner
fn next_token_inner(&mut self) -> Result<token::Token, ()> {
let c = self.ch;
use crate::ast::{Ident, CrateConfig};
use crate::symbol::Symbol;
use crate::source_map::SourceMap;
- use crate::errors;
use crate::feature_gate::UnstableFeatures;
use crate::parse::token;
use crate::diagnostics::plugin::ErrorMap;
use crate::print::pprust::token_to_string;
-use crate::parse::lexer::StringReader;
+use crate::parse::lexer::{StringReader, UnmatchedBrace};
use crate::parse::{token, PResult};
use crate::tokenstream::{DelimSpan, IsJoint::*, TokenStream, TokenTree, TreeAndJoint};
}
// Incorrect delimiter.
token::CloseDelim(other) => {
- let token_str = token_to_string(&self.token);
+ let mut unclosed_delimiter = None;
+ let mut candidate = None;
if self.last_unclosed_found_span != Some(self.span) {
// do not complain about the same unclosed delimiter multiple times
self.last_unclosed_found_span = Some(self.span);
- let msg = format!("incorrect close delimiter: `{}`", token_str);
- let mut err = self.sess.span_diagnostic.struct_span_err(
- self.span,
- &msg,
- );
- err.span_label(self.span, "incorrect close delimiter");
// This is a conservative error: only report the last unclosed
// delimiter. The previous unclosed delimiters could actually be
// closed! The parser just hasn't gotten to them yet.
if let Some(&(_, sp)) = self.open_braces.last() {
- err.span_label(sp, "un-closed delimiter");
+ unclosed_delimiter = Some(sp);
};
if let Some(current_padding) = sm.span_to_margin(self.span) {
for (brace, brace_span) in &self.open_braces {
if let Some(padding) = sm.span_to_margin(*brace_span) {
// high likelihood of these two corresponding
if current_padding == padding && brace == &other {
- err.span_label(
- *brace_span,
- "close delimiter possibly meant for this",
- );
+ candidate = Some(*brace_span);
}
}
}
}
- err.emit();
+ let (tok, _) = self.open_braces.pop().unwrap();
+ self.unmatched_braces.push(UnmatchedBrace {
+ expected_delim: tok,
+ found_delim: other,
+ found_span: self.span,
+ unclosed_span: unclosed_delimiter,
+ candidate_span: candidate,
+ });
+ } else {
+ self.open_braces.pop();
}
- self.open_braces.pop().unwrap();
// If the incorrect delimiter matches an earlier opening
// delimiter, then don't consume it (it can be used to
// http://www.unicode.org/Public/security/10.0.0/confusables.txt
use syntax_pos::{Span, NO_EXPANSION};
-use crate::errors::{Applicability, DiagnosticBuilder};
+use errors::{Applicability, DiagnosticBuilder};
use super::StringReader;
const UNICODE_ARRAY: &[(char, &str, char)] = &[
-//! The main parser interface
+//! The main parser interface.
use crate::ast::{self, CrateConfig, NodeId};
use crate::early_buffered_lints::{BufferedEarlyLint, BufferedEarlyLintId};
use crate::source_map::{SourceMap, FilePathMapping};
-use crate::errors::{FatalError, Level, Handler, ColorConfig, Diagnostic, DiagnosticBuilder};
use crate::feature_gate::UnstableFeatures;
use crate::parse::parser::Parser;
use crate::symbol::Symbol;
use crate::tokenstream::{TokenStream, TokenTree};
use crate::diagnostics::plugin::ErrorMap;
+use crate::print::pprust::token_to_string;
+use errors::{FatalError, Level, Handler, ColorConfig, Diagnostic, DiagnosticBuilder};
use rustc_data_structures::sync::{Lrc, Lock};
use syntax_pos::{Span, SourceFile, FileName, MultiSpan};
use log::debug;
pub unstable_features: UnstableFeatures,
pub config: CrateConfig,
pub missing_fragment_specifiers: Lock<FxHashSet<Span>>,
- /// Places where raw identifiers were used. This is used for feature gating
- /// raw identifiers
+ /// Places where raw identifiers were used. This is used for feature-gating raw identifiers.
pub raw_identifier_spans: Lock<Vec<Span>>,
- /// The registered diagnostics codes
+ /// The registered diagnostics codes.
crate registered_diagnostics: Lock<ErrorMap>,
- /// Used to determine and report recursive mod inclusions
+ /// Used to determine and report recursive module inclusions.
included_mod_stack: Lock<Vec<PathBuf>>,
source_map: Lrc<SourceMap>,
pub buffered_lints: Lock<Vec<BufferedEarlyLint>>,
new_parser_from_source_str(sess, name, source).parse_inner_attributes()
}
-pub fn parse_stream_from_source_str(name: FileName, source: String, sess: &ParseSess,
- override_span: Option<Span>)
- -> TokenStream {
+pub fn parse_stream_from_source_str(
+ name: FileName,
+ source: String,
+ sess: &ParseSess,
+ override_span: Option<Span>,
+) -> (TokenStream, Vec<lexer::UnmatchedBrace>) {
source_file_to_stream(sess, sess.source_map().new_source_file(name, source), override_span)
}
-/// Create a new parser from a source string
-pub fn new_parser_from_source_str(sess: &ParseSess, name: FileName, source: String)
- -> Parser<'_> {
+/// Creates a new parser from a source string.
+pub fn new_parser_from_source_str(sess: &ParseSess, name: FileName, source: String) -> Parser<'_> {
panictry_buffer!(&sess.span_diagnostic, maybe_new_parser_from_source_str(sess, name, source))
}
-/// Create a new parser from a source string. Returns any buffered errors from lexing the initial
+/// Creates a new parser from a source string. Returns any buffered errors from lexing the initial
/// token stream.
pub fn maybe_new_parser_from_source_str(sess: &ParseSess, name: FileName, source: String)
-> Result<Parser<'_>, Vec<Diagnostic>>
Ok(parser)
}
-/// Create a new parser, handling errors as appropriate
+/// Creates a new parser, handling errors as appropriate
/// if the file doesn't exist
pub fn new_parser_from_file<'a>(sess: &'a ParseSess, path: &Path) -> Parser<'a> {
source_file_to_parser(sess, file_to_source_file(sess, path, None))
}
-/// Create a new parser, returning buffered diagnostics if the file doesn't
+/// Creates a new parser, returning buffered diagnostics if the file doesn't
/// exist or from lexing the initial token stream.
pub fn maybe_new_parser_from_file<'a>(sess: &'a ParseSess, path: &Path)
-> Result<Parser<'a>, Vec<Diagnostic>> {
/// Given a source_file and config, return a parser. Returns any buffered errors from lexing the
/// initial token stream.
-fn maybe_source_file_to_parser(sess: &ParseSess, source_file: Lrc<SourceFile>)
- -> Result<Parser<'_>, Vec<Diagnostic>>
-{
+fn maybe_source_file_to_parser(
+ sess: &ParseSess,
+ source_file: Lrc<SourceFile>,
+) -> Result<Parser<'_>, Vec<Diagnostic>> {
let end_pos = source_file.end_pos;
- let mut parser = stream_to_parser(sess, maybe_file_to_stream(sess, source_file, None)?);
-
+ let (stream, unclosed_delims) = maybe_file_to_stream(sess, source_file, None)?;
+ let mut parser = stream_to_parser(sess, stream);
+ parser.unclosed_delims = unclosed_delims;
if parser.token == token::Eof && parser.span.is_dummy() {
parser.span = Span::new(end_pos, end_pos, parser.span.ctxt());
}
}
/// Given a session and a path and an optional span (for error reporting),
-/// add the path to the session's source_map and return the new source_file.
+/// add the path to the session's `source_map` and return the new `source_file`.
fn file_to_source_file(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
-> Lrc<SourceFile> {
match try_file_to_source_file(sess, path, spanopt) {
}
}
-/// Given a source_file, produce a sequence of token-trees
-pub fn source_file_to_stream(sess: &ParseSess,
- source_file: Lrc<SourceFile>,
- override_span: Option<Span>) -> TokenStream {
+/// Given a source_file, produces a sequence of token trees.
+pub fn source_file_to_stream(
+ sess: &ParseSess,
+ source_file: Lrc<SourceFile>,
+ override_span: Option<Span>,
+) -> (TokenStream, Vec<lexer::UnmatchedBrace>) {
panictry_buffer!(&sess.span_diagnostic, maybe_file_to_stream(sess, source_file, override_span))
}
-/// Given a source file, produce a sequence of token-trees. Returns any buffered errors from
+/// Given a source file, produces a sequence of token trees. Returns any buffered errors from
/// parsing the token tream.
-pub fn maybe_file_to_stream(sess: &ParseSess,
- source_file: Lrc<SourceFile>,
- override_span: Option<Span>) -> Result<TokenStream, Vec<Diagnostic>> {
+pub fn maybe_file_to_stream(
+ sess: &ParseSess,
+ source_file: Lrc<SourceFile>,
+ override_span: Option<Span>,
+) -> Result<(TokenStream, Vec<lexer::UnmatchedBrace>), Vec<Diagnostic>> {
let mut srdr = lexer::StringReader::new_or_buffered_errs(sess, source_file, override_span)?;
srdr.real_token();
match srdr.parse_all_token_trees() {
- Ok(stream) => Ok(stream),
+ Ok(stream) => Ok((stream, srdr.unmatched_braces)),
Err(err) => {
let mut buffer = Vec::with_capacity(1);
err.buffer(&mut buffer);
+ // Not using `emit_unclosed_delims` to use `db.buffer`
+ for unmatched in srdr.unmatched_braces {
+ let mut db = sess.span_diagnostic.struct_span_err(unmatched.found_span, &format!(
+ "incorrect close delimiter: `{}`",
+ token_to_string(&token::Token::CloseDelim(unmatched.found_delim)),
+ ));
+ db.span_label(unmatched.found_span, "incorrect close delimiter");
+ if let Some(sp) = unmatched.candidate_span {
+ db.span_label(sp, "close delimiter possibly meant for this");
+ }
+ if let Some(sp) = unmatched.unclosed_span {
+ db.span_label(sp, "un-closed delimiter");
+ }
+ db.buffer(&mut buffer);
+ }
Err(buffer)
}
}
}
-/// Given stream and the `ParseSess`, produce a parser
+/// Given stream and the `ParseSess`, produces a parser.
pub fn stream_to_parser(sess: &ParseSess, stream: TokenStream) -> Parser<'_> {
Parser::new(sess, stream, None, true, false)
}
-/// Parse a string representing a character literal into its final form.
+/// Parses a string representing a character literal into its final form.
/// Rather than just accepting/rejecting a given literal, unescapes it as
/// well. Can take any slice prefixed by a character escape. Returns the
/// character and the number of characters consumed.
}
}
-/// Parse a string representing a string literal into its final form. Does
-/// unescaping.
+/// Parses a string representing a string literal into its final form. Does unescaping.
pub fn str_lit(lit: &str, diag: Option<(Span, &Handler)>) -> String {
debug!("str_lit: given {}", lit.escape_default());
let mut res = String::with_capacity(lit.len());
let error = |i| format!("lexer should have rejected {} at {}", lit, i);
- /// Eat everything up to a non-whitespace
+ /// Eat everything up to a non-whitespace.
fn eat<'a>(it: &mut iter::Peekable<str::CharIndices<'a>>) {
loop {
match it.peek().map(|x| x.1) {
res
}
-/// Parse a string representing a raw string literal into its final form. The
+/// Parses a string representing a raw string literal into its final form. The
/// only operation this does is convert embedded CRLF into a single LF.
fn raw_str_lit(lit: &str) -> String {
debug!("raw_str_lit: given {}", lit.escape_default());
filtered_float_lit(Symbol::intern(s), suffix, diag)
}
-/// Parse a string representing a byte literal into its final form. Similar to `char_lit`
+/// Parses a string representing a byte literal into its final form. Similar to `char_lit`.
fn byte_lit(lit: &str) -> (u8, usize) {
let err = |i| format!("lexer accepted invalid byte literal {} step {}", lit, i);
let error = |i| panic!("lexer should have rejected {} at {}", lit, i);
- /// Eat everything up to a non-whitespace
+ /// Eat everything up to a non-whitespace.
fn eat<I: Iterator<Item=(usize, u8)>>(it: &mut iter::Peekable<I>) {
loop {
match it.peek().map(|x| x.1) {
})
}
-/// `SeqSep` : a sequence separator (token)
-/// and whether a trailing separator is allowed.
+/// A sequence separator.
pub struct SeqSep {
+ /// The seperator token.
pub sep: Option<token::Token>,
+ /// `true` if a trailing separator is allowed.
pub trailing_sep_allowed: bool,
}
use crate::{ast, attr};
use crate::ext::base::DummyResult;
use crate::source_map::{self, SourceMap, Spanned, respan};
-use crate::errors::{self, Applicability, DiagnosticBuilder, DiagnosticId};
use crate::parse::{self, SeqSep, classify, token};
-use crate::parse::lexer::TokenAndSpan;
+use crate::parse::lexer::{TokenAndSpan, UnmatchedBrace};
use crate::parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration};
use crate::parse::token::DelimToken;
use crate::parse::{new_sub_parser_from_file, ParseSess, Directory, DirectoryOwnership};
use crate::tokenstream::{self, DelimSpan, TokenTree, TokenStream, TreeAndJoint};
use crate::symbol::{Symbol, keywords};
+use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
use rustc_target::spec::abi::{self, Abi};
-use syntax_pos::{self, Span, MultiSpan, BytePos, FileName};
+use syntax_pos::{Span, MultiSpan, BytePos, FileName};
use log::{debug, trace};
use std::borrow::Cow;
type ItemInfo = (Ident, ItemKind, Option<Vec<Attribute>>);
-/// How to parse a path.
+/// Specifies how to parse a path.
#[derive(Copy, Clone, PartialEq)]
pub enum PathStyle {
/// In some contexts, notably in expressions, paths with generic arguments are ambiguous
Ignore,
}
-/// Possibly accept an `token::Interpolated` expression (a pre-parsed expression
+/// Possibly accepts an `token::Interpolated` expression (a pre-parsed expression
/// dropped into the token stream, which happens while parsing the result of
/// macro expansion). Placement of these is not as complex as I feared it would
/// be. The important thing is to make sure that lookahead doesn't balk at
///
/// See the comments in the `parse_path_segment` function for more details.
crate unmatched_angle_bracket_count: u32,
+ crate max_angle_bracket_count: u32,
+ /// List of all unclosed delimiters found by the lexer. If an entry is used for error recovery
+ /// it gets removed from here. Every entry left at the end gets emitted as an independent
+ /// error.
+ crate unclosed_delims: Vec<UnmatchedBrace>,
}
}
}
-/// Returns true if `IDENT t` can start a type - `IDENT::a::b`, `IDENT<u8, u8>`,
+/// Returns `true` if `IDENT t` can start a type -- `IDENT::a::b`, `IDENT<u8, u8>`,
/// `IDENT<<u8 as Trait>::AssocTy>`.
///
/// Types can also be of the form `IDENT(u8, u8) -> u8`, however this assumes
-/// that IDENT is not the ident of a fn trait
+/// that `IDENT` is not the ident of a fn trait.
fn can_continue_type_after_non_fn_ident(t: &token::Token) -> bool {
t == &token::ModSep || t == &token::Lt ||
t == &token::BinOp(token::Shl)
}
}
-/// Create a placeholder argument.
+/// Creates a placeholder argument.
fn dummy_arg(span: Span) -> Arg {
let ident = Ident::new(keywords::Invalid.name(), span);
let pat = P(Pat {
desugar_doc_comments,
cfg_mods: true,
unmatched_angle_bracket_count: 0,
+ max_angle_bracket_count: 0,
+ unclosed_delims: Vec::new(),
};
let tok = parser.next_tok();
next
}
- /// Convert the current token to a string using self's reader
+ /// Converts the current token to a string using `self`'s reader.
pub fn this_token_to_string(&self) -> String {
pprust::token_to_string(&self.token)
}
}
}
- /// Expect and consume the token t. Signal an error if
- /// the next token is not t.
- pub fn expect(&mut self, t: &token::Token) -> PResult<'a, ()> {
+ /// Expects and consumes the token `t`. Signals an error if the next token is not `t`.
+ pub fn expect(&mut self, t: &token::Token) -> PResult<'a, bool /* recovered */> {
if self.expected_tokens.is_empty() {
if self.token == *t {
self.bump();
- Ok(())
+ Ok(false)
} else {
let token_str = pprust::token_to_string(t);
let this_token_str = self.this_token_descr();
self.sess.source_map().next_point(self.prev_span)
};
let label_exp = format!("expected `{}`", token_str);
+ match self.recover_closing_delimiter(&[t.clone()], err) {
+ Err(e) => err = e,
+ Ok(recovered) => {
+ return Ok(recovered);
+ }
+ }
let cm = self.sess.source_map();
match (cm.lookup_line(self.span.lo()), cm.lookup_line(sp.lo())) {
(Ok(ref a), Ok(ref b)) if a.line == b.line => {
}
}
+ fn recover_closing_delimiter(
+ &mut self,
+ tokens: &[token::Token],
+ mut err: DiagnosticBuilder<'a>,
+ ) -> PResult<'a, bool> {
+ let mut pos = None;
+ // we want to use the last closing delim that would apply
+ for (i, unmatched) in self.unclosed_delims.iter().enumerate().rev() {
+ if tokens.contains(&token::CloseDelim(unmatched.expected_delim))
+ && Some(self.span) > unmatched.unclosed_span
+ {
+ pos = Some(i);
+ }
+ }
+ match pos {
+ Some(pos) => {
+ // Recover and assume that the detected unclosed delimiter was meant for
+ // this location. Emit the diagnostic and act as if the delimiter was
+ // present for the parser's sake.
+
+ // Don't attempt to recover from this unclosed delimiter more than once.
+ let unmatched = self.unclosed_delims.remove(pos);
+ let delim = TokenType::Token(token::CloseDelim(unmatched.expected_delim));
+
+ // We want to suggest the inclusion of the closing delimiter where it makes
+ // the most sense, which is immediately after the last token:
+ //
+ // {foo(bar {}}
+ // - ^
+ // | |
+ // | help: `)` may belong here (FIXME: #58270)
+ // |
+ // unclosed delimiter
+ if let Some(sp) = unmatched.unclosed_span {
+ err.span_label(sp, "unclosed delimiter");
+ }
+ err.span_suggestion_short(
+ self.sess.source_map().next_point(self.prev_span),
+ &format!("{} may belong here", delim.to_string()),
+ delim.to_string(),
+ Applicability::MaybeIncorrect,
+ );
+ err.emit();
+ self.expected_tokens.clear(); // reduce errors
+ Ok(true)
+ }
+ _ => Err(err),
+ }
+ }
+
/// Expect next token to be edible or inedible token. If edible,
/// then consume it; if inedible, then return without consuming
/// anything. Signal a fatal error if next token is unexpected.
- pub fn expect_one_of(&mut self,
- edible: &[token::Token],
- inedible: &[token::Token]) -> PResult<'a, ()>{
+ pub fn expect_one_of(
+ &mut self,
+ edible: &[token::Token],
+ inedible: &[token::Token],
+ ) -> PResult<'a, bool /* recovered */> {
fn tokens_to_string(tokens: &[TokenType]) -> String {
let mut i = tokens.iter();
// This might be a sign we need a connect method on Iterator.
}
if edible.contains(&self.token) {
self.bump();
- Ok(())
+ Ok(false)
} else if inedible.contains(&self.token) {
// leave it in the input
- Ok(())
+ Ok(false)
} else {
let mut expected = edible.iter()
.map(|x| TokenType::Token(x.clone()))
} else {
label_sp
};
+ match self.recover_closing_delimiter(&expected.iter().filter_map(|tt| match tt {
+ TokenType::Token(t) => Some(t.clone()),
+ _ => None,
+ }).collect::<Vec<_>>(), err) {
+ Err(e) => err = e,
+ Ok(recovered) => {
+ return Ok(recovered);
+ }
+ }
let cm = self.sess.source_map();
match (cm.lookup_line(self.span.lo()), cm.lookup_line(sp.lo())) {
}
}
- /// returns the span of expr, if it was not interpolated or the span of the interpolated token
+ /// Returns the span of expr, if it was not interpolated or the span of the interpolated token.
fn interpolated_or_expr_span(&self,
expr: PResult<'a, P<Expr>>)
-> PResult<'a, (Span, P<Expr>)> {
}
}
- /// Check if the next token is `tok`, and return `true` if so.
+ /// Checks if the next token is `tok`, and returns `true` if so.
///
/// This method will automatically add `tok` to `expected_tokens` if `tok` is not
/// encountered.
is_present
}
- /// Consume token 'tok' if it exists. Returns true if the given
- /// token was present, false otherwise.
+ /// Consumes a token 'tok' if it exists. Returns whether the given token was present.
pub fn eat(&mut self, tok: &token::Token) -> bool {
let is_present = self.check(tok);
if is_present { self.bump() }
self.token.is_keyword(kw)
}
- /// If the next token is the given keyword, eat it and return
- /// true. Otherwise, return false.
+ /// If the next token is the given keyword, eats it and returns
+ /// `true`. Otherwise, returns `false`.
pub fn eat_keyword(&mut self, kw: keywords::Keyword) -> bool {
if self.check_keyword(kw) {
self.bump();
}
}
- /// If the given word is not a keyword, signal an error.
- /// If the next token is not the given word, signal an error.
- /// Otherwise, eat it.
+ /// If the given word is not a keyword, signals an error.
+ /// If the next token is not the given word, signals an error.
+ /// Otherwise, eats it.
fn expect_keyword(&mut self, kw: keywords::Keyword) -> PResult<'a, ()> {
if !self.eat_keyword(kw) {
self.unexpected()
}
}
- /// Expect and consume a `+`. if `+=` is seen, replace it with a `=`
- /// and continue. If a `+` is not seen, return false.
+ /// Expects and consumes a `+`. if `+=` is seen, replaces it with a `=`
+ /// and continues. If a `+` is not seen, returns `false`.
///
- /// This is using when token splitting += into +.
- /// See issue 47856 for an example of when this may occur.
+ /// This is used when token-splitting `+=` into `+`.
+ /// See issue #47856 for an example of when this may occur.
fn eat_plus(&mut self) -> bool {
self.expected_tokens.push(TokenType::Token(token::BinOp(token::Plus)));
match self.token {
/// Checks to see if the next token is either `+` or `+=`.
- /// Otherwise returns false.
+ /// Otherwise returns `false`.
fn check_plus(&mut self) -> bool {
if self.token.is_like_plus() {
true
}
}
- /// Expect and consume an `&`. If `&&` is seen, replace it with a single
- /// `&` and continue. If an `&` is not seen, signal an error.
+ /// Expects and consumes an `&`. If `&&` is seen, replaces it with a single
+ /// `&` and continues. If an `&` is not seen, signals an error.
fn expect_and(&mut self) -> PResult<'a, ()> {
self.expected_tokens.push(TokenType::Token(token::BinOp(token::And)));
match self.token {
}
}
- /// Expect and consume an `|`. If `||` is seen, replace it with a single
- /// `|` and continue. If an `|` is not seen, signal an error.
+ /// Expects and consumes an `|`. If `||` is seen, replaces it with a single
+ /// `|` and continues. If an `|` is not seen, signals an error.
fn expect_or(&mut self) -> PResult<'a, ()> {
self.expected_tokens.push(TokenType::Token(token::BinOp(token::Or)));
match self.token {
}
}
- /// Attempt to consume a `<`. If `<<` is seen, replace it with a single
- /// `<` and continue. If `<-` is seen, replace it with a single `<`
- /// and continue. If a `<` is not seen, return false.
+ /// Attempts to consume a `<`. If `<<` is seen, replaces it with a single
+ /// `<` and continue. If `<-` is seen, replaces it with a single `<`
+ /// and continue. If a `<` is not seen, returns false.
///
/// This is meant to be used when parsing generics on a path to get the
/// starting token.
if ate {
// See doc comment for `unmatched_angle_bracket_count`.
self.unmatched_angle_bracket_count += 1;
+ self.max_angle_bracket_count += 1;
debug!("eat_lt: (increment) count={:?}", self.unmatched_angle_bracket_count);
}
}
}
- /// Expect and consume a GT. if a >> is seen, replace it
- /// with a single > and continue. If a GT is not seen,
- /// signal an error.
+ /// Expects and consumes a single `>` token. if a `>>` is seen, replaces it
+ /// with a single `>` and continues. If a `>` is not seen, signals an error.
fn expect_gt(&mut self) -> PResult<'a, ()> {
self.expected_tokens.push(TokenType::Token(token::Gt));
let ate = match self.token {
};
match ate {
- Some(x) => {
+ Some(_) => {
// See doc comment for `unmatched_angle_bracket_count`.
self.unmatched_angle_bracket_count -= 1;
debug!("expect_gt: (decrement) count={:?}", self.unmatched_angle_bracket_count);
- Ok(x)
+ Ok(())
},
None => self.unexpected(),
}
}
- /// Eat and discard tokens until one of `kets` is encountered. Respects token trees,
+ /// Eats and discards tokens until one of `kets` is encountered. Respects token trees,
/// passes through any errors encountered. Used for error recovery.
fn eat_to_tokens(&mut self, kets: &[&token::Token]) {
let handler = self.diagnostic();
}
}
- /// Parse a sequence, including the closing delimiter. The function
- /// f must consume tokens until reaching the next separator or
+ /// Parses a sequence, including the closing delimiter. The function
+ /// `f` must consume tokens until reaching the next separator or
/// closing bracket.
pub fn parse_seq_to_end<T, F>(&mut self,
ket: &token::Token,
-> PResult<'a, Vec<T>> where
F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
{
- let val = self.parse_seq_to_before_end(ket, sep, f)?;
- self.bump();
+ let (val, recovered) = self.parse_seq_to_before_end(ket, sep, f)?;
+ if !recovered {
+ self.bump();
+ }
Ok(val)
}
- /// Parse a sequence, not including the closing delimiter. The function
- /// f must consume tokens until reaching the next separator or
+ /// Parses a sequence, not including the closing delimiter. The function
+ /// `f` must consume tokens until reaching the next separator or
/// closing bracket.
- pub fn parse_seq_to_before_end<T, F>(&mut self,
- ket: &token::Token,
- sep: SeqSep,
- f: F)
- -> PResult<'a, Vec<T>>
+ pub fn parse_seq_to_before_end<T, F>(
+ &mut self,
+ ket: &token::Token,
+ sep: SeqSep,
+ f: F,
+ ) -> PResult<'a, (Vec<T>, bool)>
where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>
{
self.parse_seq_to_before_tokens(&[ket], sep, TokenExpectType::Expect, f)
sep: SeqSep,
expect: TokenExpectType,
mut f: F,
- ) -> PResult<'a, Vec<T>>
+ ) -> PResult<'a, (Vec<T>, bool /* recovered */)>
where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>
{
- let mut first: bool = true;
+ let mut first = true;
+ let mut recovered = false;
let mut v = vec![];
while !kets.iter().any(|k| {
match expect {
if first {
first = false;
} else {
- if let Err(mut e) = self.expect(t) {
- // Attempt to keep parsing if it was a similar separator
- if let Some(ref tokens) = t.similar_tokens() {
- if tokens.contains(&self.token) {
- self.bump();
- }
+ match self.expect(t) {
+ Ok(false) => {}
+ Ok(true) => {
+ recovered = true;
+ break;
}
- e.emit();
- // Attempt to keep parsing if it was an omitted separator
- match f(self) {
- Ok(t) => {
- v.push(t);
- continue;
- },
- Err(mut e) => {
- e.cancel();
- break;
+ Err(mut e) => {
+ // Attempt to keep parsing if it was a similar separator
+ if let Some(ref tokens) = t.similar_tokens() {
+ if tokens.contains(&self.token) {
+ self.bump();
+ }
+ }
+ e.emit();
+ // Attempt to keep parsing if it was an omitted separator
+ match f(self) {
+ Ok(t) => {
+ v.push(t);
+ continue;
+ },
+ Err(mut e) => {
+ e.cancel();
+ break;
+ }
}
}
}
v.push(t);
}
- Ok(v)
+ Ok((v, recovered))
}
- /// Parse a sequence, including the closing delimiter. The function
- /// f must consume tokens until reaching the next separator or
+ /// Parses a sequence, including the closing delimiter. The function
+ /// `f` must consume tokens until reaching the next separator or
/// closing bracket.
- fn parse_unspanned_seq<T, F>(&mut self,
- bra: &token::Token,
- ket: &token::Token,
- sep: SeqSep,
- f: F)
- -> PResult<'a, Vec<T>> where
+ fn parse_unspanned_seq<T, F>(
+ &mut self,
+ bra: &token::Token,
+ ket: &token::Token,
+ sep: SeqSep,
+ f: F,
+ ) -> PResult<'a, Vec<T>> where
F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
{
self.expect(bra)?;
- let result = self.parse_seq_to_before_end(ket, sep, f)?;
- self.eat(ket);
+ let (result, recovered) = self.parse_seq_to_before_end(ket, sep, f)?;
+ if !recovered {
+ self.eat(ket);
+ }
Ok(result)
}
&self.sess.span_diagnostic
}
- /// Is the current token one of the keywords that signals a bare function
- /// type?
+ /// Is the current token one of the keywords that signals a bare function type?
fn token_is_bare_fn_keyword(&mut self) -> bool {
self.check_keyword(keywords::Fn) ||
self.check_keyword(keywords::Unsafe) ||
self.check_keyword(keywords::Extern)
}
- /// parse a `TyKind::BareFn` type:
+ /// Parses a `TyKind::BareFn` type.
fn parse_ty_bare_fn(&mut self, generic_params: Vec<GenericParam>) -> PResult<'a, TyKind> {
/*
})))
}
- /// Parse asyncness: `async` or nothing
+ /// Parses asyncness: `async` or nothing.
fn parse_asyncness(&mut self) -> IsAsync {
if self.eat_keyword(keywords::Async) {
IsAsync::Async {
}
}
- /// Parse unsafety: `unsafe` or nothing.
+ /// Parses unsafety: `unsafe` or nothing.
fn parse_unsafety(&mut self) -> Unsafety {
if self.eat_keyword(keywords::Unsafe) {
Unsafety::Unsafe
}
}
- /// Parse the items in a trait declaration
+ /// Parses the items in a trait declaration.
pub fn parse_trait_item(&mut self, at_end: &mut bool) -> PResult<'a, TraitItem> {
maybe_whole!(self, NtTraitItem, |x| x);
let attrs = self.parse_outer_attributes()?;
})
}
- /// Parse optional return type [ -> TY ] in function decl
+ /// Parses an optional return type `[ -> TY ]` in a function declaration.
fn parse_ret_ty(&mut self, allow_plus: bool) -> PResult<'a, FunctionRetTy> {
if self.eat(&token::RArrow) {
Ok(FunctionRetTy::Ty(self.parse_ty_common(allow_plus, true)?))
}
}
- // Parse a type
+ /// Parses a type.
pub fn parse_ty(&mut self) -> PResult<'a, P<Ty>> {
self.parse_ty_common(true, true)
}
- /// Parse a type in restricted contexts where `+` is not permitted.
+ /// Parses a type in restricted contexts where `+` is not permitted.
+ ///
/// Example 1: `&'a TYPE`
/// `+` is prohibited to maintain operator priority (P(+) < P(&)).
/// Example 2: `value1 as TYPE + value2`
self.look_ahead(offset + 1, |t| t == &token::Colon)
}
- /// Skip unexpected attributes and doc comments in this position and emit an appropriate error.
+ /// Skips unexpected attributes and doc comments in this position and emits an appropriate
+ /// error.
fn eat_incorrect_doc_comment(&mut self, applied_to: &str) {
if let token::DocComment(_) = self.token {
let mut err = self.diagnostic().struct_span_err(
}
}
- /// This version of parse arg doesn't necessarily require
- /// identifier names.
+ /// This version of parse arg doesn't necessarily require identifier names.
fn parse_arg_general(&mut self, require_name: bool, is_trait_item: bool) -> PResult<'a, Arg> {
maybe_whole!(self, NtArg, |x| x);
Ok(Arg { ty, pat, id: ast::DUMMY_NODE_ID })
}
- /// Parse a single function argument
+ /// Parses a single function argument.
crate fn parse_arg(&mut self) -> PResult<'a, Arg> {
self.parse_arg_general(true, false)
}
- /// Parse an argument in a lambda header e.g., |arg, arg|
+ /// Parses an argument in a lambda header (e.g., `|arg, arg|`).
fn parse_fn_block_arg(&mut self) -> PResult<'a, Arg> {
let pat = self.parse_pat(Some("argument name"))?;
let t = if self.eat(&token::Colon) {
}
}
- /// Matches token_lit = LIT_INTEGER | ...
+ /// Matches `token_lit = LIT_INTEGER | ...`.
fn parse_lit_token(&mut self) -> PResult<'a, LitKind> {
let out = match self.token {
token::Interpolated(ref nt) => match nt.0 {
Ok(out)
}
- /// Matches lit = true | false | token_lit
+ /// Matches `lit = true | false | token_lit`.
crate fn parse_lit(&mut self) -> PResult<'a, Lit> {
let lo = self.span;
let lit = if self.eat_keyword(keywords::True) {
Ok(source_map::Spanned { node: lit, span: lo.to(self.prev_span) })
}
- /// matches '-' lit | lit (cf. ast_validation::AstValidator::check_expr_within_pat)
+ /// Matches `'-' lit | lit` (cf. `ast_validation::AstValidator::check_expr_within_pat`).
crate fn parse_literal_maybe_minus(&mut self) -> PResult<'a, P<Expr>> {
maybe_whole_expr!(self);
}
}
- /// Parses qualified path.
+ /// Parses a qualified path.
/// Assumes that the leading `<` has been parsed already.
///
/// `qualified_path = <type [as trait_ref]>::path`
Ok(ast::Path { segments, span: lo.to(self.prev_span) })
}
- /// Like `parse_path`, but also supports parsing `Word` meta items into paths for back-compat.
- /// This is used when parsing derive macro paths in `#[derive]` attributes.
+ /// Like `parse_path`, but also supports parsing `Word` meta items into paths for
+ /// backwards-compatibility. This is used when parsing derive macro paths in `#[derive]`
+ /// attributes.
pub fn parse_path_allowing_meta(&mut self, style: PathStyle) -> PResult<'a, ast::Path> {
let meta_ident = match self.token {
token::Interpolated(ref nt) => match nt.0 {
// We use `style == PathStyle::Expr` to check if this is in a recursion or not. If
// it isn't, then we reset the unmatched angle bracket count as we're about to start
// parsing a new path.
- if style == PathStyle::Expr { self.unmatched_angle_bracket_count = 0; }
+ if style == PathStyle::Expr {
+ self.unmatched_angle_bracket_count = 0;
+ self.max_angle_bracket_count = 0;
+ }
let args = if self.eat_lt() {
// `<'a, T, A = U>`
} else {
// `(T, U) -> R`
self.bump(); // `(`
- let inputs = self.parse_seq_to_before_tokens(
+ let (inputs, recovered) = self.parse_seq_to_before_tokens(
&[&token::CloseDelim(token::Paren)],
SeqSep::trailing_allowed(token::Comma),
TokenExpectType::Expect,
|p| p.parse_ty())?;
- self.bump(); // `)`
+ if !recovered {
+ self.bump(); // `)`
+ }
let span = lo.to(self.prev_span);
let output = if self.eat(&token::RArrow) {
Some(self.parse_ty_common(false, false)?)
self.token.is_lifetime()
}
- /// Parse single lifetime 'a or panic.
+ /// Parses a single lifetime `'a` or panics.
crate fn expect_lifetime(&mut self) -> Lifetime {
if let Some(ident) = self.token.lifetime() {
let span = self.span;
}
}
- /// Parse mutability (`mut` or nothing).
+ /// Parses mutability (`mut` or nothing).
fn parse_mutability(&mut self) -> Mutability {
if self.eat_keyword(keywords::Mut) {
Mutability::Mutable
}
/// At the bottom (top?) of the precedence hierarchy,
- /// parse things like parenthesized exprs,
- /// macros, return, etc.
+ /// Parses things like parenthesized exprs, macros, `return`, etc.
///
- /// N.B., this does not parse outer attributes,
- /// and is private because it only works
- /// correctly if called from parse_dot_or_call_expr().
+ /// N.B., this does not parse outer attributes, and is private because it only works
+ /// correctly if called from `parse_dot_or_call_expr()`.
fn parse_bottom_expr(&mut self) -> PResult<'a, P<Expr>> {
maybe_whole_expr!(self);
// (e,) is a tuple with only one field, e
let mut es = vec![];
let mut trailing_comma = false;
+ let mut recovered = false;
while self.token != token::CloseDelim(token::Paren) {
es.push(self.parse_expr()?);
- self.expect_one_of(&[], &[token::Comma, token::CloseDelim(token::Paren)])?;
+ recovered = self.expect_one_of(
+ &[],
+ &[token::Comma, token::CloseDelim(token::Paren)],
+ )?;
if self.eat(&token::Comma) {
trailing_comma = true;
} else {
break;
}
}
- self.bump();
+ if !recovered {
+ self.bump();
+ }
hi = self.prev_span;
ex = if es.len() == 1 && !trailing_comma {
hi = pth.span;
ex = ExprKind::Path(None, pth);
} else {
+ if !self.unclosed_delims.is_empty() && self.check(&token::Semi) {
+ // Don't complain about bare semicolons after unclosed braces
+ // recovery in order to keep the error count down. Fixing the
+ // delimiters will possibly also fix the bare semicolon found in
+ // expression context. For example, silence the following error:
+ // ```
+ // error: expected expression, found `;`
+ // --> file.rs:2:13
+ // |
+ // 2 | foo(bar(;
+ // | ^ expected expression
+ // ```
+ self.bump();
+ return Ok(self.mk_expr(self.span, ExprKind::Err, ThinVec::new()));
+ }
match self.parse_literal_maybe_minus() {
Ok(expr) => {
hi = expr.span;
match self.expect_one_of(&[token::Comma],
&[token::CloseDelim(token::Brace)]) {
- Ok(()) => if let Some(f) = parsed_field.or(recovery_field) {
+ Ok(_) => if let Some(f) = parsed_field.or(recovery_field) {
// only include the field if there's no parse error for the field name
fields.push(f);
}
}
}
- /// Parse a block or unsafe block
+ /// Parses a block or unsafe block.
fn parse_block_expr(&mut self, opt_label: Option<Label>,
lo: Span, blk_mode: BlockCheckMode,
outer_attrs: ThinVec<Attribute>)
return Ok(self.mk_expr(blk.span, ExprKind::Block(blk, opt_label), attrs));
}
- /// parse a.b or a(13) or a[4] or just a
+ /// Parses `a.b` or `a(13)` or `a[4]` or just `a`.
fn parse_dot_or_call_expr(&mut self,
already_parsed_attrs: Option<ThinVec<Attribute>>)
-> PResult<'a, P<Expr>> {
self.span = span;
}
- /// parse a single token tree from the input.
+ /// Parses a single token tree from the input.
crate fn parse_token_tree(&mut self) -> TokenTree {
match self.token {
token::OpenDelim(..) => {
return Ok(self.mk_expr(lo.to(hi), ex, attrs));
}
- /// Parse an associative expression
+ /// Parses an associative expression.
///
/// This parses an expression accounting for associativity and precedence of the operators in
/// the expression.
self.parse_assoc_expr_with(0, already_parsed_attrs.into())
}
- /// Parse an associative expression with operators of at least `min_prec` precedence
+ /// Parses an associative expression with operators of at least `min_prec` precedence.
fn parse_assoc_expr_with(&mut self,
min_prec: usize,
lhs: LhsExpr)
}
}
- /// Parse an 'if' or 'if let' expression ('if' token already eaten)
+ /// Parses an `if` or `if let` expression (`if` token already eaten).
fn parse_if_expr(&mut self, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
if self.check_keyword(keywords::Let) {
return self.parse_if_let_expr(attrs);
Ok(self.mk_expr(lo.to(hi), ExprKind::If(cond, thn, els), attrs))
}
- /// Parse an 'if let' expression ('if' token already eaten)
+ /// Parses an `if let` expression (`if` token already eaten).
fn parse_if_let_expr(&mut self, attrs: ThinVec<Attribute>)
-> PResult<'a, P<Expr>> {
let lo = self.prev_span;
Ok(self.mk_expr(lo.to(hi), ExprKind::IfLet(pats, expr, thn, els), attrs))
}
- // `move |args| expr`
+ /// Parses `move |args| expr`.
fn parse_lambda_expr(&mut self,
attrs: ThinVec<Attribute>)
-> PResult<'a, P<Expr>>
Ok(self.mk_expr(span_lo.to(hi), ExprKind::ForLoop(pat, expr, loop_block, opt_label), attrs))
}
- /// Parse a 'while' or 'while let' expression ('while' token already eaten)
+ /// Parses a `while` or `while let` expression (`while` token already eaten).
fn parse_while_expr(&mut self, opt_label: Option<Label>,
span_lo: Span,
mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
return Ok(self.mk_expr(span, ExprKind::While(cond, body, opt_label), attrs));
}
- /// Parse a 'while let' expression ('while' token already eaten)
+ /// Parses a `while let` expression (`while` token already eaten).
fn parse_while_let_expr(&mut self, opt_label: Option<Label>,
span_lo: Span,
mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
Ok(self.mk_expr(span, ExprKind::Loop(body, opt_label), attrs))
}
- /// Parse an `async move {...}` expression
+ /// Parses an `async move {...}` expression.
pub fn parse_async_block(&mut self, mut attrs: ThinVec<Attribute>)
-> PResult<'a, P<Expr>>
{
ExprKind::Async(capture_clause, ast::DUMMY_NODE_ID, body), attrs))
}
- /// Parse a `try {...}` expression (`try` token already eaten)
+ /// Parses a `try {...}` expression (`try` token already eaten).
fn parse_try_block(&mut self, span_lo: Span, mut attrs: ThinVec<Attribute>)
-> PResult<'a, P<Expr>>
{
})
}
- /// Parse an expression
+ /// Parses an expression.
#[inline]
pub fn parse_expr(&mut self) -> PResult<'a, P<Expr>> {
self.parse_expr_res(Restrictions::empty(), None)
}
- /// Evaluate the closure with restrictions in place.
+ /// Evaluates the closure with restrictions in place.
///
- /// After the closure is evaluated, restrictions are reset.
+ /// Afters the closure is evaluated, restrictions are reset.
fn with_res<F, T>(&mut self, r: Restrictions, f: F) -> T
where F: FnOnce(&mut Self) -> T
{
}
- /// Parse an expression, subject to the given restrictions
+ /// Parses an expression, subject to the given restrictions.
#[inline]
fn parse_expr_res(&mut self, r: Restrictions,
already_parsed_attrs: Option<ThinVec<Attribute>>)
self.with_res(r, |this| this.parse_assoc_expr(already_parsed_attrs))
}
- /// Parse the RHS of a local variable declaration (e.g., '= 14;')
+ /// Parses the RHS of a local variable declaration (e.g., '= 14;').
fn parse_initializer(&mut self, skip_eq: bool) -> PResult<'a, Option<P<Expr>>> {
if self.eat(&token::Eq) {
Ok(Some(self.parse_expr()?))
}
}
- /// Parse patterns, separated by '|' s
+ /// Parses patterns, separated by '|' s.
fn parse_pats(&mut self) -> PResult<'a, Vec<P<Pat>>> {
// Allow a '|' before the pats (RFC 1925 + RFC 2530)
self.eat(&token::BinOp(token::Or));
})
}
- /// Parse the fields of a struct-like pattern
+ /// Parses the fields of a struct-like pattern.
fn parse_pat_fields(&mut self) -> PResult<'a, (Vec<source_map::Spanned<ast::FieldPat>>, bool)> {
let mut fields = Vec::new();
let mut etc = false;
Ok(pat)
}
- /// Parse a pattern.
+ /// Parses a pattern.
pub fn parse_pat(&mut self, expected: Option<&'static str>) -> PResult<'a, P<Pat>> {
self.parse_pat_with_range_pat(true, expected)
}
- /// Parse a pattern, with a setting whether modern range patterns e.g., `a..=b`, `a..b` are
- /// allowed.
+ /// Parses a pattern, with a setting whether modern range patterns (e.g., `a..=b`, `a..b` are
+ /// allowed).
fn parse_pat_with_range_pat(
&mut self,
allow_range_pat: bool,
Ok(P(pat))
}
- /// Parse ident or ident @ pat
+ /// Parses `ident` or `ident @ pat`.
/// used by the copy foo and ref foo patterns to give a good
- /// error message when parsing mistakes like ref foo(a,b)
+ /// error message when parsing mistakes like `ref foo(a, b)`.
fn parse_pat_ident(&mut self,
binding_mode: ast::BindingMode)
-> PResult<'a, PatKind> {
Ok(PatKind::Ident(binding_mode, ident, sub))
}
- /// Parse a local variable declaration
+ /// Parses a local variable declaration.
fn parse_local(&mut self, attrs: ThinVec<Attribute>) -> PResult<'a, P<Local>> {
let lo = self.prev_span;
let pat = self.parse_top_level_pat()?;
}))
}
- /// Parse a structure field
+ /// Parses a structure field.
fn parse_name_and_ty(&mut self,
lo: Span,
vis: Visibility,
})
}
- /// Emit an expected item after attributes error.
+ /// Emits an expected-item-after-attributes error.
fn expected_item_err(&mut self, attrs: &[Attribute]) -> PResult<'a, ()> {
let message = match attrs.last() {
Some(&Attribute { is_sugared_doc: true, .. }) => "expected item after doc comment",
}))
}
- /// Is this expression a successfully-parsed statement?
+ /// Checks if this expression is a successfully parsed statement.
fn expr_is_complete(&mut self, e: &Expr) -> bool {
self.restrictions.contains(Restrictions::STMT_EXPR) &&
!classify::expr_requires_semi_to_be_stmt(e)
}
- /// Parse a block. No inner attrs are allowed.
+ /// Parses a block. No inner attributes are allowed.
pub fn parse_block(&mut self) -> PResult<'a, P<Block>> {
maybe_whole!(self, NtBlock, |x| x);
self.parse_block_tail(lo, BlockCheckMode::Default)
}
- /// Parse a block. Inner attrs are allowed.
+ /// Parses a block. Inner attributes are allowed.
fn parse_inner_attrs_and_block(&mut self) -> PResult<'a, (Vec<Attribute>, P<Block>)> {
maybe_whole!(self, NtBlock, |x| (Vec::new(), x));
self.parse_block_tail(lo, BlockCheckMode::Default)?))
}
- /// Parse the rest of a block expression or function body
+ /// Parses the rest of a block expression or function body.
/// Precondition: already parsed the '{'.
fn parse_block_tail(&mut self, lo: Span, s: BlockCheckMode) -> PResult<'a, P<Block>> {
let mut stmts = vec![];
}))
}
- /// Parse a statement, including the trailing semicolon.
+ /// Parses a statement, including the trailing semicolon.
crate fn parse_full_stmt(&mut self, macro_legacy_warnings: bool) -> PResult<'a, Option<Stmt>> {
// skip looking for a trailing semicolon when we have an interpolated statement
maybe_whole!(self, NtStmt, |x| Some(x));
).emit();
}
- // Parse bounds of a type parameter `BOUND + BOUND + BOUND`, possibly with trailing `+`.
- // BOUND = TY_BOUND | LT_BOUND
- // LT_BOUND = LIFETIME (e.g., `'a`)
- // TY_BOUND = TY_BOUND_NOPAREN | (TY_BOUND_NOPAREN)
- // TY_BOUND_NOPAREN = [?] [for<LT_PARAM_DEFS>] SIMPLE_PATH (e.g., `?for<'a: 'b> m::Trait<'a>`)
+ /// Parses bounds of a type parameter `BOUND + BOUND + ...`, possibly with trailing `+`.
+ ///
+ /// ```
+ /// BOUND = TY_BOUND | LT_BOUND
+ /// LT_BOUND = LIFETIME (e.g., `'a`)
+ /// TY_BOUND = TY_BOUND_NOPAREN | (TY_BOUND_NOPAREN)
+ /// TY_BOUND_NOPAREN = [?] [for<LT_PARAM_DEFS>] SIMPLE_PATH (e.g., `?for<'a: 'b> m::Trait<'a>`)
+ /// ```
fn parse_generic_bounds_common(&mut self, allow_plus: bool) -> PResult<'a, GenericBounds> {
let mut bounds = Vec::new();
loop {
self.parse_generic_bounds_common(true)
}
- // Parse bounds of a lifetime parameter `BOUND + BOUND + BOUND`, possibly with trailing `+`.
- // BOUND = LT_BOUND (e.g., `'a`)
+ /// Parses bounds of a lifetime parameter `BOUND + BOUND + BOUND`, possibly with trailing `+`.
+ ///
+ /// ```
+ /// BOUND = LT_BOUND (e.g., `'a`)
+ /// ```
fn parse_lt_param_bounds(&mut self) -> GenericBounds {
let mut lifetimes = Vec::new();
while self.check_lifetime() {
lifetimes
}
- /// Matches typaram = IDENT (`?` unbound)? optbounds ( EQ ty )?
+ /// Matches `typaram = IDENT (`?` unbound)? optbounds ( EQ ty )?`.
fn parse_ty_param(&mut self,
preceding_attrs: Vec<Attribute>)
-> PResult<'a, GenericParam> {
}
/// Parses the following grammar:
+ ///
/// TraitItemAssocTy = Ident ["<"...">"] [":" [GenericBounds]] ["where" ...] ["=" Ty]
fn parse_trait_item_assoc_ty(&mut self)
-> PResult<'a, (Ident, TraitItemKind, ast::Generics)> {
})
}
- /// Parses (possibly empty) list of lifetime and type parameters, possibly including
- /// trailing comma and erroneous trailing attributes.
+ /// Parses a (possibly empty) list of lifetime and type parameters, possibly including
+ /// a trailing comma and erroneous trailing attributes.
crate fn parse_generic_params(&mut self) -> PResult<'a, Vec<ast::GenericParam>> {
let mut params = Vec::new();
loop {
Ok(params)
}
- /// Parse a set of optional generic type parameter declarations. Where
+ /// Parses a set of optional generic type parameter declarations. Where
/// clauses are not parsed here, and must be added later via
/// `parse_where_clause()`.
///
}
}
- /// Parse generic args (within a path segment) with recovery for extra leading angle brackets.
+ /// Parses generic args (within a path segment) with recovery for extra leading angle brackets.
/// For the purposes of understanding the parsing logic of generic arguments, this function
/// can be thought of being the same as just calling `self.parse_generic_args()` if the source
/// had the correct amount of leading angle brackets.
Ok((args, bindings))
}
- /// Parses an optional `where` clause and places it in `generics`.
+ /// Parses an optional where-clause and places it in `generics`.
///
/// ```ignore (only-for-syntax-highlight)
/// where T : Trait<U, V> + 'b, 'a : 'b
let sp = self.span;
let mut variadic = false;
- let args: Vec<Option<Arg>> =
+ let (args, recovered): (Vec<Option<Arg>>, bool) =
self.parse_seq_to_before_end(
&token::CloseDelim(token::Paren),
SeqSep::trailing_allowed(token::Comma),
}
)?;
- self.eat(&token::CloseDelim(token::Paren));
+ if !recovered {
+ self.eat(&token::CloseDelim(token::Paren));
+ }
let args: Vec<_> = args.into_iter().filter_map(|x| x).collect();
Ok((args, variadic))
}
- /// Parse the argument list and result type of a function declaration
+ /// Parses the argument list and result type of a function declaration.
fn parse_fn_decl(&mut self, allow_variadic: bool) -> PResult<'a, P<FnDecl>> {
let (args, variadic) = self.parse_fn_args(true, allow_variadic)?;
Ok(Some(Arg::from_self(eself, eself_ident)))
}
- /// Parse the parameter list and result type of a function that may have a `self` parameter.
+ /// Parses the parameter list and result type of a function that may have a `self` parameter.
fn parse_fn_decl_with_self<F>(&mut self, parse_arg_fn: F) -> PResult<'a, P<FnDecl>>
where F: FnMut(&mut Parser<'a>) -> PResult<'a, Arg>,
{
// Parse the rest of the function parameter list.
let sep = SeqSep::trailing_allowed(token::Comma);
- let fn_inputs = if let Some(self_arg) = self_arg {
+ let (fn_inputs, recovered) = if let Some(self_arg) = self_arg {
if self.check(&token::CloseDelim(token::Paren)) {
- vec![self_arg]
+ (vec![self_arg], false)
} else if self.eat(&token::Comma) {
let mut fn_inputs = vec![self_arg];
- fn_inputs.append(&mut self.parse_seq_to_before_end(
- &token::CloseDelim(token::Paren), sep, parse_arg_fn)?
- );
- fn_inputs
+ let (mut input, recovered) = self.parse_seq_to_before_end(
+ &token::CloseDelim(token::Paren), sep, parse_arg_fn)?;
+ fn_inputs.append(&mut input);
+ (fn_inputs, recovered)
} else {
return self.unexpected();
}
self.parse_seq_to_before_end(&token::CloseDelim(token::Paren), sep, parse_arg_fn)?
};
- // Parse closing paren and return type.
- self.expect(&token::CloseDelim(token::Paren))?;
+ if !recovered {
+ // Parse closing paren and return type.
+ self.expect(&token::CloseDelim(token::Paren))?;
+ }
Ok(P(FnDecl {
inputs: fn_inputs,
output: self.parse_ret_ty(true)?,
}))
}
- // parse the |arg, arg| header on a lambda
+ /// Parses the `|arg, arg|` header of a closure.
fn parse_fn_block_decl(&mut self) -> PResult<'a, P<FnDecl>> {
let inputs_captures = {
if self.eat(&token::OrOr) {
SeqSep::trailing_allowed(token::Comma),
TokenExpectType::NoExpect,
|p| p.parse_fn_block_arg()
- )?;
+ )?.0;
self.expect_or()?;
args
}
}))
}
- /// Parse the name and optional generic types of a function header.
+ /// Parses the name and optional generic types of a function header.
fn parse_fn_header(&mut self) -> PResult<'a, (Ident, ast::Generics)> {
let id = self.parse_ident()?;
let generics = self.parse_generics()?;
})
}
- /// Parse an item-position function declaration.
+ /// Parses an item-position function declaration.
fn parse_item_fn(&mut self,
unsafety: Unsafety,
asyncness: IsAsync,
Ok((ident, ItemKind::Fn(decl, header, generics, body), Some(inner_attrs)))
}
- /// true if we are looking at `const ID`, false for things like `const fn` etc
+ /// Returns `true` if we are looking at `const ID`
+ /// (returns `false` for things like `const fn`, etc.).
fn is_const_item(&mut self) -> bool {
self.token.is_keyword(keywords::Const) &&
!self.look_ahead(1, |t| t.is_keyword(keywords::Fn)) &&
!self.look_ahead(1, |t| t.is_keyword(keywords::Unsafe))
}
- /// parses all the "front matter" for a `fn` declaration, up to
+ /// Parses all the "front matter" for a `fn` declaration, up to
/// and including the `fn` keyword:
///
/// - `const fn`
/// - `unsafe fn`
/// - `const unsafe fn`
/// - `extern fn`
- /// - etc
+ /// - etc.
fn parse_fn_front_matter(&mut self)
-> PResult<'a, (
Spanned<Constness>,
Ok((constness, unsafety, asyncness, abi))
}
- /// Parse an impl item.
+ /// Parses an impl item.
pub fn parse_impl_item(&mut self, at_end: &mut bool) -> PResult<'a, ImplItem> {
maybe_whole!(self, NtImplItem, |x| x);
let attrs = self.parse_outer_attributes()?;
}
}
- /// Parse `trait Foo { ... }` or `trait Foo = Bar;`
+ /// Parses `trait Foo { ... }` or `trait Foo = Bar;`.
fn parse_item_trait(&mut self, is_auto: IsAuto, unsafety: Unsafety) -> PResult<'a, ItemInfo> {
let ident = self.parse_ident()?;
let mut tps = self.parse_generics()?;
let bounds = self.parse_generic_bounds()?;
tps.where_clause = self.parse_where_clause()?;
self.expect(&token::Semi)?;
+ if is_auto == IsAuto::Yes {
+ let msg = "trait aliases cannot be `auto`";
+ self.struct_span_err(self.prev_span, msg)
+ .span_label(self.prev_span, msg)
+ .emit();
+ }
if unsafety != Unsafety::Normal {
- let msg = "trait aliases cannot be unsafe";
+ let msg = "trait aliases cannot be `unsafe`";
self.struct_span_err(self.prev_span, msg)
.span_label(self.prev_span, msg)
.emit();
}
/// Parses an implementation item, `impl` keyword is already parsed.
+ ///
/// impl<'a, T> TYPE { /* impl items */ }
/// impl<'a, T> TRAIT for TYPE { /* impl items */ }
/// impl<'a, T> !TRAIT for TYPE { /* impl items */ }
+ ///
/// We actually parse slightly more relaxed grammar for better error reporting and recovery.
/// `impl` GENERICS `!`? TYPE `for`? (TYPE | `..`) (`where` PREDICATES)? `{` BODY `}`
/// `impl` GENERICS `!`? TYPE (`where` PREDICATES)? `{` BODY `}`
}
}
- /// Parse struct Foo { ... }
+ /// Parses `struct Foo { ... }`.
fn parse_item_struct(&mut self) -> PResult<'a, ItemInfo> {
let class_name = self.parse_ident()?;
Ok((class_name, ItemKind::Struct(vdata, generics), None))
}
- /// Parse union Foo { ... }
+ /// Parses `union Foo { ... }`.
fn parse_item_union(&mut self) -> PResult<'a, ItemInfo> {
let class_name = self.parse_ident()?;
Ok(fields)
}
- /// Parse a structure field declaration
+ /// Parses a structure field declaration.
fn parse_single_struct_field(&mut self,
lo: Span,
vis: Visibility,
Ok(a_var)
}
- /// Parse an element of a struct definition
+ /// Parses an element of a struct declaration.
fn parse_struct_decl_field(&mut self) -> PResult<'a, StructField> {
let attrs = self.parse_outer_attributes()?;
let lo = self.span;
self.parse_single_struct_field(lo, vis, attrs)
}
- /// Parse `pub`, `pub(crate)` and `pub(in path)` plus shortcuts `crate` for `pub(crate)`,
+ /// Parses `pub`, `pub(crate)` and `pub(in path)` plus shortcuts `crate` for `pub(crate)`,
/// `pub(self)` for `pub(in self)` and `pub(super)` for `pub(in super)`.
- /// If the following element can't be a tuple (i.e., it's a function definition,
- /// it's not a tuple struct field) and the contents within the parens
- /// isn't valid, emit a proper diagnostic.
+ /// If the following element can't be a tuple (i.e., it's a function definition), then
+ /// it's not a tuple struct field), and the contents within the parentheses isn't valid,
+ /// so emit a proper diagnostic.
pub fn parse_visibility(&mut self, can_take_tuple: bool) -> PResult<'a, Visibility> {
maybe_whole!(self, NtVis, |x| x);
Ok(respan(lo, VisibilityKind::Public))
}
- /// Parse defaultness: `default` or nothing.
+ /// Parses defaultness (i.e., `default` or nothing).
fn parse_defaultness(&mut self) -> Defaultness {
// `pub` is included for better error messages
if self.check_keyword(keywords::Default) &&
}
}
- /// Given a termination token, parse all of the items in a module
+ /// Given a termination token, parses all of the items in a module.
fn parse_mod_items(&mut self, term: &token::Token, inner_lo: Span) -> PResult<'a, Mod> {
let mut items = vec![];
while let Some(item) = self.parse_item()? {
}
}
- /// Returns either a path to a module, or .
+ /// Returns a path to a module.
pub fn default_submod_path(
id: ast::Ident,
relative: Option<ast::Ident>,
}
}
- /// Read a module from a source file.
+ /// Reads a module from a source file.
fn eval_src_mod(&mut self,
path: PathBuf,
directory_ownership: DirectoryOwnership,
Ok((m0, mod_attrs))
}
- /// Parse a function declaration from a foreign module
+ /// Parses a function declaration from a foreign module.
fn parse_item_foreign_fn(&mut self, vis: ast::Visibility, lo: Span, attrs: Vec<Attribute>)
-> PResult<'a, ForeignItem> {
self.expect_keyword(keywords::Fn)?;
})
}
- /// Parse a static item from a foreign module.
+ /// Parses a static item from a foreign module.
/// Assumes that the `static` keyword is already parsed.
fn parse_item_foreign_static(&mut self, vis: ast::Visibility, lo: Span, attrs: Vec<Attribute>)
-> PResult<'a, ForeignItem> {
})
}
- /// Parse a type from a foreign module
+ /// Parses a type from a foreign module.
fn parse_item_foreign_type(&mut self, vis: ast::Visibility, lo: Span, attrs: Vec<Attribute>)
-> PResult<'a, ForeignItem> {
self.expect_keyword(keywords::Type)?;
Ok(ident)
}
- /// Parse extern crate links
+ /// Parses `extern crate` links.
///
/// # Examples
///
+ /// ```
/// extern crate foo;
/// extern crate bar as foo;
+ /// ```
fn parse_item_extern_crate(&mut self,
lo: Span,
visibility: Visibility,
Ok(self.mk_item(span, item_name, ItemKind::ExternCrate(orig_name), visibility, attrs))
}
- /// Parse `extern` for foreign ABIs
- /// modules.
+ /// Parses `extern` for foreign ABIs modules.
///
/// `extern` is expected to have been
- /// consumed before calling this method
+ /// consumed before calling this method.
///
- /// # Examples:
+ /// # Examples
///
+ /// ```ignore (only-for-syntax-highlight)
/// extern "C" {}
/// extern {}
+ /// ```
fn parse_item_foreign_mod(&mut self,
lo: Span,
opt_abi: Option<Abi>,
Ok(self.mk_item(lo.to(prev_span), invalid, ItemKind::ForeignMod(m), visibility, attrs))
}
- /// Parse `type Foo = Bar;`
+ /// Parses `type Foo = Bar;`
/// or
/// `existential type Foo: Bar;`
/// or
- /// `return None` without modifying the parser state
+ /// `return `None``
+ /// without modifying the parser state.
fn eat_type(&mut self) -> Option<PResult<'a, (Ident, AliasKind, ast::Generics)>> {
// This parses the grammar:
// Ident ["<"...">"] ["where" ...] ("=" | ":") Ty ";"
}
}
- /// Parse type alias or existential type
+ /// Parses a type alias or existential type.
fn parse_existential_or_alias(
&mut self,
existential: bool,
Ok((ident, alias, tps))
}
- /// Parse the part of an "enum" decl following the '{'
+ /// Parses the part of an enum declaration following the `{`.
fn parse_enum_def(&mut self, _generics: &ast::Generics) -> PResult<'a, EnumDef> {
let mut variants = Vec::new();
let mut all_nullary = true;
Ok(ast::EnumDef { variants })
}
- /// Parse an "enum" declaration
+ /// Parses an enum declaration.
fn parse_item_enum(&mut self) -> PResult<'a, ItemInfo> {
let id = self.parse_ident()?;
let mut generics = self.parse_generics()?;
}))
}
- /// Parse one of the items allowed by the flags.
+ /// Parses one of the items allowed by the flags.
fn parse_item_implementation(
&mut self,
attrs: Vec<Attribute>,
self.parse_macro_use_or_failure(attrs, macros_allowed, attributes_allowed, lo, visibility)
}
- /// Parse a foreign item.
+ /// Parses a foreign item.
crate fn parse_foreign_item(&mut self) -> PResult<'a, ForeignItem> {
maybe_whole!(self, NtForeignItem, |ni| ni);
Ok(None)
}
- /// Parse a macro invocation inside a `trait`, `impl` or `extern` block
+ /// Parses a macro invocation inside a `trait`, `impl` or `extern` block.
fn parse_assoc_macro_invoc(&mut self, item_kind: &str, vis: Option<&Visibility>,
at_end: &mut bool) -> PResult<'a, Option<Mac>>
{
// eat a matched-delimiter token tree:
let (delim, tts) = self.expect_delimited_token_tree()?;
if delim != MacDelimiter::Brace {
- self.expect(&token::Semi)?
+ self.expect(&token::Semi)?;
}
Ok(Some(respan(lo.to(self.prev_span), Mac_ { path: pth, tts, delim })))
*t == token::BinOp(token::Star))
}
- /// Parse UseTree
+ /// Parses a `UseTree`.
///
+ /// ```
/// USE_TREE = [`::`] `*` |
/// [`::`] `{` USE_TREE_LIST `}` |
/// PATH `::` `*` |
/// PATH `::` `{` USE_TREE_LIST `}` |
/// PATH [`as` IDENT]
+ /// ```
fn parse_use_tree(&mut self) -> PResult<'a, UseTree> {
let lo = self.span;
Ok(UseTree { prefix, kind, span: lo.to(self.prev_span) })
}
- /// Parse UseTreeKind::Nested(list)
+ /// Parses a `UseTreeKind::Nested(list)`.
///
+ /// ```
/// USE_TREE_LIST = Ø | (USE_TREE `,`)* USE_TREE [`,`]
+ /// ```
fn parse_use_tree_list(&mut self) -> PResult<'a, Vec<(UseTree, ast::NodeId)>> {
self.parse_unspanned_seq(&token::OpenDelim(token::Brace),
&token::CloseDelim(token::Brace),
}
}
- /// Parses a source module as a crate. This is the main
- /// entry point for the parser.
+ /// Parses a source module as a crate. This is the main entry point for the parser.
pub fn parse_crate_mod(&mut self) -> PResult<'a, Crate> {
let lo = self.span;
- Ok(ast::Crate {
+ let krate = Ok(ast::Crate {
attrs: self.parse_inner_attributes()?,
module: self.parse_mod_items(&token::Eof, lo)?,
span: lo.to(self.span),
- })
+ });
+ emit_unclosed_delims(&self.unclosed_delims, self.diagnostic());
+ self.unclosed_delims.clear();
+ krate
}
pub fn parse_optional_str(&mut self) -> Option<(Symbol, ast::StrStyle, Option<ast::Name>)> {
}
}
}
+
+pub fn emit_unclosed_delims(unclosed_delims: &[UnmatchedBrace], handler: &errors::Handler) {
+ for unmatched in unclosed_delims {
+ let mut err = handler.struct_span_err(unmatched.found_span, &format!(
+ "incorrect close delimiter: `{}`",
+ pprust::token_to_string(&token::Token::CloseDelim(unmatched.found_delim)),
+ ));
+ err.span_label(unmatched.found_span, "incorrect close delimiter");
+ if let Some(sp) = unmatched.candidate_span {
+ err.span_label(sp, "close delimiter possibly meant for this");
+ }
+ if let Some(sp) = unmatched.unclosed_span {
+ err.span_label(sp, "un-closed delimiter");
+ }
+ err.emit();
+ }
+}
use crate::ptr::P;
use crate::symbol::keywords;
use crate::syntax::parse::parse_stream_from_source_str;
+use crate::syntax::parse::parser::emit_unclosed_delims;
use crate::tokenstream::{self, DelimSpan, TokenStream, TokenTree};
use serialize::{Decodable, Decoder, Encodable, Encoder};
Shr,
}
-/// A delimiter token
+/// A delimiter token.
#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum DelimToken {
- /// A round parenthesis: `(` or `)`
+ /// A round parenthesis (i.e., `(` or `)`).
Paren,
- /// A square bracket: `[` or `]`
+ /// A square bracket (i.e., `[` or `]`).
Bracket,
- /// A curly brace: `{` or `}`
+ /// A curly brace (i.e., `{` or `}`).
Brace,
- /// An empty delimiter
+ /// An empty delimiter.
NoDelim,
}
Question,
/// Used by proc macros for representing lifetimes, not generated by lexer right now.
SingleQuote,
- /// An opening delimiter, eg. `{`
+ /// An opening delimiter (e.g., `{`).
OpenDelim(DelimToken),
- /// A closing delimiter, eg. `}`
+ /// A closing delimiter (e.g., `}`).
CloseDelim(DelimToken),
/* Literals */
// and so the `LazyTokenStream` can be ignored by Eq, Hash, etc.
Interpolated(Lrc<(Nonterminal, LazyTokenStream)>),
// Can be expanded into several tokens.
- /// Doc comment
+ /// A doc comment.
DocComment(ast::Name),
// Junk. These carry no data because we don't really care about the data
// they *would* carry, and don't really want to allocate a new ident for
// them. Instead, users could extract that from the associated span.
- /// Whitespace
+ /// Whitespace.
Whitespace,
- /// Comment
+ /// A comment.
Comment,
Shebang(ast::Name),
/// Enables better error recovery when the wrong token is found.
crate fn similar_tokens(&self) -> Option<Vec<Token>> {
match *self {
- Comma => Some(vec![Dot, Lt]),
- Semi => Some(vec![Colon]),
+ Comma => Some(vec![Dot, Lt, Semi]),
+ Semi => Some(vec![Colon, Comma]),
_ => None
}
}
// FIXME(#43081): Avoid this pretty-print + reparse hack
let source = pprust::token_to_string(self);
let filename = FileName::macro_expansion_source_code(&source);
- parse_stream_from_source_str(filename, source, sess, Some(span))
+ let (tokens, errors) = parse_stream_from_source_str(
+ filename, source, sess, Some(span));
+ emit_unclosed_delims(&errors, &sess.span_diagnostic);
+ tokens
});
// During early phases of the compiler the AST could get modified
let source = pprust::attr_to_string(attr);
let macro_filename = FileName::macro_expansion_source_code(&source);
if attr.is_sugared_doc {
- let stream = parse_stream_from_source_str(
+ let (stream, errors) = parse_stream_from_source_str(
macro_filename,
source,
sess,
Some(span),
);
+ emit_unclosed_delims(&errors, &sess.span_diagnostic);
builder.push(stream);
continue
}
// ... and for more complicated paths, fall back to a reparse hack that
// should eventually be removed.
} else {
- let stream = parse_stream_from_source_str(
+ let (stream, errors) = parse_stream_from_source_str(
macro_filename,
source,
sess,
Some(span),
);
+ emit_unclosed_delims(&errors, &sess.span_diagnostic);
brackets.push(stream);
}
//! This pretty-printer is a direct reimplementation of Philip Karlton's
//! Mesa pretty-printer, as described in appendix A of
//!
-//! ````text
+//! ```text
//! STAN-CS-79-770: "Pretty Printing", by Derek C. Oppen.
//! Stanford Department of Computer Science, 1979.
-//! ````
+//! ```
//!
//! The algorithm's aim is to break a stream into as few lines as possible
//! while respecting the indentation-consistency requirements of the enclosing
match lit.node {
ast::LitKind::Str(st, style) => self.print_string(&st.as_str(), style),
ast::LitKind::Err(st) => {
- let st = st.as_str().escape_debug();
+ let st = st.as_str().escape_debug().to_string();
let mut res = String::with_capacity(st.len() + 2);
res.push('\'');
res.push_str(&st);
-//! The AST pointer
+//! The AST pointer.
//!
//! Provides `P<T>`, a frozen owned smart pointer, as a replacement for `@T` in
//! the AST.
use std::str::FromStr;
use crate::ast;
-use crate::errors;
use crate::visit;
use crate::visit::Visitor;
use std::io;
use log::debug;
-use crate::errors::SourceMapper;
+use errors::SourceMapper;
-/// Return the span itself if it doesn't come from a macro expansion,
+/// Returns the span itself if it doesn't come from a macro expansion,
/// otherwise return the call site span up to the `enclosing_sp` by
/// following the `expn_info` chain.
pub fn original_sp(sp: Span, enclosing_sp: Span) -> Span {
/// Query the existence of a file.
fn file_exists(&self, path: &Path) -> bool;
- /// Return an absolute path to a file, if possible.
+ /// Returns an absolute path to a file, if possible.
fn abs_path(&self, path: &Path) -> Option<PathBuf>;
/// Read the contents of an UTF-8 file into memory.
}
}
- /// Returns `Some(span)`, a union of the lhs and rhs span. The lhs must precede the rhs. If
+ /// Returns `Some(span)`, a union of the lhs and rhs span. The lhs must precede the rhs. If
/// there are gaps between lhs and rhs, the resulting union will cross these gaps.
/// For this to work, the spans have to be:
///
Ok(FileLines {file: lo.file, lines: lines})
}
- /// Extract the source surrounding the given `Span` using the `extract_source` function. The
+ /// Extracts the source surrounding the given `Span` using the `extract_source` function. The
/// extract function takes three arguments: a string slice containing the source, an index in
/// the slice for the beginning of the span and an index in the slice for the end of the span.
fn span_to_source<F>(&self, sp: Span, extract_source: F) -> Result<String, SpanSnippetError>
}
}
- /// Return the source snippet as `String` corresponding to the given `Span`
+ /// Returns the source snippet as `String` corresponding to the given `Span`
pub fn span_to_snippet(&self, sp: Span) -> Result<String, SpanSnippetError> {
self.span_to_source(sp, |src, start_index, end_index| src[start_index..end_index]
.to_string())
}
}
- /// Return the source snippet as `String` before the given `Span`
+ /// Returns the source snippet as `String` before the given `Span`
pub fn span_to_prev_source(&self, sp: Span) -> Result<String, SpanSnippetError> {
self.span_to_source(sp, |src, start_index, _| src[..start_index].to_string())
}
/// Given a string like " ~~~~~~~~~~~~ ", produces a span
/// converting that range. The idea is that the string has the same
- /// length as the input, and we uncover the byte positions. Note
+ /// length as the input, and we uncover the byte positions. Note
/// that this can span lines and so on.
fn span_from_selection(input: &str, selection: &str) -> Span {
assert_eq!(input.len(), selection.len());
Span::new(BytePos(left_index), BytePos(right_index + 1), NO_EXPANSION)
}
- /// Test span_to_snippet and span_to_lines for a span converting 3
+ /// Tests span_to_snippet and span_to_lines for a span converting 3
/// lines in the middle of a file.
#[test]
fn span_to_snippet_and_lines_spanning_multiple_lines() {
assert_eq!(sstr, "blork.rs:2:1: 2:12");
}
- /// Test failing to merge two spans on different lines
+ /// Tests failing to merge two spans on different lines
#[test]
fn span_merging_fail() {
let sm = SourceMap::new(FilePathMapping::empty());
call_site: DUMMY_SP,
def_site: None,
format: MacroAttribute(Symbol::intern("std_inject")),
- allow_internal_unstable: true,
+ allow_internal_unstable: Some(vec![
+ Symbol::intern("prelude_import"),
+ ].into()),
allow_internal_unsafe: false,
local_inner_macros: false,
edition: hygiene::default_edition(),
use log::debug;
use smallvec::{smallvec, SmallVec};
-use syntax_pos::{self, DUMMY_SP, NO_EXPANSION, Span, SourceFile, BytePos};
+use syntax_pos::{DUMMY_SP, NO_EXPANSION, Span, SourceFile, BytePos};
use crate::attr::{self, HasAttrs};
use crate::source_map::{self, SourceMap, ExpnInfo, MacroAttribute, dummy_spanned, respan};
-use crate::errors;
use crate::config;
use crate::entry::{self, EntryPointType};
use crate::ext::base::{ExtCtxt, Resolver};
call_site: DUMMY_SP,
def_site: None,
format: MacroAttribute(Symbol::intern("test_case")),
- allow_internal_unstable: true,
+ allow_internal_unstable: Some(vec![
+ Symbol::intern("main"),
+ Symbol::intern("test"),
+ Symbol::intern("rustc_attrs"),
+ ].into()),
allow_internal_unsafe: false,
local_inner_macros: false,
edition: hygiene::default_edition(),
use crate::source_map::{SourceMap, FilePathMapping};
-use crate::errors::Handler;
-use crate::errors::emitter::EmitterWriter;
use crate::with_globals;
+use errors::Handler;
+use errors::emitter::EmitterWriter;
+
use std::io;
use std::io::prelude::*;
use rustc_data_structures::sync::Lrc;
//! which are themselves a single `Token` or a `Delimited` subsequence of tokens.
//!
//! ## Ownership
+//!
//! `TokenStreams` are persistent data structures constructed as ropes with reference
//! counted-children. In general, this means that calling an operation on a `TokenStream`
//! (such as `slice`) produces an entirely new `TokenStream` from the borrowed reference to
macro_parser::parse(cx.parse_sess(), tts, mtch, Some(directory), true)
}
- /// Check if this TokenTree is equal to the other, regardless of span information.
+ /// Checks if this TokenTree is equal to the other, regardless of span information.
pub fn eq_unspanned(&self, other: &TokenTree) -> bool {
match (self, other) {
(&TokenTree::Token(_, ref tk), &TokenTree::Token(_, ref tk2)) => tk == tk2,
}
}
- /// Retrieve the TokenTree's span.
+ /// Retrieves the TokenTree's span.
pub fn span(&self) -> Span {
match *self {
TokenTree::Token(sp, _) => sp,
use std::cmp;
use crate::symbol::Symbol;
-/// Find the Levenshtein distance between two strings
+/// Finds the Levenshtein distance between two strings
pub fn lev_distance(a: &str, b: &str) -> usize {
// cases which don't require further computation
if a.is_empty() {
dcol[t_last + 1]
}
-/// Find the best match for a given word in the given iterator
+/// Finds the best match for a given word in the given iterator
///
/// As a loose rule to avoid the obviously incorrect suggestions, it takes
/// an optional limit for the maximum allowable edit distance, which defaults
}
impl AssocOp {
- /// Create a new AssocOP from a token
+ /// Creates a new AssocOP from a token
pub fn from_token(t: &Token) -> Option<AssocOp> {
use AssocOp::*;
match *t {
}
}
- /// Create a new AssocOp from ast::BinOpKind.
+ /// Creates a new AssocOp from ast::BinOpKind.
pub fn from_ast_binop(op: BinOpKind) -> Self {
use AssocOp::*;
match op {
/// Map a string to tts, using a made-up filename:
pub fn string_to_stream(source_str: String) -> TokenStream {
let ps = ParseSess::new(FilePathMapping::empty());
- source_file_to_stream(&ps, ps.source_map()
- .new_source_file(PathBuf::from("bogofile").into(), source_str), None)
+ source_file_to_stream(
+ &ps,
+ ps.source_map().new_source_file(PathBuf::from("bogofile").into(),
+ source_str,
+ ), None).0
}
/// Map string to parser (via tts)
})
}
-/// Convert a vector of strings to a vector of Ident's
+/// Converts a vector of strings to a vector of Ident's
pub fn strs_to_idents(ids: Vec<&str> ) -> Vec<Ident> {
ids.iter().map(|u| Ident::from_str(*u)).collect()
}
//! Note: it is an important invariant that the default visitor walks the body
//! of a function in "execution order" (more concretely, reverse post-order
//! with respect to the CFG implied by the AST), meaning that if AST node A may
-//! execute before AST node B, then A is visited first. The borrow checker in
+//! execute before AST node B, then A is visited first. The borrow checker in
//! particular relies on this property.
//!
//! Note: walking an AST before macro expansion is probably a bad idea. For
}
/// Each method of the Visitor trait is a hook to be potentially
-/// overridden. Each method's default implementation recursively visits
+/// overridden. Each method's default implementation recursively visits
/// the substructure of the input via the corresponding `walk` method;
/// e.g., the `visit_mod` method by default calls `visit::walk_mod`.
///
/// If you want to ensure that your code handles every variant
-/// explicitly, you need to override each method. (And you also need
+/// explicitly, you need to override each method. (And you also need
/// to monitor future changes to `Visitor` in case a new method with a
/// new default implementation gets introduced.)
pub trait Visitor<'ast>: Sized {
[dependencies]
fmt_macros = { path = "../libfmt_macros" }
-rustc_errors = { path = "../librustc_errors" }
+errors = { path = "../librustc_errors", package = "rustc_errors" }
syntax = { path = "../libsyntax" }
syntax_pos = { path = "../libsyntax_pos" }
rustc_data_structures = { path = "../librustc_data_structures" }
use rustc_data_structures::thin_vec::ThinVec;
-use crate::errors::DiagnosticBuilder;
+use errors::DiagnosticBuilder;
use syntax::ast;
use syntax::ext::base::{self, *};
-use crate::errors::DiagnosticBuilder;
+use errors::DiagnosticBuilder;
use syntax::ast::{self, *};
use syntax::source_map::Spanned;
/// a literal `true` or `false` based on whether the given cfg matches the
/// current compilation environment.
-use crate::errors::DiagnosticBuilder;
+use errors::DiagnosticBuilder;
use syntax::ast;
use syntax::ext::base::{self, *};
-use crate::errors::FatalError;
use crate::proc_macro_impl::EXEC_STRATEGY;
use crate::proc_macro_server;
+use errors::FatalError;
use syntax::ast::{self, ItemKind, Attribute, Mac};
use syntax::attr::{mark_used, mark_known};
use syntax::source_map::Span;
};
}
-/// Create a decoder for a single enum variant/struct:
+/// Creates a decoder for a single enum variant/struct:
/// - `outer_pat_path` is the path to this enum variant/struct
/// - `getarg` should retrieve the `usize`-th field with name `@str`.
fn decode_static_fields<F>(cx: &mut ExtCtxt<'_>,
//! The compiler code necessary to implement the `#[derive(Encodable)]`
-//! (and `Decodable`, in decodable.rs) extension. The idea here is that
+//! (and `Decodable`, in `decodable.rs`) extension. The idea here is that
//! type-defining items may be tagged with `#[derive(Encodable, Decodable)]`.
//!
//! For example, a type like:
//! ```
//!
//! Other interesting scenarios are when the item has type parameters or
-//! references other non-built-in types. A type definition like:
+//! references other non-built-in types. A type definition like:
//!
//! ```
//! # #[derive(Encodable, Decodable)] struct Span;
/// Arguments other than the self argument
pub args: Vec<(Ty<'a>, &'a str)>,
- /// Return type
+ /// Returns type
pub ret_ty: Ty<'a>,
pub attributes: Vec<ast::Attribute>,
EnumMatching(usize, usize, &'a ast::Variant, Vec<FieldInfo<'a>>),
/// Non-matching variants of the enum, but with all state hidden from
- /// the consequent code. The first component holds `Ident`s for all of
+ /// the consequent code. The first component holds `Ident`s for all of
/// the `Self` arguments; the second component is a slice of all of the
/// variants for the enum itself, and the third component is a list of
/// `Ident`s bound to the variant index values for each of the actual
pub type CombineSubstructureFunc<'a> =
Box<dyn FnMut(&mut ExtCtxt<'_>, Span, &Substructure<'_>) -> P<Expr> + 'a>;
-/// Deal with non-matching enum variants. The tuple is a list of
+/// Deal with non-matching enum variants. The tuple is a list of
/// identifiers (one for each `Self` argument, which could be any of the
/// variants since they have been collapsed together) and the identifiers
-/// holding the variant index value for each of the `Self` arguments. The
+/// holding the variant index value for each of the `Self` arguments. The
/// last argument is all the non-`Self` args of the method being derived.
pub type EnumNonMatchCollapsedFunc<'a> =
Box<dyn FnMut(&mut ExtCtxt<'_>, Span, (&[Ident], &[Ident]), &[P<Expr>]) -> P<Expr> + 'a>;
/// create an impl like:
///
/// ```ignore (only-for-syntax-highlight)
- /// impl<'a, ..., 'z, A, B: DeclaredTrait, C, ... Z> where
+ /// impl<'a, ..., 'z, A, B: DeclaredTrait, C, ... Z> where
/// C: WhereTrait,
/// A: DerivedTrait + B1 + ... + BN,
/// B: DerivedTrait + B1 + ... + BN,
///
/// (Of course `__self_vi` and `__arg_1_vi` are unused for
/// `PartialEq`, and those subcomputations will hopefully be removed
- /// as their results are unused. The point of `__self_vi` and
+ /// as their results are unused. The point of `__self_vi` and
/// `__arg_1_vi` is for `PartialOrd`; see #15503.)
fn expand_enum_method_body<'b>(&self,
cx: &mut ExtCtxt<'_>,
/// Function to fold over fields, with three cases, to generate more efficient and concise code.
/// When the `substructure` has grouped fields, there are two cases:
-/// Zero fields: call the base case function with None (like the usual base case of `cs_fold`).
+/// Zero fields: call the base case function with `None` (like the usual base case of `cs_fold`).
/// One or more fields: call the base case function on the first value (which depends on
/// `use_fold`), and use that as the base case. Then perform `cs_fold` on the remainder of the
/// fields.
}
}
-/// Return true if the type has no value fields
+/// Returns `true` if the type has no value fields
/// (for an enum, no variant has any fields)
pub fn is_type_without_fields(item: &Annotatable) -> bool {
if let Annotatable::Item(ref item) = *item {
intrinsic: &str,
args: Vec<P<ast::Expr>>)
-> P<ast::Expr> {
- if cx.current_expansion.mark.expn_info().unwrap().allow_internal_unstable {
+ let intrinsic_allowed_via_allow_internal_unstable = cx
+ .current_expansion.mark.expn_info().unwrap()
+ .allow_internal_unstable.map_or(false, |features| features.iter().any(|&s|
+ s == "core_intrinsics"
+ ));
+ if intrinsic_allowed_via_allow_internal_unstable {
span = span.with_ctxt(cx.backtrace());
} else { // Avoid instability errors with user defined curstom derives, cc #36316
let mut info = cx.current_expansion.mark.expn_info().unwrap();
- info.allow_internal_unstable = true;
+ info.allow_internal_unstable = Some(vec![Symbol::intern("core_intrinsics")].into());
let mark = Mark::fresh(Mark::root());
mark.set_expn_info(info);
span = span.with_ctxt(SyntaxContext::empty().apply_mark(mark));
use fmt_macros as parse;
-use crate::errors::DiagnosticBuilder;
-use crate::errors::Applicability;
+use errors::DiagnosticBuilder;
+use errors::Applicability;
use syntax::ast;
use syntax::ext::base::{self, *};
self.ecx.expr_str(sp, s)
}
- /// Build a static `rt::Argument` from a `parse::Piece` or append
+ /// Builds a static `rt::Argument` from a `parse::Piece` or append
/// to the `literal` string.
fn build_piece(&mut self,
piece: &parse::Piece<'_>,
}
/// Actually builds the expression which the format_args! block will be
- /// expanded to
+ /// expanded to.
fn into_expr(self) -> P<ast::Expr> {
let mut locals = Vec::with_capacity(
(0..self.args.len()).map(|i| self.arg_unique_types[i].len()).sum()
//if !ecx.ecfg.enable_allow_internal_unstable() {
// For some reason, the only one that actually works for `println` is the first check
- if !sp.allows_unstable() // the enclosing span is marked as `#[allow_insternal_unsable]`
+ if !sp.allows_unstable("format_args_nl") // the span is marked as `#[allow_insternal_unsable]`
&& !ecx.ecfg.enable_allow_internal_unstable() // NOTE: when is this enabled?
&& !ecx.ecfg.enable_format_args_nl() // enabled using `#[feature(format_args_nl]`
{
},
};
- /// Find the indices of all characters that have been processed and differ between the actual
+ /// Finds the indices of all characters that have been processed and differ between the actual
/// written code (code snippet) and the `InternedString` that get's processed in the `Parser`
/// in order to properly synthethise the intra-string `Span`s for error diagnostics.
fn find_skips(snippet: &str, is_raw: bool) -> Vec<usize> {
);
}
- /// Check that the translations are what we expect.
+ /// Checks that the translations are what we expect.
#[test]
fn test_translation() {
assert_eq_pnsat!("%c", Some("{}"));
/// LLVM's `module asm "some assembly here"`. All of LLVM's caveats
/// therefore apply.
-use crate::errors::DiagnosticBuilder;
+use errors::DiagnosticBuilder;
use syntax::ast;
use syntax::source_map::respan;
#![feature(proc_macro_internals)]
#![feature(proc_macro_span)]
#![feature(decl_macro)]
-#![feature(str_escape)]
+#![feature(nll)]
#![feature(rustc_diagnostic_macros)]
#![recursion_limit="256"]
extern crate proc_macro;
-use rustc_errors as errors;
-
mod diagnostics;
mod asm;
NormalTT {
expander: Box::new($f as MacroExpanderFn),
def_info: None,
- allow_internal_unstable: false,
+ allow_internal_unstable: None,
allow_internal_unsafe: false,
local_inner_macros: false,
unstable_feature: None,
NormalTT {
expander: Box::new(format::expand_format_args),
def_info: None,
- allow_internal_unstable: true,
+ allow_internal_unstable: Some(vec![
+ Symbol::intern("fmt_internals"),
+ ].into()),
allow_internal_unsafe: false,
local_inner_macros: false,
unstable_feature: None,
NormalTT {
expander: Box::new(format::expand_format_args_nl),
def_info: None,
- allow_internal_unstable: true,
+ allow_internal_unstable: Some(vec![
+ Symbol::intern("fmt_internals"),
+ ].into()),
allow_internal_unsafe: false,
local_inner_macros: false,
unstable_feature: None,
use std::mem;
use crate::deriving;
-use crate::errors;
use syntax::ast::{self, Ident};
use syntax::attr;
call_site: DUMMY_SP,
def_site: None,
format: MacroAttribute(Symbol::intern("proc_macro")),
- allow_internal_unstable: true,
+ allow_internal_unstable: Some(vec![
+ Symbol::intern("rustc_attrs"),
+ Symbol::intern("proc_macro_internals"),
+ ].into()),
allow_internal_unsafe: false,
local_inner_macros: false,
edition: hygiene::default_edition(),
-use crate::errors::FatalError;
use crate::proc_macro_server;
+use errors::FatalError;
use syntax::source_map::Span;
use syntax::ext::base::{self, *};
use syntax::tokenstream::TokenStream;
-use crate::errors::{self, Diagnostic, DiagnosticBuilder};
+use errors::{Diagnostic, DiagnosticBuilder};
use std::panic;
use syntax::ext::base::ExtCtxt;
use syntax::parse::lexer::comments;
use syntax::parse::{self, token, ParseSess};
+use syntax::parse::parser::emit_unclosed_delims;
use syntax::tokenstream::{self, DelimSpan, IsJoint::*, TokenStream, TreeAndJoint};
use syntax_pos::hygiene::{SyntaxContext, Transparency};
use syntax_pos::symbol::{keywords, Symbol};
stream.is_empty()
}
fn from_str(&mut self, src: &str) -> Self::TokenStream {
- parse::parse_stream_from_source_str(
+ let (tokens, errors) = parse::parse_stream_from_source_str(
FileName::proc_macro_source_code(src.clone()),
src.to_string(),
self.sess,
Some(self.call_site),
- )
+ );
+ emit_unclosed_delims(&errors, &self.sess.span_diagnostic);
+ tokens
}
fn to_string(&mut self, stream: &Self::TokenStream) -> String {
stream.to_string()
call_site: DUMMY_SP,
def_site: None,
format: MacroAttribute(Symbol::intern("test")),
- allow_internal_unstable: true,
+ allow_internal_unstable: Some(vec![
+ Symbol::intern("rustc_attrs"),
+ Symbol::intern("test"),
+ ].into()),
allow_internal_unsafe: false,
local_inner_macros: false,
edition: hygiene::default_edition(),
call_site: DUMMY_SP,
def_site: None,
format: MacroAttribute(Symbol::intern("test_case")),
- allow_internal_unstable: true,
+ allow_internal_unstable: Some(vec![
+ Symbol::intern("test"),
+ Symbol::intern("rustc_attrs"),
+ ].into()),
allow_internal_unsafe: false,
local_inner_macros: false,
edition: hygiene::default_edition(),
use unicode_width::UnicodeWidthChar;
use super::*;
-/// Find all newlines, multi-byte characters, and non-narrow characters in a
+/// Finds all newlines, multi-byte characters, and non-narrow characters in a
/// SourceFile.
///
/// This function will use an SSE2 enhanced implementation if hardware support
}
}
- /// Check 16 byte chunks of text at a time. If the chunk contains
+ /// Checks 16 byte chunks of text at a time. If the chunk contains
/// something other than printable ASCII characters and newlines, the
/// function falls back to the generic implementation. Otherwise it uses
/// SSE2 intrinsics to quickly find all newlines.
use serialize::{Encodable, Decodable, Encoder, Decoder};
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::sync::Lrc;
use std::{fmt, mem};
/// A SyntaxContext represents a chain of macro expansions (represented by marks).
dollar_crate_name: Symbol,
}
-/// A mark is a unique id associated with a macro expansion.
+/// A mark is a unique ID associated with a macro expansion.
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)]
pub struct Mark(u32);
pub def_site: Option<Span>,
/// The format with which the macro was invoked.
pub format: ExpnFormat,
- /// Whether the macro is allowed to use #[unstable]/feature-gated
- /// features internally without forcing the whole crate to opt-in
+ /// List of #[unstable]/feature-gated features that the macro is allowed to use
+ /// internally without forcing the whole crate to opt-in
/// to them.
- pub allow_internal_unstable: bool,
+ pub allow_internal_unstable: Option<Lrc<[Symbol]>>,
/// Whether the macro is allowed to use `unsafe` internally
/// even if the user crate has `#![forbid(unsafe_code)]`.
pub allow_internal_unsafe: bool,
QuestionMark,
TryBlock,
/// Desugaring of an `impl Trait` in return type position
- /// to an `existential type Foo: Trait;` + replacing the
+ /// to an `existential type Foo: Trait;` and replacing the
/// `impl Trait` with `Foo`.
ExistentialReturnType,
Async,
#![feature(const_fn)]
#![feature(crate_visibility_modifier)]
#![feature(custom_attribute)]
+#![feature(nll)]
#![feature(non_exhaustive)]
#![feature(optin_builtin_traits)]
#![feature(rustc_attrs)]
#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash, RustcDecodable, RustcEncodable)]
pub enum FileName {
Real(PathBuf),
- /// A macro. This includes the full name of the macro, so that there are no clashes.
+ /// A macro. This includes the full name of the macro, so that there are no clashes.
Macros(String),
/// Call to `quote!`.
QuoteExpansion(u64),
if self.is_dummy() { other } else { self }
}
- /// Return `true` if `self` fully encloses `other`.
+ /// Returns `true` if `self` fully encloses `other`.
pub fn contains(self, other: Span) -> bool {
let span = self.data();
let other = other.data();
span.lo <= other.lo && other.hi <= span.hi
}
- /// Return `true` if `self` touches `other`.
+ /// Returns `true` if `self` touches `other`.
pub fn overlaps(self, other: Span) -> bool {
let span = self.data();
let other = other.data();
span.lo < other.hi && other.lo < span.hi
}
- /// Return true if the spans are equal with regards to the source text.
+ /// Returns `true` if the spans are equal with regards to the source text.
///
/// Use this instead of `==` when either span could be generated code,
/// and you only care that they point to the same bytes of source text.
}
}
- /// Return the source span -- this is either the supplied span, or the span for
+ /// Returns the source span -- this is either the supplied span, or the span for
/// the macro callsite that expanded to it.
pub fn source_callsite(self) -> Span {
self.ctxt().outer().expn_info().map(|info| info.call_site.source_callsite()).unwrap_or(self)
self.edition() >= edition::Edition::Edition2018
}
- /// Return the source callee.
+ /// Returns the source callee.
///
/// Returns `None` if the supplied span has no expansion trace,
/// else returns the `ExpnInfo` for the macro definition
self.ctxt().outer().expn_info().map(source_callee)
}
- /// Check if a span is "internal" to a macro in which `#[unstable]`
+ /// Checks if a span is "internal" to a macro in which `#[unstable]`
/// items can be used (that is, a macro marked with
/// `#[allow_internal_unstable]`).
- pub fn allows_unstable(&self) -> bool {
+ pub fn allows_unstable(&self, feature: &str) -> bool {
match self.ctxt().outer().expn_info() {
- Some(info) => info.allow_internal_unstable,
+ Some(info) => info
+ .allow_internal_unstable
+ .map_or(false, |features| features.iter().any(|&f|
+ f == feature || f == "allow_internal_unstable_backcompat_hack"
+ )),
None => false,
}
}
- /// Check if this span arises from a compiler desugaring of kind `kind`.
+ /// Checks if this span arises from a compiler desugaring of kind `kind`.
pub fn is_compiler_desugaring(&self, kind: CompilerDesugaringKind) -> bool {
match self.ctxt().outer().expn_info() {
Some(info) => match info.format {
}
}
- /// Return the compiler desugaring that created this span, or `None`
+ /// Returns the compiler desugaring that created this span, or `None`
/// if this span is not from a desugaring.
pub fn compiler_desugaring_kind(&self) -> Option<CompilerDesugaringKind> {
match self.ctxt().outer().expn_info() {
}
}
- /// Check if a span is "internal" to a macro in which `unsafe`
+ /// Checks if a span is "internal" to a macro in which `unsafe`
/// can be used without triggering the `unsafe_code` lint
// (that is, a macro marked with `#[allow_internal_unsafe]`).
pub fn allows_unsafe(&self) -> bool {
result
}
- /// Return a `Span` that would enclose both `self` and `end`.
+ /// Returns a `Span` that would enclose both `self` and `end`.
pub fn to(self, end: Span) -> Span {
let span_data = self.data();
let end_data = end.data();
)
}
- /// Return a `Span` between the end of `self` to the beginning of `end`.
+ /// Returns a `Span` between the end of `self` to the beginning of `end`.
pub fn between(self, end: Span) -> Span {
let span = self.data();
let end = end.data();
)
}
- /// Return a `Span` between the beginning of `self` to the beginning of `end`.
+ /// Returns a `Span` between the beginning of `self` to the beginning of `end`.
pub fn until(self, end: Span) -> Span {
let span = self.data();
let end = end.data();
&self.primary_spans
}
- /// Returns whether any of the primary spans is displayable.
+ /// Returns `true` if any of the primary spans are displayable.
pub fn has_primary_spans(&self) -> bool {
self.primary_spans.iter().any(|sp| !sp.is_dummy())
}
}
/// Replaces all occurrences of one Span with another. Used to move `Span`s in areas that don't
- /// display well (like std macros). Returns true if replacements occurred.
+ /// display well (like std macros). Returns whether replacements occurred.
pub fn replace(&mut self, before: Span, after: Span) -> bool {
let mut replacements_occurred = false;
for primary_span in &mut self.primary_spans {
span_labels
}
- /// Returns whether any of the span labels is displayable.
+ /// Returns `true` if any of the span labels is displayable.
pub fn has_span_labels(&self) -> bool {
self.span_labels.iter().any(|(sp, _)| !sp.is_dummy())
}
/// originate from files has names between angle brackets by convention
/// (e.g., `<anon>`).
pub name: FileName,
- /// True if the `name` field above has been modified by `--remap-path-prefix`.
+ /// `true` if the `name` field above has been modified by `--remap-path-prefix`.
pub name_was_remapped: bool,
/// The unmapped path of the file that the source came from.
/// Set to `None` if the `SourceFile` was imported from an external crate.
}
}
- /// Return the `BytePos` of the beginning of the current line.
+ /// Returns the `BytePos` of the beginning of the current line.
pub fn line_begin_pos(&self, pos: BytePos) -> BytePos {
let line_index = self.lookup_line(pos).unwrap();
self.lines[line_index]
}
}
- /// Get a line from the list of pre-computed line-beginnings.
+ /// Gets a line from the list of pre-computed line-beginnings.
/// The line number here is 0-based.
pub fn get_line(&self, line_number: usize) -> Option<Cow<'_, str>> {
fn get_until_newline(src: &str, begin: usize) -> &str {
self.lines.len()
}
- /// Find the line containing the given position. The return value is the
+ /// Finds the line containing the given position. The return value is the
/// index into the `lines` array of this `SourceFile`, not the 1-based line
/// number. If the source_file is empty or the position is located before the
/// first line, `None` is returned.
}
}
-/// Remove utf-8 BOM if any.
+/// Removes UTF-8 BOM, if any.
fn remove_bom(src: &mut String) {
if src.starts_with("\u{feff}") {
src.drain(..3);
Ident::with_empty_ctxt(Symbol::intern(string))
}
- /// Replace `lo` and `hi` with those from `span`, but keep hygiene context.
+ /// Replaces `lo` and `hi` with those from `span`, but keep hygiene context.
pub fn with_span_pos(self, span: Span) -> Ident {
Ident::new(self.name, span.with_ctxt(self.span.ctxt()))
}
}
}
-/// A symbol is an interned or gensymed string. The use of newtype_index! means
-/// that Option<Symbol> only takes up 4 bytes, because newtype_index! reserves
+/// A symbol is an interned or gensymed string. The use of `newtype_index!` means
+/// that `Option<Symbol>` only takes up 4 bytes, because `newtype_index! reserves
/// the last 256 values for tagging purposes.
///
-/// Note that Symbol cannot be a newtype_index! directly because it implements
-/// fmt::Debug, Encodable, and Decodable in special ways.
+/// Note that `Symbol` cannot directly be a `newtype_index!` because it implements
+/// `fmt::Debug`, `Encodable`, and `Decodable` in special ways.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Symbol(SymbolIndex);
with_interner(|interner| interner.interned(self))
}
- /// Gensyms a new usize, using the current interner.
+ /// Gensyms a new `usize`, using the current interner.
pub fn gensym(string: &str) -> Self {
with_interner(|interner| interner.gensym(string))
}
authors = ["The Rust Project Developers"]
name = "term"
version = "0.0.0"
+edition = "2018"
[lib]
name = "term"
test(attr(deny(warnings))))]
#![deny(missing_docs)]
+#![deny(rust_2018_idioms)]
+
#![cfg_attr(windows, feature(libc))]
// Handle rustfmt skips
#![feature(custom_attribute)]
-#![feature(nll)]
#![allow(unused_attributes)]
use std::io::prelude::*;
+use std::io::{self, Stdout, Stderr};
pub use terminfo::TerminfoTerminal;
#[cfg(windows)]
pub use win::WinConsole;
-use std::io::{self, Stdout, Stderr};
-
pub mod terminfo;
#[cfg(windows)]
pub type StderrTerminal = dyn Terminal<Output = Stderr> + Send;
#[cfg(not(windows))]
-/// Return a Terminal wrapping stdout, or None if a terminal couldn't be
+/// Returns a Terminal wrapping stdout, or None if a terminal couldn't be
/// opened.
pub fn stdout() -> Option<Box<StdoutTerminal>> {
TerminfoTerminal::new(io::stdout()).map(|t| Box::new(t) as Box<StdoutTerminal>)
}
#[cfg(windows)]
-/// Return a Terminal wrapping stdout, or None if a terminal couldn't be
+/// Returns a Terminal wrapping stdout, or None if a terminal couldn't be
/// opened.
pub fn stdout() -> Option<Box<StdoutTerminal>> {
TerminfoTerminal::new(io::stdout())
}
#[cfg(not(windows))]
-/// Return a Terminal wrapping stderr, or None if a terminal couldn't be
+/// Returns a Terminal wrapping stderr, or None if a terminal couldn't be
/// opened.
pub fn stderr() -> Option<Box<StderrTerminal>> {
TerminfoTerminal::new(io::stderr()).map(|t| Box::new(t) as Box<StderrTerminal>)
}
#[cfg(windows)]
-/// Return a Terminal wrapping stderr, or None if a terminal couldn't be
+/// Returns a Terminal wrapping stderr, or None if a terminal couldn't be
/// opened.
pub fn stderr() -> Option<Box<StderrTerminal>> {
TerminfoTerminal::new(io::stderr())
/// if there was an I/O error.
fn bg(&mut self, color: color::Color) -> io::Result<bool>;
- /// Sets the given terminal attribute, if supported. Returns `Ok(true)`
+ /// Sets the given terminal attribute, if supported. Returns `Ok(true)`
/// if the attribute was supported, `Ok(false)` otherwise, and `Err(e)` if
/// there was an I/O error.
fn attr(&mut self, attr: Attr) -> io::Result<bool>;
- /// Returns whether the given terminal attribute is supported.
+ /// Returns `true` if the given terminal attribute is supported.
fn supports_attr(&self, attr: Attr) -> bool;
/// Resets all terminal attributes and colors to their defaults.
use std::error;
use std::fmt;
use std::fs::File;
-use std::io::prelude::*;
-use std::io;
-use std::io::BufReader;
+use std::io::{self, prelude::*, BufReader};
use std::path::Path;
-use Attr;
-use color;
-use Terminal;
-use self::searcher::get_dbpath_for_term;
-use self::parser::compiled::{parse, msys_terminfo};
-use self::parm::{expand, Variables, Param};
+use crate::Attr;
+use crate::color;
+use crate::Terminal;
+use searcher::get_dbpath_for_term;
+use parser::compiled::{parse, msys_terminfo};
+use parm::{expand, Variables, Param};
/// A parsed terminfo database entry.
#[derive(Debug)]
}
fn cause(&self) -> Option<&dyn error::Error> {
- use self::Error::*;
+ use Error::*;
match *self {
IoError(ref e) => Some(e),
_ => None,
}
impl fmt::Display for Error {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- use self::Error::*;
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ use Error::*;
match *self {
TermUnset => Ok(()),
MalformedTerminfo(ref e) => e.fmt(f),
}
impl TermInfo {
- /// Create a TermInfo based on current environment.
+ /// Creates a TermInfo based on current environment.
pub fn from_env() -> Result<TermInfo, Error> {
let term = match env::var("TERM") {
Ok(name) => TermInfo::from_name(&name),
}
}
- /// Create a TermInfo for the named terminal.
+ /// Creates a TermInfo for the named terminal.
pub fn from_name(name: &str) -> Result<TermInfo, Error> {
get_dbpath_for_term(name)
.ok_or_else(|| {
}
impl<T: Write + Send> TerminfoTerminal<T> {
- /// Create a new TerminfoTerminal with the given TermInfo and Write.
+ /// Creates a new TerminfoTerminal with the given TermInfo and Write.
pub fn new_with_terminfo(out: T, terminfo: TermInfo) -> TerminfoTerminal<T> {
let nc = if terminfo.strings.contains_key("setaf") &&
terminfo.strings.contains_key("setab") {
}
}
- /// Create a new TerminfoTerminal for the current environment with the given Write.
+ /// Creates a new TerminfoTerminal for the current environment with the given Write.
///
/// Returns `None` when the terminfo cannot be found or parsed.
pub fn new(out: T) -> Option<TerminfoTerminal<T>> {
/// Container for static and dynamic variable arrays
pub struct Variables {
/// Static variables A-Z
- sta: [Param; 26],
+ sta_va: [Param; 26],
/// Dynamic variables a-z
- dyn: [Param; 26],
+ dyn_va: [Param; 26],
}
impl Variables {
- /// Return a new zero-initialized Variables
+ /// Returns a new zero-initialized Variables
pub fn new() -> Variables {
Variables {
- sta: [Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
- Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
- Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
- Number(0), Number(0), Number(0), Number(0), Number(0)],
- dyn: [Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
- Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
- Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
- Number(0), Number(0), Number(0), Number(0), Number(0)],
+ sta_va: [
+ Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
+ Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
+ Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
+ Number(0), Number(0), Number(0), Number(0), Number(0)
+ ],
+ dyn_va: [
+ Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
+ Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
+ Number(0), Number(0), Number(0), Number(0), Number(0), Number(0), Number(0),
+ Number(0), Number(0), Number(0), Number(0), Number(0)
+ ],
}
}
}
if cur >= 'A' && cur <= 'Z' {
if let Some(arg) = stack.pop() {
let idx = (cur as u8) - b'A';
- vars.sta[idx as usize] = arg;
+ vars.sta_va[idx as usize] = arg;
} else {
return Err("stack is empty".to_string());
}
} else if cur >= 'a' && cur <= 'z' {
if let Some(arg) = stack.pop() {
let idx = (cur as u8) - b'a';
- vars.dyn[idx as usize] = arg;
+ vars.dyn_va[idx as usize] = arg;
} else {
return Err("stack is empty".to_string());
}
GetVar => {
if cur >= 'A' && cur <= 'Z' {
let idx = (cur as u8) - b'A';
- stack.push(vars.sta[idx as usize].clone());
+ stack.push(vars.sta_va[idx as usize].clone());
} else if cur >= 'a' && cur <= 'z' {
let idx = (cur as u8) - b'a';
- stack.push(vars.dyn[idx as usize].clone());
+ stack.push(vars.dyn_va[idx as usize].clone());
} else {
return Err("bad variable name in %g".to_string());
}
//! ncurses-compatible compiled terminfo format parsing (term(5))
use std::collections::HashMap;
-use std::io::prelude::*;
use std::io;
+use std::io::prelude::*;
use super::super::TermInfo;
// These are the orders ncurses uses in its compiled format (as of 5.9). Not sure if portable.
#[rustfmt_skip]
-pub static boolfnames: &'static[&'static str] = &["auto_left_margin", "auto_right_margin",
+pub static boolfnames: &[&str] = &["auto_left_margin", "auto_right_margin",
"no_esc_ctlc", "ceol_standout_glitch", "eat_newline_glitch", "erase_overstrike", "generic_type",
"hard_copy", "has_meta_key", "has_status_line", "insert_null_glitch", "memory_above",
"memory_below", "move_insert_mode", "move_standout_mode", "over_strike", "status_line_esc_ok",
"return_does_clr_eol"];
#[rustfmt_skip]
-pub static boolnames: &'static[&'static str] = &["bw", "am", "xsb", "xhp", "xenl", "eo",
+pub static boolnames: &[&str] = &["bw", "am", "xsb", "xhp", "xenl", "eo",
"gn", "hc", "km", "hs", "in", "db", "da", "mir", "msgr", "os", "eslok", "xt", "hz", "ul", "xon",
"nxon", "mc5i", "chts", "nrrmc", "npc", "ndscr", "ccc", "bce", "hls", "xhpa", "crxm", "daisy",
"xvpa", "sam", "cpix", "lpix", "OTbs", "OTns", "OTnc", "OTMT", "OTNL", "OTpt", "OTxr"];
#[rustfmt_skip]
-pub static numfnames: &'static[&'static str] = &[ "columns", "init_tabs", "lines",
+pub static numfnames: &[&str] = &[ "columns", "init_tabs", "lines",
"lines_of_memory", "magic_cookie_glitch", "padding_baud_rate", "virtual_terminal",
"width_status_line", "num_labels", "label_height", "label_width", "max_attributes",
"maximum_windows", "max_colors", "max_pairs", "no_color_video", "buffer_capacity",
"new_line_delay", "backspace_delay", "horizontal_tab_delay", "number_of_function_keys"];
#[rustfmt_skip]
-pub static numnames: &'static[&'static str] = &[ "cols", "it", "lines", "lm", "xmc", "pb",
+pub static numnames: &[&str] = &[ "cols", "it", "lines", "lm", "xmc", "pb",
"vt", "wsl", "nlab", "lh", "lw", "ma", "wnum", "colors", "pairs", "ncv", "bufsz", "spinv",
"spinh", "maddr", "mjump", "mcs", "mls", "npins", "orc", "orl", "orhi", "orvi", "cps", "widcs",
"btns", "bitwin", "bitype", "UTug", "OTdC", "OTdN", "OTdB", "OTdT", "OTkn"];
#[rustfmt_skip]
-pub static stringfnames: &'static[&'static str] = &[ "back_tab", "bell", "carriage_return",
+pub static stringfnames: &[&str] = &[ "back_tab", "bell", "carriage_return",
"change_scroll_region", "clear_all_tabs", "clear_screen", "clr_eol", "clr_eos",
"column_address", "command_character", "cursor_address", "cursor_down", "cursor_home",
"cursor_invisible", "cursor_left", "cursor_mem_address", "cursor_normal", "cursor_right",
"acs_plus", "memory_lock", "memory_unlock", "box_chars_1"];
#[rustfmt_skip]
-pub static stringnames: &'static[&'static str] = &[ "cbt", "_", "cr", "csr", "tbc", "clear",
+pub static stringnames: &[&str] = &[ "cbt", "_", "cr", "csr", "tbc", "clear",
"_", "_", "hpa", "cmdch", "cup", "cud1", "home", "civis", "cub1", "mrcup", "cnorm", "cuf1",
"ll", "cuu1", "cvvis", "dch1", "dl1", "dsl", "hd", "smacs", "blink", "bold", "smcup", "smdc",
"dim", "smir", "invis", "prot", "rev", "smso", "smul", "ech", "rmacs", "sgr0", "rmcup", "rmdc",
})
}
-/// Create a dummy TermInfo struct for msys terminals
+/// Creates a dummy TermInfo struct for msys terminals
pub fn msys_terminfo() -> TermInfo {
let mut strings = HashMap::new();
strings.insert("sgr0".to_string(), b"\x1B[0m".to_vec());
-//! ncurses-compatible database discovery
+//! ncurses-compatible database discovery.
//!
//! Does not support hashed database, only filesystem!
use std::io;
use std::io::prelude::*;
-use Attr;
-use color;
-use Terminal;
+use crate::Attr;
+use crate::color;
+use crate::Terminal;
-/// A Terminal implementation which uses the Win32 Console API.
+/// A Terminal implementation that uses the Win32 Console API.
pub struct WinConsole<T> {
buf: T,
def_foreground: color::Color,
}
}
- /// Returns `None` whenever the terminal cannot be created for some
- /// reason.
+ /// Returns `None` whenever the terminal cannot be created for some reason.
pub fn new(out: T) -> io::Result<WinConsole<T>> {
let fg;
let bg;
//! benchmarks themselves) should be done via the `#[test]` and
//! `#[bench]` attributes.
//!
-//! See the [Testing Chapter](../book/first-edition/testing.html) of the book for more details.
+//! See the [Testing Chapter](../book/ch11-00-testing.html) of the book for more details.
// Currently, not much of this is meant for users. It is intended to
// support the simplest interface possible for representing and
}
/// Invoked when unit tests terminate. Should panic if the unit
-/// test is considered a failure. By default, invokes `report()`
+/// Tests is considered a failure. By default, invokes `report()`
/// and checks for a `0` result.
pub fn assert_test_result<T: Termination>(result: T) {
let code = result.report();
#![deny(rust_2018_idioms)]
#![feature(link_cfg)]
+#![feature(nll)]
#![feature(staged_api)]
#![feature(unwind_attributes)]
#![feature(static_nobundle)]
// processing. We'll call this once per module optimized through ThinLTO, and
// it'll be called concurrently on many threads.
extern "C" LLVMModuleRef
-LLVMRustParseBitcodeForThinLTO(LLVMContextRef Context,
- const char *data,
- size_t len,
- const char *identifier) {
+LLVMRustParseBitcodeForLTO(LLVMContextRef Context,
+ const char *data,
+ size_t len,
+ const char *identifier) {
StringRef Data(data, len);
MemoryBufferRef Buffer(Data, identifier);
unwrap(Context)->enableDebugTypeODRUniquing();
pub fn box_uninitialized() -> Box<MaybeUninit<usize>> {
// CHECK-LABEL: @box_uninitialized
// CHECK-NOT: store
+ // CHECK-NOT: alloca
+ // CHECK-NOT: memcpy
+ // CHECK-NOT: memset
Box::new(MaybeUninit::uninitialized())
}
// no-prefer-dynamic
// only-msvc
-// compile-flags: -Z cross-lang-lto
+// compile-flags: -C linker-plugin-lto
#![crate_type = "rlib"]
// no-prefer-dynamic
// ignore-tidy-linelength
-// compile-flags: -C no-prepopulate-passes -C panic=abort -Z cross-lang-lto -Cpasses=name-anon-globals
+// compile-flags: -C no-prepopulate-passes -C panic=abort -C linker-plugin-lto -Cpasses=name-anon-globals
#![crate_type = "staticlib"]
use std::iter::Iterator;
use std::future::Future;
-use std::task::{Poll, LocalWaker};
+use std::task::{Poll, Waker};
use std::pin::Pin;
use std::unimplemented;
impl Future for MyFuture {
type Output = u32;
- fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<u32> {
+ fn poll(self: Pin<&mut Self>, waker: &Waker) -> Poll<u32> {
Poll::Pending
}
}
}
}
-/// A fn that has the changed type in its signature; must currently be
+/// A function that has the changed type in its signature; must currently be
/// rebuilt.
///
/// You could imagine that, in the future, if the change were
}
}
-/// Call a fn that has the changed type in its signature; this
+/// Call a function that has the changed type in its signature; this
/// currently must also be rebuilt.
///
/// You could imagine that, in the future, if the change were
}
}
-/// A fn that uses the changed type, but only in its body, not its
+/// A function that uses the changed type, but only in its body, not its
/// signature.
///
/// You could imagine that, in the future, if the change were
}
}
-/// A fn X that calls a fn Y, where Y uses the changed type in its
+/// A function `X` that calls a function `Y`, where `Y` uses the changed type in its
/// body. In this case, the effects of the change should be contained
-/// to Y; X should not have to be rebuilt, nor should it need to be
-/// typechecked again.
+/// to `Y`; `X` should not have to be rebuilt, nor should it need to be
+/// type-checked again.
pub mod call_fn_with_type_in_body {
use fn_with_type_in_body;
}
}
-/// A fn item that makes an instance of `Point` but does not invoke methods
+/// A function item that makes an instance of `Point` but does not invoke methods.
pub mod fn_make_struct {
use point::Point;
}
}
-/// A fn item that reads fields from `Point` but does not invoke methods
+/// A function item that reads fields from `Point` but does not invoke methods.
pub mod fn_read_field {
use point::Point;
}
}
-/// A fn item that writes to a field of `Point` but does not invoke methods
+/// A function item that writes to a field of `Point` but does not invoke methods.
pub mod fn_write_field {
use point::Point;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_callee_function() {
callee2(1, 2)
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_argument_function() {
callee1(1, 3)
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_callee_method() {
let s = Struct;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_argument_method() {
let s = Struct;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_ufcs_callee_method() {
let s = Struct;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_argument_method_ufcs() {
let s = Struct;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
// One might think this would be expanded in the HirBody/Mir, but it actually
// results in slightly different Hir/Mir.
#[cfg(not(cfail1))]
use super::Struct2 as Struct;
- #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+ #[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_parameter() {
let x = 0u32;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_parameter_pattern() {
let _ = |&x: &u32| x;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_type_ascription_to_parameter() {
let closure = |x: u32| x + 1u32;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_parameter_type() {
let closure = |x: u16| (x as u64) + 1;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn change_field_value_struct_like() -> Enum {
Enum::Struct {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_constructor_path_struct_like() {
let _ = Enum2::Struct {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn change_constructor_variant_struct_like() {
let _ = Enum2::Struct2 {
#[rustc_clean(
cfg="cfail2",
- except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,\
+ except="FnSignature,Hir,HirBody,MirOptimized,MirBuilt,\
TypeckTables"
)]
#[rustc_clean(cfg="cfail3")]
#[cfg(not(cfail1))]
use super::Enum2::Struct2 as Variant;
- #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")]
+ #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn function() -> Enum2 {
Variant {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn change_field_value_tuple_like() -> Enum {
Enum::Tuple(0, 1, 3)
#[cfg(not(cfail1))]
#[rustc_clean(
cfg="cfail2",
- except="HirBody,MirOptimized,MirValidated,TypeckTables"
+ except="HirBody,MirOptimized,MirBuilt,TypeckTables"
)]
#[rustc_clean(cfg="cfail3")]
pub fn change_constructor_path_tuple_like() {
#[cfg(not(cfail1))]
#[rustc_clean(
cfg="cfail2",
- except="HirBody,MirOptimized,MirValidated,TypeckTables"
+ except="HirBody,MirOptimized,MirBuilt,TypeckTables"
)]
#[rustc_clean(cfg="cfail3")]
pub fn change_constructor_variant_tuple_like() {
#[rustc_clean(
cfg="cfail2",
- except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,\
+ except="FnSignature,Hir,HirBody,MirOptimized,MirBuilt,\
TypeckTables"
)]
#[rustc_clean(cfg="cfail3")]
#[cfg(not(cfail1))]
use super::Enum2::Tuple2 as Variant;
- #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")]
+ #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn function() -> Enum2 {
Variant(0, 1, 2)
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_constructor_path_c_like() {
let _ = Clike2::B;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn change_constructor_variant_c_like() {
let _ = Clike::C;
#[rustc_clean(
cfg="cfail2",
- except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,\
+ except="FnSignature,Hir,HirBody,MirOptimized,MirBuilt,\
TypeckTables"
)]
#[rustc_clean(cfg="cfail3")]
#[cfg(not(cfail1))]
use super::Clike::B as Variant;
- #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")]
+ #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn function() -> Clike {
Variant
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn body_not_exported_to_metadata() -> u32 {
2
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
#[inline]
pub fn body_exported_to_metadata_because_of_inline() -> u32 {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
#[inline]
pub fn body_exported_to_metadata_because_of_generic() -> u32 {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_loop_body() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_iteration_variable_name() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_iteration_variable_pattern() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_iterable() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_break() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_break_label() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_continue_label() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_continue_to_break() {
let mut _x = 0;
#[cfg(not(cfail1))]
#[rustc_clean(cfg = "cfail2",
- except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")]
+ except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")]
#[rustc_clean(cfg = "cfail3")]
pub fn add_parameter(p: i32) {}
#[cfg(not(cfail1))]
#[rustc_clean(cfg = "cfail2",
- except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")]
+ except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")]
#[rustc_clean(cfg = "cfail3")]
pub fn type_of_parameter(p: i64) {}
#[cfg(not(cfail1))]
#[rustc_clean(cfg = "cfail2",
- except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")]
+ except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")]
#[rustc_clean(cfg = "cfail3")]
pub fn type_of_parameter_ref(p: &mut i32) {}
#[cfg(not(cfail1))]
#[rustc_clean(cfg = "cfail2",
- except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")]
+ except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")]
#[rustc_clean(cfg = "cfail3")]
pub fn order_of_parameters(p2: i64, p1: i32) {}
#[cfg(not(cfail1))]
#[rustc_clean(cfg = "cfail2",
- except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")]
+ except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")]
#[rustc_clean(cfg = "cfail3")]
pub unsafe fn make_unsafe() {}
pub fn make_extern() {}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg = "cfail2", except = "Hir, HirBody, TypeckTables, FnSignature")]
+#[rustc_clean(cfg = "cfail2", except = "Hir, HirBody, MirBuilt, TypeckTables, FnSignature")]
#[rustc_clean(cfg = "cfail3")]
pub extern "C" fn make_extern() {}
use super::ReferencedType2 as ReturnType;
#[rustc_clean(cfg = "cfail2",
- except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")]
+ except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")]
#[rustc_clean(cfg = "cfail3")]
pub fn indirect_return_type() -> ReturnType {
ReturnType {}
use super::ReferencedType2 as ParameterType;
#[rustc_clean(cfg = "cfail2",
- except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")]
+ except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")]
#[rustc_clean(cfg = "cfail3")]
pub fn indirect_parameter_type(p: ParameterType) {}
}
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_condition(x: bool) -> u32 {
if !x {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_then_branch(x: bool) -> u32 {
if x {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_else_branch(x: bool) -> u32 {
if x {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_condition_if_let(x: Option<u32>) -> u32 {
if let Some(_) = x {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_then_branch_if_let(x: Option<u32>) -> u32 {
if let Some(x) = x {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_else_branch_if_let(x: Option<u32>) -> u32 {
if let Some(x) = x {
#[rustc_clean(cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
impl Foo {
- #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")]
+ #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn method_body() {
println!("Hello, world!");
#[rustc_clean(cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
impl Foo {
- #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")]
+ #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
#[inline]
pub fn method_body_inlined() {
impl Foo {
#[rustc_clean(
cfg="cfail2",
- except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirValidated"
+ except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirBuilt"
)]
#[rustc_clean(cfg="cfail3")]
pub fn method_selfmutness(&mut self) { }
impl Foo {
#[rustc_clean(
cfg="cfail2",
- except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirValidated"
+ except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirBuilt"
)]
#[rustc_clean(cfg="cfail3")]
pub fn add_method_parameter(&self, _: i32) { }
#[rustc_clean(cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
impl Foo {
- #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")]
+ #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn change_method_parameter_name(&self, b: i64) { }
}
impl Foo {
#[rustc_clean(
cfg="cfail2",
- except="Hir,HirBody,FnSignature,MirOptimized,MirValidated,TypeckTables")]
+ except="Hir,HirBody,FnSignature,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_method_return_type(&self) -> u8 { 0 }
}
#[rustc_clean(cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
impl Foo {
- #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")]
+ #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn change_method_parameter_order(&self, b: i64, a: i64) { }
}
impl Foo {
#[rustc_clean(
cfg="cfail2",
- except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirValidated"
+ except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirBuilt"
)]
#[rustc_clean(cfg="cfail3")]
pub unsafe fn make_method_unsafe(&self) { }
#[rustc_clean(cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
impl Foo {
- #[rustc_clean(cfg="cfail2", except="Hir,HirBody,FnSignature,TypeckTables")]
+ #[rustc_clean(cfg="cfail2", except="Hir,HirBody,MirBuilt,FnSignature,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub extern fn make_method_extern(&self) { }
}
impl<T> Bar<T> {
#[rustc_clean(
cfg="cfail2",
- except="GenericsOfItem,FnSignature,TypeckTables,TypeOfItem,MirOptimized,MirValidated"
+ except="GenericsOfItem,FnSignature,TypeckTables,TypeOfItem,MirOptimized,MirBuilt"
)]
#[rustc_clean(cfg="cfail3")]
pub fn add_type_parameter_to_impl(&self) { }
#[rustc_clean(cfg="cfail2", except="Hir,HirBody")]
#[rustc_clean(cfg="cfail3")]
impl Bar<u64> {
- #[rustc_clean(cfg="cfail2", except="FnSignature,MirOptimized,MirValidated,TypeckTables")]
+ #[rustc_clean(cfg="cfail2", except="FnSignature,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_impl_self_type(&self) { }
}
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_template(a: i32) -> i32 {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_output(a: i32) -> i32 {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_input(_a: i32, _b: i32) -> i32 {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_input_constraint(_a: i32, _b: i32) -> i32 {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_clobber(_a: i32) -> i32 {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_options(_a: i32) -> i32 {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized")]
+ except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_name() {
let _y = 2u64;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+ except="HirBody,TypeckTables,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn add_type() {
let _x: u32 = 2u32;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+ except="HirBody,TypeckTables,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_type() {
let _x: u8 = 2;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+ except="HirBody,TypeckTables,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_mutability_of_reference_type() {
let _x: &mut u64;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+ except="HirBody,TypeckTables,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_mutability_of_slot() {
let _x: u64 = 0;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+ except="HirBody,TypeckTables,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_simple_binding_to_pattern() {
let (_a, _b) = (0u8, 'x');
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized")]
+ except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_name_in_pattern() {
let (_a, _c) = (1u8, 'y');
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+ except="HirBody,TypeckTables,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn add_ref_in_pattern() {
let (ref _a, _b) = (1u8, 'y');
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+ except="HirBody,TypeckTables,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn add_amp_in_pattern() {
let (&_a, _b) = (&1u8, 'y');
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+ except="HirBody,TypeckTables,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_mutability_of_binding_in_pattern() {
let (mut _a, _b) = (99u8, 'q');
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+ except="HirBody,TypeckTables,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn add_initializer() {
let _x: i16 = 3i16;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized")]
+ except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_initializer() {
let _x = 5u16;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_loop_body() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_break() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_break_label() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_continue_label() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_continue_to_break() {
let mut _x = 0;
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+ except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_arm(x: u32) -> u32 {
match x {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized")]
+ except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_order_of_arms(x: u32) -> u32 {
match x {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+ except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_guard_clause(x: u32, y: bool) -> u32 {
match x {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+ except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_guard_clause(x: u32, y: bool) -> u32 {
match x {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+ except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_at_binding(x: u32) -> u32 {
match x {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized")]
+ except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_name_of_at_binding(x: u32) -> u32 {
match x {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+ except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_simple_name_to_pattern(x: u32) -> u32 {
match (x, x & 1) {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized")]
+ except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_name_in_pattern(x: u32) -> u32 {
match (x, x & 1) {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+ except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_mutability_of_binding_in_pattern(x: u32) -> u32 {
match (x, x & 1) {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+ except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_ref_to_binding_in_pattern(x: u32) -> u32 {
match (x, x & 1) {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
-except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_amp_to_binding_in_pattern(x: u32) -> u32 {
match (&x, x & 1) {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized")]
+ except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_rhs_of_arm(x: u32) -> u32 {
match x {
#[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2",
- except="HirBody,MirValidated,MirOptimized,TypeckTables")]
+ except="HirBody,MirBuilt,MirOptimized,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_alternative_to_arm(x: u32) -> u32 {
match x {
// Indexing expression ---------------------------------------------------------
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn indexing(slice: &[u8]) -> u8 {
#[cfg(cfail1)]
// Arithmetic overflow plus ----------------------------------------------------
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn arithmetic_overflow_plus(val: i32) -> i32 {
#[cfg(cfail1)]
// Arithmetic overflow minus ----------------------------------------------------
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn arithmetic_overflow_minus(val: i32) -> i32 {
#[cfg(cfail1)]
// Arithmetic overflow mult ----------------------------------------------------
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn arithmetic_overflow_mult(val: i32) -> i32 {
#[cfg(cfail1)]
// Arithmetic overflow negation ------------------------------------------------
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn arithmetic_overflow_negation(val: i32) -> i32 {
#[cfg(cfail1)]
// Division by zero ------------------------------------------------------------
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn division_by_zero(val: i32) -> i32 {
#[cfg(cfail1)]
}
// Division by zero ------------------------------------------------------------
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn mod_by_zero(val: i32) -> i32 {
#[cfg(cfail1)]
// shift left ------------------------------------------------------------------
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn shift_left(val: i32, shift: usize) -> i32 {
#[cfg(cfail1)]
// shift right ------------------------------------------------------------------
-#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn shift_right(val: i32, shift: usize) -> i32 {
#[cfg(cfail1)]
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn change_field_value_regular_struct() -> RegularStruct {
RegularStruct {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_field_regular_struct() -> RegularStruct {
let struct1 = RegularStruct {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_field_label_regular_struct() -> RegularStruct {
let struct1 = RegularStruct {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_constructor_path_regular_struct() {
let _ = RegularStruct2 {
#[rustc_clean(
cfg="cfail2",
- except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,TypeckTables"
+ except="FnSignature,Hir,HirBody,MirOptimized,MirBuilt,TypeckTables"
)]
#[rustc_clean(cfg="cfail3")]
pub fn function() -> Struct {
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn change_field_value_tuple_struct() -> TupleStruct {
TupleStruct(0, 1, 3)
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_constructor_path_tuple_struct() {
let _ = TupleStruct2(0, 1, 2);
#[rustc_clean(
cfg="cfail2",
- except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,TypeckTables"
+ except="FnSignature,Hir,HirBody,MirOptimized,MirBuilt,TypeckTables"
)]
#[rustc_clean(cfg="cfail3")]
pub fn function() -> Struct {
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn const_negation() -> i32 {
-1
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn const_bitwise_not() -> i32 {
!99
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn var_negation(x: i32, y: i32) -> i32 {
-y
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn var_bitwise_not(x: i32, y: i32) -> i32 {
!y
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated,TypeckTables", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt,TypeckTables", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn var_deref(x: &i32, y: &i32) -> i32 {
*y
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn first_const_add() -> i32 {
2 + 3
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn second_const_add() -> i32 {
1 + 3
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn first_var_add(a: i32, b: i32) -> i32 {
b + 2
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn second_var_add(a: i32, b: i32) -> i32 {
1 + b
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn plus_to_minus(a: i32) -> i32 {
1 - a
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn plus_to_mult(a: i32) -> i32 {
1 * a
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn plus_to_div(a: i32) -> i32 {
1 / a
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn plus_to_mod(a: i32) -> i32 {
1 % a
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn and_to_or(a: bool, b: bool) -> bool {
a || b
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn bitwise_and_to_bitwise_or(a: i32) -> i32 {
1 | a
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn bitwise_and_to_bitwise_xor(a: i32) -> i32 {
1 ^ a
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn bitwise_and_to_lshift(a: i32) -> i32 {
a << 1
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn bitwise_and_to_rshift(a: i32) -> i32 {
a >> 1
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn eq_to_uneq(a: i32) -> bool {
a != 1
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn eq_to_lt(a: i32) -> bool {
a < 1
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn eq_to_gt(a: i32) -> bool {
a > 1
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn eq_to_le(a: i32) -> bool {
a <= 1
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn eq_to_ge(a: i32) -> bool {
a >= 1
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated,TypeckTables", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt,TypeckTables", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn type_cast(a: u8) -> u64 {
let b = a as u32;
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn value_cast(a: u32) -> i32 {
2 as i32
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn place() -> i32 {
let mut x = 10;
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn rvalue() -> i32 {
let mut x = 10;
}
#[cfg(not(cfail1))]
-#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
+#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
pub fn index_to_slice(s: &[u8], i: usize, j: usize) -> u8 {
s[j]
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_loop_body() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_loop_condition() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_break() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_break_label() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn change_continue_label() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_continue_to_break() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_loop_body() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_loop_condition() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")]
#[rustc_clean(cfg="cfail3")]
pub fn add_break() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_break_label() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt")]
#[rustc_clean(cfg="cfail3")]
pub fn change_continue_label() {
let mut _x = 0;
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")]
+#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")]
#[rustc_clean(cfg="cfail3")]
pub fn change_continue_to_break() {
let mut _x = 0;
--- /dev/null
+// revisions: rpass cfail
+
+trait Tr {
+ type Arr;
+
+ const C: usize = 0;
+}
+
+impl Tr for str {
+ #[cfg(rpass)]
+ type Arr = [u8; 8];
+ #[cfg(cfail)]
+ type Arr = [u8; Self::C];
+ //[cfail]~^ ERROR cycle detected when const-evaluating
+}
+
+fn main() {}
--- /dev/null
+// no-prefer-dynamic
+// revisions:rpass1 rpass2
+// compile-flags: -C lto
+
+mod x {
+ pub struct X {
+ x: u32, y: u32,
+ }
+
+ #[cfg(rpass1)]
+ fn make() -> X {
+ X { x: 22, y: 0 }
+ }
+
+ #[cfg(rpass2)]
+ fn make() -> X {
+ X { x: 11, y: 11 }
+ }
+
+ pub fn new() -> X {
+ make()
+ }
+
+ pub fn sum(x: &X) -> u32 {
+ x.x + x.y
+ }
+}
+
+mod y {
+ use x;
+
+ pub fn assert_sum() -> bool {
+ let x = x::new();
+ x::sum(&x) == 22
+ }
+}
+
+pub fn main() {
+ y::assert_sum();
+}
--- /dev/null
+// Test that we don't ICE when trying to dump MIR for unusual item types and
+// that we don't create filenames containing `<` and `>`
+
+struct A;
+
+impl A {
+ const ASSOCIATED_CONSTANT: i32 = 2;
+}
+
+enum E {
+ V = 5,
+}
+
+fn main() {
+ let v = Vec::<i32>::new();
+}
+
+// END RUST SOURCE
+
+// START rustc.{{impl}}-ASSOCIATED_CONSTANT.mir_map.0.mir
+// bb0: {
+// _0 = const 2i32;
+// return;
+// }
+// bb1: {
+// resume;
+// }
+// END rustc.{{impl}}-ASSOCIATED_CONSTANT.mir_map.0.mir
+
+// START rustc.E-V-{{constant}}.mir_map.0.mir
+// bb0: {
+// _0 = const 5isize;
+// return;
+// }
+// bb1: {
+// resume;
+// }
+// END rustc.E-V-{{constant}}.mir_map.0.mir
+
+// START rustc.ptr-real_drop_in_place.std__vec__Vec_i32_.AddMovesForPackedDrops.before.mir
+// bb0: {
+// goto -> bb7;
+// }
+// bb1: {
+// return;
+// }
+// bb2: {
+// resume;
+// }
+// bb3: {
+// goto -> bb1;
+// }
+// bb4: {
+// goto -> bb2;
+// }
+// bb5: {
+// drop(((*_1).0: alloc::raw_vec::RawVec<i32>)) -> bb4;
+// }
+// bb6: {
+// drop(((*_1).0: alloc::raw_vec::RawVec<i32>)) -> [return: bb3, unwind: bb4];
+// }
+// bb7: {
+// _2 = &mut (*_1);
+// _3 = const std::ops::Drop::drop(move _2) -> [return: bb6, unwind: bb5];
+// }
+// END rustc.ptr-real_drop_in_place.std__vec__Vec_i32_.AddMovesForPackedDrops.before.mir
-include ../tools.mk
+# ignore-macos
+#
# This hits an assertion in the linker on older versions of osx apparently
-ifeq ($(shell uname),Darwin)
-all:
- echo ignored
-else
+
all: $(call DYLIB,cfoo)
$(RUSTC) foo.rs -C prefer-dynamic
$(RUSTC) bar.rs
$(call RUN,bar)
$(call REMOVE_DYLIBS,cfoo)
$(call FAIL,bar)
-endif
-include ../tools.mk
+# ignore-macos
+#
+# This hits an assertion in the linker on older versions of osx apparently
+
# This overrides the LD_LIBRARY_PATH for RUN
TARGET_RPATH_DIR:=$(TARGET_RPATH_DIR):$(TMPDIR)
-# This hits an assertion in the linker on older versions of osx apparently
-ifeq ($(shell uname),Darwin)
-all:
- echo ignored
-else
all: $(call DYLIB,cfoo)
$(RUSTC) foo.rs
$(RUSTC) bar.rs
$(call RUN,bar)
$(call REMOVE_DYLIBS,cfoo)
$(call FAIL,bar)
-endif
-include ../tools.mk
-# FIXME: ignore freebsd
-ifneq ($(shell uname),FreeBSD)
+# ignore-freebsd
+# FIXME
+
all:
$(RUSTC) foo.rs
$(CC) bar.c $(call STATICLIB,foo) $(call OUT_EXE,bar) \
$(call RUN,bar)
rm $(call STATICLIB,foo)
$(call RUN,bar)
-
-else
-all:
-
-endif
-include ../tools.mk
+# ignore-windows
# FIXME: The __rdl_ and __rust_ symbol still remains, no matter using MSVC or GNU
# See https://github.com/rust-lang/rust/pull/46207#issuecomment-347561753
-ifdef IS_WINDOWS
-all:
- true
-else
+
all:
$(RUSTC) foo.rs
nm -g "$(call DYLIB,foo)" | $(CGREP) -v __rdl_ __rde_ __rg_ __rust_
-endif
-include ../tools.mk
-ifneq (,$(findstring MINGW,$(UNAME)))
-ifndef IS_MSVC
+# only-mingw
+
all:
$(CXX) foo.cpp -c -o $(TMPDIR)/foo.o
$(AR) crus $(TMPDIR)/libfoo.a $(TMPDIR)/foo.o
$(RUSTC) foo.rs -lfoo -lstdc++
$(call RUN,foo)
-else
-all:
-
-endif
-else
-all:
-
-endif
all: cpp-executable rust-executable
cpp-executable:
- $(RUSTC) -Zcross-lang-lto=on -o $(TMPDIR)/librustlib-xlto.a -Copt-level=2 -Ccodegen-units=1 ./rustlib.rs
+ $(RUSTC) -Clinker-plugin-lto=on -o $(TMPDIR)/librustlib-xlto.a -Copt-level=2 -Ccodegen-units=1 ./rustlib.rs
$(CLANG) -flto=thin -fuse-ld=lld -L $(TMPDIR) -lrustlib-xlto -o $(TMPDIR)/cmain ./cmain.c -O3
# Make sure we don't find a call instruction to the function we expect to
# always be inlined.
rust-executable:
$(CLANG) ./clib.c -flto=thin -c -o $(TMPDIR)/clib.o -O2
(cd $(TMPDIR); $(AR) crus ./libxyz.a ./clib.o)
- $(RUSTC) -Zcross-lang-lto=on -L$(TMPDIR) -Copt-level=2 -Clinker=$(CLANG) -Clink-arg=-fuse-ld=lld ./main.rs -o $(TMPDIR)/rsmain
+ $(RUSTC) -Clinker-plugin-lto=on -L$(TMPDIR) -Copt-level=2 -Clinker=$(CLANG) -Clink-arg=-fuse-ld=lld ./main.rs -o $(TMPDIR)/rsmain
llvm-objdump -d $(TMPDIR)/rsmain | $(CGREP) -e "call.*c_never_inlined"
llvm-objdump -d $(TMPDIR)/rsmain | $(CGREP) -v -e "call.*c_always_inlined"
ifndef IS_WINDOWS
# This test makes sure that we don't loose upstream object files when compiling
-# staticlibs with -Zcross-lang-lto
+# staticlibs with -C linker-plugin-lto
all: staticlib.rs upstream.rs
- $(RUSTC) upstream.rs -Z cross-lang-lto -Ccodegen-units=1
+ $(RUSTC) upstream.rs -C linker-plugin-lto -Ccodegen-units=1
# Check No LTO
- $(RUSTC) staticlib.rs -Z cross-lang-lto -Ccodegen-units=1 -L. -o $(TMPDIR)/staticlib.a
+ $(RUSTC) staticlib.rs -C linker-plugin-lto -Ccodegen-units=1 -L. -o $(TMPDIR)/staticlib.a
(cd $(TMPDIR); $(LD_LIB_PATH_ENVVAR)=$(REAL_LD_LIBRARY_PATH) llvm-ar x ./staticlib.a)
# Make sure the upstream object file was included
ls $(TMPDIR)/upstream.*.rcgu.o
rm $(TMPDIR)/*
# Check ThinLTO
- $(RUSTC) upstream.rs -Z cross-lang-lto -Ccodegen-units=1 -Clto=thin
- $(RUSTC) staticlib.rs -Z cross-lang-lto -Ccodegen-units=1 -Clto=thin -L. -o $(TMPDIR)/staticlib.a
+ $(RUSTC) upstream.rs -C linker-plugin-lto -Ccodegen-units=1 -Clto=thin
+ $(RUSTC) staticlib.rs -C linker-plugin-lto -Ccodegen-units=1 -Clto=thin -L. -o $(TMPDIR)/staticlib.a
(cd $(TMPDIR); $(LD_LIB_PATH_ENVVAR)=$(REAL_LD_LIBRARY_PATH) llvm-ar x ./staticlib.a)
ls $(TMPDIR)/upstream.*.rcgu.o
# This test makes sure that the object files we generate are actually
# LLVM bitcode files (as used by linker LTO plugins) when compiling with
-# -Z cross-lang-lto.
+# -Clinker-plugin-lto.
# this only succeeds for bitcode files
ASSERT_IS_BITCODE_OBJ=($(LD_LIB_PATH_ENVVAR)=$(REAL_LD_LIBRARY_PATH) llvm-bcanalyzer $(1))
EXTRACT_OBJS=(cd $(TMPDIR); rm -f ./*.o; $(LD_LIB_PATH_ENVVAR)=$(REAL_LD_LIBRARY_PATH) llvm-ar x $(1))
-BUILD_LIB=$(RUSTC) lib.rs -Copt-level=2 -Z cross-lang-lto=on -Ccodegen-units=1
-BUILD_EXE=$(RUSTC) main.rs -Copt-level=2 -Z cross-lang-lto=on -Ccodegen-units=1 --emit=obj
+BUILD_LIB=$(RUSTC) lib.rs -Copt-level=2 -Clinker-plugin-lto -Ccodegen-units=1
+BUILD_EXE=$(RUSTC) main.rs -Copt-level=2 -Clinker-plugin-lto -Ccodegen-units=1 --emit=obj
all: staticlib staticlib-fat-lto staticlib-thin-lto rlib exe cdylib rdylib
-include ../tools.mk
-# FIXME: ignore freebsd/windows
-# (windows: see `../dep-info/Makefile`)
-ifneq ($(shell uname),FreeBSD)
-ifndef IS_WINDOWS
+# ignore-windows
+# ignore-freebsd
+# FIXME: (windows: see `../dep-info/Makefile`)
+
all:
cp lib.rs $(TMPDIR)/
cp 'foo foo.rs' $(TMPDIR)/
pwd
$(MAKE) -drf Makefile.foo
rm $(TMPDIR)/done && exit 1 || exit 0
-else
-all:
-
-endif
-
-else
-all:
-
-endif
-include ../tools.mk
-# FIXME: ignore freebsd/windows
-# on windows `rustc --dep-info` produces Makefile dependency with
+# ignore-windows
+# ignore-freebsd
+# FIXME: on windows `rustc --dep-info` produces Makefile dependency with
# windows native paths (e.g. `c:\path\to\libfoo.a`)
# but msys make seems to fail to recognize such paths, so test fails.
-ifneq ($(shell uname),FreeBSD)
-ifndef IS_WINDOWS
+
all:
cp *.rs $(TMPDIR)
$(RUSTC) --emit dep-info,link --crate-type=lib $(TMPDIR)/lib.rs
rm $(TMPDIR)/bar.rs
cp $(TMPDIR)/lib2.rs $(TMPDIR)/lib.rs
$(MAKE) -drf Makefile.foo
-else
-all:
-
-endif
-
-else
-all:
-
-endif
-include ../tools.mk
+# ignore-windows
+# ignore-macos
+# min-llvm-version 6.0
+#
# This feature only works when the output object format is ELF so we ignore
# macOS and Windows
-ifdef IS_WINDOWS
-# Do nothing on Windows.
-all:
- exit 0
-else ifneq (,$(filter $(TARGET),i686-apple-darwin x86_64-apple-darwin))
-# Do nothing on macOS.
-all:
- exit 0
-else
+
# check that the .stack_sizes section is generated
-# this test requires LLVM >= 6.0.0
-vers = $(shell $(RUSTC) -Vv)
-ifneq (,$(findstring LLVM version: 3,$(vers)))
-all:
- exit 0
-else ifneq (,$(findstring LLVM version: 4,$(vers)))
-all:
- exit 0
-else ifneq (,$(findstring LLVM version: 5,$(vers)))
-all:
- exit 0
-else
all:
$(RUSTC) -C opt-level=3 -Z emit-stack-sizes --emit=obj foo.rs
size -A $(TMPDIR)/foo.o | $(CGREP) .stack_sizes
-endif
-endif
-include ../tools.mk
+# ignore-windows
+# ignore-macos
+
# Test for #39529.
# `-z text` causes ld to error if there are any non-PIC sections
-ifeq ($(UNAME),Darwin)
-all:
-else ifdef IS_WINDOWS
-all:
-else
all:
$(RUSTC) hello.rs -C link-args=-Wl,-z,text
-endif
-include ../tools.mk
-# FIXME: ignore freebsd/windows
-# on windows `rustc --dep-info` produces Makefile dependency with
+# ignore-windows
+# ignore-freebsd
+# FIXME: on windows `rustc --dep-info` produces Makefile dependency with
# windows native paths (e.g. `c:\path\to\libfoo.a`)
# but msys make seems to fail to recognize such paths, so test fails.
-ifneq ($(shell uname),FreeBSD)
-ifndef IS_WINDOWS
+
all:
$(RUSTC) --emit dep-info main.rs
$(CGREP) "input.txt" "input.bin" "input.md" < $(TMPDIR)/main.d
-else
-all:
-
-endif
-
-else
-all:
-
-endif
-include ../tools.mk
-ifndef IS_WINDOWS
-# The assembly for exit-unreachable.rs should be shorter because it's missing
-# (at minimum) a return instruction.
+# ignore-windows
+#
+# Because of Windows exception handling, the code is not necessarily any shorter.
+# https://github.com/llvm-mirror/llvm/commit/64b2297786f7fd6f5fa24cdd4db0298fbf211466
all:
$(RUSTC) -O --emit asm exit-ret.rs
$(RUSTC) -O --emit asm exit-unreachable.rs
test `wc -l < $(TMPDIR)/exit-unreachable.s` -lt `wc -l < $(TMPDIR)/exit-ret.s`
-else
-# Because of Windows exception handling, the code is not necessarily any shorter.
-# https://github.com/llvm-mirror/llvm/commit/64b2297786f7fd6f5fa24cdd4db0298fbf211466
-all:
-endif
-include ../tools.mk
-ifeq ($(UNAME),Linux)
+# only-linux
+
all:
$(RUSTC) foo.rs
$(CC) foo.c -lfoo -L $(TMPDIR) -Wl,--gc-sections -lpthread -ldl -o $(TMPDIR)/foo
$(call RUN,foo)
$(CC) foo.c -lfoo -L $(TMPDIR) -Wl,--gc-sections -lpthread -ldl -pie -fPIC -o $(TMPDIR)/foo
$(call RUN,foo)
-else
-all:
-endif
-include ../tools.mk
+# ignore-windows
+
OUT := $(TMPDIR)/out
-ifndef IS_WINDOWS
all: time
time: libc
libc:
mkdir -p $(OUT)/libc
$(RUSTC) in/libc/lib.rs --crate-name=libc -Cmetadata=foo -o $(OUT)/libc/liblibc.rlib
-else
-all:
-endif
-include ../tools.mk
-ifeq (musl,$(findstring musl,$(TARGET)))
-all: skip
-else
-all: test
-endif
+# ignore-musl
-test: foo
+all: foo
$(call RUN,foo)
-skip:
- echo "expected failure"
-
foo: foo.rs $(call NATIVE_STATICLIB,foo)
$(RUSTC) $< -lfoo $(EXTRACXXFLAGS)
$(TMPDIR)/libfoo.o: foo.cpp
$(call COMPILE_OBJ_CXX,$@,$<)
-
-.PHONY: all test skip
-include ../tools.mk
-ifeq ($(findstring stage1,$(RUST_BUILD_STAGE)),stage1)
-# ignore stage1
-all:
+# ignore-stage1
-else
all:
$(RUSTC) a.rs && $(RUSTC) b.rs
$(BARE_RUSTC) c.rs -L dependency=$(TMPDIR) --extern b=$(TMPDIR)/libb.rlib \
--out-dir=$(TMPDIR)
-endif
-include ../tools.mk
-ifeq ($(findstring stage1,$(RUST_BUILD_STAGE)),stage1)
-# ignore stage1
-all:
+# ignore-stage1
-else
all:
$(RUSTC) a.rs && $(RUSTC) b.rs && $(RUSTC) c.rs
-endif
-include ../tools.mk
-ifdef IS_WINDOWS
-# Do nothing on MSVC.
-all:
- exit 0
-else
+# ignore-windows
+
all:
$(RUSTC) --emit=obj app.rs
nm $(TMPDIR)/app.o | $(CGREP) rust_begin_unwind
nm $(TMPDIR)/app.o | $(CGREP) rust_eh_personality
nm $(TMPDIR)/app.o | $(CGREP) rust_oom
-endif
-include ../tools.mk
-ifeq ($(if $(IS_WINDOWS),$(IS_MSVC),no),)
+# only-mingw
all: empty.rs
cp -r $(shell cygpath -u $(shell $(RUSTC) --print sysroot)) $(TMPDIR)/sysroot
mkdir -p $(TMPDIR)/obj
mv $(TMPDIR)/sysroot/lib/rustlib/$(TARGET)/lib/crt2.o $(TMPDIR)/obj/crt2.o
$(RUSTC) --target $(TARGET) --sysroot $(TMPDIR)/sysroot -L$(TMPDIR)/obj -Z print-link-args empty.rs | $(CGREP) 'obj\\crt2.o'
-
-else
-
-all:
-
-endif
-include ../tools.mk
-ifdef IS_WINDOWS
-all:
-else
+# ignore-windows
NAME := $(shell $(RUSTC) --print file-names foo.rs)
$(RUSTC) foo.rs -o $(TMPDIR)/outdir/$(NAME)
ln -nsf outdir/$(NAME) $(TMPDIR)
RUST_LOG=rustc_metadata::loader $(RUSTC) bar.rs
-endif
# Make sure we don't ICE if the linker prints a non-UTF-8 error message.
-# Ignore Windows and Apple
-
+# ignore-windows
+#
# This does not work in its current form on windows, possibly due to
# gcc bugs or something about valid Windows paths. See issue #29151
# for more information.
-ifndef IS_WINDOWS
+# ignore-macos
+#
# This also does not work on Apple APFS due to the filesystem requiring
# valid UTF-8 paths.
-ifneq ($(shell uname),Darwin)
# The zzz it to allow humans to tab complete or glob this thing.
bad_dir := $(TMPDIR)/zzz$$'\xff'
mkdir $(bad_dir)
mv $(TMPDIR)/liblibrary.a $(bad_dir)
LIBRARY_PATH=$(bad_dir) $(RUSTC) exec.rs 2>&1 | $(CGREP) this_symbol_not_defined
-else
-all:
-
-endif
-
-else
-all:
-
-endif
-include ../tools.mk
+# only-linux
+
# This tests ensure that global variables respect the target minimum alignment.
# The three bools `STATIC_BOOL`, `STATIC_MUT_BOOL`, and `CONST_BOOL` all have
# type-alignment of 1, but some targets require greater global alignment.
LL = $(TMPDIR)/min_global_align.ll
all:
-ifeq ($(UNAME),Linux)
# Most targets are happy with default alignment -- take i686 for example.
ifeq ($(filter x86,$(LLVM_COMPONENTS)),x86)
$(RUSTC) --target=i686-unknown-linux-gnu --emit=llvm-ir $(SRC)
$(RUSTC) --target=s390x-unknown-linux-gnu --emit=llvm-ir $(SRC)
[ "$$(grep -c 'align 2' "$(LL)")" -eq "3" ]
endif
-endif
-include ../tools.mk
+# only-linux
+# only-x86_64
+
all:
-ifeq ($(TARGET),x86_64-unknown-linux-gnu)
$(RUSTC) hello.rs -C no_integrated_as
$(call RUN,hello)
-endif
-include ../tools.mk
+# ignore-windows
+
all:
ifeq ($(PROFILER_SUPPORT),1)
-ifndef IS_WINDOWS
$(RUSTC) -Copt-level=3 -Clto=fat -Z pgo-gen="$(TMPDIR)/test.profraw" test.rs
$(call RUN,test) || exit 1
[ -e "$(TMPDIR)/test.profraw" ] || (echo "No .profraw file"; exit 1)
endif
-endif
-include ../tools.mk
+# ignore-windows
+
all:
ifeq ($(PROFILER_SUPPORT),1)
-ifndef IS_WINDOWS
$(RUSTC) -g -Z pgo-gen="$(TMPDIR)/test.profraw" test.rs
$(call RUN,test) || exit 1
[ -e "$(TMPDIR)/test.profraw" ] || (echo "No .profraw file"; exit 1)
endif
-endif
-include ../tools.mk
-ifdef IS_WINDOWS
-# ignore windows
-RUSTC_FLAGS =
-else
+
+# ignore-windows
+
# Notice the space in the end, this emulates the output of pkg-config
RUSTC_FLAGS = -C link-args="-lc "
-endif
all:
$(RUSTC) $(RUSTC_FLAGS) empty.rs
-include ../tools.mk
+# only-linux
+#
# This tests the different -Zrelro-level values, and makes sure that they work properly.
all:
-ifeq ($(UNAME),Linux)
# Ensure that binaries built with the full relro level links them with both
# RELRO and BIND_NOW for doing eager symbol resolving.
$(RUSTC) -Zrelro-level=full hello.rs
# enabled by default.
$(RUSTC) -Zrelro-level=off hello.rs
! readelf -l $(TMPDIR)/hello | grep -q GNU_RELRO
-endif
# while generating files. Ideally this would be a rustdoc-ui test, so we could
# verify the error message as well.
-OUTPUT_DIR := "$(TMPDIR)/rustdoc-io-error"
+# ignore-windows
+# The test uses `chmod`.
-# Ignore Windows: the test uses `chmod`.
-ifndef IS_WINDOWS
+OUTPUT_DIR := "$(TMPDIR)/rustdoc-io-error"
# This test operates by creating a temporary directory and modifying its
# permissions so that it is not writable. We have to take special care to set
-$(shell $(RUSTDOC) -o $(OUTPUT_DIR) foo.rs)
chmod u+w $(OUTPUT_DIR)
exit $($(.SHELLSTATUS) -eq 1)
-
-else
-all:
-
-endif
-include ../tools.mk
+# only-linux
+# only-x86_64
+# ignore-test
# FIXME(#46126) ThinLTO for libstd broke this test
-ifeq (1,0)
+
all:
-ifeq ($(TARGET),x86_64-unknown-linux-gnu)
ifdef SANITIZER_SUPPORT
$(RUSTC) -C opt-level=1 -g -Z sanitizer=leak -Z print-link-args leak.rs | $(CGREP) librustc_lsan
$(TMPDIR)/leak 2>&1 | $(CGREP) 'detected memory leaks'
endif
-endif
-
-else
-all:
-endif
-
-include ../tools.mk
+# only-linux
+# only-x86_64
+
all:
-ifeq ($(TARGET),x86_64-unknown-linux-gnu)
ifdef SANITIZER_SUPPORT
$(RUSTC) -g -Z sanitizer=memory -Z print-link-args uninit.rs | $(CGREP) librustc_msan
$(TMPDIR)/uninit 2>&1 | $(CGREP) use-of-uninitialized-value
endif
-endif
-
include ../tools.mk
-ifdef IS_WINDOWS
-# Do nothing on MSVC.
+# ignore-windows
+#
# On MINGW the --version-script, --dynamic-list, and --retain-symbol args don't
# seem to work reliably.
-all:
- exit 0
-else
NM=nm -D
CDYLIB_NAME=liba_cdylib.so
# Check that an executable does not export any dynamic symbols
[ "$$($(NM) $(TMPDIR)/$(EXE_NAME) | grep -c public_c_function_from_rlib)" -eq "0" ]
[ "$$($(NM) $(TMPDIR)/$(EXE_NAME) | grep -c public_rust_function_from_exe)" -eq "0" ]
-endif
-include ../tools.mk
-# ignore windows: `ln` is actually `cp` on msys.
-ifndef IS_WINDOWS
+# ignore-windows
+# `ln` is actually `cp` on msys.
all:
$(RUSTC) foo.rs
ln -nsf $(TMPDIR)/libfoo.rlib $(TMPDIR)/other
$(RUSTC) bar.rs -L $(TMPDIR)
$(RUSTC) baz.rs --extern foo=$(TMPDIR)/other/libfoo.rlib -L $(TMPDIR)
-
-else
-all:
-
-endif
-include ../tools.mk
-# ignore windows: `ln` is actually `cp` on msys.
-ifndef IS_WINDOWS
+# ignore-windows
+# `ln` is actually `cp` on msys.
all:
$(RUSTC) foo.rs -C prefer-dynamic
mkdir -p $(TMPDIR)/other
ln -nsf $(TMPDIR)/$(call DYLIB_GLOB,foo) $(TMPDIR)/other
$(RUSTC) bar.rs -L $(TMPDIR)/other
-
-else
-all:
-
-endif
-include ../tools.mk
-# ignore windows: `ln` is actually `cp` on msys.
-ifndef IS_WINDOWS
+# ignore-windows
+# `ln` is actually `cp` on msys.
all:
$(RUSTC) foo.rs --crate-type=rlib -o $(TMPDIR)/foo.xxx
ln -nsf $(TMPDIR)/foo.xxx $(TMPDIR)/libfoo.rlib
$(RUSTC) bar.rs -L $(TMPDIR)
-
-else
-all:
-
-endif
-include ../tools.mk
+# only-linux
+# only-x86_64
+#
# I *really* don't want to deal with a cross-platform way to compare file sizes,
# tests in `make` sort of are awful
-ifeq ($(TARGET),x86_64-unknown-linux-gnu)
+
all: $(TMPDIR)/out.log
# Make sure no warnings about "unknown CPU `native`" were emitted
if [ "$$(wc -c $(TMPDIR)/out.log | cut -d' ' -f 1)" = "0" ]; then \
else \
exit 1; \
fi
-else
-all: $(TMPDIR)/out.log
-endif
$(TMPDIR)/out.log:
-include ../tools.mk
-SKIP_OS := 'FreeBSD OpenBSD Bitrig SunOS'
-
-ifneq ($(UNAME),$(findstring $(UNAME),$(SKIP_OS)))
+# ignore-freebsd
+# ignore-openbsd
+# ignore-bitrig
+# ignore-sunos
HOST := $(shell $(RUSTC) -vV | grep 'host:' | sed 's/host: //')
ifeq ($(findstring i686,$(HOST)),i686)
$(RUSTC) foo.rs -C extra-filename=-host
$(RUSTC) bar.rs -C extra-filename=-targ --target $(TARGET)
$(RUSTC) baz.rs --extern a=$(TMPDIR)/liba-targ.rlib --target $(TARGET)
-else
-# FreeBSD, OpenBSD, and Bitrig support only x86_64 architecture for now
-all:
-endif
-include ../tools.mk
-ifdef IS_WINDOWS
-# Do nothing on MSVC.
-all:
- exit 0
-else
+# ignore-windows
+
all:
$(RUSTC) -C opt-level=3 --emit=obj used.rs
nm $(TMPDIR)/used.o | $(CGREP) FOO
-endif
-include ../tools.mk
-ifdef IS_WINDOWS
+# only-windows
all:
$(RUSTC) -o "$(TMPDIR)/hopefullydoesntexist bar.exe" hello.rs
$(RUSTC) spawn.rs
$(TMPDIR)/spawn.exe
-
-else
-
-all:
-
-endif
# - thumbv7em-none-eabihf (Bare Cortex-M4F, M7F, FPU, hardfloat)
# - thumbv7m-none-eabi (Bare Cortex-M3)
-# See https://stackoverflow.com/questions/7656425/makefile-ifeq-logical-or
-ifneq (,$(filter $(TARGET),thumbv6m-none-eabi thumbv7em-none-eabi thumbv7em-none-eabihf thumbv7m-none-eabi))
+# only-thumbv6m-none-eabi
+# only-thumbv7em-none-eabi
+# only-thumbv7em-none-eabihf
+# only-thumbv7m-none-eabi
# For cargo setting
RUSTC := $(RUSTC_ORIGINAL)
# These come from the top-level Rust workspace, that this crate is not a
# member of, but Cargo tries to load the workspace `Cargo.toml` anyway.
cd $(WORK_DIR) && cd $(CRATE) && env RUSTC_BOOTSTRAP=1 $(CARGO) build --target $(TARGET) -v
-else
-
-all:
-
-endif
-include ../../run-make-fulldeps/tools.mk
+# only-thumbv7m-none-eabi
+# only-thumbv6m-none-eabi
+
# How to run this
# $ ./x.py clean
# $ ./x.py test --target thumbv7m-none-eabi src/test/run-make
-ifneq (,$(filter $(TARGET),thumbv6m-none-eabi thumbv7m-none-eabi))
-
# For cargo setting
export RUSTC := $(RUSTC_ORIGINAL)
export LD_LIBRARY_PATH := $(HOST_RPATH_DIR)
all:
bash script.sh
-else
-all:
-endif
-include ../../run-make-fulldeps/tools.mk
-ifeq ($(TARGET),wasm32-unknown-unknown)
+# only-wasm32
+
all:
$(RUSTC) foo.rs --target wasm32-unknown-unknown
$(RUSTC) bar.rs -C lto -O --target wasm32-unknown-unknown
$(NODE) foo.js $(TMPDIR)/bar.wasm
-else
-all:
-endif
-include ../../run-make-fulldeps/tools.mk
-ifeq ($(TARGET),wasm32-unknown-unknown)
+# only-wasm32
+
all:
$(RUSTC) foo.rs -O --target wasm32-unknown-unknown
$(NODE) foo.js $(TMPDIR)/foo.wasm
-else
-all:
-endif
-include ../../run-make-fulldeps/tools.mk
-ifeq ($(TARGET),wasm32-unknown-unknown)
+# only-wasm32
+
all:
$(RUSTC) bar.rs --target wasm32-unknown-unknown
$(RUSTC) foo.rs --target wasm32-unknown-unknown
$(NODE) verify.js $(TMPDIR)/foo.wasm
$(RUSTC) foo.rs --target wasm32-unknown-unknown -C lto
$(NODE) verify.js $(TMPDIR)/foo.wasm
-else
-all:
-endif
-
-include ../../run-make-fulldeps/tools.mk
-ifeq ($(TARGET),wasm32-unknown-unknown)
+ # only-wasm32
+
all:
$(RUSTC) foo.rs --target wasm32-unknown-unknown
$(RUSTC) bar.rs -C lto -O --target wasm32-unknown-unknown
$(NODE) foo.js $(TMPDIR)/bar.wasm
-else
-all:
-endif
-include ../../run-make-fulldeps/tools.mk
-ifeq ($(TARGET),wasm32-unknown-unknown)
+# only-wasm32
+
all:
$(RUSTC) foo.rs -C lto -O --target wasm32-unknown-unknown --cfg a
wc -c < $(TMPDIR)/foo.wasm
$(RUSTC) foo.rs -C lto -O --target wasm32-unknown-unknown --cfg d
wc -c < $(TMPDIR)/foo.wasm
[ "`wc -c < $(TMPDIR)/foo.wasm`" -lt "5120" ]
-else
-all:
-endif
-
--- /dev/null
+-include ../../run-make-fulldeps/tools.mk
+
+ifeq ($(TARGET),wasm32-unknown-unknown)
+all:
+ $(RUSTC) foo.rs -C lto -O --target wasm32-unknown-unknown
+ wc -c < $(TMPDIR)/foo.wasm
+ [ "`wc -c < $(TMPDIR)/foo.wasm`" -lt "20500" ]
+else
+all:
+endif
--- /dev/null
+#![crate_type = "cdylib"]
+
+extern "C" {
+ fn observe(ptr: *const u8, len: usize);
+}
+
+macro_rules! s {
+ ( $( $f:ident -> $t:ty );* $(;)* ) => {
+ $(
+ extern "C" {
+ fn $f() -> $t;
+ }
+ let s = $f().to_string();
+ observe(s.as_ptr(), s.len());
+ )*
+ };
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn foo() {
+ s! {
+ get_u8 -> u8;
+ get_i8 -> i8;
+ get_u16 -> u16;
+ get_i16 -> i16;
+ get_u32 -> u32;
+ get_i32 -> i32;
+ get_u64 -> u64;
+ get_i64 -> i64;
+ get_usize -> usize;
+ get_isize -> isize;
+ }
+}
-include ../../run-make-fulldeps/tools.mk
-ifeq ($(TARGET),wasm32-unknown-unknown)
+# only-wasm32
+
all:
$(RUSTC) foo.rs --target wasm32-unknown-unknown
$(NODE) verify-exported-symbols.js $(TMPDIR)/foo.wasm
$(NODE) verify-exported-symbols.js $(TMPDIR)/bar.wasm
$(RUSTC) bar.rs --target wasm32-unknown-unknown -O
$(NODE) verify-exported-symbols.js $(TMPDIR)/bar.wasm
-else
-all:
-endif
-
-include ../../run-make-fulldeps/tools.mk
-ifeq ($(TARGET),wasm32-unknown-unknown)
+# only-wasm32
+
all:
$(RUSTC) foo.rs --target wasm32-unknown-unknown
$(NODE) verify-no-imports.js $(TMPDIR)/foo.wasm
$(NODE) verify-no-imports.js $(TMPDIR)/foo.wasm
$(RUSTC) foo.rs --target wasm32-unknown-unknown -O -C lto
$(NODE) verify-no-imports.js $(TMPDIR)/foo.wasm
-else
-all:
-endif
-
NormalTT {
expander: Box::new(Expander { args: args, }),
def_info: None,
- allow_internal_unstable: false,
+ allow_internal_unstable: None,
allow_internal_unsafe: false,
local_inner_macros: false,
unstable_feature: None,
expr(ExprKind::Path(None, path))
}
-/// Iterate over exprs of depth up to `depth`. The goal is to explore all "interesting"
-/// combinations of expression nesting. For example, we explore combinations using `if`, but not
+/// Iterate over exprs of depth up to `depth`. The goal is to explore all "interesting"
+/// combinations of expression nesting. For example, we explore combinations using `if`, but not
/// `while` or `match`, since those should print and parse in much the same way as `if`.
fn iter_exprs(depth: usize, f: &mut FnMut(P<Expr>)) {
if depth == 0 {
// edition:2018
+// aux-build:arc_wake.rs
#![feature(arbitrary_self_types, async_await, await_macro, futures_api)]
+extern crate arc_wake;
+
use std::pin::Pin;
use std::future::Future;
use std::sync::{
atomic::{self, AtomicUsize},
};
use std::task::{
- LocalWaker, Poll, Wake,
- local_waker_from_nonlocal,
+ Poll, Waker,
};
+use arc_wake::ArcWake;
struct Counter {
wakes: AtomicUsize,
}
-impl Wake for Counter {
- fn wake(this: &Arc<Self>) {
- this.wakes.fetch_add(1, atomic::Ordering::SeqCst);
+impl ArcWake for Counter {
+ fn wake(arc_self: &Arc<Self>) {
+ arc_self.wakes.fetch_add(1, atomic::Ordering::SeqCst);
}
}
impl Future for WakeOnceThenComplete {
type Output = ();
- fn poll(mut self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<()> {
+ fn poll(mut self: Pin<&mut Self>, waker: &Waker) -> Poll<()> {
if self.0 {
Poll::Ready(())
} else {
- lw.wake();
+ waker.wake();
self.0 = true;
Poll::Pending
}
{
let mut fut = Box::pin(f(9));
let counter = Arc::new(Counter { wakes: AtomicUsize::new(0) });
- let waker = local_waker_from_nonlocal(counter.clone());
+ let waker = ArcWake::into_waker(counter.clone());
assert_eq!(0, counter.wakes.load(atomic::Ordering::SeqCst));
assert_eq!(Poll::Pending, fut.as_mut().poll(&waker));
assert_eq!(1, counter.wakes.load(atomic::Ordering::SeqCst));
--- /dev/null
+// edition:2018
+
+#![feature(arbitrary_self_types, futures_api)]
+
+use std::sync::Arc;
+use std::task::{
+ Poll, Waker, RawWaker, RawWakerVTable,
+};
+
+macro_rules! waker_vtable {
+ ($ty:ident) => {
+ &RawWakerVTable {
+ clone: clone_arc_raw::<$ty>,
+ drop: drop_arc_raw::<$ty>,
+ wake: wake_arc_raw::<$ty>,
+ }
+ };
+}
+
+pub trait ArcWake {
+ fn wake(arc_self: &Arc<Self>);
+
+ fn into_waker(wake: Arc<Self>) -> Waker where Self: Sized
+ {
+ let ptr = Arc::into_raw(wake) as *const();
+
+ unsafe {
+ Waker::new_unchecked(RawWaker::new(ptr, waker_vtable!(Self)))
+ }
+ }
+}
+
+unsafe fn increase_refcount<T: ArcWake>(data: *const()) {
+ // Retain Arc by creating a copy
+ let arc: Arc<T> = Arc::from_raw(data as *const T);
+ let arc_clone = arc.clone();
+ // Forget the Arcs again, so that the refcount isn't decrased
+ let _ = Arc::into_raw(arc);
+ let _ = Arc::into_raw(arc_clone);
+}
+
+unsafe fn clone_arc_raw<T: ArcWake>(data: *const()) -> RawWaker {
+ increase_refcount::<T>(data);
+ RawWaker::new(data, waker_vtable!(T))
+}
+
+unsafe fn drop_arc_raw<T: ArcWake>(data: *const()) {
+ // Drop Arc
+ let _: Arc<T> = Arc::from_raw(data as *const T);
+}
+
+unsafe fn wake_arc_raw<T: ArcWake>(data: *const()) {
+ let arc: Arc<T> = Arc::from_raw(data as *const T);
+ ArcWake::wake(&arc);
+ let _ = Arc::into_raw(arc);
+}
-//! This is a client of the `a` crate defined in "svn-a-base.rs". The
-//! rpass and cfail tests (such as "run-pass/svh-add-comment.rs") use
+//! This is a client of the `a` crate defined in `svn-a-base.rs`. The
+//! rpass and cfail tests (such as `run-pass/svh-add-comment.rs`) use
//! it by swapping in a different object code library crate built from
-//! some variant of "svn-a-base.rs", and then we are checking if the
+//! some variant of `svn-a-base.rs`, and then we are checking if the
//! compiler properly ignores or accepts the change, based on whether
//! the change could affect the downstream crate content or not
//! (#14132).
--- /dev/null
+// ignore-emscripten no i128 support
+#![feature(const_saturating_int_methods)]
+
+const INT_U32_NO: u32 = (42 as u32).saturating_add(2);
+const INT_U32: u32 = u32::max_value().saturating_add(1);
+const INT_U128: u128 = u128::max_value().saturating_add(1);
+const INT_I128: i128 = i128::max_value().saturating_add(1);
+const INT_I128_NEG: i128 = i128::min_value().saturating_add(-1);
+
+const INT_U32_NO_SUB: u32 = (42 as u32).saturating_sub(2);
+const INT_U32_SUB: u32 = (1 as u32).saturating_sub(2);
+const INT_I32_NO_SUB: i32 = (-42 as i32).saturating_sub(2);
+const INT_I32_NEG_SUB: i32 = i32::min_value().saturating_sub(1);
+const INT_I32_POS_SUB: i32 = i32::max_value().saturating_sub(-1);
+const INT_U128_SUB: u128 = (0 as u128).saturating_sub(1);
+const INT_I128_NEG_SUB: i128 = i128::min_value().saturating_sub(1);
+const INT_I128_POS_SUB: i128 = i128::max_value().saturating_sub(-1);
+
+fn main() {
+ assert_eq!(INT_U32_NO, 44);
+ assert_eq!(INT_U32, u32::max_value());
+ assert_eq!(INT_U128, u128::max_value());
+ assert_eq!(INT_I128, i128::max_value());
+ assert_eq!(INT_I128_NEG, i128::min_value());
+
+ assert_eq!(INT_U32_NO_SUB, 40);
+ assert_eq!(INT_U32_SUB, 0);
+ assert_eq!(INT_I32_NO_SUB, -44);
+ assert_eq!(INT_I32_NEG_SUB, i32::min_value());
+ assert_eq!(INT_I32_POS_SUB, i32::max_value());
+ assert_eq!(INT_U128_SUB, 0);
+ assert_eq!(INT_I128_NEG_SUB, i128::min_value());
+ assert_eq!(INT_I128_POS_SUB, i128::max_value());
+}
+// aux-build:arc_wake.rs
+
#![feature(arbitrary_self_types, futures_api)]
#![allow(unused)]
+extern crate arc_wake;
+
use std::future::Future;
use std::pin::Pin;
-use std::rc::Rc;
use std::sync::{
Arc,
atomic::{self, AtomicUsize},
};
use std::task::{
- Poll, Wake, Waker, LocalWaker,
- local_waker, local_waker_from_nonlocal,
+ Poll, Waker,
};
+use arc_wake::ArcWake;
struct Counter {
- local_wakes: AtomicUsize,
- nonlocal_wakes: AtomicUsize,
+ wakes: AtomicUsize,
}
-impl Wake for Counter {
- fn wake(this: &Arc<Self>) {
- this.nonlocal_wakes.fetch_add(1, atomic::Ordering::SeqCst);
- }
-
- unsafe fn wake_local(this: &Arc<Self>) {
- this.local_wakes.fetch_add(1, atomic::Ordering::SeqCst);
+impl ArcWake for Counter {
+ fn wake(arc_self: &Arc<Self>) {
+ arc_self.wakes.fetch_add(1, atomic::Ordering::SeqCst);
}
}
impl Future for MyFuture {
type Output = ();
- fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output> {
- // Wake once locally
- lw.wake();
- // Wake twice non-locally
- let waker = lw.clone().into_waker();
+ fn poll(self: Pin<&mut Self>, waker: &Waker) -> Poll<Self::Output> {
+ // Wake twice
waker.wake();
waker.wake();
Poll::Ready(())
}
}
-fn test_local_waker() {
+fn test_waker() {
let counter = Arc::new(Counter {
- local_wakes: AtomicUsize::new(0),
- nonlocal_wakes: AtomicUsize::new(0),
+ wakes: AtomicUsize::new(0),
});
- let waker = unsafe { local_waker(counter.clone()) };
- assert_eq!(Poll::Ready(()), Pin::new(&mut MyFuture).poll(&waker));
- assert_eq!(1, counter.local_wakes.load(atomic::Ordering::SeqCst));
- assert_eq!(2, counter.nonlocal_wakes.load(atomic::Ordering::SeqCst));
-}
+ let waker = ArcWake::into_waker(counter.clone());
+ assert_eq!(2, Arc::strong_count(&counter));
-fn test_local_as_nonlocal_waker() {
- let counter = Arc::new(Counter {
- local_wakes: AtomicUsize::new(0),
- nonlocal_wakes: AtomicUsize::new(0),
- });
- let waker: LocalWaker = local_waker_from_nonlocal(counter.clone());
assert_eq!(Poll::Ready(()), Pin::new(&mut MyFuture).poll(&waker));
- assert_eq!(0, counter.local_wakes.load(atomic::Ordering::SeqCst));
- assert_eq!(3, counter.nonlocal_wakes.load(atomic::Ordering::SeqCst));
+ assert_eq!(2, counter.wakes.load(atomic::Ordering::SeqCst));
+
+ drop(waker);
+ assert_eq!(1, Arc::strong_count(&counter));
}
fn main() {
- test_local_waker();
- test_local_as_nonlocal_waker();
+ test_waker();
}
/*
# Comparison of static arrays
-The expected behaviour would be that test==test1, therefore 'true'
+The expected behaviour would be that `test == test1`, therefore 'true'
would be printed, however the below prints false.
*/
}
-// FIXME #623 - these aren't supported yet
+// FIXME(#623): - these aren't supported yet
/*mod test_literals {
#![str = "s"]
#![char = 'c']
($b:block $t:ty) => {};
($b:block $s:stmt) => {};
($b:block $p:path) => {};
- ($b:block $b:block) => {};
+ ($b:block $c:block) => {};
($b:block $i:ident) => {};
($b:block $t:tt) => {};
($b:block $i:item) => {};
($i:ident $s:stmt) => {};
($i:ident $p:path) => {};
($i:ident $b:block) => {};
- ($i:ident $i:ident) => {};
+ ($i:ident $j:ident) => {};
($i:ident $t:tt) => {};
- ($i:ident $i:item) => {};
+ ($i:ident $j:item) => {};
($i:ident $m:meta) => {};
}
// FOLLOW(tt) = any token
($t:tt ident) => {};
($t:tt $p:pat) => {};
($t:tt $e:expr) => {};
- ($t:tt $t:ty) => {};
+ ($t:tt $v:ty) => {};
($t:tt $s:stmt) => {};
($t:tt $p:path) => {};
($t:tt $b:block) => {};
($t:tt $i:ident) => {};
- ($t:tt $t:tt) => {};
+ ($t:tt $v:tt) => {};
($t:tt $i:item) => {};
($t:tt $m:meta) => {};
}
($i:item $s:stmt) => {};
($i:item $p:path) => {};
($i:item $b:block) => {};
- ($i:item $i:ident) => {};
+ ($i:item $j:ident) => {};
($i:item $t:tt) => {};
- ($i:item $i:item) => {};
+ ($i:item $j:item) => {};
($i:item $m:meta) => {};
}
// FOLLOW(meta) = any token
($m:meta $i:ident) => {};
($m:meta $t:tt) => {};
($m:meta $i:item) => {};
- ($m:meta $m:meta) => {};
+ ($m:meta $n:meta) => {};
}
fn main() {}
--- /dev/null
+// Check that method matching does not make "guesses" depending on
+// Deref impls that don't eventually end up being picked.
+
+use std::ops::Deref;
+
+// An impl with less derefs will get called over an impl with more derefs,
+// so `(t: Foo<_>).my_fn()` will use `<Foo<u32> as MyTrait1>::my_fn(t)`,
+// and does *not* force the `_` to equal `()`, because the Deref impl
+// was *not* used.
+
+trait MyTrait1 {
+ fn my_fn(&self) {}
+}
+
+impl MyTrait1 for Foo<u32> {}
+
+struct Foo<T>(T);
+
+impl Deref for Foo<()> {
+ type Target = dyn MyTrait1 + 'static;
+ fn deref(&self) -> &(dyn MyTrait1 + 'static) {
+ panic!()
+ }
+}
+
+// ...but if there is no impl with less derefs, the "guess" will be
+// forced, so `(t: Bar<_>).my_fn2()` is `<dyn MyTrait2 as MyTrait2>::my_fn2(*t)`,
+// and because the deref impl is used, the `_` is forced to equal `u8`.
+
+trait MyTrait2 {
+ fn my_fn2(&self) {}
+}
+
+impl MyTrait2 for u32 {}
+struct Bar<T>(T, u32);
+impl Deref for Bar<u8> {
+ type Target = dyn MyTrait2 + 'static;
+ fn deref(&self) -> &(dyn MyTrait2 + 'static) {
+ &self.1
+ }
+}
+
+// actually invoke things
+
+fn main() {
+ let mut foo: Option<Foo<_>> = None;
+ let mut bar: Option<Bar<_>> = None;
+ let mut first_iter = true;
+ loop {
+ if !first_iter {
+ foo.as_ref().unwrap().my_fn();
+ bar.as_ref().unwrap().my_fn2();
+ break;
+ }
+ foo = Some(Foo(0));
+ bar = Some(Bar(Default::default(), 0));
+ first_iter = false;
+ }
+}
/*!
* On x86_64-linux-gnu and possibly other platforms, structs get 8-byte "preferred" alignment,
* but their "ABI" alignment (i.e., what actually matters for data layout) is the largest alignment
- * of any field. (Also, u64 has 8-byte ABI alignment; this is not always true).
+ * of any field. (Also, `u64` has 8-byte ABI alignment; this is not always true).
*
* On such platforms, if monomorphize uses the "preferred" alignment, then it will unify
* `A` and `B`, even though `S<A>` and `S<B>` have the field `t` at different offsets,
assert_eq!(black_box(tmp), Wrapping($ans));
}
- // FIXME(30524): Uncomment this test
+ // FIXME(30524): uncomment this test
/*
{
let mut tmp = Wrapping($initial);
assert_eq!(
panic::catch_unwind(|| {
- mem::MaybeUninit::<!>::uninitialized().into_inner()
+ mem::MaybeUninit::<!>::uninitialized().into_initialized()
}).err().and_then(|a| a.downcast_ref::<String>().map(|s| {
s == "Attempted to instantiate uninhabited type !"
})),
assert_eq!(
panic::catch_unwind(|| {
- mem::MaybeUninit::<Foo>::uninitialized().into_inner()
+ mem::MaybeUninit::<Foo>::uninitialized().into_initialized()
}).err().and_then(|a| a.downcast_ref::<String>().map(|s| {
s == "Attempted to instantiate uninhabited type Foo"
})),
assert_eq!(
panic::catch_unwind(|| {
- mem::MaybeUninit::<Bar>::uninitialized().into_inner()
+ mem::MaybeUninit::<Bar>::uninitialized().into_initialized()
}).err().and_then(|a| a.downcast_ref::<String>().map(|s| {
s == "Attempted to instantiate uninhabited type Bar"
})),
// pretty-expanded FIXME #23616
#![allow(warnings)]
-#![feature(iter_empty)]
-#![feature(iter_once)]
-#![feature(str_escape)]
use std::iter::{empty, once, repeat};
+++ /dev/null
-// exact-check
-
-const QUERY = 'waker_from';
-
-const EXPECTED = {
- 'others': [
- { 'path': 'std::task', 'name': 'local_waker_from_nonlocal' },
- { 'path': 'alloc::task', 'name': 'local_waker_from_nonlocal' },
- ],
-};
// edition:2018
-// compile-flags:-Z unstable-options
-
-// FIXME: once `--edition` is stable in rustdoc, remove that `compile-flags` directive
#![feature(async_await, futures_api)]
-// @has async_fn/struct.S.html
-// @has - '//code' 'pub async fn f()'
-pub struct S;
+// @has async_fn/fn.foo.html '//pre[@class="rust fn"]' 'pub async fn foo() -> Option<Foo>'
+pub async fn foo() -> Option<Foo> {
+ None
+}
+
+// @has async_fn/fn.bar.html '//pre[@class="rust fn"]' 'pub async fn bar(a: i32, b: i32) -> i32'
+pub async fn bar(a: i32, b: i32) -> i32 {
+ 0
+}
+
+// @has async_fn/fn.baz.html '//pre[@class="rust fn"]' 'pub async fn baz<T>(a: T) -> T'
+pub async fn baz<T>(a: T) -> T {
+ a
+}
+
+trait Bar {}
+
+impl Bar for () {}
+
+// @has async_fn/fn.quux.html '//pre[@class="rust fn"]' 'pub async fn quux() -> impl Bar'
+pub async fn quux() -> impl Bar {
+ ()
+}
+
+// @has async_fn/struct.Foo.html
+// @matches - '//code' 'pub async fn f\(\)$'
+pub struct Foo;
-impl S {
+impl Foo {
pub async fn f() {}
}
//! This crate exports a macro `enum_from_primitive!` that wraps an
//! `enum` declaration and automatically adds an implementation of
//! `num::FromPrimitive` (reexported here), to allow conversion from
-//! primitive integers to the enum. It therefore provides an
+//! primitive integers to the enum. It therefore provides an
//! alternative to the built-in `#[derive(FromPrimitive)]`, which
//! requires the unstable `std::num::FromPrimitive` and is disabled in
//! Rust 1.0.
#![feature(deprecated)]
+// @has deprecated_future/index.html '//*[@class="stab deprecated"]' \
+// 'Deprecated'
// @has deprecated_future/struct.S.html '//*[@class="stab deprecated"]' \
-// 'Deprecating in 99.99.99: effectively never'
+// 'Deprecated since 99.99.99: effectively never'
#[deprecated(since = "99.99.99", note = "effectively never")]
pub struct S;
// 'Deprecated$'
#[deprecated]
pub struct W;
+
+// @matches deprecated/struct.X.html '//*[@class="stab deprecated"]' \
+// 'Deprecated: shorthand reason$'
+#[deprecated = "shorthand reason"]
+pub struct X;
-/// Test | Table
+/// Tests | Table
/// ------|-------------
/// t = b | id = \|x\| x
pub struct Foo; // @has issue_27862/struct.Foo.html //td 'id = |x| x'
--- /dev/null
+#![feature(staged_api)]
+
+#![stable(feature = "rustc_deprecated-future-test", since = "1.0.0")]
+
+// @has rustc_deprecated_future/index.html '//*[@class="stab deprecated"]' \
+// 'Deprecation planned'
+// @has rustc_deprecated_future/struct.S.html '//*[@class="stab deprecated"]' \
+// 'Deprecating in 99.99.99: effectively never'
+#[rustc_deprecated(since = "99.99.99", reason = "effectively never")]
+#[stable(feature = "rustc_deprecated-future-test", since = "1.0.0")]
+pub struct S;
--- /dev/null
+#![feature(trait_alias)]
+
+#![crate_name = "foo"]
+
+use std::fmt::Debug;
+
+// @has foo/all.html '//a[@href="traitalias.CopyAlias.html"]' 'CopyAlias'
+// @has foo/all.html '//a[@href="traitalias.Alias2.html"]' 'Alias2'
+// @has foo/all.html '//a[@href="traitalias.Foo.html"]' 'Foo'
+
+// @has foo/index.html '//h2[@id="trait-aliases"]' 'Trait aliases'
+// @has foo/index.html '//a[@class="traitalias"]' 'CopyAlias'
+// @has foo/index.html '//a[@class="traitalias"]' 'Alias2'
+// @has foo/index.html '//a[@class="traitalias"]' 'Foo'
+
+// @has foo/traitalias.CopyAlias.html '//section[@id="main"]/pre' 'trait CopyAlias = Copy;'
+pub trait CopyAlias = Copy;
+// @has foo/traitalias.Alias2.html '//section[@id="main"]/pre' 'trait Alias2 = Copy + Debug;'
+pub trait Alias2 = Copy + Debug;
+// @has foo/traitalias.Foo.html '//section[@id="main"]/pre' 'trait Foo<T> = Into<T> + Debug;'
+pub trait Foo<T> = Into<T> + Debug;
pub trait ToOwned {
type Owned;
- /// Create owned data from borrowed data, usually by copying.
+ /// Creates owned data from borrowed data, usually by copying.
fn to_owned(&self) -> Self::Owned;
}
LL | | //~^ value used here after move
LL | | +=
LL | | x; //~ value moved here
- | | -
+ | | ^
| | |
| |_____move out of `x` occurs here
| borrow later used here
-error: heap allocations are not allowed in const fn
+error[E0723]: heap allocations are not allowed in const fn (see issue #57563)
--> $DIR/bad_const_fn_body_ice.rs:2:5
|
LL | vec![1, 2, 3] //~ ERROR heap allocations are not allowed in const fn
| ^^^^^^^^^^^^^
|
+ = help: add #![feature(const_fn)] to the crate attributes to enable
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0723`.
-error: unsizing casts are not allowed in const fn
+error[E0723]: unsizing casts are not allowed in const fn (see issue #57563)
--> $DIR/cast_errors.rs:3:41
|
LL | const fn unsize(x: &[u8; 3]) -> &[u8] { x }
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/cast_errors.rs:5:23
|
LL | const fn closure() -> fn() { || {} }
| ^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/cast_errors.rs:8:5
|
LL | (|| {}) as fn();
| ^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/cast_errors.rs:11:28
|
LL | const fn reify(f: fn()) -> unsafe fn() { f }
| ^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/cast_errors.rs:13:21
|
LL | const fn reify2() { main as unsafe fn(); }
| ^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to 5 previous errors
+For more information about this error, try `rustc --explain E0723`.
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/cmp_fn_pointers.rs:1:14
|
LL | const fn cmp(x: fn(), y: fn()) -> bool { //~ ERROR function pointers in const fn are unstable
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0723`.
-error: loops are not allowed in const fn
+error[E0723]: loops are not allowed in const fn (see issue #57563)
--> $DIR/loop_ice.rs:2:5
|
LL | loop {} //~ ERROR loops are not allowed in const fn
| ^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0723`.
LL | const fn into_inner(self) -> T { self.0 } //~ destructors cannot be evaluated
| ^^^^ constant functions cannot evaluate destructors
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:39:36
|
LL | const fn get_mut(&mut self) -> &mut T { &mut self.0 }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error[E0493]: destructors cannot be evaluated at compile-time
--> $DIR/min_const_fn.rs:44:28
LL | const fn into_inner_lt(self) -> T { self.0 } //~ destructors cannot be evaluated
| ^^^^ constant functions cannot evaluate destructors
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:46:42
|
LL | const fn get_mut_lt(&'a mut self) -> &mut T { &mut self.0 }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error[E0493]: destructors cannot be evaluated at compile-time
--> $DIR/min_const_fn.rs:51:27
LL | const fn into_inner_s(self) -> T { self.0 } //~ ERROR destructors
| ^^^^ constant functions cannot evaluate destructors
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:53:38
|
LL | const fn get_mut_s(&mut self) -> &mut T { &mut self.0 }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:58:39
|
LL | const fn get_mut_sq(&mut self) -> &mut T { &mut self.0 }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:76:16
|
LL | const fn foo11<T: std::fmt::Display>(t: T) -> T { t }
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:78:18
|
LL | const fn foo11_2<T: Send>(t: T) -> T { t }
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: only int, `bool` and `char` operations are stable in const fn
+error[E0723]: only int, `bool` and `char` operations are stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:80:33
|
LL | const fn foo19(f: f32) -> f32 { f * 2.0 }
| ^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: only int, `bool` and `char` operations are stable in const fn
+error[E0723]: only int, `bool` and `char` operations are stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:82:35
|
LL | const fn foo19_2(f: f32) -> f32 { 2.0 - f }
| ^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: only int and `bool` operations are stable in const fn
+error[E0723]: only int and `bool` operations are stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:84:35
|
LL | const fn foo19_3(f: f32) -> f32 { -f }
| ^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: only int, `bool` and `char` operations are stable in const fn
+error[E0723]: only int, `bool` and `char` operations are stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:86:43
|
LL | const fn foo19_4(f: f32, g: f32) -> f32 { f / g }
| ^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: cannot access `static` items in const fn
+error[E0723]: cannot access `static` items in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:90:27
|
LL | const fn foo25() -> u32 { BAR } //~ ERROR cannot access `static` items in const fn
| ^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: cannot access `static` items in const fn
+error[E0723]: cannot access `static` items in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:91:36
|
LL | const fn foo26() -> &'static u32 { &BAR } //~ ERROR cannot access `static` items
| ^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: casting pointers to ints is unstable in const fn
+error[E0723]: casting pointers to ints is unstable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:92:42
|
LL | const fn foo30(x: *const u32) -> usize { x as usize }
| ^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: casting pointers to ints is unstable in const fn
+error[E0723]: casting pointers to ints is unstable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:94:63
|
LL | const fn foo30_with_unsafe(x: *const u32) -> usize { unsafe { x as usize } }
| ^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: casting pointers to ints is unstable in const fn
+error[E0723]: casting pointers to ints is unstable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:96:42
|
LL | const fn foo30_2(x: *mut u32) -> usize { x as usize }
| ^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: casting pointers to ints is unstable in const fn
+error[E0723]: casting pointers to ints is unstable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:98:63
|
LL | const fn foo30_2_with_unsafe(x: *mut u32) -> usize { unsafe { x as usize } }
| ^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `if`, `match`, `&&` and `||` are not stable in const fn
+error[E0723]: `if`, `match`, `&&` and `||` are not stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:100:38
|
LL | const fn foo30_4(b: bool) -> usize { if b { 1 } else { 42 } }
| ^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `if`, `match`, `&&` and `||` are not stable in const fn
+error[E0723]: `if`, `match`, `&&` and `||` are not stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:102:29
|
LL | const fn foo30_5(b: bool) { while b { } } //~ ERROR not stable in const fn
| ^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `if`, `match`, `&&` and `||` are not stable in const fn
+error[E0723]: `if`, `match`, `&&` and `||` are not stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:104:44
|
LL | const fn foo36(a: bool, b: bool) -> bool { a && b }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `if`, `match`, `&&` and `||` are not stable in const fn
+error[E0723]: `if`, `match`, `&&` and `||` are not stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:106:44
|
LL | const fn foo37(a: bool, b: bool) -> bool { a || b }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:108:14
|
LL | const fn inc(x: &mut i32) { *x += 1 }
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:113:6
|
LL | impl<T: std::fmt::Debug> Foo<T> {
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:118:6
|
LL | impl<T: std::fmt::Debug + Sized> Foo<T> {
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:123:6
|
LL | impl<T: Sync + Sized> Foo<T> {
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `impl Trait` in const fn is unstable
+error[E0723]: `impl Trait` in const fn is unstable (see issue #57563)
--> $DIR/min_const_fn.rs:129:24
|
LL | const fn no_rpit2() -> AlanTuring<impl std::fmt::Debug> { AlanTuring(0) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:131:34
|
LL | const fn no_apit2(_x: AlanTuring<impl std::fmt::Debug>) {}
| ^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:133:22
|
LL | const fn no_apit(_x: impl std::fmt::Debug) {} //~ ERROR trait bounds other than `Sized`
| ^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `impl Trait` in const fn is unstable
+error[E0723]: `impl Trait` in const fn is unstable (see issue #57563)
--> $DIR/min_const_fn.rs:134:23
|
LL | const fn no_rpit() -> impl std::fmt::Debug {} //~ ERROR `impl Trait` in const fn is unstable
| ^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:135:23
|
LL | const fn no_dyn_trait(_x: &dyn std::fmt::Debug) {} //~ ERROR trait bounds other than `Sized`
| ^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:136:32
|
LL | const fn no_dyn_trait_ret() -> &'static dyn std::fmt::Debug { &() }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
warning[E0515]: cannot return reference to temporary value
--> $DIR/min_const_fn.rs:136:63
= warning: this error has been downgraded to a warning for backwards compatibility with previous releases
= warning: this represents potential undefined behavior in your code and this warning will become a hard error in the future
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:141:41
|
LL | const fn really_no_traits_i_mean_it() { (&() as &std::fmt::Debug, ()).1 }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:144:21
|
LL | const fn no_fn_ptrs(_x: fn()) {}
| ^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:146:27
|
LL | const fn no_fn_ptrs2() -> fn() { fn foo() {} foo }
| ^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to 36 previous errors
-Some errors occurred: E0493, E0515.
+Some errors occurred: E0493, E0515, E0723.
For more information about an error, try `rustc --explain E0493`.
LL | const fn into_inner(self) -> T { self.0 } //~ destructors cannot be evaluated
| ^^^^ constant functions cannot evaluate destructors
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:39:36
|
LL | const fn get_mut(&mut self) -> &mut T { &mut self.0 }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error[E0493]: destructors cannot be evaluated at compile-time
--> $DIR/min_const_fn.rs:44:28
LL | const fn into_inner_lt(self) -> T { self.0 } //~ destructors cannot be evaluated
| ^^^^ constant functions cannot evaluate destructors
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:46:42
|
LL | const fn get_mut_lt(&'a mut self) -> &mut T { &mut self.0 }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error[E0493]: destructors cannot be evaluated at compile-time
--> $DIR/min_const_fn.rs:51:27
LL | const fn into_inner_s(self) -> T { self.0 } //~ ERROR destructors
| ^^^^ constant functions cannot evaluate destructors
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:53:38
|
LL | const fn get_mut_s(&mut self) -> &mut T { &mut self.0 }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:58:39
|
LL | const fn get_mut_sq(&mut self) -> &mut T { &mut self.0 }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:76:16
|
LL | const fn foo11<T: std::fmt::Display>(t: T) -> T { t }
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:78:18
|
LL | const fn foo11_2<T: Send>(t: T) -> T { t }
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: only int, `bool` and `char` operations are stable in const fn
+error[E0723]: only int, `bool` and `char` operations are stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:80:33
|
LL | const fn foo19(f: f32) -> f32 { f * 2.0 }
| ^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: only int, `bool` and `char` operations are stable in const fn
+error[E0723]: only int, `bool` and `char` operations are stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:82:35
|
LL | const fn foo19_2(f: f32) -> f32 { 2.0 - f }
| ^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: only int and `bool` operations are stable in const fn
+error[E0723]: only int and `bool` operations are stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:84:35
|
LL | const fn foo19_3(f: f32) -> f32 { -f }
| ^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: only int, `bool` and `char` operations are stable in const fn
+error[E0723]: only int, `bool` and `char` operations are stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:86:43
|
LL | const fn foo19_4(f: f32, g: f32) -> f32 { f / g }
| ^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: cannot access `static` items in const fn
+error[E0723]: cannot access `static` items in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:90:27
|
LL | const fn foo25() -> u32 { BAR } //~ ERROR cannot access `static` items in const fn
| ^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: cannot access `static` items in const fn
+error[E0723]: cannot access `static` items in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:91:36
|
LL | const fn foo26() -> &'static u32 { &BAR } //~ ERROR cannot access `static` items
| ^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: casting pointers to ints is unstable in const fn
+error[E0723]: casting pointers to ints is unstable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:92:42
|
LL | const fn foo30(x: *const u32) -> usize { x as usize }
| ^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: casting pointers to ints is unstable in const fn
+error[E0723]: casting pointers to ints is unstable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:94:63
|
LL | const fn foo30_with_unsafe(x: *const u32) -> usize { unsafe { x as usize } }
| ^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: casting pointers to ints is unstable in const fn
+error[E0723]: casting pointers to ints is unstable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:96:42
|
LL | const fn foo30_2(x: *mut u32) -> usize { x as usize }
| ^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: casting pointers to ints is unstable in const fn
+error[E0723]: casting pointers to ints is unstable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:98:63
|
LL | const fn foo30_2_with_unsafe(x: *mut u32) -> usize { unsafe { x as usize } }
| ^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `if`, `match`, `&&` and `||` are not stable in const fn
+error[E0723]: `if`, `match`, `&&` and `||` are not stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:100:38
|
LL | const fn foo30_4(b: bool) -> usize { if b { 1 } else { 42 } }
| ^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `if`, `match`, `&&` and `||` are not stable in const fn
+error[E0723]: `if`, `match`, `&&` and `||` are not stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:102:29
|
LL | const fn foo30_5(b: bool) { while b { } } //~ ERROR not stable in const fn
| ^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `if`, `match`, `&&` and `||` are not stable in const fn
+error[E0723]: `if`, `match`, `&&` and `||` are not stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:104:44
|
LL | const fn foo36(a: bool, b: bool) -> bool { a && b }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `if`, `match`, `&&` and `||` are not stable in const fn
+error[E0723]: `if`, `match`, `&&` and `||` are not stable in const fn (see issue #57563)
--> $DIR/min_const_fn.rs:106:44
|
LL | const fn foo37(a: bool, b: bool) -> bool { a || b }
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:108:14
|
LL | const fn inc(x: &mut i32) { *x += 1 }
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:113:6
|
LL | impl<T: std::fmt::Debug> Foo<T> {
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:118:6
|
LL | impl<T: std::fmt::Debug + Sized> Foo<T> {
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:123:6
|
LL | impl<T: Sync + Sized> Foo<T> {
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `impl Trait` in const fn is unstable
+error[E0723]: `impl Trait` in const fn is unstable (see issue #57563)
--> $DIR/min_const_fn.rs:129:24
|
LL | const fn no_rpit2() -> AlanTuring<impl std::fmt::Debug> { AlanTuring(0) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:131:34
|
LL | const fn no_apit2(_x: AlanTuring<impl std::fmt::Debug>) {}
| ^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:133:22
|
LL | const fn no_apit(_x: impl std::fmt::Debug) {} //~ ERROR trait bounds other than `Sized`
| ^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: `impl Trait` in const fn is unstable
+error[E0723]: `impl Trait` in const fn is unstable (see issue #57563)
--> $DIR/min_const_fn.rs:134:23
|
LL | const fn no_rpit() -> impl std::fmt::Debug {} //~ ERROR `impl Trait` in const fn is unstable
| ^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:135:23
|
LL | const fn no_dyn_trait(_x: &dyn std::fmt::Debug) {} //~ ERROR trait bounds other than `Sized`
| ^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:136:32
|
LL | const fn no_dyn_trait_ret() -> &'static dyn std::fmt::Debug { &() }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:141:41
|
LL | const fn really_no_traits_i_mean_it() { (&() as &std::fmt::Debug, ()).1 }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:144:21
|
LL | const fn no_fn_ptrs(_x: fn()) {}
| ^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn.rs:146:27
|
LL | const fn no_fn_ptrs2() -> fn() { fn foo() {} foo }
| ^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to 36 previous errors
-For more information about this error, try `rustc --explain E0493`.
+Some errors occurred: E0493, E0723.
+For more information about an error, try `rustc --explain E0493`.
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn_dyn.rs:9:5
|
LL | x.0.field;
| ^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn_dyn.rs:12:66
|
LL | const fn no_inner_dyn_trait_ret() -> Hide { Hide(HasDyn { field: &0 }) }
| ^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
warning[E0716]: temporary value dropped while borrowed
--> $DIR/min_const_fn_dyn.rs:12:67
error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0716`.
+Some errors occurred: E0716, E0723.
+For more information about an error, try `rustc --explain E0716`.
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn_dyn.rs:9:5
|
LL | x.0.field;
| ^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: trait bounds other than `Sized` on const fn parameters are unstable
+error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable (see issue #57563)
--> $DIR/min_const_fn_dyn.rs:12:66
|
LL | const fn no_inner_dyn_trait_ret() -> Hide { Hide(HasDyn { field: &0 }) }
| ^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to 2 previous errors
+For more information about this error, try `rustc --explain E0723`.
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn_fn_ptr.rs:11:5
|
LL | x.0.field;
| ^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/min_const_fn_fn_ptr.rs:14:59
|
LL | const fn no_inner_dyn_trait_ret() -> Hide { Hide(HasPtr { field }) }
| ^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to 2 previous errors
+For more information about this error, try `rustc --explain E0723`.
-error: can only call other `min_const_fn` within a `min_const_fn`
+error[E0723]: can only call other `min_const_fn` within a `min_const_fn` (see issue #57563)
--> $DIR/min_const_fn_libstd_stability.rs:15:25
|
LL | const fn bar() -> u32 { foo() } //~ ERROR can only call other `min_const_fn`
| ^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: can only call other `min_const_fn` within a `min_const_fn`
+error[E0723]: can only call other `min_const_fn` within a `min_const_fn` (see issue #57563)
--> $DIR/min_const_fn_libstd_stability.rs:22:26
|
LL | const fn bar2() -> u32 { foo2() } //~ ERROR can only call other `min_const_fn`
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: only int, `bool` and `char` operations are stable in const fn
+error[E0723]: only int, `bool` and `char` operations are stable in const fn (see issue #57563)
--> $DIR/min_const_fn_libstd_stability.rs:26:26
|
LL | const fn bar3() -> u32 { (5f32 + 6f32) as u32 } //~ ERROR only int, `bool` and `char` operations
| ^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: can only call other `min_const_fn` within a `min_const_fn`
+error[E0723]: can only call other `min_const_fn` within a `min_const_fn` (see issue #57563)
--> $DIR/min_const_fn_libstd_stability.rs:34:32
|
LL | const fn bar2_gated() -> u32 { foo2_gated() } //~ ERROR can only call other `min_const_fn`
| ^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to 4 previous errors
+For more information about this error, try `rustc --explain E0723`.
-error: can only call other `min_const_fn` within a `min_const_fn`
+error[E0723]: can only call other `min_const_fn` within a `min_const_fn` (see issue #57563)
--> $DIR/min_const_unsafe_fn_libstd_stability.rs:15:41
|
LL | const unsafe fn bar() -> u32 { unsafe { foo() } } //~ ERROR can only call other `min_const_fn`
| ^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: can only call other `min_const_fn` within a `min_const_fn`
+error[E0723]: can only call other `min_const_fn` within a `min_const_fn` (see issue #57563)
--> $DIR/min_const_unsafe_fn_libstd_stability.rs:22:42
|
LL | const unsafe fn bar2() -> u32 { unsafe { foo2() } } //~ ERROR can only call other `min_const_fn`
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: only int, `bool` and `char` operations are stable in const fn
+error[E0723]: only int, `bool` and `char` operations are stable in const fn (see issue #57563)
--> $DIR/min_const_unsafe_fn_libstd_stability.rs:26:33
|
LL | const unsafe fn bar3() -> u32 { (5f32 + 6f32) as u32 } //~ ERROR only int, `bool` and `char` op
| ^^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: can only call other `min_const_fn` within a `min_const_fn`
+error[E0723]: can only call other `min_const_fn` within a `min_const_fn` (see issue #57563)
--> $DIR/min_const_unsafe_fn_libstd_stability.rs:34:48
|
LL | const unsafe fn bar2_gated() -> u32 { unsafe { foo2_gated() } } //~ ERROR can only call other
| ^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to 4 previous errors
+For more information about this error, try `rustc --explain E0723`.
-error: can only call other `min_const_fn` within a `min_const_fn`
+error[E0723]: can only call other `min_const_fn` within a `min_const_fn` (see issue #57563)
--> $DIR/min_const_unsafe_fn_libstd_stability2.rs:15:32
|
LL | const unsafe fn bar() -> u32 { foo() } //~ ERROR can only call other `min_const_fn`
| ^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: can only call other `min_const_fn` within a `min_const_fn`
+error[E0723]: can only call other `min_const_fn` within a `min_const_fn` (see issue #57563)
--> $DIR/min_const_unsafe_fn_libstd_stability2.rs:22:33
|
LL | const unsafe fn bar2() -> u32 { foo2() } //~ ERROR can only call other `min_const_fn`
| ^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: can only call other `min_const_fn` within a `min_const_fn`
+error[E0723]: can only call other `min_const_fn` within a `min_const_fn` (see issue #57563)
--> $DIR/min_const_unsafe_fn_libstd_stability2.rs:30:39
|
LL | const unsafe fn bar2_gated() -> u32 { foo2_gated() } //~ ERROR can only call other `min_const_fn`
| ^^^^^^^^^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to 3 previous errors
+For more information about this error, try `rustc --explain E0723`.
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/mutable_borrow.rs:3:9
|
LL | let b = &mut a; //~ ERROR mutable references in const fn
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/mutable_borrow.rs:12:13
|
LL | let b = &mut a; //~ ERROR mutable references in const fn
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to 2 previous errors
+For more information about this error, try `rustc --explain E0723`.
LL | x => 42, //~ ERROR unimplemented expression type
| ^
-error: `if`, `match`, `&&` and `||` are not stable in const fn
+error[E0723]: `if`, `match`, `&&` and `||` are not stable in const fn (see issue #57563)
--> $DIR/single_variant_match_ice.rs:18:13
|
LL | Prob => 0x1, //~ ERROR `if`, `match`, `&&` and `||` are not stable in const fn
| ^^^^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to 3 previous errors
-For more information about this error, try `rustc --explain E0019`.
+Some errors occurred: E0019, E0723.
+For more information about an error, try `rustc --explain E0019`.
// ignore-tidy-linelength
+// run-pass
+
#![deny(deprecated_in_future)]
#[deprecated(since = "99.99.99", note = "text")]
pub fn deprecated_future() {}
fn test() {
- deprecated_future(); //~ ERROR use of item 'deprecated_future' that will be deprecated in future version 99.99.99: text
+ deprecated_future(); // ok; deprecated_in_future only applies to rustc_deprecated
}
fn main() {}
-error: use of item 'deprecated_future' that will be deprecated in future version 99.99.99: text
- --> $DIR/deprecation-in-future.rs:9:5
+warning: use of deprecated item 'deprecated_future': text
+ --> $DIR/deprecation-in-future.rs:11:5
|
-LL | deprecated_future(); //~ ERROR use of item 'deprecated_future' that will be deprecated in future version 99.99.99: text
+LL | deprecated_future(); // ok; deprecated_in_future only applies to rustc_deprecated
| ^^^^^^^^^^^^^^^^^
|
-note: lint level defined here
- --> $DIR/deprecation-in-future.rs:3:9
- |
-LL | #![deny(deprecated_in_future)]
- | ^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to previous error
+ = note: #[warn(deprecated)] on by default
<Foo>::trait_deprecated_text(&foo); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
<Foo as Trait>::trait_deprecated_text(&foo); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
- deprecated_future(); // Fine; no error.
- deprecated_future_text(); // Fine; no error.
+ // Future deprecations are only permitted for rustc_deprecated.
+ deprecated_future(); //~ ERROR use of deprecated item
+ deprecated_future_text(); //~ ERROR use of deprecated item
let _ = DeprecatedStruct {
//~^ ERROR use of deprecated item 'this_crate::DeprecatedStruct': text
LL | <Foo as Trait>::trait_deprecated_text(&foo); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+error: use of deprecated item 'this_crate::deprecated_future': text
+ --> $DIR/deprecation-lint.rs:265:9
+ |
+LL | deprecated_future(); //~ ERROR use of deprecated item
+ | ^^^^^^^^^^^^^^^^^
+
+error: use of deprecated item 'this_crate::deprecated_future_text': text
+ --> $DIR/deprecation-lint.rs:266:9
+ |
+LL | deprecated_future_text(); //~ ERROR use of deprecated item
+ | ^^^^^^^^^^^^^^^^^^^^^^
+
error: use of deprecated item 'this_crate::DeprecatedStruct': text
- --> $DIR/deprecation-lint.rs:267:17
+ --> $DIR/deprecation-lint.rs:268:17
|
LL | let _ = DeprecatedStruct {
| ^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::DeprecatedUnitStruct': text
- --> $DIR/deprecation-lint.rs:272:17
+ --> $DIR/deprecation-lint.rs:273:17
|
LL | let _ = DeprecatedUnitStruct; //~ ERROR use of deprecated item 'this_crate::DeprecatedUnitStruct': text
| ^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::Enum::DeprecatedVariant': text
- --> $DIR/deprecation-lint.rs:274:17
+ --> $DIR/deprecation-lint.rs:275:17
|
LL | let _ = Enum::DeprecatedVariant; //~ ERROR use of deprecated item 'this_crate::Enum::DeprecatedVariant': text
| ^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::DeprecatedTupleStruct': text
- --> $DIR/deprecation-lint.rs:276:17
+ --> $DIR/deprecation-lint.rs:277:17
|
LL | let _ = DeprecatedTupleStruct (1); //~ ERROR use of deprecated item 'this_crate::DeprecatedTupleStruct': text
| ^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::nested::DeprecatedStruct': text
- --> $DIR/deprecation-lint.rs:278:17
+ --> $DIR/deprecation-lint.rs:279:17
|
LL | let _ = nested::DeprecatedStruct {
| ^^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::nested::DeprecatedUnitStruct': text
- --> $DIR/deprecation-lint.rs:283:17
+ --> $DIR/deprecation-lint.rs:284:17
|
LL | let _ = nested::DeprecatedUnitStruct; //~ ERROR use of deprecated item 'this_crate::nested::DeprecatedUnitStruct': text
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::nested::Enum::DeprecatedVariant': text
- --> $DIR/deprecation-lint.rs:285:17
+ --> $DIR/deprecation-lint.rs:286:17
|
LL | let _ = nested::Enum::DeprecatedVariant; //~ ERROR use of deprecated item 'this_crate::nested::Enum::DeprecatedVariant': text
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::nested::DeprecatedTupleStruct': text
- --> $DIR/deprecation-lint.rs:287:17
+ --> $DIR/deprecation-lint.rs:288:17
|
LL | let _ = nested::DeprecatedTupleStruct (1); //~ ERROR use of deprecated item 'this_crate::nested::DeprecatedTupleStruct': text
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::Trait::trait_deprecated': text
- --> $DIR/deprecation-lint.rs:292:9
+ --> $DIR/deprecation-lint.rs:293:9
|
LL | Trait::trait_deprecated(&foo); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated'
| ^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::Trait::trait_deprecated': text
- --> $DIR/deprecation-lint.rs:294:9
+ --> $DIR/deprecation-lint.rs:295:9
|
LL | <Foo as Trait>::trait_deprecated(&foo); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated'
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
- --> $DIR/deprecation-lint.rs:296:9
+ --> $DIR/deprecation-lint.rs:297:9
|
LL | Trait::trait_deprecated_text(&foo); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
- --> $DIR/deprecation-lint.rs:298:9
+ --> $DIR/deprecation-lint.rs:299:9
|
LL | <Foo as Trait>::trait_deprecated_text(&foo); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::test_fn_closure_body::{{closure}}::bar'
- --> $DIR/deprecation-lint.rs:316:13
+ --> $DIR/deprecation-lint.rs:317:13
|
LL | bar(); //~ ERROR use of deprecated item 'this_crate::test_fn_closure_body::{{closure}}::bar'
| ^^^
error: use of deprecated item 'this_crate::DeprecatedTrait': text
- --> $DIR/deprecation-lint.rs:335:10
+ --> $DIR/deprecation-lint.rs:336:10
|
LL | impl DeprecatedTrait for S { } //~ ERROR use of deprecated item 'this_crate::DeprecatedTrait': text
| ^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::DeprecatedTrait': text
- --> $DIR/deprecation-lint.rs:337:24
+ --> $DIR/deprecation-lint.rs:338:24
|
LL | trait LocalTrait : DeprecatedTrait { } //~ ERROR use of deprecated item 'this_crate::DeprecatedTrait': text
| ^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate2::Deprecated': text
- --> $DIR/deprecation-lint.rs:389:17
+ --> $DIR/deprecation-lint.rs:390:17
|
LL | let x = Deprecated {
| ^^^^^^^^^^
error: use of deprecated item 'this_crate2::Deprecated': text
- --> $DIR/deprecation-lint.rs:398:13
+ --> $DIR/deprecation-lint.rs:399:13
|
LL | let Deprecated {
| ^^^^^^^^^^
error: use of deprecated item 'this_crate2::Deprecated': text
- --> $DIR/deprecation-lint.rs:404:13
+ --> $DIR/deprecation-lint.rs:405:13
|
LL | let Deprecated
| ^^^^^^^^^^
error: use of deprecated item 'this_crate2::Deprecated2': text
- --> $DIR/deprecation-lint.rs:409:17
+ --> $DIR/deprecation-lint.rs:410:17
|
LL | let x = Deprecated2(1, 2, 3);
| ^^^^^^^^^^^
error: use of deprecated item 'this_crate2::Deprecated2': text
- --> $DIR/deprecation-lint.rs:419:13
+ --> $DIR/deprecation-lint.rs:420:13
|
LL | let Deprecated2
| ^^^^^^^^^^^
error: use of deprecated item 'this_crate2::Deprecated2': text
- --> $DIR/deprecation-lint.rs:428:13
+ --> $DIR/deprecation-lint.rs:429:13
|
LL | let Deprecated2
| ^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::DeprecatedStruct::i': text
- --> $DIR/deprecation-lint.rs:269:13
+ --> $DIR/deprecation-lint.rs:270:13
|
LL | i: 0 //~ ERROR use of deprecated item 'this_crate::DeprecatedStruct::i': text
| ^^^^
error: use of deprecated item 'this_crate::nested::DeprecatedStruct::i': text
- --> $DIR/deprecation-lint.rs:280:13
+ --> $DIR/deprecation-lint.rs:281:13
|
LL | i: 0 //~ ERROR use of deprecated item 'this_crate::nested::DeprecatedStruct::i': text
| ^^^^
error: use of deprecated item 'this_crate::Trait::trait_deprecated': text
- --> $DIR/deprecation-lint.rs:291:13
+ --> $DIR/deprecation-lint.rs:292:13
|
LL | foo.trait_deprecated(); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated'
| ^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::Trait::trait_deprecated': text
- --> $DIR/deprecation-lint.rs:293:9
+ --> $DIR/deprecation-lint.rs:294:9
|
LL | <Foo>::trait_deprecated(&foo); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated'
| ^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
- --> $DIR/deprecation-lint.rs:295:13
+ --> $DIR/deprecation-lint.rs:296:13
|
LL | foo.trait_deprecated_text(); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
| ^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
- --> $DIR/deprecation-lint.rs:297:9
+ --> $DIR/deprecation-lint.rs:298:9
|
LL | <Foo>::trait_deprecated_text(&foo); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::Trait::trait_deprecated': text
- --> $DIR/deprecation-lint.rs:302:13
+ --> $DIR/deprecation-lint.rs:303:13
|
LL | foo.trait_deprecated(); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated'
| ^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
- --> $DIR/deprecation-lint.rs:303:13
+ --> $DIR/deprecation-lint.rs:304:13
|
LL | foo.trait_deprecated_text(); //~ ERROR use of deprecated item 'this_crate::Trait::trait_deprecated_text': text
| ^^^^^^^^^^^^^^^^^^^^^
error: use of deprecated item 'this_crate2::Stable::override2': text
- --> $DIR/deprecation-lint.rs:362:13
+ --> $DIR/deprecation-lint.rs:363:13
|
LL | override2: 3,
| ^^^^^^^^^^^^
error: use of deprecated item 'this_crate2::Stable::override2': text
- --> $DIR/deprecation-lint.rs:366:17
+ --> $DIR/deprecation-lint.rs:367:17
|
LL | let _ = x.override2;
| ^^^^^^^^^^^
error: use of deprecated item 'this_crate2::Stable::override2': text
- --> $DIR/deprecation-lint.rs:370:13
+ --> $DIR/deprecation-lint.rs:371:13
|
LL | override2: _
| ^^^^^^^^^^^^
error: use of deprecated item 'this_crate2::Stable2::2': text
- --> $DIR/deprecation-lint.rs:378:17
+ --> $DIR/deprecation-lint.rs:379:17
|
LL | let _ = x.2;
| ^^^
error: use of deprecated item 'this_crate2::Stable2::2': text
- --> $DIR/deprecation-lint.rs:383:20
+ --> $DIR/deprecation-lint.rs:384:20
|
LL | _)
| ^
error: use of deprecated item 'this_crate2::Deprecated::inherit': text
- --> $DIR/deprecation-lint.rs:391:13
+ --> $DIR/deprecation-lint.rs:392:13
|
LL | inherit: 1,
| ^^^^^^^^^^
error: use of deprecated item 'this_crate2::Deprecated::inherit': text
- --> $DIR/deprecation-lint.rs:395:17
+ --> $DIR/deprecation-lint.rs:396:17
|
LL | let _ = x.inherit;
| ^^^^^^^^^
error: use of deprecated item 'this_crate2::Deprecated::inherit': text
- --> $DIR/deprecation-lint.rs:400:13
+ --> $DIR/deprecation-lint.rs:401:13
|
LL | inherit: _,
| ^^^^^^^^^^
error: use of deprecated item 'this_crate2::Deprecated2::0': text
- --> $DIR/deprecation-lint.rs:412:17
+ --> $DIR/deprecation-lint.rs:413:17
|
LL | let _ = x.0;
| ^^^
error: use of deprecated item 'this_crate2::Deprecated2::1': text
- --> $DIR/deprecation-lint.rs:414:17
+ --> $DIR/deprecation-lint.rs:415:17
|
LL | let _ = x.1;
| ^^^
error: use of deprecated item 'this_crate2::Deprecated2::2': text
- --> $DIR/deprecation-lint.rs:416:17
+ --> $DIR/deprecation-lint.rs:417:17
|
LL | let _ = x.2;
| ^^^
error: use of deprecated item 'this_crate2::Deprecated2::0': text
- --> $DIR/deprecation-lint.rs:421:14
+ --> $DIR/deprecation-lint.rs:422:14
|
LL | (_,
| ^
error: use of deprecated item 'this_crate2::Deprecated2::1': text
- --> $DIR/deprecation-lint.rs:423:14
+ --> $DIR/deprecation-lint.rs:424:14
|
LL | _,
| ^
error: use of deprecated item 'this_crate2::Deprecated2::2': text
- --> $DIR/deprecation-lint.rs:425:14
+ --> $DIR/deprecation-lint.rs:426:14
|
LL | _)
| ^
-error: aborting due to 120 previous errors
+error: aborting due to 122 previous errors
#[deprecated(since(b), note = "a")] //~ ERROR incorrect meta item
fn f6() { }
+
+ #[deprecated(note = b"test")] //~ ERROR literal in `deprecated` value must be a string
+ fn f7() { }
+
+ #[deprecated("test")] //~ ERROR item in `deprecated` must be a key/value pair
+ fn f8() { }
}
#[deprecated(since = "a", note = "b")]
LL | #[deprecated(since(b), note = "a")] //~ ERROR incorrect meta item
| ^^^^^^^^
+error[E0565]: literal in `deprecated` value must be a string
+ --> $DIR/deprecation-sanity.rs:19:25
+ |
+LL | #[deprecated(note = b"test")] //~ ERROR literal in `deprecated` value must be a string
+ | ^^^^^^^ help: consider removing the prefix: `"test"`
+
+error[E0565]: item in `deprecated` must be a key/value pair
+ --> $DIR/deprecation-sanity.rs:22:18
+ |
+LL | #[deprecated("test")] //~ ERROR item in `deprecated` must be a key/value pair
+ | ^^^^^^
+
error[E0550]: multiple deprecated attributes
- --> $DIR/deprecation-sanity.rs:22:1
+ --> $DIR/deprecation-sanity.rs:28:1
|
LL | fn multiple1() { } //~ ERROR multiple deprecated attributes
| ^^^^^^^^^^^^^^^^^^
error[E0538]: multiple 'since' items
- --> $DIR/deprecation-sanity.rs:24:27
+ --> $DIR/deprecation-sanity.rs:30:27
|
LL | #[deprecated(since = "a", since = "b", note = "c")] //~ ERROR multiple 'since' items
| ^^^^^^^^^^^
-error: aborting due to 7 previous errors
+error: aborting due to 9 previous errors
-Some errors occurred: E0538, E0541, E0550, E0551.
+Some errors occurred: E0538, E0541, E0550, E0551, E0565.
For more information about an error, try `rustc --explain E0538`.
--- /dev/null
+#[deprecated = b"test"] //~ ERROR attribute must be of the form
+fn foo() {}
+
+fn main() {}
--- /dev/null
+error: attribute must be of the form `#[deprecated]` or `#[deprecated(/*opt*/ since = "version", /*opt*/ note = "reason)]` or `#[deprecated = "reason"]`
+ --> $DIR/invalid-literal.rs:1:1
+ |
+LL | #[deprecated = b"test"] //~ ERROR attribute must be of the form
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /dev/null
+// ignore-tidy-linelength
+
+#![deny(deprecated_in_future)]
+
+#![feature(staged_api)]
+
+#![stable(feature = "rustc_deprecation-in-future-test", since = "1.0.0")]
+
+#[rustc_deprecated(since = "99.99.99", reason = "effectively never")]
+#[stable(feature = "rustc_deprecation-in-future-test", since = "1.0.0")]
+pub struct S;
+
+fn main() {
+ let _ = S; //~ ERROR use of item 'S' that will be deprecated in future version 99.99.99: effectively never
+}
--- /dev/null
+error: use of item 'S' that will be deprecated in future version 99.99.99: effectively never
+ --> $DIR/rustc_deprecation-in-future.rs:14:13
+ |
+LL | let _ = S; //~ ERROR use of item 'S' that will be deprecated in future version 99.99.99: effectively never
+ | ^
+ |
+note: lint level defined here
+ --> $DIR/rustc_deprecation-in-future.rs:3:9
+ |
+LL | #![deny(deprecated_in_future)]
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
LL | const CR: &'static mut i32 = &mut C; //~ ERROR E0017
| ^^^^^^ constants require immutable values
-error: cannot mutate statics in the initializer of another static
+error[E0017]: references in statics may only refer to immutable values
--> $DIR/E0017.rs:5:39
|
LL | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
- | ^^^^^^
+ | ^^^^^^ statics require immutable values
-error[E0017]: references in statics may only refer to immutable values
+error: cannot mutate statics in the initializer of another static
--> $DIR/E0017.rs:5:39
|
LL | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
- | ^^^^^^ statics require immutable values
+ | ^^^^^^
error[E0596]: cannot borrow immutable static item `X` as mutable
--> $DIR/E0017.rs:5:39
LL | const CR: &'static mut i32 = &mut C; //~ ERROR E0017
| ^^^^^^ constants require immutable values
-error: cannot mutate statics in the initializer of another static
+error[E0017]: references in statics may only refer to immutable values
--> $DIR/E0017.rs:5:39
|
LL | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
- | ^^^^^^
+ | ^^^^^^ statics require immutable values
-error[E0017]: references in statics may only refer to immutable values
+error: cannot mutate statics in the initializer of another static
--> $DIR/E0017.rs:5:39
|
LL | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
- | ^^^^^^ statics require immutable values
+ | ^^^^^^
error[E0596]: cannot borrow immutable static item as mutable
--> $DIR/E0017.rs:5:44
LL | const CR: &'static mut i32 = &mut C; //~ ERROR E0017
| ^^^^^^ constants require immutable values
-error: cannot mutate statics in the initializer of another static
+error[E0017]: references in statics may only refer to immutable values
--> $DIR/E0388.rs:5:39
|
LL | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
- | ^^^^^^
+ | ^^^^^^ statics require immutable values
-error[E0017]: references in statics may only refer to immutable values
+error: cannot mutate statics in the initializer of another static
--> $DIR/E0388.rs:5:39
|
LL | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
- | ^^^^^^ statics require immutable values
+ | ^^^^^^
error[E0596]: cannot borrow immutable static item `X` as mutable
--> $DIR/E0388.rs:5:39
LL | const CR: &'static mut i32 = &mut C; //~ ERROR E0017
| ^^^^^^ constants require immutable values
-error: cannot mutate statics in the initializer of another static
+error[E0017]: references in statics may only refer to immutable values
--> $DIR/E0388.rs:5:39
|
LL | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
- | ^^^^^^
+ | ^^^^^^ statics require immutable values
-error[E0017]: references in statics may only refer to immutable values
+error: cannot mutate statics in the initializer of another static
--> $DIR/E0388.rs:5:39
|
LL | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
- | ^^^^^^ statics require immutable values
+ | ^^^^^^
error[E0596]: cannot borrow immutable static item as mutable
--> $DIR/E0388.rs:5:44
macro_rules! bar {
() => {
// more layers don't help:
- #[allow_internal_unstable] //~ ERROR allow_internal_unstable side-steps
+ #[allow_internal_unstable()] //~ ERROR allow_internal_unstable side-steps
macro_rules! baz {
() => {}
}
error[E0658]: allow_internal_unstable side-steps feature gating and stability checks
--> $DIR/feature-gate-allow-internal-unstable-nested-macro.rs:8:9
|
-LL | #[allow_internal_unstable] //~ ERROR allow_internal_unstable side-steps
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[allow_internal_unstable()] //~ ERROR allow_internal_unstable side-steps
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
LL | bar!();
| ------- in this macro invocation
// checks that this attribute is caught on non-macro items.
// this needs a different test since this is done after expansion
-#[allow_internal_unstable] //~ ERROR allow_internal_unstable side-steps
+#[allow_internal_unstable()] //~ ERROR allow_internal_unstable side-steps
struct S;
fn main() {}
error[E0658]: allow_internal_unstable side-steps feature gating and stability checks
--> $DIR/feature-gate-allow-internal-unstable-struct.rs:4:1
|
-LL | #[allow_internal_unstable] //~ ERROR allow_internal_unstable side-steps
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[allow_internal_unstable()] //~ ERROR allow_internal_unstable side-steps
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: add #![feature(allow_internal_unstable)] to the crate attributes to enable
#![allow(unused_macros)]
-#[allow_internal_unstable] //~ ERROR allow_internal_unstable side-steps
+#[allow_internal_unstable()] //~ ERROR allow_internal_unstable side-steps
macro_rules! foo {
() => {}
}
error[E0658]: allow_internal_unstable side-steps feature gating and stability checks
--> $DIR/feature-gate-allow-internal-unstable.rs:3:1
|
-LL | #[allow_internal_unstable] //~ ERROR allow_internal_unstable side-steps
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[allow_internal_unstable()] //~ ERROR allow_internal_unstable side-steps
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: add #![feature(allow_internal_unstable)] to the crate attributes to enable
fn main() {
- if let Some(b) = None { //~ ERROR: `if let` arms have incompatible types
- //~^ expected (), found integer
- //~| expected type `()`
- //~| found type `{integer}`
+ if let Some(b) = None {
+ //~^ NOTE if let` arms have incompatible types
()
} else {
1
};
+ //~^^ ERROR: `if let` arms have incompatible types
+ //~| NOTE expected (), found integer
+ //~| NOTE expected type `()`
}
error[E0308]: `if let` arms have incompatible types
- --> $DIR/if-let-arm-types.rs:2:5
+ --> $DIR/if-let-arm-types.rs:6:9
|
-LL | / if let Some(b) = None { //~ ERROR: `if let` arms have incompatible types
-LL | | //~^ expected (), found integer
-LL | | //~| expected type `()`
-LL | | //~| found type `{integer}`
-... |
+LL | / if let Some(b) = None {
+LL | | //~^ NOTE if let` arms have incompatible types
+LL | | ()
+LL | | } else {
LL | | 1
+ | | ^ expected (), found integer
LL | | };
- | |_____^ expected (), found integer
+ | |_____- `if let` arms have incompatible types
|
= note: expected type `()`
found type `{integer}`
-note: `if let` arm with an incompatible type
- --> $DIR/if-let-arm-types.rs:7:12
- |
-LL | } else {
- | ____________^
-LL | | 1
-LL | | };
- | |_____^
error: aborting due to previous error
}
#[stable(feature = "stable", since = "1.0.0")]
-#[allow_internal_unstable]
+#[allow_internal_unstable(function)]
#[macro_export]
macro_rules! call_unstable_allow {
() => { $crate::unstable() }
}
#[stable(feature = "stable", since = "1.0.0")]
-#[allow_internal_unstable]
+#[allow_internal_unstable(struct_field)]
#[macro_export]
macro_rules! construct_unstable_allow {
($e: expr) => {
}
#[stable(feature = "stable", since = "1.0.0")]
-#[allow_internal_unstable]
+#[allow_internal_unstable(method)]
#[macro_export]
macro_rules! call_method_allow {
($e: expr) => { $e.method() }
}
#[stable(feature = "stable", since = "1.0.0")]
-#[allow_internal_unstable]
+#[allow_internal_unstable(struct_field, struct2_field)]
#[macro_export]
macro_rules! access_field_allow {
($e: expr) => { $e.x }
}
#[stable(feature = "stable", since = "1.0.0")]
-#[allow_internal_unstable]
+#[allow_internal_unstable()]
#[macro_export]
macro_rules! pass_through_allow {
($e: expr) => { $e }
}}
}
-#[allow_internal_unstable]
+#[allow_internal_unstable(function)]
macro_rules! bar {
($e: expr) => {{
foo!($e,
--- /dev/null
+mod foo {
+ pub struct B(());
+}
+
+mod bar {
+ use foo::B;
+
+ fn foo() {
+ B(()); //~ ERROR expected function, found struct `B` [E0423]
+ }
+}
+
+mod baz {
+ fn foo() {
+ B(()); //~ ERROR cannot find function `B` in this scope [E0425]
+ }
+}
+
+fn main() {}
--- /dev/null
+error[E0423]: expected function, found struct `B`
+ --> $DIR/issue-42944.rs:9:9
+ |
+LL | B(()); //~ ERROR expected function, found struct `B` [E0423]
+ | ^ constructor is not visible here due to private fields
+
+error[E0425]: cannot find function `B` in this scope
+ --> $DIR/issue-42944.rs:15:9
+ |
+LL | B(()); //~ ERROR cannot find function `B` in this scope [E0425]
+ | ^ not found in this scope
+help: possible candidate is found in another module, you can import it into scope
+ |
+LL | use foo::B;
+ |
+
+error: aborting due to 2 previous errors
+
+Some errors occurred: E0423, E0425.
+For more information about an error, try `rustc --explain E0423`.
fn main() {
match Some(10) {
- //~^ ERROR match arms have incompatible types
- //~| expected type `bool`
- //~| found type `()`
- //~| expected bool, found ()
+ //~^ NOTE `match` arms have incompatible types
Some(5) => false,
+ //~^ NOTE this is found to be of type `bool`
Some(2) => true,
+ //~^ NOTE this is found to be of type `bool`
None => (),
+ //~^ ERROR match arms have incompatible types
+ //~| NOTE expected bool, found ()
+ //~| NOTE expected type `bool`
_ => true
}
}
error[E0308]: match arms have incompatible types
- --> $DIR/issue-11319.rs:2:5
+ --> $DIR/issue-11319.rs:8:20
|
LL | / match Some(10) {
-LL | | //~^ ERROR match arms have incompatible types
-LL | | //~| expected type `bool`
-LL | | //~| found type `()`
-... |
+LL | | //~^ NOTE `match` arms have incompatible types
+LL | | Some(5) => false,
+ | | ----- this is found to be of type `bool`
+LL | | //~^ NOTE this is found to be of type `bool`
+LL | | Some(2) => true,
+ | | ---- this is found to be of type `bool`
+LL | | //~^ NOTE this is found to be of type `bool`
LL | | None => (),
- | | -- match arm with an incompatible type
+ | | ^^ expected bool, found ()
+... |
LL | | _ => true
LL | | }
- | |_____^ expected bool, found ()
+ | |_____- `match` arms have incompatible types
|
= note: expected type `bool`
found type `()`
LL | const C1: &'static mut [usize] = &mut [];
| ^^^^^^^ constants require immutable values
-error[E0013]: constants cannot refer to statics, use a constant instead
+error[E0017]: references in constants may only refer to immutable values
--> $DIR/issue-17718-const-bad-values.rs:5:41
|
LL | const C2: &'static mut usize = unsafe { &mut S };
- | ^^^^^^
+ | ^^^^^^ constants require immutable values
-error[E0017]: references in constants may only refer to immutable values
+error[E0013]: constants cannot refer to statics, use a constant instead
--> $DIR/issue-17718-const-bad-values.rs:5:41
|
LL | const C2: &'static mut usize = unsafe { &mut S };
- | ^^^^^^ constants require immutable values
+ | ^^^^^^
error: aborting due to 3 previous errors
}
fn str_to_direction(to_parse: &str) -> RoomDirection {
- match to_parse { //~ ERROR match arms have incompatible types
+ match to_parse {
"w" | "west" => RoomDirection::West,
"e" | "east" => RoomDirection::East,
"n" | "north" => RoomDirection::North,
"down" => RoomDirection::Down,
_ => None
}
+ //~^^ ERROR match arms have incompatible types
}
fn main() {
| ^^^^^^^^^ ...but data from `room` is returned here
error[E0308]: match arms have incompatible types
- --> $DIR/issue-17728.rs:100:5
+ --> $DIR/issue-17728.rs:109:14
|
-LL | / match to_parse { //~ ERROR match arms have incompatible types
+LL | / match to_parse {
LL | | "w" | "west" => RoomDirection::West,
LL | | "e" | "east" => RoomDirection::East,
LL | | "n" | "north" => RoomDirection::North,
... |
+LL | | "down" => RoomDirection::Down,
+ | | ------------------- this and all prior arms are found to be of type `RoomDirection`
LL | | _ => None
- | | ---- match arm with an incompatible type
+ | | ^^^^ expected enum `RoomDirection`, found enum `std::option::Option`
LL | | }
- | |_____^ expected enum `RoomDirection`, found enum `std::option::Option`
+ | |_____- `match` arms have incompatible types
|
= note: expected type `RoomDirection`
found type `std::option::Option<_>`
/// A strategy for acquiring more subpaths to walk.
pub trait Strategy {
type P: PathExtensions;
- /// Get additional subpaths from a given path.
+ /// Gets additional subpaths from a given path.
fn get_more(&self, item: &Self::P) -> io::Result<Vec<Self::P>>;
/// Determine whether a path should be walked further.
/// This is run against each item from `get_more()`.
}
impl<S: Strategy> Subpaths<S> {
- /// Create a directory walker with a root path and strategy.
+ /// Creates a directory walker with a root path and strategy.
pub fn new(p: &S::P, strategy: S) -> io::Result<Subpaths<S>> {
let stack = strategy.get_more(p)?;
Ok(Subpaths { stack: stack, strategy: strategy })
}
impl<S: Default + Strategy> Subpaths<S> {
- /// Create a directory walker with a root path and a default strategy.
+ /// Creates a directory walker with a root path and a default strategy.
pub fn walk(p: &S::P) -> io::Result<Subpaths<S>> {
Subpaths::new(p, Default::default())
}
fn closure_from_match() {
let x = match 1usize {
- //~^ ERROR match arms have incompatible types
1 => |c| c + 1,
2 => |c| c - 1,
_ => |c| c - 1
};
+ //~^^^ ERROR match arms have incompatible types
}
fn main() { }
= help: consider boxing your closure and/or using it as a trait object
error[E0308]: match arms have incompatible types
- --> $DIR/issue-24036.rs:8:13
+ --> $DIR/issue-24036.rs:10:14
|
LL | let x = match 1usize {
- | _____________^
-LL | | //~^ ERROR match arms have incompatible types
+ | _____________-
LL | | 1 => |c| c + 1,
+ | | --------- this is found to be of type `[closure@$DIR/issue-24036.rs:9:14: 9:23]`
LL | | 2 => |c| c - 1,
- | | --------- match arm with an incompatible type
+ | | ^^^^^^^^^ expected closure, found a different closure
LL | | _ => |c| c - 1
LL | | };
- | |_____^ expected closure, found a different closure
+ | |_____- `match` arms have incompatible types
|
- = note: expected type `[closure@$DIR/issue-24036.rs:10:14: 10:23]`
- found type `[closure@$DIR/issue-24036.rs:11:14: 11:23]`
+ = note: expected type `[closure@$DIR/issue-24036.rs:9:14: 9:23]`
+ found type `[closure@$DIR/issue-24036.rs:10:14: 10:23]`
= note: no two closures, even if identical, have the same type
= help: consider boxing your closure and/or using it as a trait object
-error: function pointers in const fn are unstable
+error[E0723]: function pointers in const fn are unstable (see issue #57563)
--> $DIR/issue-37550.rs:3:9
|
LL | let x = || t; //~ ERROR function pointers in const fn are unstable
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0723`.
struct S {
x: u8,
- /// The id of the parent core
+ /// The ID of the parent core
y: u8,
}
//~^^^ ERROR found a documentation comment that doesn't document anything
+
fn main() {}
struct S {
x: u8
- /// The id of the parent core
+ /// The ID of the parent core
y: u8,
}
//~^^^ ERROR found a documentation comment that doesn't document anything
+
fn main() {}
|
LL | x: u8
| - help: missing comma here: `,`
-LL | /// The id of the parent core
+LL | /// The ID of the parent core
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: doc comments must come before what they document, maybe a comment was intended with `//`?
}
}
-/// often times crashes, if not prints invalid strings
+/// Often crashes, if not prints invalid strings.
pub fn panics() {
let mut acc = Counter{map: HashMap::new()};
for line in vec!["123456789".to_string(), "12345678".to_string()] {
LL | m,
| ______-
LL | | a}; //~ ERROR `a` is defined multiple times
- | | -
+ | | ^
| | |
| |_____`a` reimported here
| help: remove unnecessary import
--- /dev/null
+// Regression test for #57979. This situation is meant to be an error.
+// As noted in the issue thread, we decided to forbid nested impl
+// trait of this kind:
+//
+// ```rust
+// fn foo() -> impl Foo<impl Bar> { .. }
+// ```
+//
+// Basically there are two hidden variables here, let's call them `X`
+// and `Y`, and we must prove that:
+//
+// ```
+// X: Foo<Y>
+// Y: Bar
+// ```
+//
+// However, the user is only giving us the return type `X`. It's true
+// that in some cases, we can infer `Y` from `X`, because `X` only
+// implements `Foo` for one type (and indeed the compiler does
+// inference of this kind), but I do recall that we intended to forbid
+// this -- in part because such inference is fragile, and there is not
+// necessarily a way for the user to be more explicit should the
+// inference fail (so you could get stuck with no way to port your
+// code forward if, for example, more impls are added to an existing
+// type).
+//
+// The same seems to apply in this situation. Here there are three impl traits, so we have
+//
+// ```
+// X: IntoIterator<Item = Y>
+// Y: Borrow<Data<Z>>
+// Z: AsRef<[u8]>
+// ```
+
+use std::borrow::Borrow;
+
+pub struct Data<TBody>(TBody);
+
+pub fn collect(_: impl IntoIterator<Item = impl Borrow<Data<impl AsRef<[u8]>>>>) {
+ //~^ ERROR
+ unimplemented!()
+}
--- /dev/null
+error[E0666]: nested `impl Trait` is not allowed
+ --> $DIR/issue-57979.rs:39:61
+ |
+LL | pub fn collect(_: impl IntoIterator<Item = impl Borrow<Data<impl AsRef<[u8]>>>>) {
+ | -----------------^^^^^^^^^^^^^^^^--
+ | | |
+ | | nested `impl Trait` here
+ | outer `impl Trait`
+
+error[E0601]: `main` function not found in crate `issue_57979`
+ |
+ = note: consider adding a `main` function to `$DIR/issue-57979.rs`
+
+error: aborting due to 2 previous errors
+
+Some errors occurred: E0601, E0666.
+For more information about an error, try `rustc --explain E0601`.
fn CamelCase() {} //~ WARN should have a snake
- struct snake_case; //~ WARN should have a camel
+ struct snake_case; //~ WARN should have an upper camel
}
}
-warning: type `snake_case` should have a camel case name
+warning: type `snake_case` should have an upper camel case name
--> $DIR/lint-group-nonstandard-style.rs:22:16
|
-LL | struct snake_case; //~ WARN should have a camel
- | ^^^^^^^^^^ help: convert the identifier to camel case: `SnakeCase`
+LL | struct snake_case; //~ WARN should have an upper camel
+ | ^^^^^^^^^^ help: convert the identifier to upper camel case: `SnakeCase`
|
note: lint level defined here
--> $DIR/lint-group-nonstandard-style.rs:18:17
#![allow(dead_code)]
struct ONE_TWO_THREE;
-//~^ ERROR type `ONE_TWO_THREE` should have a camel case name
+//~^ ERROR type `ONE_TWO_THREE` should have an upper camel case name
-struct foo { //~ ERROR type `foo` should have a camel case name
+struct foo { //~ ERROR type `foo` should have an upper camel case name
bar: isize,
}
-enum foo2 { //~ ERROR type `foo2` should have a camel case name
+enum foo2 { //~ ERROR type `foo2` should have an upper camel case name
Bar
}
-struct foo3 { //~ ERROR type `foo3` should have a camel case name
+struct foo3 { //~ ERROR type `foo3` should have an upper camel case name
bar: isize
}
-type foo4 = isize; //~ ERROR type `foo4` should have a camel case name
+type foo4 = isize; //~ ERROR type `foo4` should have an upper camel case name
enum Foo5 {
- bar //~ ERROR variant `bar` should have a camel case name
+ bar //~ ERROR variant `bar` should have an upper camel case name
}
-trait foo6 { //~ ERROR trait `foo6` should have a camel case name
+trait foo6 { //~ ERROR trait `foo6` should have an upper camel case name
fn dummy(&self) { }
}
-fn f<ty>(_: ty) {} //~ ERROR type parameter `ty` should have a camel case name
+fn f<ty>(_: ty) {} //~ ERROR type parameter `ty` should have an upper camel case name
#[repr(C)]
struct foo7 {
bar: isize,
}
-struct X86_64;
-
-struct X86__64; //~ ERROR type `X86__64` should have a camel case name
-
-struct Abc_123; //~ ERROR type `Abc_123` should have a camel case name
-
-struct A1_b2_c3; //~ ERROR type `A1_b2_c3` should have a camel case name
-
fn main() { }
-error: type `ONE_TWO_THREE` should have a camel case name
+error: type `ONE_TWO_THREE` should have an upper camel case name
--> $DIR/lint-non-camel-case-types.rs:4:8
|
LL | struct ONE_TWO_THREE;
- | ^^^^^^^^^^^^^ help: convert the identifier to camel case: `OneTwoThree`
+ | ^^^^^^^^^^^^^ help: convert the identifier to upper camel case: `OneTwoThree`
|
note: lint level defined here
--> $DIR/lint-non-camel-case-types.rs:1:11
LL | #![forbid(non_camel_case_types)]
| ^^^^^^^^^^^^^^^^^^^^
-error: type `foo` should have a camel case name
+error: type `foo` should have an upper camel case name
--> $DIR/lint-non-camel-case-types.rs:7:8
|
-LL | struct foo { //~ ERROR type `foo` should have a camel case name
- | ^^^ help: convert the identifier to camel case: `Foo`
+LL | struct foo { //~ ERROR type `foo` should have an upper camel case name
+ | ^^^ help: convert the identifier to upper camel case: `Foo`
-error: type `foo2` should have a camel case name
+error: type `foo2` should have an upper camel case name
--> $DIR/lint-non-camel-case-types.rs:11:6
|
-LL | enum foo2 { //~ ERROR type `foo2` should have a camel case name
- | ^^^^ help: convert the identifier to camel case: `Foo2`
+LL | enum foo2 { //~ ERROR type `foo2` should have an upper camel case name
+ | ^^^^ help: convert the identifier to upper camel case: `Foo2`
-error: type `foo3` should have a camel case name
+error: type `foo3` should have an upper camel case name
--> $DIR/lint-non-camel-case-types.rs:15:8
|
-LL | struct foo3 { //~ ERROR type `foo3` should have a camel case name
- | ^^^^ help: convert the identifier to camel case: `Foo3`
+LL | struct foo3 { //~ ERROR type `foo3` should have an upper camel case name
+ | ^^^^ help: convert the identifier to upper camel case: `Foo3`
-error: type `foo4` should have a camel case name
+error: type `foo4` should have an upper camel case name
--> $DIR/lint-non-camel-case-types.rs:19:6
|
-LL | type foo4 = isize; //~ ERROR type `foo4` should have a camel case name
- | ^^^^ help: convert the identifier to camel case: `Foo4`
+LL | type foo4 = isize; //~ ERROR type `foo4` should have an upper camel case name
+ | ^^^^ help: convert the identifier to upper camel case: `Foo4`
-error: variant `bar` should have a camel case name
+error: variant `bar` should have an upper camel case name
--> $DIR/lint-non-camel-case-types.rs:22:5
|
-LL | bar //~ ERROR variant `bar` should have a camel case name
- | ^^^ help: convert the identifier to camel case: `Bar`
+LL | bar //~ ERROR variant `bar` should have an upper camel case name
+ | ^^^ help: convert the identifier to upper camel case: `Bar`
-error: trait `foo6` should have a camel case name
+error: trait `foo6` should have an upper camel case name
--> $DIR/lint-non-camel-case-types.rs:25:7
|
-LL | trait foo6 { //~ ERROR trait `foo6` should have a camel case name
- | ^^^^ help: convert the identifier to camel case: `Foo6`
+LL | trait foo6 { //~ ERROR trait `foo6` should have an upper camel case name
+ | ^^^^ help: convert the identifier to upper camel case: `Foo6`
-error: type parameter `ty` should have a camel case name
+error: type parameter `ty` should have an upper camel case name
--> $DIR/lint-non-camel-case-types.rs:29:6
|
-LL | fn f<ty>(_: ty) {} //~ ERROR type parameter `ty` should have a camel case name
- | ^^ help: convert the identifier to camel case: `Ty`
+LL | fn f<ty>(_: ty) {} //~ ERROR type parameter `ty` should have an upper camel case name
+ | ^^ help: convert the identifier to upper camel case: `Ty`
-error: type `X86__64` should have a camel case name
- --> $DIR/lint-non-camel-case-types.rs:38:8
- |
-LL | struct X86__64; //~ ERROR type `X86__64` should have a camel case name
- | ^^^^^^^ help: convert the identifier to camel case: `X86_64`
-
-error: type `Abc_123` should have a camel case name
- --> $DIR/lint-non-camel-case-types.rs:40:8
- |
-LL | struct Abc_123; //~ ERROR type `Abc_123` should have a camel case name
- | ^^^^^^^ help: convert the identifier to camel case: `Abc123`
-
-error: type `A1_b2_c3` should have a camel case name
- --> $DIR/lint-non-camel-case-types.rs:42:8
- |
-LL | struct A1_b2_c3; //~ ERROR type `A1_b2_c3` should have a camel case name
- | ^^^^^^^^ help: convert the identifier to camel case: `A1B2C3`
-
-error: aborting due to 11 previous errors
+error: aborting due to 8 previous errors
use std::mem::*; // shouldn't get errors for not using
// everything imported
use std::fmt::{};
-//~^ ERROR unused import: `use std::fmt::{};`
+//~^ ERROR unused import: `std::fmt::{}`
// Should get errors for both 'Some' and 'None'
use std::option::Option::{Some, None};
-error: unused import: `use std::fmt::{};`
- --> $DIR/lint-unused-imports.rs:8:1
+error: unused import: `std::fmt::{}`
+ --> $DIR/lint-unused-imports.rs:8:5
|
LL | use std::fmt::{};
- | ^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^
|
note: lint level defined here
--> $DIR/lint-unused-imports.rs:1:9
($p:pat >) => {}; //~ERROR `$p:pat` is followed by `>`
($p:pat +) => {}; //~ERROR `$p:pat` is followed by `+`
($p:pat ident) => {}; //~ERROR `$p:pat` is followed by `ident`
- ($p:pat $p:pat) => {}; //~ERROR `$p:pat` is followed by `$p:pat`
+ ($p:pat $q:pat) => {}; //~ERROR `$p:pat` is followed by `$q:pat`
($p:pat $e:expr) => {}; //~ERROR `$p:pat` is followed by `$e:expr`
($p:pat $t:ty) => {}; //~ERROR `$p:pat` is followed by `$t:ty`
($p:pat $s:stmt) => {}; //~ERROR `$p:pat` is followed by `$s:stmt`
- ($p:pat $p:path) => {}; //~ERROR `$p:pat` is followed by `$p:path`
+ ($p:pat $q:path) => {}; //~ERROR `$p:pat` is followed by `$q:path`
($p:pat $b:block) => {}; //~ERROR `$p:pat` is followed by `$b:block`
($p:pat $i:ident) => {}; //~ERROR `$p:pat` is followed by `$i:ident`
($p:pat $t:tt) => {}; //~ERROR `$p:pat` is followed by `$t:tt`
($e:expr if) => {}; //~ERROR `$e:expr` is followed by `if`
($e:expr in) => {}; //~ERROR `$e:expr` is followed by `in`
($e:expr $p:pat) => {}; //~ERROR `$e:expr` is followed by `$p:pat`
- ($e:expr $e:expr) => {}; //~ERROR `$e:expr` is followed by `$e:expr`
+ ($e:expr $f:expr) => {}; //~ERROR `$e:expr` is followed by `$f:expr`
($e:expr $t:ty) => {}; //~ERROR `$e:expr` is followed by `$t:ty`
($e:expr $s:stmt) => {}; //~ERROR `$e:expr` is followed by `$s:stmt`
($e:expr $p:path) => {}; //~ERROR `$e:expr` is followed by `$p:path`
($t:ty if) => {}; //~ERROR `$t:ty` is followed by `if`
($t:ty $p:pat) => {}; //~ERROR `$t:ty` is followed by `$p:pat`
($t:ty $e:expr) => {}; //~ERROR `$t:ty` is followed by `$e:expr`
- ($t:ty $t:ty) => {}; //~ERROR `$t:ty` is followed by `$t:ty`
+ ($t:ty $r:ty) => {}; //~ERROR `$t:ty` is followed by `$r:ty`
($t:ty $s:stmt) => {}; //~ERROR `$t:ty` is followed by `$s:stmt`
($t:ty $p:path) => {}; //~ERROR `$t:ty` is followed by `$p:path`
($t:ty $b:block) => {}; // ok (RFC 1494)
($t:ty $i:ident) => {}; //~ERROR `$t:ty` is followed by `$i:ident`
- ($t:ty $t:tt) => {}; //~ERROR `$t:ty` is followed by `$t:tt`
+ ($t:ty $r:tt) => {}; //~ERROR `$t:ty` is followed by `$r:tt`
($t:ty $i:item) => {}; //~ERROR `$t:ty` is followed by `$i:item`
($t:ty $m:meta) => {}; //~ERROR `$t:ty` is followed by `$m:meta`
}
($s:stmt $p:pat) => {}; //~ERROR `$s:stmt` is followed by `$p:pat`
($s:stmt $e:expr) => {}; //~ERROR `$s:stmt` is followed by `$e:expr`
($s:stmt $t:ty) => {}; //~ERROR `$s:stmt` is followed by `$t:ty`
- ($s:stmt $s:stmt) => {}; //~ERROR `$s:stmt` is followed by `$s:stmt`
+ ($s:stmt $t:stmt) => {}; //~ERROR `$s:stmt` is followed by `$t:stmt`
($s:stmt $p:path) => {}; //~ERROR `$s:stmt` is followed by `$p:path`
($s:stmt $b:block) => {}; //~ERROR `$s:stmt` is followed by `$b:block`
($s:stmt $i:ident) => {}; //~ERROR `$s:stmt` is followed by `$i:ident`
($p:path +) => {}; //~ERROR `$p:path` is followed by `+`
($p:path ident) => {}; //~ERROR `$p:path` is followed by `ident`
($p:path if) => {}; //~ERROR `$p:path` is followed by `if`
- ($p:path $p:pat) => {}; //~ERROR `$p:path` is followed by `$p:pat`
+ ($p:path $q:pat) => {}; //~ERROR `$p:path` is followed by `$q:pat`
($p:path $e:expr) => {}; //~ERROR `$p:path` is followed by `$e:expr`
($p:path $t:ty) => {}; //~ERROR `$p:path` is followed by `$t:ty`
($p:path $s:stmt) => {}; //~ERROR `$p:path` is followed by `$s:stmt`
- ($p:path $p:path) => {}; //~ERROR `$p:path` is followed by `$p:path`
+ ($p:path $q:path) => {}; //~ERROR `$p:path` is followed by `$q:path`
($p:path $b:block) => {}; // ok (RFC 1494)
($p:path $i:ident) => {}; //~ERROR `$p:path` is followed by `$i:ident`
($p:path $t:tt) => {}; //~ERROR `$p:path` is followed by `$t:tt`
|
= note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
-error: `$p:pat` is followed by `$p:pat`, which is not allowed for `pat` fragments
+error: `$p:pat` is followed by `$q:pat`, which is not allowed for `pat` fragments
--> $DIR/macro-follow.rs:15:13
|
-LL | ($p:pat $p:pat) => {}; //~ERROR `$p:pat` is followed by `$p:pat`
+LL | ($p:pat $q:pat) => {}; //~ERROR `$p:pat` is followed by `$q:pat`
| ^^^^^^ not allowed after `pat` fragments
|
= note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
|
= note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
-error: `$p:pat` is followed by `$p:path`, which is not allowed for `pat` fragments
+error: `$p:pat` is followed by `$q:path`, which is not allowed for `pat` fragments
--> $DIR/macro-follow.rs:19:13
|
-LL | ($p:pat $p:path) => {}; //~ERROR `$p:pat` is followed by `$p:path`
+LL | ($p:pat $q:path) => {}; //~ERROR `$p:pat` is followed by `$q:path`
| ^^^^^^^ not allowed after `pat` fragments
|
= note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in`
|
= note: allowed there are: `=>`, `,` or `;`
-error: `$e:expr` is followed by `$e:expr`, which is not allowed for `expr` fragments
+error: `$e:expr` is followed by `$f:expr`, which is not allowed for `expr` fragments
--> $DIR/macro-follow.rs:40:14
|
-LL | ($e:expr $e:expr) => {}; //~ERROR `$e:expr` is followed by `$e:expr`
+LL | ($e:expr $f:expr) => {}; //~ERROR `$e:expr` is followed by `$f:expr`
| ^^^^^^^ not allowed after `expr` fragments
|
= note: allowed there are: `=>`, `,` or `;`
|
= note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
-error: `$t:ty` is followed by `$t:ty`, which is not allowed for `ty` fragments
+error: `$t:ty` is followed by `$r:ty`, which is not allowed for `ty` fragments
--> $DIR/macro-follow.rs:60:12
|
-LL | ($t:ty $t:ty) => {}; //~ERROR `$t:ty` is followed by `$t:ty`
+LL | ($t:ty $r:ty) => {}; //~ERROR `$t:ty` is followed by `$r:ty`
| ^^^^^ not allowed after `ty` fragments
|
= note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
|
= note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
-error: `$t:ty` is followed by `$t:tt`, which is not allowed for `ty` fragments
+error: `$t:ty` is followed by `$r:tt`, which is not allowed for `ty` fragments
--> $DIR/macro-follow.rs:65:12
|
-LL | ($t:ty $t:tt) => {}; //~ERROR `$t:ty` is followed by `$t:tt`
+LL | ($t:ty $r:tt) => {}; //~ERROR `$t:ty` is followed by `$r:tt`
| ^^^^^ not allowed after `ty` fragments
|
= note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
|
= note: allowed there are: `=>`, `,` or `;`
-error: `$s:stmt` is followed by `$s:stmt`, which is not allowed for `stmt` fragments
+error: `$s:stmt` is followed by `$t:stmt`, which is not allowed for `stmt` fragments
--> $DIR/macro-follow.rs:85:14
|
-LL | ($s:stmt $s:stmt) => {}; //~ERROR `$s:stmt` is followed by `$s:stmt`
+LL | ($s:stmt $t:stmt) => {}; //~ERROR `$s:stmt` is followed by `$t:stmt`
| ^^^^^^^ not allowed after `stmt` fragments
|
= note: allowed there are: `=>`, `,` or `;`
|
= note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
-error: `$p:path` is followed by `$p:pat`, which is not allowed for `path` fragments
+error: `$p:path` is followed by `$q:pat`, which is not allowed for `path` fragments
--> $DIR/macro-follow.rs:100:14
|
-LL | ($p:path $p:pat) => {}; //~ERROR `$p:path` is followed by `$p:pat`
+LL | ($p:path $q:pat) => {}; //~ERROR `$p:path` is followed by `$q:pat`
| ^^^^^^ not allowed after `path` fragments
|
= note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
|
= note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
-error: `$p:path` is followed by `$p:path`, which is not allowed for `path` fragments
+error: `$p:path` is followed by `$q:path`, which is not allowed for `path` fragments
--> $DIR/macro-follow.rs:104:14
|
-LL | ($p:path $p:path) => {}; //~ERROR `$p:path` is followed by `$p:path`
+LL | ($p:path $q:path) => {}; //~ERROR `$p:path` is followed by `$q:path`
| ^^^^^^^ not allowed after `path` fragments
|
= note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where`
--- /dev/null
+// Test that duplicate matcher binding names are caught at declaration time, rather than at macro
+// invocation time.
+//
+// FIXME(mark-i-m): Update this when it becomes a hard error.
+
+// compile-pass
+
+#![allow(unused_macros)]
+
+macro_rules! foo1 {
+ ($a:ident, $a:ident) => {}; //~WARNING duplicate matcher binding
+ ($a:ident, $a:path) => {}; //~WARNING duplicate matcher binding
+}
+
+macro_rules! foo2 {
+ ($a:ident) => {}; // OK
+ ($a:path) => {}; // OK
+}
+
+macro_rules! foo3 {
+ ($a:ident, $($a:ident),*) => {}; //~WARNING duplicate matcher binding
+ ($($a:ident)+ # $($($a:path),+);*) => {}; //~WARNING duplicate matcher binding
+}
+
+fn main() {}
--- /dev/null
+warning: duplicate matcher binding
+ --> $DIR/macro-multiple-matcher-bindings.rs:11:6
+ |
+LL | ($a:ident, $a:ident) => {}; //~WARNING duplicate matcher binding
+ | ^^^^^^^^ ^^^^^^^^
+ |
+ = note: #[warn(duplicate_matcher_binding_name)] on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #57593 <https://github.com/rust-lang/rust/issues/57593>
+
+warning: duplicate matcher binding
+ --> $DIR/macro-multiple-matcher-bindings.rs:12:6
+ |
+LL | ($a:ident, $a:path) => {}; //~WARNING duplicate matcher binding
+ | ^^^^^^^^ ^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #57593 <https://github.com/rust-lang/rust/issues/57593>
+
+warning: duplicate matcher binding
+ --> $DIR/macro-multiple-matcher-bindings.rs:21:6
+ |
+LL | ($a:ident, $($a:ident),*) => {}; //~WARNING duplicate matcher binding
+ | ^^^^^^^^ ^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #57593 <https://github.com/rust-lang/rust/issues/57593>
+
+warning: duplicate matcher binding
+ --> $DIR/macro-multiple-matcher-bindings.rs:22:8
+ |
+LL | ($($a:ident)+ # $($($a:path),+);*) => {}; //~WARNING duplicate matcher binding
+ | ^^^^^^^^ ^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #57593 <https://github.com/rust-lang/rust/issues/57593>
+
--- /dev/null
+fn main() {
+ let _ = test_func1(1);
+ let _ = test_func2(1);
+}
+
+fn test_func1(n: i32) -> i32 {
+ //~^ NOTE expected `i32` because of return type
+ match n {
+ 12 => 'b',
+ //~^ ERROR mismatched types
+ //~| NOTE expected i32, found char
+ _ => 42,
+ }
+}
+
+fn test_func2(n: i32) -> i32 {
+ let x = match n {
+ //~^ NOTE `match` arms have incompatible types
+ 12 => 'b',
+ //~^ NOTE this is found to be of type `char`
+ _ => 42,
+ //~^ ERROR match arms have incompatible types
+ //~| NOTE expected char, found integer
+ //~| NOTE expected type `char`
+ };
+ x
+}
+
+fn test_func3(n: i32) -> i32 {
+ let x = match n {
+ //~^ NOTE `match` arms have incompatible types
+ 1 => 'b',
+ 2 => 'b',
+ 3 => 'b',
+ 4 => 'b',
+ 5 => 'b',
+ 6 => 'b',
+ //~^ NOTE this and all prior arms are found to be of type `char`
+ _ => 42,
+ //~^ ERROR match arms have incompatible types
+ //~| NOTE expected char, found integer
+ //~| NOTE expected type `char`
+ };
+ x
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/match-type-err-first-arm.rs:9:15
+ |
+LL | fn test_func1(n: i32) -> i32 {
+ | --- expected `i32` because of return type
+...
+LL | 12 => 'b',
+ | ^^^ expected i32, found char
+
+error[E0308]: match arms have incompatible types
+ --> $DIR/match-type-err-first-arm.rs:21:14
+ |
+LL | let x = match n {
+ | _____________-
+LL | | //~^ NOTE `match` arms have incompatible types
+LL | | 12 => 'b',
+ | | --- this is found to be of type `char`
+LL | | //~^ NOTE this is found to be of type `char`
+LL | | _ => 42,
+ | | ^^ expected char, found integer
+... |
+LL | | //~| NOTE expected type `char`
+LL | | };
+ | |_____- `match` arms have incompatible types
+ |
+ = note: expected type `char`
+ found type `{integer}`
+
+error[E0308]: match arms have incompatible types
+ --> $DIR/match-type-err-first-arm.rs:39:14
+ |
+LL | let x = match n {
+ | _____________-
+LL | | //~^ NOTE `match` arms have incompatible types
+LL | | 1 => 'b',
+LL | | 2 => 'b',
+... |
+LL | | 6 => 'b',
+ | | --- this and all prior arms are found to be of type `char`
+LL | | //~^ NOTE this and all prior arms are found to be of type `char`
+LL | | _ => 42,
+ | | ^^ expected char, found integer
+... |
+LL | | //~| NOTE expected type `char`
+LL | | };
+ | |_____- `match` arms have incompatible types
+ |
+ = note: expected type `char`
+ found type `{integer}`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+#![feature(arbitrary_self_types, coerce_unsized, dispatch_from_dyn, unsize, unsized_locals)]
+
+// This tests a few edge-cases around `arbitrary_self_types`. Most specifically,
+// it checks that the `ObjectCandidate` you get from method matching can't
+// match a trait with the same DefId as a supertrait but a bad type parameter.
+
+use std::marker::PhantomData;
+
+mod internal {
+ use std::ops::{CoerceUnsized, Deref, DispatchFromDyn};
+ use std::marker::{PhantomData, Unsize};
+
+ pub struct Smaht<T: ?Sized, MISC>(pub Box<T>, pub PhantomData<MISC>);
+
+ impl<T: ?Sized, MISC> Deref for Smaht<T, MISC> {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+ }
+ impl<T: ?Sized + Unsize<U>, U: ?Sized, MISC> CoerceUnsized<Smaht<U, MISC>>
+ for Smaht<T, MISC>
+ {}
+ impl<T: ?Sized + Unsize<U>, U: ?Sized, MISC> DispatchFromDyn<Smaht<U, MISC>>
+ for Smaht<T, MISC>
+ {}
+
+ pub trait Foo: X<u32> {}
+ pub trait X<T> {
+ fn foo(self: Smaht<Self, T>) -> T;
+ }
+
+ impl X<u32> for () {
+ fn foo(self: Smaht<Self, u32>) -> u32 {
+ 0
+ }
+ }
+
+ pub trait Marker {}
+ impl Marker for dyn Foo {}
+ impl<T: Marker + ?Sized> X<u64> for T {
+ fn foo(self: Smaht<Self, u64>) -> u64 {
+ 1
+ }
+ }
+
+ impl Deref for dyn Foo {
+ type Target = ();
+ fn deref(&self) -> &() { &() }
+ }
+
+ impl Foo for () {}
+}
+
+pub trait FinalFoo {
+ fn foo(&self) -> u8;
+}
+
+impl FinalFoo for () {
+ fn foo(&self) -> u8 { 0 }
+}
+
+mod nuisance_foo {
+ pub trait NuisanceFoo {
+ fn foo(self);
+ }
+
+ impl<T: ?Sized> NuisanceFoo for T {
+ fn foo(self) {}
+ }
+}
+
+
+fn objectcandidate_impl() {
+ let x: internal::Smaht<(), u32> = internal::Smaht(Box::new(()), PhantomData);
+ let x: internal::Smaht<dyn internal::Foo, u32> = x;
+
+ // This picks `<dyn internal::Foo as X<u32>>::foo` via `ObjectCandidate`.
+ //
+ // The `TraitCandidate` is not relevant because `X` is not in scope.
+ let z = x.foo();
+
+ // Observe the type of `z` is `u32`
+ let _seetype: () = z; //~ ERROR mismatched types
+ //~| expected (), found u32
+}
+
+fn traitcandidate_impl() {
+ use internal::X;
+
+ let x: internal::Smaht<(), u64> = internal::Smaht(Box::new(()), PhantomData);
+ let x: internal::Smaht<dyn internal::Foo, u64> = x;
+
+ // This picks `<dyn internal::Foo as X<u64>>::foo` via `TraitCandidate`.
+ //
+ // The `ObjectCandidate` does not apply, as it only applies to
+ // `X<u32>` (and not `X<u64>`).
+ let z = x.foo();
+
+ // Observe the type of `z` is `u64`
+ let _seetype: () = z; //~ ERROR mismatched types
+ //~| expected (), found u64
+}
+
+fn traitcandidate_impl_with_nuisance() {
+ use internal::X;
+ use nuisance_foo::NuisanceFoo;
+
+ let x: internal::Smaht<(), u64> = internal::Smaht(Box::new(()), PhantomData);
+ let x: internal::Smaht<dyn internal::Foo, u64> = x;
+
+ // This picks `<dyn internal::Foo as X<u64>>::foo` via `TraitCandidate`.
+ //
+ // The `ObjectCandidate` does not apply, as it only applies to
+ // `X<u32>` (and not `X<u64>`).
+ //
+ // The NuisanceFoo impl has the same priority as the `X` impl,
+ // so we get a conflict.
+ let z = x.foo(); //~ ERROR multiple applicable items in scope
+}
+
+
+fn neither_impl() {
+ let x: internal::Smaht<(), u64> = internal::Smaht(Box::new(()), PhantomData);
+ let x: internal::Smaht<dyn internal::Foo, u64> = x;
+
+ // This can't pick the `TraitCandidate` impl, because `Foo` is not
+ // imported. However, this also can't pick the `ObjectCandidate`
+ // impl, because it only applies to `X<u32>` (and not `X<u64>`).
+ //
+ // Therefore, neither of the candidates is applicable, and we pick
+ // the `FinalFoo` impl after another deref, which will return `u8`.
+ let z = x.foo();
+
+ // Observe the type of `z` is `u8`
+ let _seetype: () = z; //~ ERROR mismatched types
+ //~| expected (), found u8
+}
+
+fn both_impls() {
+ use internal::X;
+
+ let x: internal::Smaht<(), u32> = internal::Smaht(Box::new(()), PhantomData);
+ let x: internal::Smaht<dyn internal::Foo, u32> = x;
+
+ // This can pick both the `TraitCandidate` and the `ObjectCandidate` impl.
+ //
+ // However, the `ObjectCandidate` is considered an "inherent candidate",
+ // and therefore has priority over both the `TraitCandidate` as well as
+ // any other "nuisance" candidate" (if present).
+ let z = x.foo();
+
+ // Observe the type of `z` is `u32`
+ let _seetype: () = z; //~ ERROR mismatched types
+ //~| expected (), found u32
+}
+
+
+fn both_impls_with_nuisance() {
+ // Similar to the `both_impls` example, except with a nuisance impl to
+ // make sure the `ObjectCandidate` indeed has a higher priority.
+
+ use internal::X;
+ use nuisance_foo::NuisanceFoo;
+
+ let x: internal::Smaht<(), u32> = internal::Smaht(Box::new(()), PhantomData);
+ let x: internal::Smaht<dyn internal::Foo, u32> = x;
+ let z = x.foo();
+
+ // Observe the type of `z` is `u32`
+ let _seetype: () = z; //~ ERROR mismatched types
+ //~| expected (), found u32
+}
+
+fn main() {
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:85:24
+ |
+LL | let _seetype: () = z; //~ ERROR mismatched types
+ | ^ expected (), found u32
+ |
+ = note: expected type `()`
+ found type `u32`
+
+error[E0308]: mismatched types
+ --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:102:24
+ |
+LL | let _seetype: () = z; //~ ERROR mismatched types
+ | ^ expected (), found u64
+ |
+ = note: expected type `()`
+ found type `u64`
+
+error[E0034]: multiple applicable items in scope
+ --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:120:15
+ |
+LL | let z = x.foo(); //~ ERROR multiple applicable items in scope
+ | ^^^ multiple `foo` found
+ |
+note: candidate #1 is defined in an impl of the trait `internal::X` for the type `_`
+ --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:43:9
+ |
+LL | fn foo(self: Smaht<Self, u64>) -> u64 {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl of the trait `nuisance_foo::NuisanceFoo` for the type `_`
+ --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:70:9
+ |
+LL | fn foo(self) {}
+ | ^^^^^^^^^^^^
+note: candidate #3 is defined in the trait `FinalFoo`
+ --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:57:5
+ |
+LL | fn foo(&self) -> u8;
+ | ^^^^^^^^^^^^^^^^^^^^
+ = help: to disambiguate the method call, write `FinalFoo::foo(x)` instead
+
+error[E0308]: mismatched types
+ --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:137:24
+ |
+LL | let _seetype: () = z; //~ ERROR mismatched types
+ | ^ expected (), found u8
+ |
+ = note: expected type `()`
+ found type `u8`
+
+error[E0308]: mismatched types
+ --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:155:24
+ |
+LL | let _seetype: () = z; //~ ERROR mismatched types
+ | ^ expected (), found u32
+ |
+ = note: expected type `()`
+ found type `u32`
+
+error[E0308]: mismatched types
+ --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:172:24
+ |
+LL | let _seetype: () = z; //~ ERROR mismatched types
+ | ^ expected (), found u32
+ |
+ = note: expected type `()`
+ found type `u32`
+
+error: aborting due to 6 previous errors
+
+Some errors occurred: E0034, E0308.
+For more information about an error, try `rustc --explain E0034`.
--- /dev/null
+// compile-pass
+
+// Check that method probing ObjectCandidate works in the presence of
+// auto traits and/or HRTBs.
+
+mod internal {
+ pub trait MyObject<'a> {
+ type Output;
+
+ fn foo(&self) -> Self::Output;
+ }
+
+ impl<'a> MyObject<'a> for () {
+ type Output = &'a u32;
+
+ fn foo(&self) -> Self::Output { &4 }
+ }
+}
+
+fn t1(d: &dyn for<'a> internal::MyObject<'a, Output=&'a u32>) {
+ d.foo();
+}
+
+fn t2(d: &dyn internal::MyObject<'static, Output=&'static u32>) {
+ d.foo();
+}
+
+fn t3(d: &(dyn for<'a> internal::MyObject<'a, Output=&'a u32> + Sync)) {
+ d.foo();
+}
+
+fn t4(d: &(dyn internal::MyObject<'static, Output=&'static u32> + Sync)) {
+ d.foo();
+}
+
+fn main() {
+ t1(&());
+ t2(&());
+ t3(&());
+ t4(&());
+}
#![stable(feature = "stable_test_feature", since = "1.0.0")]
pub fn unmarked() {
- //~^ ERROR This node does not have a stability attribute
+ //~^ ERROR function has missing stability attribute
()
}
pub mod bar {
// #[stable] is not inherited
pub fn unmarked() {}
- //~^ ERROR This node does not have a stability attribute
+ //~^ ERROR function has missing stability attribute
}
-error: This node does not have a stability attribute
+error: function has missing stability attribute
--> $DIR/missing-stability.rs:8:1
|
LL | / pub fn unmarked() {
-LL | | //~^ ERROR This node does not have a stability attribute
+LL | | //~^ ERROR function has missing stability attribute
LL | | ()
LL | | }
| |_^
-error: This node does not have a stability attribute
+error: function has missing stability attribute
--> $DIR/missing-stability.rs:22:5
|
LL | pub fn unmarked() {}
--- /dev/null
+// revisions: migrate nll
+//[migrate]compile-flags: -Z borrowck=migrate
+#![cfg_attr(nll, feature(nll))]
+
+// compile-pass
+
+// Test that we propagate region relations from closures precisely when there is
+// more than one non-local lower bound.
+
+// In this case the closure has signature
+// |x: &'4 mut (&'5 (&'1 str, &'2 str), &'3 str)| -> ..
+// We end up with a `'3: '5` constraint that we can propagate as
+// `'3: '1`, `'3: '2`, but previously we approximated it as `'3: 'static`.
+
+// As an optimization, we primarily propagate bounds for the "representative"
+// of each SCC. As such we have these two similar cases where hopefully one
+// of them will test the case we want (case2, when this test was added).
+mod case1 {
+ fn f(s: &str) {
+ g(s, |x| h(x));
+ }
+
+ fn g<T, F>(_: T, _: F)
+ where F: Fn(&mut (&(T, T), T)) {}
+
+ fn h<T>(_: &mut (&(T, T), T)) {}
+}
+
+mod case2 {
+ fn f(s: &str) {
+ g(s, |x| h(x));
+ }
+
+ fn g<T, F>(_: T, _: F)
+ where F: Fn(&mut (T, &(T, T))) {}
+
+ fn h<T>(_: &mut (T, &(T, T))) {}
+}
+
+fn main() {}
--- /dev/null
+// run-pass
+
+#![allow(dead_code)]
+
+trait Range {
+ const FIRST: u8;
+ const LAST: u8;
+}
+
+struct OneDigit;
+impl Range for OneDigit {
+ const FIRST: u8 = 0;
+ const LAST: u8 = 9;
+}
+
+struct TwoDigits;
+impl Range for TwoDigits {
+ const FIRST: u8 = 10;
+ const LAST: u8 = 99;
+}
+
+struct ThreeDigits;
+impl Range for ThreeDigits {
+ const FIRST: u8 = 100;
+ const LAST: u8 = 255;
+}
+
+fn digits(x: u8) -> u32 {
+ match x {
+ OneDigit::FIRST...OneDigit::LAST => 1,
+ TwoDigits::FIRST...TwoDigits::LAST => 2,
+ ThreeDigits::FIRST...ThreeDigits::LAST => 3,
+ _ => unreachable!(),
+ }
+}
+
+fn main() {
+ assert_eq!(digits(100), 3);
+}
--- /dev/null
+#![allow(warnings)]
+#![feature(nll)]
+
+fn main() {
+ let i = &3;
+
+ let f = |x: &i32| -> &i32 { x };
+ //~^ ERROR lifetime may not live long enough
+ let j = f(i);
+
+ let g = |x: &i32| { x };
+ //~^ ERROR lifetime may not live long enough
+ let k = g(i);
+}
--- /dev/null
+error: lifetime may not live long enough
+ --> $DIR/issue-58053.rs:7:33
+ |
+LL | let f = |x: &i32| -> &i32 { x };
+ | - ---- ^ returning this value requires that `'1` must outlive `'2`
+ | | |
+ | | return type of closure is &'2 i32
+ | let's call the lifetime of this reference `'1`
+
+error: lifetime may not live long enough
+ --> $DIR/issue-58053.rs:11:25
+ |
+LL | let g = |x: &i32| { x };
+ | - - ^ returning this value requires that `'1` must outlive `'2`
+ | | |
+ | | return type of closure is &'2 i32
+ | let's call the lifetime of this reference `'1`
+
+error: aborting due to 2 previous errors
+
--- /dev/null
+#![allow(dead_code)]
+#![feature(nll)]
+
+struct A<'a>(&'a ());
+
+trait Y {
+ const X: i32;
+}
+
+impl Y for A<'static> {
+ const X: i32 = 10;
+}
+
+fn foo<'a>(x: i32) {
+ match x {
+ // This uses <A<'a> as Y>::X, but `A<'a>` does not implement `Y`.
+ A::<'a>::X..=A::<'static>::X => (), //~ ERROR lifetime may not live long enough
+ _ => (),
+ }
+}
+
+fn bar<'a>(x: i32) {
+ match x {
+ // This uses <A<'a> as Y>::X, but `A<'a>` does not implement `Y`.
+ A::<'static>::X..=A::<'a>::X => (), //~ ERROR lifetime may not live long enough
+ _ => (),
+ }
+}
+
+fn main() {}
--- /dev/null
+error: lifetime may not live long enough
+ --> $DIR/issue-58299.rs:17:9
+ |
+LL | fn foo<'a>(x: i32) {
+ | -- lifetime `'a` defined here
+...
+LL | A::<'a>::X..=A::<'static>::X => (), //~ ERROR lifetime may not live long enough
+ | ^^^^^^^^^^ requires that `'a` must outlive `'static`
+
+error: lifetime may not live long enough
+ --> $DIR/issue-58299.rs:25:27
+ |
+LL | fn bar<'a>(x: i32) {
+ | -- lifetime `'a` defined here
+...
+LL | A::<'static>::X..=A::<'a>::X => (), //~ ERROR lifetime may not live long enough
+ | ^^^^^^^^^^ requires that `'a` must outlive `'static`
+
+error: aborting due to 2 previous errors
+
}
pub trait Trie<H: Hasher, C: NodeCodec<H>> {
- /// Return the root of the trie.
+ /// Returns the root of the trie.
fn root(&self) -> &H::Out;
/// Is the trie empty?
#[rustc_on_unimplemented="a collection of type `{Self}` cannot be built from an iterator over elements of type `{A}`"]
trait MyFromIterator<A> {
- /// Build a container with elements from an external iterator.
+ /// Builds a container with elements from an external iterator.
fn my_from_iter<T: Iterator<Item=A>>(iterator: T) -> Self;
}
#[rustc_on_unimplemented="a collection of type `{Self}` cannot be built from an iterator over elements of type `{A}`"]
trait MyFromIterator<A> {
- /// Build a container with elements from an external iterator.
+ /// Builds a container with elements from an external iterator.
fn my_from_iter<T: Iterator<Item=A>>(iterator: T) -> Self;
}
+error: unexpected token: `;`
+ --> $DIR/parser-recovery-2.rs:12:15
+ |
+LL | let x = y.; //~ ERROR unexpected token
+ | ^
+
error: incorrect close delimiter: `)`
--> $DIR/parser-recovery-2.rs:8:5
|
LL | ) //~ ERROR incorrect close delimiter: `)`
| ^ incorrect close delimiter
-error: unexpected token: `;`
- --> $DIR/parser-recovery-2.rs:12:15
- |
-LL | let x = y.; //~ ERROR unexpected token
- | ^
-
error[E0425]: cannot find function `foo` in this scope
--> $DIR/parser-recovery-2.rs:7:17
|
option.map(|some| 42;
//~^ ERROR: expected one of
-} //~ ERROR: incorrect close delimiter
+}
//~^ ERROR: expected expression, found `)`
fn main() {}
-error: incorrect close delimiter: `}`
- --> $DIR/issue-10636-2.rs:8:1
- |
-LL | pub fn trace_option(option: Option<isize>) {
- | - close delimiter possibly meant for this
-LL | option.map(|some| 42;
- | - un-closed delimiter
-...
-LL | } //~ ERROR: incorrect close delimiter
- | ^ incorrect close delimiter
-
error: expected one of `)`, `,`, `.`, `?`, or an operator, found `;`
--> $DIR/issue-10636-2.rs:5:25
|
LL | option.map(|some| 42;
- | ^ expected one of `)`, `,`, `.`, `?`, or an operator here
+ | - ^
+ | | |
+ | | help: `)` may belong here
+ | unclosed delimiter
error: expected expression, found `)`
--> $DIR/issue-10636-2.rs:8:1
|
-LL | } //~ ERROR: incorrect close delimiter
+LL | }
| ^ expected expression
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
+error: unexpected close delimiter: `}`
+ --> $DIR/macro-mismatched-delim-paren-brace.rs:5:1
+ |
+LL | } //~ ERROR unexpected close delimiter: `}`
+ | ^ unexpected close delimiter
+
error: incorrect close delimiter: `}`
--> $DIR/macro-mismatched-delim-paren-brace.rs:4:5
|
LL | } //~ ERROR incorrect close delimiter
| ^ incorrect close delimiter
-error: unexpected close delimiter: `}`
- --> $DIR/macro-mismatched-delim-paren-brace.rs:5:1
- |
-LL | } //~ ERROR unexpected close delimiter: `}`
- | ^ unexpected close delimiter
-
error: aborting due to 2 previous errors
--> $DIR/privacy-struct-ctor.rs:20:9
|
LL | Z;
- | ^ constructor is not visible here due to private fields
-help: a tuple struct with a similar name exists
- |
-LL | S;
| ^
-help: possible better candidate is found in another module, you can import it into scope
- |
-LL | use m::n::Z;
- |
+ | |
+ | constructor is not visible here due to private fields
+ | help: a tuple struct with a similar name exists: `S`
error[E0423]: expected value, found struct `S`
--> $DIR/privacy-struct-ctor.rs:33:5
|
LL | S;
| ^ constructor is not visible here due to private fields
-help: possible better candidate is found in another module, you can import it into scope
- |
-LL | use m::S;
- |
error[E0423]: expected value, found struct `S2`
--> $DIR/privacy-struct-ctor.rs:38:5
//~| expected type `()`
//~| found type `std::result::Result<bool, std::io::Error>`
//~| expected one of
- } else { //~ ERROR: incorrect close delimiter: `}`
+ } else {
//~^ ERROR: expected one of
//~| unexpected token
Ok(false);
-error: incorrect close delimiter: `}`
- --> $DIR/token-error-correct-3.rs:20:9
- |
-LL | if !is_directory(path.as_ref()) { //~ ERROR: cannot find function `is_directory`
- | - close delimiter possibly meant for this
-LL | callback(path.as_ref(); //~ ERROR expected one of
- | - un-closed delimiter
-...
-LL | } else { //~ ERROR: incorrect close delimiter: `}`
- | ^ incorrect close delimiter
-
error: expected one of `)`, `,`, `.`, `?`, or an operator, found `;`
--> $DIR/token-error-correct-3.rs:14:35
|
LL | callback(path.as_ref(); //~ ERROR expected one of
- | ^ expected one of `)`, `,`, `.`, `?`, or an operator here
+ | - ^
+ | | |
+ | | help: `)` may belong here
+ | unclosed delimiter
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `)`
--> $DIR/token-error-correct-3.rs:20:9
LL | fs::create_dir_all(path.as_ref()).map(|()| true) //~ ERROR: mismatched types
| - expected one of `.`, `;`, `?`, `}`, or an operator here
...
-LL | } else { //~ ERROR: incorrect close delimiter: `}`
+LL | } else {
| ^ unexpected token
error[E0425]: cannot find function `is_directory` in this scope
= note: expected type `()`
found type `std::result::Result<bool, std::io::Error>`
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
Some errors occurred: E0308, E0425.
For more information about an error, try `rustc --explain E0308`.
fn main() {
foo(bar(;
- //~^ ERROR: expected expression, found `;`
+ //~^ ERROR cannot find function `bar` in this scope
}
//~^ ERROR: incorrect close delimiter: `}`
+
+fn foo(_: usize) {}
| - close delimiter possibly meant for this
LL | foo(bar(;
| - un-closed delimiter
-LL | //~^ ERROR: expected expression, found `;`
+LL | //~^ ERROR cannot find function `bar` in this scope
LL | }
| ^ incorrect close delimiter
-error: expected expression, found `;`
- --> $DIR/token-error-correct.rs:4:13
+error[E0425]: cannot find function `bar` in this scope
+ --> $DIR/token-error-correct.rs:4:9
|
LL | foo(bar(;
- | ^ expected expression
+ | ^^^ not found in this scope
error: aborting due to 2 previous errors
+For more information about this error, try `rustc --explain E0425`.
--- /dev/null
+#![feature(staged_api)]
+//~^ ERROR crate has missing stability attribute
+
+fn main() {}
--- /dev/null
+error: crate has missing stability attribute
+ --> $DIR/missing-stability-attr-at-top-level.rs:1:1
+ |
+LL | / #![feature(staged_api)]
+LL | | //~^ ERROR crate has missing stability attribute
+LL | |
+LL | | fn main() {}
+ | |____________^
+
+error: aborting due to previous error
+
#![stable(feature = "test", since = "0")]
#[stable(feature = "test", since = "0")]
-pub struct Reverse<T>(pub T); //~ ERROR This node does not have a stability attribute
+pub struct Reverse<T>(pub T); //~ ERROR field has missing stability attribute
fn main() {
// Make sure the field is used to fill the stability cache
-error: This node does not have a stability attribute
+error: field has missing stability attribute
--> $DIR/stability-attribute-issue-43027.rs:5:23
|
-LL | pub struct Reverse<T>(pub T); //~ ERROR This node does not have a stability attribute
+LL | pub struct Reverse<T>(pub T); //~ ERROR field has missing stability attribute
| ^^^^^
error: aborting due to previous error
#![stable(feature = "stable_test_feature", since = "1.0.0")]
#[macro_export]
-macro_rules! mac { //~ ERROR This node does not have a stability attribute
+macro_rules! mac { //~ ERROR macro has missing stability attribute
() => ()
}
-error: This node does not have a stability attribute
+error: macro has missing stability attribute
--> $DIR/stability-attribute-sanity-3.rs:8:1
|
-LL | / macro_rules! mac { //~ ERROR This node does not have a stability attribute
+LL | / macro_rules! mac { //~ ERROR macro has missing stability attribute
LL | | () => ()
LL | | }
| |_^
--> $DIR/as-ref.rs:6:27
|
LL | opt.map(|arg| takes_ref(arg));
- | - ^^^ expected &Foo, found struct `Foo`
+ | --- ^^^ expected &Foo, found struct `Foo`
| |
- | help: consider using `as_ref` instead: `as_ref().`
+ | help: consider using `as_ref` instead: `as_ref().map`
|
= note: expected type `&Foo`
found type `Foo`
--> $DIR/as-ref.rs:8:37
|
LL | opt.and_then(|arg| Some(takes_ref(arg)));
- | - ^^^ expected &Foo, found struct `Foo`
+ | -------- ^^^ expected &Foo, found struct `Foo`
| |
- | help: consider using `as_ref` instead: `as_ref().`
+ | help: consider using `as_ref` instead: `as_ref().and_then`
|
= note: expected type `&Foo`
found type `Foo`
--> $DIR/as-ref.rs:11:27
|
LL | opt.map(|arg| takes_ref(arg));
- | - ^^^ expected &Foo, found struct `Foo`
+ | --- ^^^ expected &Foo, found struct `Foo`
| |
- | help: consider using `as_ref` instead: `as_ref().`
+ | help: consider using `as_ref` instead: `as_ref().map`
|
= note: expected type `&Foo`
found type `Foo`
--> $DIR/as-ref.rs:13:35
|
LL | opt.and_then(|arg| Ok(takes_ref(arg)));
- | - ^^^ expected &Foo, found struct `Foo`
+ | -------- ^^^ expected &Foo, found struct `Foo`
| |
- | help: consider using `as_ref` instead: `as_ref().`
+ | help: consider using `as_ref` instead: `as_ref().and_then`
|
= note: expected type `&Foo`
found type `Foo`
-//! This is a client of the `a` crate defined in "svn-a-base.rs". The
-//! rpass and cfail tests (such as "run-pass/svh-add-comment.rs") use
+//! This is a client of the `a` crate defined in `svn-a-base.rs`. The
+//! rpass and cfail tests (such as `run-pass/svh-add-comment.rs`) use
//! it by swapping in a different object code library crate built from
-//! some variant of "svn-a-base.rs", and then we are checking if the
+//! some variant of `svn-a-base.rs`, and then we are checking if the
//! compiler properly ignores or accepts the change, based on whether
//! the change could affect the downstream crate content or not
//! (#14132).
--- /dev/null
+#![feature(trait_alias)]
+
+trait Foo {}
+auto trait A = Foo; //~ ERROR trait aliases cannot be `auto`
+unsafe trait B = Foo; //~ ERROR trait aliases cannot be `unsafe`
+
+fn main() {}
--- /dev/null
+error: trait aliases cannot be `auto`
+ --> $DIR/trait-alias-syntax.rs:4:19
+ |
+LL | auto trait A = Foo; //~ ERROR trait aliases cannot be `auto`
+ | ^ trait aliases cannot be `auto`
+
+error: trait aliases cannot be `unsafe`
+ --> $DIR/trait-alias-syntax.rs:5:21
+ |
+LL | unsafe trait B = Foo; //~ ERROR trait aliases cannot be `unsafe`
+ | ^ trait aliases cannot be `unsafe`
+
+error: aborting due to 2 previous errors
+
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/ranged_ints2_const.rs:11:9
|
LL | let y = &mut x.0; //~ ERROR references in const fn are unstable
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
-error: mutable references in const fn are unstable
+error[E0723]: mutable references in const fn are unstable (see issue #57563)
--> $DIR/ranged_ints2_const.rs:18:9
|
LL | let y = unsafe { &mut x.0 }; //~ ERROR mutable references in const fn are unstable
| ^
+ |
+ = help: add #![feature(const_fn)] to the crate attributes to enable
error[E0133]: mutation of layout constrained field is unsafe and requires unsafe function or block
--> $DIR/ranged_ints2_const.rs:11:13
error: aborting due to 3 previous errors
-For more information about this error, try `rustc --explain E0133`.
+Some errors occurred: E0133, E0723.
+For more information about an error, try `rustc --explain E0133`.
use foo::bar::baz::{*, *};
//~^ ERROR unused import: `*`
use foo::{};
- //~^ ERROR unused import: `use foo::{};`
+ //~^ ERROR unused import: `foo::{}`
fn main() {
let _: Bar;
LL | use foo::bar::baz::{*, *};
| ^
-error: unused import: `use foo::{};`
- --> $DIR/use-nested-groups-unused-imports.rs:20:1
+error: unused import: `foo::{}`
+ --> $DIR/use-nested-groups-unused-imports.rs:20:5
|
LL | use foo::{};
- | ^^^^^^^^^^^^
+ | ^^^^^^^
error: aborting due to 3 previous errors
-//
-
fn foo<
'β, //~ ERROR non-ascii idents are not fully supported
γ //~ ERROR non-ascii idents are not fully supported
- //~^ WARN type parameter `γ` should have a camel case name
+ //~^ WARN type parameter `γ` should have an upper camel case name
>() {}
struct X {
error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
- --> $DIR/utf8_idents.rs:4:5
+ --> $DIR/utf8_idents.rs:2:5
|
LL | 'β, //~ ERROR non-ascii idents are not fully supported
| ^^
= help: add #![feature(non_ascii_idents)] to the crate attributes to enable
error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
- --> $DIR/utf8_idents.rs:5:5
+ --> $DIR/utf8_idents.rs:3:5
|
LL | γ //~ ERROR non-ascii idents are not fully supported
| ^
= help: add #![feature(non_ascii_idents)] to the crate attributes to enable
error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
- --> $DIR/utf8_idents.rs:10:5
+ --> $DIR/utf8_idents.rs:8:5
|
LL | δ: usize //~ ERROR non-ascii idents are not fully supported
| ^
= help: add #![feature(non_ascii_idents)] to the crate attributes to enable
error[E0658]: non-ascii idents are not fully supported. (see issue #55467)
- --> $DIR/utf8_idents.rs:14:9
+ --> $DIR/utf8_idents.rs:12:9
|
LL | let α = 0.00001f64; //~ ERROR non-ascii idents are not fully supported
| ^
|
= help: add #![feature(non_ascii_idents)] to the crate attributes to enable
-warning: type parameter `γ` should have a camel case name
- --> $DIR/utf8_idents.rs:5:5
+warning: type parameter `γ` should have an upper camel case name
+ --> $DIR/utf8_idents.rs:3:5
|
LL | γ //~ ERROR non-ascii idents are not fully supported
- | ^ help: convert the identifier to camel case: `Γ`
+ | ^ help: convert the identifier to upper camel case: `Γ`
|
= note: #[warn(non_camel_case_types)] on by default
-Subproject commit 4e74e2fc0908524d17735c768067117d3e84ee9c
+Subproject commit 865cb70106a6b1171a500ff68f93ab52eea56e72
authors = ["The Rust Project Developers"]
name = "compiletest"
version = "0.0.0"
+edition = "2018"
[dependencies]
diff = "0.1.10"
use std::str::FromStr;
use test::ColorConfig;
-use util::PathBufExt;
+use crate::util::PathBufExt;
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Mode {
}
impl fmt::Display for Mode {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let s = match *self {
CompileFail => "compile-fail",
RunFail => "run-fail",
#[derive(Clone)]
pub struct Config {
- /// Whether to overwrite stderr/stdout files instead of complaining about changes in output
+ /// `true` to to overwrite stderr/stdout files instead of complaining about changes in output.
pub bless: bool,
- /// The library paths required for running the compiler
+ /// The library paths required for running the compiler.
pub compile_lib_path: PathBuf,
- /// The library paths required for running compiled programs
+ /// The library paths required for running compiled programs.
pub run_lib_path: PathBuf,
- /// The rustc executable
+ /// The rustc executable.
pub rustc_path: PathBuf,
- /// The rustdoc executable
+ /// The rustdoc executable.
pub rustdoc_path: Option<PathBuf>,
- /// The python executable to use for LLDB
+ /// The Python executable to use for LLDB.
pub lldb_python: String,
- /// The python executable to use for htmldocck
+ /// The Python executable to use for htmldocck.
pub docck_python: String,
- /// The llvm FileCheck binary path
+ /// The LLVM `FileCheck` binary path.
pub llvm_filecheck: Option<PathBuf>,
- /// The valgrind path
+ /// The valgrind path.
pub valgrind_path: Option<String>,
/// Whether to fail if we can't run run-pass-valgrind tests under valgrind
}
/// Absolute path to the directory where all output for the given
-/// test/revision should reside. Example:
+/// test/revision should reside. Example:
/// /path/to/build/host-triple/test/ui/relative/testname.revision.mode/
pub fn output_base_dir(config: &Config, testpaths: &TestPaths, revision: Option<&str>) -> PathBuf {
output_relative_path(config, &testpaths.relative_dir)
}
/// Absolute path to the base filename used as output for the given
-/// test/revision. Example:
+/// test/revision. Example:
/// /path/to/build/host-triple/test/ui/relative/testname.revision.mode/testname
pub fn output_base_name(config: &Config, testpaths: &TestPaths, revision: Option<&str>) -> PathBuf {
output_base_dir(config, testpaths, revision).join(testpaths.file.file_stem().unwrap())
}
impl fmt::Display for ErrorKind {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
ErrorKind::Help => write!(f, "help message"),
ErrorKind::Error => write!(f, "error"),
use std::io::BufReader;
use std::path::{Path, PathBuf};
-use common::{self, CompareMode, Config, Mode};
-use util;
+use crate::common::{self, CompareMode, Config, Mode};
+use crate::util;
-use extract_gdb_version;
+use crate::extract_gdb_version;
/// Whether to ignore the test.
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Ignore {
- /// Run it.
+ /// Runs it.
Run,
/// Ignore it totally.
Ignore,
props
}
- /// Load properties from `testfile` into `props`. If a property is
+ /// Loads properties from `testfile` into `props`. If a property is
/// tied to a particular revision `foo` (indicated by writing
/// `//[foo]`), then the property is ignored unless `cfg` is
/// `Some("foo")`.
-use errors::{Error, ErrorKind};
-use runtest::ProcRes;
+use crate::errors::{Error, ErrorKind};
+use crate::runtest::ProcRes;
use serde_json;
use std::path::Path;
use std::str::FromStr;
#![crate_name = "compiletest"]
#![feature(test)]
-#![deny(warnings)]
+#![deny(warnings, rust_2018_idioms)]
-extern crate diff;
-extern crate env_logger;
-extern crate filetime;
-extern crate getopts;
#[cfg(unix)]
extern crate libc;
#[macro_use]
extern crate log;
-extern crate regex;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate serde_derive;
-extern crate serde_json;
extern crate test;
-extern crate rustfix;
-extern crate walkdir;
-use common::CompareMode;
-use common::{expected_output_path, output_base_dir, output_relative_path, UI_EXTENSIONS};
-use common::{Config, TestPaths};
-use common::{DebugInfoBoth, DebugInfoGdb, DebugInfoLldb, Mode, Pretty};
+use crate::common::CompareMode;
+use crate::common::{expected_output_path, output_base_dir, output_relative_path, UI_EXTENSIONS};
+use crate::common::{Config, TestPaths};
+use crate::common::{DebugInfoBoth, DebugInfoGdb, DebugInfoLldb, Mode, Pretty};
use filetime::FileTime;
use getopts::Options;
use std::env;
use std::path::{Path, PathBuf};
use std::process::Command;
use test::ColorConfig;
-use util::logv;
+use crate::util::logv;
use walkdir::WalkDir;
+use env_logger;
+use getopts;
use self::header::{EarlyProps, Ignore};
}))
}
-/// Returns true if the given target is an Android target for the
+/// Returns `true` if the given target is an Android target for the
/// purposes of GDB testing.
fn is_android_gdb_target(target: &String) -> bool {
match &target[..] {
#[cfg(windows)]
mod imp {
- extern crate miow;
- extern crate winapi;
-
use std::io;
use std::os::windows::prelude::*;
use std::process::{ChildStderr, ChildStdout};
use std::slice;
- use self::miow::iocp::{CompletionPort, CompletionStatus};
- use self::miow::pipe::NamedPipe;
- use self::miow::Overlapped;
- use self::winapi::shared::winerror::ERROR_BROKEN_PIPE;
+ use miow::iocp::{CompletionPort, CompletionStatus};
+ use miow::pipe::NamedPipe;
+ use miow::Overlapped;
+ use winapi::shared::winerror::ERROR_BROKEN_PIPE;
struct Pipe<'a> {
dst: &'a mut Vec<u8>,
-use common::CompareMode;
-use common::{expected_output_path, UI_EXTENSIONS, UI_FIXED, UI_STDERR, UI_STDOUT};
-use common::{output_base_dir, output_base_name, output_testname_unique};
-use common::{Codegen, CodegenUnits, DebugInfoBoth, DebugInfoGdb, DebugInfoLldb, Rustdoc};
-use common::{CompileFail, Pretty, RunFail, RunPass, RunPassValgrind};
-use common::{Config, TestPaths};
-use common::{Incremental, MirOpt, RunMake, Ui};
+use crate::common::CompareMode;
+use crate::common::{expected_output_path, UI_EXTENSIONS, UI_FIXED, UI_STDERR, UI_STDOUT};
+use crate::common::{output_base_dir, output_base_name, output_testname_unique};
+use crate::common::{Codegen, CodegenUnits, DebugInfoBoth, DebugInfoGdb, DebugInfoLldb, Rustdoc};
+use crate::common::{CompileFail, Pretty, RunFail, RunPass, RunPassValgrind};
+use crate::common::{Config, TestPaths};
+use crate::common::{Incremental, MirOpt, RunMake, Ui};
use diff;
-use errors::{self, Error, ErrorKind};
+use crate::errors::{self, Error, ErrorKind};
use filetime::FileTime;
-use header::TestProps;
-use json;
+use crate::header::TestProps;
+use crate::json;
use regex::Regex;
use rustfix::{apply_suggestions, get_suggestions_from_json, Filter};
-use util::{logv, PathBufExt};
+use crate::util::{logv, PathBufExt};
use std::collections::hash_map::DefaultHasher;
use std::collections::{HashMap, HashSet, VecDeque};
use std::process::{Child, Command, ExitStatus, Output, Stdio};
use std::str;
-use extract_gdb_version;
-use is_android_gdb_target;
+use crate::extract_gdb_version;
+use crate::is_android_gdb_target;
#[cfg(windows)]
fn disable_error_reporting<F: FnOnce() -> R, R>(f: F) -> R {
}
}
- /// Returns true if we should report an error about `actual_error`,
+ /// Returns `true` if we should report an error about `actual_error`,
/// which did not match any of the expected error. We always require
/// errors/warnings to be explicitly listed, but only require
/// helps/notes if there are explicit helps/notes given.
}
fn make_cmdline(&self, command: &Command, libpath: &str) -> String {
- use util;
+ use crate::util;
// Linux and mac don't require adjusting the library search path
if cfg!(unix) {
fs::write(&outfile, out).unwrap();
}
- /// Create a filename for output with the given extension. Example:
- /// /.../testname.revision.mode/testname.extension
+ /// Creates a filename for output with the given extension.
+ /// E.g., `/.../testname.revision.mode/testname.extension`.
fn make_out_name(&self, extension: &str) -> PathBuf {
self.output_base_name().with_extension(extension)
}
- /// Directory where auxiliary files are written. Example:
- /// /.../testname.revision.mode/auxiliary/
+ /// Gets the directory where auxiliary files are written.
+ /// E.g., `/.../testname.revision.mode/auxiliary/`.
fn aux_output_dir_name(&self) -> PathBuf {
self.output_base_dir()
.join("auxiliary")
output_testname_unique(self.config, self.testpaths, self.safe_revision())
}
- /// The revision, ignored for Incremental since it wants all revisions in
+ /// The revision, ignored for incremental compilation since it wants all revisions in
/// the same directory.
fn safe_revision(&self) -> Option<&str> {
if self.config.mode == Incremental {
}
}
- /// Absolute path to the directory where all output for the given
- /// test/revision should reside. Example:
- /// /path/to/build/host-triple/test/ui/relative/testname.revision.mode/
+ /// Gets the absolute path to the directory where all output for the given
+ /// test/revision should reside.
+ /// E.g., `/path/to/build/host-triple/test/ui/relative/testname.revision.mode/`.
fn output_base_dir(&self) -> PathBuf {
output_base_dir(self.config, self.testpaths, self.safe_revision())
}
- /// Absolute path to the base filename used as output for the given
- /// test/revision. Example:
- /// /.../relative/testname.revision.mode/testname
+ /// Gets the absolute path to the base filename used as output for the given
+ /// test/revision.
+ /// E.g., `/.../relative/testname.revision.mode/testname`.
fn output_base_name(&self) -> PathBuf {
output_base_name(self.config, self.testpaths, self.safe_revision())
}
}
fn create_stamp(&self) {
- let stamp = ::stamp(&self.config, self.testpaths, self.revision);
+ let stamp = crate::stamp(&self.config, self.testpaths, self.revision);
fs::write(&stamp, compute_stamp_hash(&self.config)).unwrap();
}
}
where
T: AsRef<str> + fmt::Debug,
{
- fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
if let &ExpectedLine::Text(ref t) = self {
write!(formatter, "{:?}", t)
} else {
}
fn read2_abbreviated(mut child: Child) -> io::Result<Output> {
- use read2::read2;
+ use crate::read2::read2;
use std::mem::replace;
const HEAD_LEN: usize = 160 * 1024;
use std::ffi::OsStr;
use std::env;
use std::path::PathBuf;
-use common::Config;
+use crate::common::Config;
/// Conversion table from triple OS name to Rust SYSNAME
const OS_TABLE: &'static [(&'static str, &'static str)] = &[
("androideabi", "android"),
("bitrig", "bitrig"),
("cloudabi", "cloudabi"),
+ ("cuda", "cuda"),
("darwin", "macos"),
("dragonfly", "dragonfly"),
("emscripten", "emscripten"),
("l4re", "l4re"),
("linux", "linux"),
("mingw32", "windows"),
+ ("none", "none"),
("netbsd", "netbsd"),
("openbsd", "openbsd"),
("redox", "redox"),
+ ("sgx", "sgx"),
("solaris", "solaris"),
("win32", "windows"),
("windows", "windows"),
("armv7", "arm"),
("armv7s", "arm"),
("asmjs", "asmjs"),
+ ("cuda", "cuda"),
("hexagon", "hexagon"),
("i386", "x86"),
("i586", "x86"),
fn test_get_arch() {
assert_eq!("x86_64", get_arch("x86_64-unknown-linux-gnu"));
assert_eq!("x86_64", get_arch("amd64"));
+ assert_eq!("cuda", get_arch("nvptx64-nvidia-cuda"));
}
#[test]
assert!(matches_os("wasm32-unknown-unknown", "emscripten"));
assert!(matches_os("wasm32-unknown-unknown", "wasm32-bare"));
assert!(!matches_os("wasm32-unknown-unknown", "windows"));
+ assert!(matches_os("thumbv6m0-none-eabi", "none"));
+ assert!(matches_os("riscv32imc-unknown-none-elf", "none"));
+ assert!(matches_os("nvptx64-nvidia-cuda", "cuda"));
+ assert!(matches_os("x86_64-fortanix-unknown-sgx", "sgx"));
}
authors = ["The Rust Project Developers"]
name = "error_index_generator"
version = "0.0.0"
+edition = "2018"
[dependencies]
rustdoc = { path = "../../librustdoc" }
#![feature(rustc_private)]
+#![deny(rust_2018_idioms)]
+
extern crate env_logger;
extern crate syntax;
-extern crate rustdoc;
extern crate serialize as rustc_serialize;
use std::collections::BTreeMap;
}
}
-/// Load all the metadata files from `metadata_dir` into an in-memory map.
+/// Loads all the metadata files from `metadata_dir` into an in-memory map.
fn load_all_errors(metadata_dir: &Path) -> Result<ErrorMetadataMap, Box<dyn Error>> {
let mut all_errors = BTreeMap::new();
'miri': '@oli-obk @RalfJung @eddyb',
'clippy-driver': '@Manishearth @llogiq @mcarton @oli-obk',
'rls': '@nrc @Xanewok',
- 'rustfmt': '@nrc',
+ 'rustfmt': '@nrc @topecongiro',
'book': '@carols10cents @steveklabnik',
'nomicon': '@frewsxcv @Gankro',
'reference': '@steveklabnik @Havvy @matthewjasper @alercah',
'rust-by-example': '@steveklabnik @marioidival @projektir',
}
+REPOS = {
+ 'miri': 'https://github.com/solson/miri',
+ 'clippy-driver': 'https://github.com/rust-lang/rust-clippy',
+ 'rls': 'https://github.com/rust-lang/rls',
+ 'rustfmt': 'https://github.com/rust-lang/rustfmt',
+ 'book': 'https://github.com/rust-lang/book',
+ 'nomicon': 'https://github.com/rust-lang-nursery/nomicon',
+ 'reference': 'https://github.com/rust-lang-nursery/reference',
+ 'rust-by-example': 'https://github.com/rust-lang/rust-by-example',
+}
+
def read_current_status(current_commit, path):
'''Reads build status of `current_commit` from content of `history/*.tsv`
return json.loads(status)
return {}
+def issue(
+ tool,
+ maintainers,
+ relevant_pr_number,
+ relevant_pr_user,
+ pr_reviewer,
+):
+ # Open an issue about the toolstate failure.
+ gh_url = 'https://api.github.com/repos/rust-lang/rust/issues'
+ assignees = [x.strip() for x in maintainers.split('@') if x != '']
+ assignees.append(relevant_pr_user)
+ response = urllib2.urlopen(urllib2.Request(
+ gh_url,
+ json.dumps({
+ 'body': textwrap.dedent('''\
+ Hello, this is your friendly neighborhood mergebot.
+ After merging PR {}, I observed that the tool {} no longer builds.
+ A follow-up PR to the repository {} is needed to fix the fallout.
+
+ cc @{}, do you think you would have time to do the follow-up work?
+ If so, that would be great!
+
+ cc @{}, the PR reviewer, and @rust-lang/compiler -- nominating for prioritization.
+
+ ''').format(relevant_pr_number, tool, REPOS[tool], relevant_pr_user, pr_reviewer),
+ 'title': '`{}` no longer builds after {}'.format(tool, relevant_pr_number),
+ 'assignees': assignees,
+ 'labels': ['T-compiler', 'I-nominated'],
+ }),
+ {
+ 'Authorization': 'token ' + github_token,
+ 'Content-Type': 'application/json',
+ }
+ ))
+ response.read()
def update_latest(
current_commit,
relevant_pr_number,
relevant_pr_url,
+ relevant_pr_user,
+ pr_reviewer,
current_datetime
):
'''Updates `_data/latest.json` to match build result of the given commit.
for status in latest:
tool = status['tool']
changed = False
+ build_failed = False
for os, s in current_status.items():
old = status[os]
new = s.get(tool, old)
status[os] = new
if new > old:
+ # things got fixed or at least the status quo improved
changed = True
message += '🎉 {} on {}: {} → {} (cc {}, @rust-lang/infra).\n' \
.format(tool, os, old, new, MAINTAINERS.get(tool))
elif new < old:
+ # tests or builds are failing and were not failing before
changed = True
- message += '💔 {} on {}: {} → {} (cc {}, @rust-lang/infra).\n' \
- .format(tool, os, old, new, MAINTAINERS.get(tool))
+ title = '💔 {} on {}: {} → {}' \
+ .format(tool, os, old, new)
+ message += '{} (cc {}, @rust-lang/infra).\n' \
+ .format(title, MAINTAINERS.get(tool))
+ # only create issues for build failures. Other failures can be spurious
+ if new == 'build-fail':
+ build_failed = True
+
+ if build_failed:
+ try:
+ issue(
+ tool, MAINTAINERS.get(tool),
+ relevant_pr_number, relevant_pr_user, pr_reviewer,
+ )
+ except IOError as (errno, strerror):
+ # network errors will simply end up not creating an issue, but that's better
+ # than failing the entire build job
+ print "I/O error({0}): {1}".format(errno, strerror)
+ except:
+ print "Unexpected error:", sys.exc_info()[0]
+ raise
if changed:
status['commit'] = current_commit
save_message_to_path = sys.argv[3]
github_token = sys.argv[4]
- relevant_pr_match = re.search('#([0-9]+)', cur_commit_msg)
+ # assume that PR authors are also owners of the repo where the branch lives
+ relevant_pr_match = re.search(
+ 'Auto merge of #([0-9]+) - ([^:]+):[^,]+ r=([^\s]+)',
+ cur_commit_msg,
+ )
if relevant_pr_match:
number = relevant_pr_match.group(1)
+ relevant_pr_user = relevant_pr_match.group(2)
relevant_pr_number = 'rust-lang/rust#' + number
relevant_pr_url = 'https://github.com/rust-lang/rust/pull/' + number
+ pr_reviewer = relevant_pr_match.group(3)
else:
number = '-1'
+ relevant_pr_user = '<unknown user>'
relevant_pr_number = '<unknown PR>'
relevant_pr_url = '<unknown>'
+ pr_reviewer = '<unknown reviewer>'
message = update_latest(
cur_commit,
relevant_pr_number,
relevant_pr_url,
+ relevant_pr_user,
+ pr_reviewer,
cur_datetime
)
if not message:
description = """
Hack for the compiler's own build system
"""
+edition = "2018"
[lib]
path = "lib.rs"
#![feature(no_core)]
#![no_core]
-
-extern crate core;
+#![deny(rust_2018_idioms)]
pub use core::*;
description = """
Hack for the compiler's own build system
"""
+edition = "2018"
[lib]
path = "lib.rs"
name = "rustdoc-tool"
version = "0.0.0"
authors = ["The Rust Project Developers"]
+edition = "2018"
# Cargo adds a number of paths to the dylib search path on windows, which results in
# the wrong rustdoc being executed. To avoid the conflicting rustdocs, we name the "tool"
+#![deny(rust_2018_idioms)]
+
#![feature(link_args)]
#[allow(unused_attributes)]
// See src/rustc/rustc.rs for the corresponding rustc settings.
extern {}
-extern crate rustdoc;
-
fn main() { rustdoc::main() }
"src/libstd/sys_common/net.rs",
"src/libterm", // Not sure how to make this crate portable, but test crate needs it.
"src/libtest", // Probably should defer to unstable `std::sys` APIs.
+ "src/libstd/sync/mpsc", // some tests are only run on non-emscripten
// std testing crates, okay for now at least
"src/libcore/tests",
EXP_END,
}
-/// Returns whether `line` appears to be a line comment containing an URL,
+/// Returns `true` if `line` appears to be a line comment containing an URL,
/// possibly with a Markdown link label in front, and nothing else.
/// The Markdown link label, if present, may not contain whitespace.
/// Lines of this form are allowed to be overlength, because Markdown
state == EXP_END
}
-/// Returns whether `line` is allowed to be longer than the normal limit.
+/// Returns `true` if `line` is allowed to be longer than the normal limit.
/// Currently there is only one exception, for long URLs, but more
/// may be added in the future.
fn long_line_is_ok(line: &str) -> bool {
.collect()
}
-/// Retrieve file names of all library feature sections in the Unstable Book with:
+/// Retrieves file names of all library feature sections in the Unstable Book with:
///
/// * hyphens replaced by underscores,
/// * the markdown suffix ('.md') removed.
projects / rust.git / commitdiff