[submodule "src/doc/rust-by-example"]
path = src/doc/rust-by-example
url = https://github.com/rust-lang/rust-by-example
+[submodule "src/llvm-emscripten"]
+ path = src/llvm-emscripten
+ url = https://github.com/rust-lang/llvm
# OSX 10.7 and `xcode7` is the latest Xcode able to compile LLVM for 10.7.
- env: >
RUST_CHECK_TARGET=dist
- RUST_CONFIGURE_ARGS="--build=i686-apple-darwin --enable-extended --enable-profiler"
+ RUST_CONFIGURE_ARGS="--build=i686-apple-darwin --enable-extended --enable-profiler --enable-emscripten"
SRC=.
DEPLOY=1
RUSTC_RETRY_LINKER_ON_SEGFAULT=1
- env: >
RUST_CHECK_TARGET=dist
- RUST_CONFIGURE_ARGS="--target=aarch64-apple-ios,armv7-apple-ios,armv7s-apple-ios,i386-apple-ios,x86_64-apple-ios --enable-extended --enable-sanitizers --enable-profiler"
+ RUST_CONFIGURE_ARGS="--target=aarch64-apple-ios,armv7-apple-ios,armv7s-apple-ios,i386-apple-ios,x86_64-apple-ios --enable-extended --enable-sanitizers --enable-profiler --enable-emscripten"
SRC=.
DEPLOY=1
RUSTC_RETRY_LINKER_ON_SEGFAULT=1
--build=x86_64-pc-windows-msvc
--enable-extended
--enable-profiler
+ --enable-emscripten
SCRIPT: python x.py dist
DEPLOY: 1
- RUST_CONFIGURE_ARGS: >
--target=i586-pc-windows-msvc
--enable-extended
--enable-profiler
+ --enable-emscripten
SCRIPT: python x.py dist
DEPLOY: 1
- MSYS_BITS: 32
- RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu --enable-extended
+ RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu --enable-extended --enable-emscripten
SCRIPT: python x.py dist
MINGW_URL: https://s3-us-west-1.amazonaws.com/rust-lang-ci2/rust-ci-mirror
MINGW_ARCHIVE: i686-6.3.0-release-posix-dwarf-rt_v5-rev2.7z
DEPLOY: 1
- MSYS_BITS: 64
SCRIPT: python x.py dist
- RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-gnu --enable-extended
+ RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-gnu --enable-extended --enable-emscripten
MINGW_URL: https://s3-us-west-1.amazonaws.com/rust-lang-ci2/rust-ci-mirror
MINGW_ARCHIVE: x86_64-6.3.0-release-posix-seh-rt_v5-rev2.7z
MINGW_DIR: mingw64
# result (broken, compiling, testing) into this JSON file.
#save-toolstates = "/path/to/toolstates.json"
+# This is an array of the codegen backends that will be compiled for the rustc
+# that's being compiled. The default is to only build the LLVM codegen backend,
+# but you can also optionally enable the "emscripten" backend for asm.js or
+# make this an empty array (but that probably won't get too far in the
+# bootstrap)
+#codegen-backends = ["llvm"]
+
+# Flag indicating whether `libstd` calls an imported function to hande basic IO
+# when targetting WebAssembly. Enable this to debug tests for the `wasm32-unknown-unknown`
+# target, as without this option the test output will not be captured.
+#wasm-syscall = false
+
# =============================================================================
# Options for specific targets
#
"rustc_privacy 0.0.0",
"rustc_resolve 0.0.0",
"rustc_save_analysis 0.0.0",
- "rustc_trans 0.0.0",
"rustc_trans_utils 0.0.0",
"rustc_typeck 0.0.0",
"serialize 0.0.0",
"bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"build_helper 0.1.0",
"cc 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc_cratesio_shim 0.0.0",
]
"cc 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
"flate2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"jobserver 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc 0.0.0",
"rustc",
"libstd",
"libtest",
+ "librustc_trans",
"tools/cargotest",
"tools/clippy",
"tools/compiletest",
os.path.join(self.rust_root, ".gitmodules"),
"--get-regexp", "path"]
).decode(default_encoding).splitlines()]
- submodules = [module for module in submodules
- if not ((module.endswith("llvm") and
- self.get_toml('llvm-config')) or
- (module.endswith("jemalloc") and
- (self.get_toml('use-jemalloc') == "false" or
- self.get_toml('jemalloc'))))]
+ filtered_submodules = []
+ for module in submodules:
+ if module.endswith("llvm"):
+ if self.get_toml('llvm-config'):
+ continue
+ if module.endswith("llvm-emscripten"):
+ backends = self.get_toml('codegen-backends')
+ if backends is None or not 'emscripten' in backends:
+ continue
+ if module.endswith("jemalloc"):
+ if self.get_toml('use-jemalloc') == 'false':
+ continue
+ if self.get_toml('jemalloc'):
+ continue
+ filtered_submodules.append(module)
run(["git", "submodule", "update",
- "--init", "--recursive"] + submodules,
+ "--init", "--recursive"] + filtered_submodules,
cwd=self.rust_root, verbose=self.verbose)
run(["git", "submodule", "-q", "foreach", "git",
"reset", "-q", "--hard"],
self.ensure(Libdir { compiler, target })
}
+ pub fn sysroot_codegen_backends(&self, compiler: Compiler) -> PathBuf {
+ self.sysroot_libdir(compiler, compiler.host)
+ .with_file_name("codegen-backends")
+ }
+
/// Returns the compiler's libdir where it stores the dynamic libraries that
/// it itself links against.
///
stage = compiler.stage;
}
+ let mut extra_args = env::var(&format!("RUSTFLAGS_STAGE_{}", stage)).unwrap_or_default();
+ if stage != 0 {
+ let s = env::var("RUSTFLAGS_STAGE_NOT_0").unwrap_or_default();
+ extra_args.push_str(" ");
+ extra_args.push_str(&s);
+ }
+
+ if !extra_args.is_empty() {
+ cargo.env("RUSTFLAGS",
+ format!("{} {}", env::var("RUSTFLAGS").unwrap_or_default(), extra_args));
+ }
+
// Customize the compiler we're running. Specify the compiler to cargo
// as our shim and then pass it some various options used to configure
// how the actual compiler itself is called.
build.clear_if_dirty(&stage_out, &libtest_stamp(build, compiler, target));
let mut cargo = builder.cargo(compiler, Mode::Librustc, target, "check");
- rustc_cargo(build, target, &mut cargo);
+ rustc_cargo(build, &mut cargo);
run_cargo(build,
&mut cargo,
&librustc_stamp(build, compiler, target),
// Even if we're not building std this stage, the new sysroot must
// still contain the musl startup objects.
- if target.contains("musl") && !target.contains("mips") {
+ if target.contains("musl") {
let libdir = builder.sysroot_libdir(compiler, target);
copy_musl_third_party_objects(build, target, &libdir);
}
println!("Building stage{} std artifacts ({} -> {})", compiler.stage,
&compiler.host, target);
- if target.contains("musl") && !target.contains("mips") {
+ if target.contains("musl") {
let libdir = builder.sysroot_libdir(compiler, target);
copy_musl_third_party_objects(build, target, &libdir);
}
}
for obj in ["crt2.o", "dllcrt2.o"].iter() {
- copy(&compiler_file(build.cc(target), obj), &sysroot_dir.join(obj));
+ let src = compiler_file(build,
+ build.cc(target),
+ target,
+ obj);
+ copy(&src, &sysroot_dir.join(obj));
}
}
}
builder.ensure(Test { compiler, target });
- // Build LLVM for our target. This will implicitly build the host LLVM
- // if necessary.
- builder.ensure(native::Llvm { target });
-
if build.force_use_stage1(compiler, target) {
builder.ensure(Rustc {
compiler: builder.compiler(1, build.build),
build.clear_if_dirty(&stage_out, &libtest_stamp(build, compiler, target));
let mut cargo = builder.cargo(compiler, Mode::Librustc, target, "build");
- rustc_cargo(build, target, &mut cargo);
+ rustc_cargo(build, &mut cargo);
run_cargo(build,
&mut cargo,
&librustc_stamp(build, compiler, target),
}
}
-/// Same as `std_cargo`, but for libtest
-pub fn rustc_cargo(build: &Build,
- target: Interned<String>,
- cargo: &mut Command) {
+pub fn rustc_cargo(build: &Build, cargo: &mut Command) {
cargo.arg("--features").arg(build.rustc_features())
.arg("--manifest-path")
.arg(build.src.join("src/rustc/Cargo.toml"));
+ rustc_cargo_env(build, cargo);
+}
+fn rustc_cargo_env(build: &Build, cargo: &mut Command) {
// Set some configuration variables picked up by build scripts and
// the compiler alike
cargo.env("CFG_RELEASE", build.rust_release())
if !build.unstable_features() {
cargo.env("CFG_DISABLE_UNSTABLE_FEATURES", "1");
}
- // Flag that rust llvm is in use
- if build.is_rust_llvm(target) {
- cargo.env("LLVM_RUSTLLVM", "1");
- }
- cargo.env("LLVM_CONFIG", build.llvm_config(target));
- let target_config = build.config.target_config.get(&target);
- if let Some(s) = target_config.and_then(|c| c.llvm_config.as_ref()) {
- cargo.env("CFG_LLVM_ROOT", s);
- }
- // Building with a static libstdc++ is only supported on linux right now,
- // not for MSVC or macOS
- if build.config.llvm_static_stdcpp &&
- !target.contains("freebsd") &&
- !target.contains("windows") &&
- !target.contains("apple") {
- cargo.env("LLVM_STATIC_STDCPP",
- compiler_file(build.cxx(target).unwrap(), "libstdc++.a"));
- }
- if build.config.llvm_link_shared {
- cargo.env("LLVM_LINK_SHARED", "1");
- }
if let Some(ref s) = build.config.rustc_default_linker {
cargo.env("CFG_DEFAULT_LINKER", s);
}
}
}
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct CodegenBackend {
+ pub compiler: Compiler,
+ pub target: Interned<String>,
+ pub backend: Interned<String>,
+}
+
+impl Step for CodegenBackend {
+ type Output = ();
+ const ONLY_HOSTS: bool = true;
+ const DEFAULT: bool = true;
+
+ fn should_run(run: ShouldRun) -> ShouldRun {
+ run.path("src/librustc_trans")
+ }
+
+ fn make_run(run: RunConfig) {
+ let backend = run.builder.config.rust_codegen_backends.get(0);
+ let backend = backend.cloned().unwrap_or_else(|| {
+ INTERNER.intern_str("llvm")
+ });
+ run.builder.ensure(CodegenBackend {
+ compiler: run.builder.compiler(run.builder.top_stage, run.host),
+ target: run.target,
+ backend
+ });
+ }
+
+ fn run(self, builder: &Builder) {
+ let build = builder.build;
+ let compiler = self.compiler;
+ let target = self.target;
+
+ builder.ensure(Rustc { compiler, target });
+
+ if build.force_use_stage1(compiler, target) {
+ builder.ensure(CodegenBackend {
+ compiler: builder.compiler(1, build.build),
+ target,
+ backend: self.backend,
+ });
+ return;
+ }
+
+ let mut cargo = builder.cargo(compiler, Mode::Librustc, target, "build");
+ let mut features = build.rustc_features().to_string();
+ cargo.arg("--manifest-path")
+ .arg(build.src.join("src/librustc_trans/Cargo.toml"));
+ rustc_cargo_env(build, &mut cargo);
+
+ match &*self.backend {
+ "llvm" | "emscripten" => {
+ // Build LLVM for our target. This will implicitly build the
+ // host LLVM if necessary.
+ let llvm_config = builder.ensure(native::Llvm {
+ target,
+ emscripten: self.backend == "emscripten",
+ });
+
+ if self.backend == "emscripten" {
+ features.push_str(" emscripten");
+ }
+
+ let _folder = build.fold_output(|| format!("stage{}-rustc_trans", compiler.stage));
+ println!("Building stage{} codegen artifacts ({} -> {}, {})",
+ compiler.stage, &compiler.host, target, self.backend);
+
+ // Pass down configuration from the LLVM build into the build of
+ // librustc_llvm and librustc_trans.
+ if build.is_rust_llvm(target) {
+ cargo.env("LLVM_RUSTLLVM", "1");
+ }
+ cargo.env("LLVM_CONFIG", &llvm_config);
+ if self.backend != "emscripten" {
+ let target_config = build.config.target_config.get(&target);
+ if let Some(s) = target_config.and_then(|c| c.llvm_config.as_ref()) {
+ cargo.env("CFG_LLVM_ROOT", s);
+ }
+ }
+ // Building with a static libstdc++ is only supported on linux right now,
+ // not for MSVC or macOS
+ if build.config.llvm_static_stdcpp &&
+ !target.contains("freebsd") &&
+ !target.contains("windows") &&
+ !target.contains("apple") {
+ let file = compiler_file(build,
+ build.cxx(target).unwrap(),
+ target,
+ "libstdc++.a");
+ cargo.env("LLVM_STATIC_STDCPP", file);
+ }
+ if build.config.llvm_link_shared {
+ cargo.env("LLVM_LINK_SHARED", "1");
+ }
+ }
+ _ => panic!("unknown backend: {}", self.backend),
+ }
+
+ let tmp_stamp = build.cargo_out(compiler, Mode::Librustc, target)
+ .join(".tmp.stamp");
+ let files = run_cargo(build,
+ cargo.arg("--features").arg(features),
+ &tmp_stamp,
+ false);
+ let mut files = files.into_iter()
+ .filter(|f| {
+ let filename = f.file_name().unwrap().to_str().unwrap();
+ is_dylib(filename) && filename.contains("rustc_trans-")
+ });
+ let codegen_backend = match files.next() {
+ Some(f) => f,
+ None => panic!("no dylibs built for codegen backend?"),
+ };
+ if let Some(f) = files.next() {
+ panic!("codegen backend built two dylibs:\n{}\n{}",
+ codegen_backend.display(),
+ f.display());
+ }
+ let stamp = codegen_backend_stamp(build, compiler, target, self.backend);
+ let codegen_backend = codegen_backend.to_str().unwrap();
+ t!(t!(File::create(&stamp)).write_all(codegen_backend.as_bytes()));
+ }
+}
+
+/// Creates the `codegen-backends` folder for a compiler that's about to be
+/// assembled as a complete compiler.
+///
+/// This will take the codegen artifacts produced by `compiler` and link them
+/// into an appropriate location for `target_compiler` to be a functional
+/// compiler.
+fn copy_codegen_backends_to_sysroot(builder: &Builder,
+ compiler: Compiler,
+ target_compiler: Compiler) {
+ let build = builder.build;
+ let target = target_compiler.host;
+
+ // Note that this step is different than all the other `*Link` steps in
+ // that it's not assembling a bunch of libraries but rather is primarily
+ // moving the codegen backend into place. The codegen backend of rustc is
+ // not linked into the main compiler by default but is rather dynamically
+ // selected at runtime for inclusion.
+ //
+ // Here we're looking for the output dylib of the `CodegenBackend` step and
+ // we're copying that into the `codegen-backends` folder.
+ let dst = builder.sysroot_codegen_backends(target_compiler);
+ t!(fs::create_dir_all(&dst));
+
+ for backend in builder.config.rust_codegen_backends.iter() {
+ let stamp = codegen_backend_stamp(build, compiler, target, *backend);
+ let mut dylib = String::new();
+ t!(t!(File::open(&stamp)).read_to_string(&mut dylib));
+ let file = Path::new(&dylib);
+ let filename = file.file_name().unwrap().to_str().unwrap();
+ // change `librustc_trans-xxxxxx.so` to `librustc_trans-llvm.so`
+ let target_filename = {
+ let dash = filename.find("-").unwrap();
+ let dot = filename.find(".").unwrap();
+ format!("{}-{}{}",
+ &filename[..dash],
+ backend,
+ &filename[dot..])
+ };
+ copy(&file, &dst.join(target_filename));
+ }
+}
+
/// Cargo's output path for the standard library in a given stage, compiled
/// by a particular compiler for the specified target.
pub fn libstd_stamp(build: &Build, compiler: Compiler, target: Interned<String>) -> PathBuf {
build.cargo_out(compiler, Mode::Librustc, target).join(".librustc.stamp")
}
-fn compiler_file(compiler: &Path, file: &str) -> PathBuf {
- let out = output(Command::new(compiler)
- .arg(format!("-print-file-name={}", file)));
+fn codegen_backend_stamp(build: &Build,
+ compiler: Compiler,
+ target: Interned<String>,
+ backend: Interned<String>) -> PathBuf {
+ build.cargo_out(compiler, Mode::Librustc, target)
+ .join(format!(".librustc_trans-{}.stamp", backend))
+}
+
+fn compiler_file(build: &Build,
+ compiler: &Path,
+ target: Interned<String>,
+ file: &str) -> PathBuf {
+ let mut cmd = Command::new(compiler);
+ cmd.args(build.cflags(target));
+ cmd.arg(format!("-print-file-name={}", file));
+ let out = output(&mut cmd);
PathBuf::from(out.trim())
}
}
// Get the compiler that we'll use to bootstrap ourselves.
- let build_compiler = if target_compiler.host != build.build {
- // Build a compiler for the host platform. We cannot use the stage0
- // compiler for the host platform for this because it doesn't have
- // the libraries we need. FIXME: Perhaps we should download those
- // libraries? It would make builds faster...
- // FIXME: It may be faster if we build just a stage 1
- // compiler and then use that to bootstrap this compiler
- // forward.
- builder.compiler(target_compiler.stage - 1, build.build)
- } else {
- // Build the compiler we'll use to build the stage requested. This
- // may build more than one compiler (going down to stage 0).
- builder.compiler(target_compiler.stage - 1, target_compiler.host)
- };
+ //
+ // Note that this is where the recursive nature of the bootstrap
+ // happens, as this will request the previous stage's compiler on
+ // downwards to stage 0.
+ //
+ // Also note that we're building a compiler for the host platform. We
+ // only assume that we can run `build` artifacts, which means that to
+ // produce some other architecture compiler we need to start from
+ // `build` to get there.
+ //
+ // FIXME: Perhaps we should download those libraries?
+ // It would make builds faster...
+ //
+ // FIXME: It may be faster if we build just a stage 1 compiler and then
+ // use that to bootstrap this compiler forward.
+ let build_compiler =
+ builder.compiler(target_compiler.stage - 1, build.build);
// Build the libraries for this compiler to link to (i.e., the libraries
// it uses at runtime). NOTE: Crates the target compiler compiles don't
builder.ensure(RustcLink { compiler, target_compiler, target });
}
} else {
- builder.ensure(Rustc { compiler: build_compiler, target: target_compiler.host });
+ builder.ensure(Rustc {
+ compiler: build_compiler,
+ target: target_compiler.host,
+ });
+ for &backend in build.config.rust_codegen_backends.iter() {
+ builder.ensure(CodegenBackend {
+ compiler: build_compiler,
+ target: target_compiler.host,
+ backend,
+ });
+ }
}
let stage = target_compiler.stage;
}
}
- let out_dir = build.cargo_out(build_compiler, Mode::Librustc, host);
+ copy_codegen_backends_to_sysroot(builder,
+ build_compiler,
+ target_compiler);
// Link the compiler binary itself into place
+ let out_dir = build.cargo_out(build_compiler, Mode::Librustc, host);
let rustc = out_dir.join(exe("rustc", &*host));
let bindir = sysroot.join("bin");
t!(fs::create_dir_all(&bindir));
}
}
-pub fn run_cargo(build: &Build, cargo: &mut Command, stamp: &Path, is_check: bool) {
+pub fn run_cargo(build: &Build, cargo: &mut Command, stamp: &Path, is_check: bool)
+ -> Vec<PathBuf>
+{
// Instruct Cargo to give us json messages on stdout, critically leaving
// stderr as piped so we can get those pretty colors.
cargo.arg("--message-format").arg("json")
let mut new_contents = Vec::new();
let mut max = None;
let mut max_path = None;
- for dep in deps {
- let mtime = mtime(&dep);
+ for dep in deps.iter() {
+ let mtime = mtime(dep);
if Some(mtime) > max {
max = Some(mtime);
max_path = Some(dep.clone());
if stamp_contents == new_contents && max <= stamp_mtime {
build.verbose(&format!("not updating {:?}; contents equal and {} <= {}",
stamp, max, stamp_mtime));
- return
+ return deps
}
if max > stamp_mtime {
build.verbose(&format!("updating {:?} as {:?} changed", stamp, max_path));
build.verbose(&format!("updating {:?} as deps changed", stamp));
}
t!(t!(File::create(stamp)).write_all(&new_contents));
+ deps
}
pub rust_optimize_tests: bool,
pub rust_debuginfo_tests: bool,
pub rust_dist_src: bool,
+ pub rust_codegen_backends: Vec<Interned<String>>,
pub build: Interned<String>,
pub hosts: Vec<Interned<String>>,
pub debug_jemalloc: bool,
pub use_jemalloc: bool,
pub backtrace: bool, // support for RUST_BACKTRACE
+ pub wasm_syscall: bool,
// misc
pub low_priority: bool,
quiet_tests: Option<bool>,
test_miri: Option<bool>,
save_toolstates: Option<String>,
+ codegen_backends: Option<Vec<String>>,
+ wasm_syscall: Option<bool>,
}
/// TOML representation of how each build target is configured.
config.ignore_git = false;
config.rust_dist_src = true;
config.test_miri = false;
+ config.rust_codegen_backends = vec![INTERNER.intern_str("llvm")];
config.on_fail = flags.on_fail;
config.stage = flags.stage;
set(&mut config.rust_dist_src, rust.dist_src);
set(&mut config.quiet_tests, rust.quiet_tests);
set(&mut config.test_miri, rust.test_miri);
+ set(&mut config.wasm_syscall, rust.wasm_syscall);
config.rustc_parallel_queries = rust.experimental_parallel_queries.unwrap_or(false);
config.rustc_default_linker = rust.default_linker.clone();
config.musl_root = rust.musl_root.clone().map(PathBuf::from);
config.save_toolstates = rust.save_toolstates.clone().map(PathBuf::from);
+ if let Some(ref backends) = rust.codegen_backends {
+ config.rust_codegen_backends = backends.iter()
+ .map(|s| INTERNER.intern_str(s))
+ .collect();
+ }
+
match rust.codegen_units {
Some(0) => config.rust_codegen_units = Some(num_cpus::get() as u32),
Some(n) => config.rust_codegen_units = Some(n),
o("dist-src", "rust.dist-src", "when building tarballs enables building a source tarball")
o("cargo-openssl-static", "build.openssl-static", "static openssl in cargo")
o("profiler", "build.profiler", "build the profiler runtime")
+o("emscripten", None, "compile the emscripten backend as well as LLVM")
# Optimization and debugging options. These may be overridden by the release
# channel, etc.
"armv7-unknown-linux-musleabihf install directory")
v("musl-root-aarch64", "target.aarch64-unknown-linux-musl.musl-root",
"aarch64-unknown-linux-musl install directory")
+v("musl-root-mips", "target.mips-unknown-linux-musl.musl-root",
+ "mips-unknown-linux-musl install directory")
+v("musl-root-mipsel", "target.mipsel-unknown-linux-musl.musl-root",
+ "mipsel-unknown-linux-musl install directory")
v("qemu-armhf-rootfs", "target.arm-unknown-linux-gnueabihf.qemu-rootfs",
"rootfs in qemu testing, you probably don't want to use this")
v("qemu-aarch64-rootfs", "target.aarch64-unknown-linux-gnu.qemu-rootfs",
set('build.host', value.split(','))
elif option.name == 'target':
set('build.target', value.split(','))
+ elif option.name == 'emscripten':
+ set('rust.codegen-backends', ['llvm', 'emscripten'])
elif option.name == 'option-checking':
# this was handled above
pass
}
}
+ // Copy over the codegen backends
+ let backends_src = builder.sysroot_codegen_backends(compiler);
+ let backends_rel = backends_src.strip_prefix(&src).unwrap();
+ let backends_dst = image.join(&backends_rel);
+ t!(fs::create_dir_all(&backends_dst));
+ cp_r(&backends_src, &backends_dst);
+
// Man pages
t!(fs::create_dir_all(image.join("share/man/man1")));
let man_src = build.src.join("src/doc/man");
t!(fs::create_dir_all(&dst));
let mut src = builder.sysroot_libdir(compiler, target).to_path_buf();
src.pop(); // Remove the trailing /lib folder from the sysroot_libdir
- cp_r(&src, &dst);
+ cp_filtered(&src, &dst, &|path| {
+ path.file_name().and_then(|s| s.to_str()) != Some("codegen-backends")
+ });
let mut cmd = rust_installer(builder);
cmd.arg("generate")
t!(symlink_dir_force(&my_out, &out_dir));
let mut cargo = builder.cargo(compiler, Mode::Librustc, target, "doc");
- compile::rustc_cargo(build, target, &mut cargo);
+ compile::rustc_cargo(build, &mut cargo);
if build.config.compiler_docs {
// src/rustc/Cargo.toml contains a bin crate called rustc which
if self.config.profiler {
features.push_str(" profiler");
}
+ if self.config.wasm_syscall {
+ features.push_str(" wasm_syscall");
+ }
features
}
if self.config.use_jemalloc {
features.push_str(" jemalloc");
}
- if self.config.llvm_enabled {
- features.push_str(" llvm");
- }
features
}
self.out.join(&*target).join("llvm")
}
+ fn emscripten_llvm_out(&self, target: Interned<String>) -> PathBuf {
+ self.out.join(&*target).join("llvm-emscripten")
+ }
+
/// Output directory for all documentation for a target
fn doc_out(&self, target: Interned<String>) -> PathBuf {
self.out.join(&*target).join("doc")
use std::ffi::OsString;
use std::fs::{self, File};
use std::io::{Read, Write};
-use std::path::Path;
+use std::path::{Path, PathBuf};
use std::process::Command;
use build_helper::output;
use cc;
use Build;
-use util;
+use util::{self, exe};
use build_helper::up_to_date;
use builder::{Builder, RunConfig, ShouldRun, Step};
use cache::Interned;
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Llvm {
pub target: Interned<String>,
+ pub emscripten: bool,
}
impl Step for Llvm {
- type Output = ();
+ type Output = PathBuf; // path to llvm-config
+
const ONLY_HOSTS: bool = true;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/llvm")
+ run.path("src/llvm").path("src/llvm-emscripten")
}
fn make_run(run: RunConfig) {
- run.builder.ensure(Llvm { target: run.target })
+ let emscripten = run.path.map(|p| {
+ p.ends_with("llvm-emscripten")
+ }).unwrap_or(false);
+ run.builder.ensure(Llvm {
+ target: run.target,
+ emscripten,
+ });
}
/// Compile LLVM for `target`.
- fn run(self, builder: &Builder) {
+ fn run(self, builder: &Builder) -> PathBuf {
let build = builder.build;
let target = self.target;
-
- // If we're not compiling for LLVM bail out here.
- if !build.config.llvm_enabled {
- return;
- }
+ let emscripten = self.emscripten;
// If we're using a custom LLVM bail out here, but we can only use a
// custom LLVM for the build triple.
- if let Some(config) = build.config.target_config.get(&target) {
- if let Some(ref s) = config.llvm_config {
- return check_llvm_version(build, s);
+ if !self.emscripten {
+ if let Some(config) = build.config.target_config.get(&target) {
+ if let Some(ref s) = config.llvm_config {
+ check_llvm_version(build, s);
+ return s.to_path_buf()
+ }
}
}
let mut rebuild_trigger_contents = String::new();
t!(t!(File::open(&rebuild_trigger)).read_to_string(&mut rebuild_trigger_contents));
- let out_dir = build.llvm_out(target);
+ let (out_dir, llvm_config_ret_dir) = if emscripten {
+ let dir = build.emscripten_llvm_out(target);
+ let config_dir = dir.join("bin");
+ (dir, config_dir)
+ } else {
+ (build.llvm_out(target),
+ build.llvm_out(build.config.build).join("bin"))
+ };
let done_stamp = out_dir.join("llvm-finished-building");
+ let build_llvm_config = llvm_config_ret_dir
+ .join(exe("llvm-config", &*build.config.build));
if done_stamp.exists() {
let mut done_contents = String::new();
t!(t!(File::open(&done_stamp)).read_to_string(&mut done_contents));
// If LLVM was already built previously and contents of the rebuild-trigger file
// didn't change from the previous build, then no action is required.
if done_contents == rebuild_trigger_contents {
- return
+ return build_llvm_config
}
}
let _folder = build.fold_output(|| "llvm");
- println!("Building LLVM for {}", target);
+ let descriptor = if emscripten { "Emscripten " } else { "" };
+ println!("Building {}LLVM for {}", descriptor, target);
let _time = util::timeit();
t!(fs::create_dir_all(&out_dir));
// http://llvm.org/docs/CMake.html
- let mut cfg = cmake::Config::new(build.src.join("src/llvm"));
+ let root = if self.emscripten { "src/llvm-emscripten" } else { "src/llvm" };
+ let mut cfg = cmake::Config::new(build.src.join(root));
if build.config.ninja {
cfg.generator("Ninja");
}
(true, true) => "RelWithDebInfo",
};
- // NOTE: remember to also update `config.toml.example` when changing the defaults!
- let llvm_targets = match build.config.llvm_targets {
- Some(ref s) => s,
- None => "X86;ARM;AArch64;Mips;PowerPC;SystemZ;JSBackend;MSP430;Sparc;NVPTX;Hexagon",
+ // NOTE: remember to also update `config.toml.example` when changing the
+ // defaults!
+ let llvm_targets = if self.emscripten {
+ "JSBackend"
+ } else {
+ match build.config.llvm_targets {
+ Some(ref s) => s,
+ None => "X86;ARM;AArch64;Mips;PowerPC;SystemZ;MSP430;Sparc;NVPTX;Hexagon",
+ }
};
- let llvm_exp_targets = &build.config.llvm_experimental_targets;
+ let llvm_exp_targets = if self.emscripten {
+ ""
+ } else {
+ &build.config.llvm_experimental_targets[..]
+ };
let assertions = if build.config.llvm_assertions {"ON"} else {"OFF"};
// http://llvm.org/docs/HowToCrossCompileLLVM.html
if target != build.build {
- builder.ensure(Llvm { target: build.build });
+ builder.ensure(Llvm {
+ target: build.build,
+ emscripten: false,
+ });
// FIXME: if the llvm root for the build triple is overridden then we
// should use llvm-tblgen from there, also should verify that it
// actually exists most of the time in normal installs of LLVM.
cfg.build();
t!(t!(File::create(&done_stamp)).write_all(rebuild_trigger_contents.as_bytes()));
+
+ build_llvm_config
}
}
}
// Make sure musl-root is valid
- if target.contains("musl") && !target.contains("mips") {
+ if target.contains("musl") {
// If this is a native target (host is also musl) and no musl-root is given,
// fall back to the system toolchain in /usr before giving up
if build.musl_root(*target).is_none() && build.config.build == *target {
cmd.env("PROFILER_SUPPORT", "1");
}
+ cmd.env("RUST_TEST_TMPDIR", build.out.join("tmp"));
+
cmd.arg("--adb-path").arg("adb");
cmd.arg("--adb-test-dir").arg(ADB_TEST_DIR);
if target.contains("android") {
}
Mode::Librustc => {
builder.ensure(compile::Rustc { compiler, target });
- compile::rustc_cargo(build, target, &mut cargo);
+ compile::rustc_cargo(build, &mut cargo);
("librustc", "rustc-main")
}
_ => panic!("can only test libraries"),
cargo.env(format!("CARGO_TARGET_{}_RUNNER", envify(&target)),
build.config.nodejs.as_ref().expect("nodejs not configured"));
} else if target.starts_with("wasm32") {
+ // Warn about running tests without the `wasm_syscall` feature enabled.
+ // The javascript shim implements the syscall interface so that test
+ // output can be correctly reported.
+ if !build.config.wasm_syscall {
+ println!("Libstd was built without `wasm_syscall` feature enabled: \
+ test output may not be visible.");
+ }
+
// On the wasm32-unknown-unknown target we're using LTO which is
// incompatible with `-C prefer-dynamic`, so disable that here
cargo.env("RUSTC_NO_PREFER_DYNAMIC", "1");
ENV TARGETS=asmjs-unknown-emscripten
-ENV RUST_CONFIGURE_ARGS --target=$TARGETS
+ENV RUST_CONFIGURE_ARGS --target=$TARGETS --enable-emscripten
ENV SCRIPT python2.7 ../x.py test --target $TARGETS
WORKDIR /build/
COPY scripts/musl.sh /build/
-RUN CC=gcc CFLAGS="-m32 -fPIC -Wa,-mrelax-relocations=no" \
+RUN CC=gcc CFLAGS="-m32 -Wa,-mrelax-relocations=no" \
CXX=g++ CXXFLAGS="-m32 -Wa,-mrelax-relocations=no" \
bash musl.sh i686 --target=i686 && \
- CC=gcc CFLAGS="-march=pentium -m32 -fPIC -Wa,-mrelax-relocations=no" \
+ CC=gcc CFLAGS="-march=pentium -m32 -Wa,-mrelax-relocations=no" \
CXX=g++ CXXFLAGS="-march=pentium -m32 -Wa,-mrelax-relocations=no" \
bash musl.sh i586 --target=i586 && \
rm -rf /build
--host=$HOSTS \
--enable-extended \
--enable-sanitizers \
- --enable-profiler
+ --enable-profiler \
+ --enable-emscripten
ENV SCRIPT python2.7 ../x.py dist --host $HOSTS --target $HOSTS
# This is the only builder which will create source tarballs
COPY dist-various-1/install-x86_64-redox.sh /build
RUN ./install-x86_64-redox.sh
+COPY dist-various-1/install-mips-musl.sh /build
+RUN ./install-mips-musl.sh
+
+COPY dist-various-1/install-mipsel-musl.sh /build
+RUN ./install-mipsel-musl.sh
+
+# Suppress some warnings in the openwrt toolchains we downloaded
+ENV STAGING_DIR=/tmp
+
COPY scripts/musl.sh /build
RUN env \
CC=arm-linux-gnueabi-gcc CFLAGS="-march=armv6 -marm" \
CC=aarch64-linux-gnu-gcc \
CXX=aarch64-linux-gnu-g++ \
bash musl.sh aarch64 && \
+ env \
+ CC=mips-openwrt-linux-gcc \
+ CXX=mips-openwrt-linux-g++ \
+ bash musl.sh mips && \
+ env \
+ CC=mipsel-openwrt-linux-gcc \
+ CXX=mipsel-openwrt-linux-g++ \
+ bash musl.sh mipsel && \
rm -rf /build/*
-COPY dist-various-1/install-mips-musl.sh /build
-RUN ./install-mips-musl.sh
-
-COPY dist-various-1/install-mipsel-musl.sh /build
-RUN ./install-mipsel-musl.sh
-
ENV TARGETS=asmjs-unknown-emscripten
ENV TARGETS=$TARGETS,wasm32-unknown-emscripten
ENV TARGETS=$TARGETS,x86_64-rumprun-netbsd
CC_armv5te_unknown_linux_gnueabi=arm-linux-gnueabi-gcc \
CFLAGS_armv5te_unknown_linux_gnueabi="-march=armv5te -marm -mfloat-abi=soft"
-# Suppress some warnings in the openwrt toolchains we downloaded
-ENV STAGING_DIR=/tmp
-
ENV RUST_CONFIGURE_ARGS \
- --enable-extended \
--target=$TARGETS \
--musl-root-arm=/musl-arm \
--musl-root-armhf=/musl-armhf \
--musl-root-armv7=/musl-armv7 \
- --musl-root-aarch64=/musl-aarch64
+ --musl-root-aarch64=/musl-aarch64 \
+ --musl-root-mips=/musl-mips \
+ --musl-root-mipsel=/musl-mipsel \
+ --enable-emscripten
+
ENV SCRIPT python2.7 ../x.py dist --target $TARGETS
# sccache
--host=$HOSTS \
--enable-extended \
--enable-sanitizers \
- --enable-profiler
+ --enable-profiler \
+ --enable-emscripten
ENV SCRIPT python2.7 ../x.py dist --host $HOSTS --target $HOSTS
# This is the only builder which will create source tarballs
COPY scripts/musl.sh /build/
# We need to mitigate rust-lang/rust#34978 when compiling musl itself as well
RUN CC=gcc \
- CFLAGS="-fPIC -Wa,-mrelax-relocations=no" \
+ CFLAGS="-Wa,-mrelax-relocations=no" \
CXX=g++ \
CXXFLAGS="-Wa,-mrelax-relocations=no" \
bash musl.sh x86_64 && rm -rf /build
TAG=$1
shift
+export CFLAGS="-fPIC $CFLAGS"
+
MUSL=musl-1.1.18
# may have been downloaded in a previous run
cd ..
-LLVM=39
+LLVM=60
+
# may have been downloaded in a previous run
if [ ! -d libunwind-release_$LLVM ]; then
curl -L https://github.com/llvm-mirror/llvm/archive/release_$LLVM.tar.gz | tar xzf -
curl -L https://github.com/llvm-mirror/libunwind/archive/release_$LLVM.tar.gz | tar xzf -
- # Whoa what's this mysterious patch we're applying to libunwind! Why are we
- # swapping the values of ESP/EBP in libunwind?!
- #
- # Discovered in #35599 it turns out that the vanilla build of libunwind is not
- # suitable for unwinding i686 musl. After some investigation it ended up
- # looking like the register values for ESP/EBP were indeed incorrect (swapped)
- # in the source. Similar commits in libunwind (r280099 and r282589) have noticed
- # this for other platforms, and we just need to realize it for musl linux as
- # well.
- #
- # More technical info can be found at #35599
- cd libunwind-release_$LLVM
- patch -Np1 << EOF
-diff --git a/include/libunwind.h b/include/libunwind.h
-index c5b9633..1360eb2 100644
---- a/include/libunwind.h
-+++ b/include/libunwind.h
-@@ -151,8 +151,8 @@ enum {
- UNW_X86_ECX = 1,
- UNW_X86_EDX = 2,
- UNW_X86_EBX = 3,
-- UNW_X86_EBP = 4,
-- UNW_X86_ESP = 5,
-+ UNW_X86_ESP = 4,
-+ UNW_X86_EBP = 5,
- UNW_X86_ESI = 6,
- UNW_X86_EDI = 7
- };
-fi
-EOF
- cd ..
fi
mkdir libunwind-build
# Update the cache (a pristine copy of the rust source master)
retry sh -c "rm -rf $cache_src_dir && mkdir -p $cache_src_dir && \
git clone --depth 1 https://github.com/rust-lang/rust.git $cache_src_dir"
-(cd $cache_src_dir && git rm src/llvm)
+if [ -d $cache_src_dir/src/llvm ]; then
+ (cd $cache_src_dir && git rm src/llvm)
+fi
+if [ -d $cache_src_dir/src/llvm-emscripten ]; then
+ (cd $cache_src_dir && git rm src/llvm-emscripten)
+fi
retry sh -c "cd $cache_src_dir && \
git submodule deinit -f . && git submodule sync && git submodule update --init"
# http://stackoverflow.com/questions/12641469/list-submodules-in-a-git-repository
modules="$(git config --file .gitmodules --get-regexp '\.path$' | cut -d' ' -f2)"
for module in $modules; do
- if [ "$module" = src/llvm ]; then
- commit="$(git ls-tree HEAD src/llvm | awk '{print $3}')"
- git rm src/llvm
+ if [ "$module" = src/llvm ] || [ "$module" = src/llvm-emscripten ]; then
+ commit="$(git ls-tree HEAD $module | awk '{print $3}')"
+ git rm $module
retry sh -c "rm -f $commit.tar.gz && \
curl -sSL -O https://github.com/rust-lang/llvm/archive/$commit.tar.gz"
tar -C src/ -xf "$commit.tar.gz"
rm "$commit.tar.gz"
- mv "src/llvm-$commit" src/llvm
+ mv "src/llvm-$commit" $module
continue
fi
if [ ! -e "$cache_src_dir/$module/.git" ]; then
types and such.
* Traits like `Send` and `Sync` are automatically implemented for a `Generator`
- depending on the captured variables of the environment. Unlike closures though
+ depending on the captured variables of the environment. Unlike closures,
generators also depend on variables live across suspension points. This means
that although the ambient environment may be `Send` or `Sync`, the generator
itself may not be due to internal variables live across `yield` points being
- not-`Send` or not-`Sync`. Note, though, that generators, like closures, do
+ not-`Send` or not-`Sync`. Note that generators, like closures, do
not implement traits like `Copy` or `Clone` automatically.
* Whenever a generator is dropped it will drop all captured environment
### Generators as state machines
-In the compiler generators are currently compiled as state machines. Each
+In the compiler, generators are currently compiled as state machines. Each
`yield` expression will correspond to a different state that stores all live
variables over that suspension point. Resumption of a generator will dispatch on
the current state and then execute internally until a `yield` is reached, at
let memory = null;
+function viewstruct(data, fields) {
+ return new Uint32Array(memory.buffer).subarray(data/4, data/4 + fields);
+}
+
function copystr(a, b) {
- if (memory === null) {
- return null
- }
- let view = new Uint8Array(memory.buffer).slice(a, a + b);
+ let view = new Uint8Array(memory.buffer).subarray(a, a + b);
return String.fromCharCode.apply(null, view);
}
+function syscall_write([fd, ptr, len]) {
+ let s = copystr(ptr, len);
+ switch (fd) {
+ case 1: process.stdout.write(s); break;
+ case 2: process.stderr.write(s); break;
+ }
+}
+
+function syscall_exit([code]) {
+ process.exit(code);
+}
+
+function syscall_args(params) {
+ let [ptr, len] = params;
+
+ // Calculate total required buffer size
+ let totalLen = -1;
+ for (let i = 2; i < process.argv.length; ++i) {
+ totalLen += Buffer.byteLength(process.argv[i]) + 1;
+ }
+ if (totalLen < 0) { totalLen = 0; }
+ params[2] = totalLen;
+
+ // If buffer is large enough, copy data
+ if (len >= totalLen) {
+ let view = new Uint8Array(memory.buffer);
+ for (let i = 2; i < process.argv.length; ++i) {
+ let value = process.argv[i];
+ Buffer.from(value).copy(view, ptr);
+ ptr += Buffer.byteLength(process.argv[i]) + 1;
+ }
+ }
+}
+
+function syscall_getenv(params) {
+ let [keyPtr, keyLen, valuePtr, valueLen] = params;
+
+ let key = copystr(keyPtr, keyLen);
+ let value = process.env[key];
+
+ if (value == null) {
+ params[4] = 0xFFFFFFFF;
+ } else {
+ let view = new Uint8Array(memory.buffer);
+ let totalLen = Buffer.byteLength(value);
+ params[4] = totalLen;
+ if (valueLen >= totalLen) {
+ Buffer.from(value).copy(view, valuePtr);
+ }
+ }
+}
+
+function syscall_time(params) {
+ let t = Date.now();
+ let secs = Math.floor(t / 1000);
+ let millis = t % 1000;
+ params[1] = Math.floor(secs / 0x100000000);
+ params[2] = secs % 0x100000000;
+ params[3] = Math.floor(millis * 1000000);
+}
+
let imports = {};
imports.env = {
// These are generated by LLVM itself for various intrinsic calls. Hopefully
log10: Math.log10,
log10f: Math.log10,
- // These are called in src/libstd/sys/wasm/stdio.rs and are used when
- // debugging is enabled.
- rust_wasm_write_stdout: function(a, b) {
- let s = copystr(a, b);
- if (s !== null) {
- process.stdout.write(s);
- }
- },
- rust_wasm_write_stderr: function(a, b) {
- let s = copystr(a, b);
- if (s !== null) {
- process.stderr.write(s);
- }
- },
-
- // These are called in src/libstd/sys/wasm/args.rs and are used when
- // debugging is enabled.
- rust_wasm_args_count: function() {
- if (memory === null)
- return 0;
- return process.argv.length - 2;
- },
- rust_wasm_args_arg_size: function(i) {
- return Buffer.byteLength(process.argv[i + 2]);
- },
- rust_wasm_args_arg_fill: function(idx, ptr) {
- let arg = process.argv[idx + 2];
- let view = new Uint8Array(memory.buffer);
- Buffer.from(arg).copy(view, ptr);
- },
-
- // These are called in src/libstd/sys/wasm/os.rs and are used when
- // debugging is enabled.
- rust_wasm_getenv_len: function(a, b) {
- let key = copystr(a, b);
- if (key === null) {
- return -1;
+ rust_wasm_syscall: function(index, data) {
+ switch (index) {
+ case 1: syscall_write(viewstruct(data, 3)); return true;
+ case 2: syscall_exit(viewstruct(data, 1)); return true;
+ case 3: syscall_args(viewstruct(data, 3)); return true;
+ case 4: syscall_getenv(viewstruct(data, 5)); return true;
+ case 6: syscall_time(viewstruct(data, 4)); return true;
+ default:
+ console.log("Unsupported syscall: " + index);
+ return false;
}
- if (!(key in process.env)) {
- return -1;
- }
- return Buffer.byteLength(process.env[key]);
- },
- rust_wasm_getenv_data: function(a, b, ptr) {
- let key = copystr(a, b);
- let value = process.env[key];
- let view = new Uint8Array(memory.buffer);
- Buffer.from(value).copy(view, ptr);
- },
-};
-
-let module_imports = WebAssembly.Module.imports(m);
-
-for (var i = 0; i < module_imports.length; i++) {
- let imp = module_imports[i];
- if (imp.module != 'env') {
- continue
}
- if (imp.name == 'memory' && imp.kind == 'memory') {
- memory = new WebAssembly.Memory({initial: 20});
- imports.env.memory = memory;
- }
-}
+};
let instance = new WebAssembly.Instance(m, imports);
+memory = instance.exports.memory;
+try {
+ instance.exports.main();
+} catch (e) {
+ console.error(e);
+ process.exit(101);
+}
{
type Output = V;
+ /// Returns a reference to the value corresponding to the supplied key.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the key is not present in the `BTreeMap`.
#[inline]
fn index(&self, key: &Q) -> &V {
self.get(key).expect("no entry found for key")
/// ```
#[stable(feature = "move_cell", since = "1.17.0")]
pub fn into_inner(self) -> T {
- unsafe { self.value.into_inner() }
+ self.value.into_inner()
}
}
// compiler statically verifies that it is not currently borrowed.
// Therefore the following assertion is just a `debug_assert!`.
debug_assert!(self.borrow.get() == UNUSED);
- unsafe { self.value.into_inner() }
+ self.value.into_inner()
}
/// Replaces the wrapped value with a new one, returning the old value,
/// Unwraps the value.
///
- /// # Safety
- ///
- /// This function is unsafe because this thread or another thread may currently be
- /// inspecting the inner value.
- ///
/// # Examples
///
/// ```
///
/// let uc = UnsafeCell::new(5);
///
- /// let five = unsafe { uc.into_inner() };
+ /// let five = uc.into_inner();
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn into_inner(self) -> T {
+ pub fn into_inner(self) -> T {
self.value
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl Debug for bool {
+ #[inline]
fn fmt(&self, f: &mut Formatter) -> Result {
Display::fmt(self, f)
}
#[stable(feature = "rust1", since = "1.0.0")]
impl Debug for () {
+ #[inline]
fn fmt(&self, f: &mut Formatter) -> Result {
f.pad("()")
}
($T:ident) => {
#[stable(feature = "rust1", since = "1.0.0")]
impl fmt::Debug for $T {
+ #[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Display::fmt(self, f)
}
use iter_private::TrustedRandomAccess;
use ops::Try;
use usize;
+use intrinsics;
#[stable(feature = "rust1", since = "1.0.0")]
pub use self::iterator::Iterator;
(f(inner_hint.0), inner_hint.1.map(f))
}
}
+
+ #[inline]
+ fn nth(&mut self, mut n: usize) -> Option<Self::Item> {
+ if self.first_take {
+ self.first_take = false;
+ let first = self.iter.next();
+ if n == 0 {
+ return first;
+ }
+ n -= 1;
+ }
+ // n and self.step are indices, we need to add 1 to get the amount of elements
+ // When calling `.nth`, we need to subtract 1 again to convert back to an index
+ // step + 1 can't overflow because `.step_by` sets `self.step` to `step - 1`
+ let mut step = self.step + 1;
+ // n + 1 could overflow
+ // thus, if n is usize::MAX, instead of adding one, we call .nth(step)
+ if n == usize::MAX {
+ self.iter.nth(step - 1);
+ } else {
+ n += 1;
+ }
+
+ // overflow handling
+ loop {
+ let mul = n.checked_mul(step);
+ if unsafe { intrinsics::likely(mul.is_some()) } {
+ return self.iter.nth(mul.unwrap() - 1);
+ }
+ let div_n = usize::MAX / n;
+ let div_step = usize::MAX / step;
+ let nth_n = div_n * n;
+ let nth_step = div_step * step;
+ let nth = if nth_n > nth_step {
+ step -= div_n;
+ nth_n
+ } else {
+ n -= div_step;
+ nth_step
+ };
+ self.iter.nth(nth - 1);
+ }
+ }
}
// StepBy can only make the iterator shorter, so the len will still fit.
pub mod str;
pub mod hash;
pub mod fmt;
+pub mod time;
// note: does not need to be public
mod char_private;
/// Type | size_of::\<Type>()
/// ---- | ---------------
/// () | 0
+/// bool | 1
/// u8 | 1
/// u16 | 2
/// u32 | 4
P: FnMut(Self::Item) -> bool,
{
// The addition might panic on overflow
- let n = self.len();
+ // Use the len of the slice to hint optimizer to remove result index bounds check.
+ let n = make_slice!(self.ptr, self.end).len();
self.try_fold(0, move |i, x| {
if predicate(x) { Err(i) }
else { Ok(i + 1) }
{
// No need for an overflow check here, because `ExactSizeIterator`
// implies that the number of elements fits into a `usize`.
- let n = self.len();
+ // Use the len of the slice to hint optimizer to remove result index bounds check.
+ let n = make_slice!(self.ptr, self.end).len();
self.try_rfold(n, move |i, x| {
let i = i - 1;
if predicate(x) { Err(i) }
#[inline]
#[stable(feature = "atomic_access", since = "1.15.0")]
pub fn into_inner(self) -> bool {
- unsafe { self.v.into_inner() != 0 }
+ self.v.into_inner() != 0
}
/// Loads a value from the bool.
#[inline]
#[stable(feature = "atomic_access", since = "1.15.0")]
pub fn into_inner(self) -> *mut T {
- unsafe { self.p.into_inner() }
+ self.p.into_inner()
}
/// Loads a value from the pointer.
#[inline]
#[$stable_access]
pub fn into_inner(self) -> $int_type {
- unsafe { self.v.into_inner() }
+ self.v.into_inner()
}
/// Loads a value from the atomic integer.
assert_eq!(it.next(), None);
}
+#[test]
+fn test_iterator_step_by_nth() {
+ let mut it = (0..16).step_by(5);
+ assert_eq!(it.nth(0), Some(0));
+ assert_eq!(it.nth(0), Some(5));
+ assert_eq!(it.nth(0), Some(10));
+ assert_eq!(it.nth(0), Some(15));
+ assert_eq!(it.nth(0), None);
+
+ let it = (0..18).step_by(5);
+ assert_eq!(it.clone().nth(0), Some(0));
+ assert_eq!(it.clone().nth(1), Some(5));
+ assert_eq!(it.clone().nth(2), Some(10));
+ assert_eq!(it.clone().nth(3), Some(15));
+ assert_eq!(it.clone().nth(4), None);
+ assert_eq!(it.clone().nth(42), None);
+}
+
+#[test]
+fn test_iterator_step_by_nth_overflow() {
+ #[cfg(target_pointer_width = "8")]
+ type Bigger = u16;
+ #[cfg(target_pointer_width = "16")]
+ type Bigger = u32;
+ #[cfg(target_pointer_width = "32")]
+ type Bigger = u64;
+ #[cfg(target_pointer_width = "64")]
+ type Bigger = u128;
+
+ #[derive(Clone)]
+ struct Test(Bigger);
+ impl<'a> Iterator for &'a mut Test {
+ type Item = i32;
+ fn next(&mut self) -> Option<Self::Item> { Some(21) }
+ fn nth(&mut self, n: usize) -> Option<Self::Item> {
+ self.0 += n as Bigger + 1;
+ Some(42)
+ }
+ }
+
+ let mut it = Test(0);
+ let root = usize::MAX >> (::std::mem::size_of::<usize>() * 8 / 2);
+ let n = root + 20;
+ (&mut it).step_by(n).nth(n);
+ assert_eq!(it.0, n as Bigger * n as Bigger);
+
+ // large step
+ let mut it = Test(0);
+ (&mut it).step_by(usize::MAX).nth(5);
+ assert_eq!(it.0, (usize::MAX as Bigger) * 5);
+
+ // n + 1 overflows
+ let mut it = Test(0);
+ (&mut it).step_by(2).nth(usize::MAX);
+ assert_eq!(it.0, (usize::MAX as Bigger) * 2);
+
+ // n + 1 overflows
+ let mut it = Test(0);
+ (&mut it).step_by(1).nth(usize::MAX);
+ assert_eq!(it.0, (usize::MAX as Bigger) * 1);
+}
+
#[test]
#[should_panic]
fn test_iterator_step_by_zero() {
--- /dev/null
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+#![stable(feature = "duration_core", since = "1.24.0")]
+
+//! Temporal quantification.
+//!
+//! Example:
+//!
+//! ```
+//! use std::time::Duration;
+//!
+//! let five_seconds = Duration::new(5, 0);
+//! // both declarations are equivalent
+//! assert_eq!(Duration::new(5, 0), Duration::from_secs(5));
+//! ```
+
+use iter::Sum;
+use ops::{Add, Sub, Mul, Div, AddAssign, SubAssign, MulAssign, DivAssign};
+
+const NANOS_PER_SEC: u32 = 1_000_000_000;
+const NANOS_PER_MILLI: u32 = 1_000_000;
+const NANOS_PER_MICRO: u32 = 1_000;
+const MILLIS_PER_SEC: u64 = 1_000;
+const MICROS_PER_SEC: u64 = 1_000_000;
+
+/// A `Duration` type to represent a span of time, typically used for system
+/// 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
+/// nanosecond-level precision, APIs binding a system timeout will typically round up
+/// the number of nanoseconds.
+///
+/// `Duration`s implement many common traits, including [`Add`], [`Sub`], and other
+/// [`ops`] traits.
+///
+/// [`Add`]: ../../std/ops/trait.Add.html
+/// [`Sub`]: ../../std/ops/trait.Sub.html
+/// [`ops`]: ../../std/ops/index.html
+///
+/// # Examples
+///
+/// ```
+/// use std::time::Duration;
+///
+/// let five_seconds = Duration::new(5, 0);
+/// let five_seconds_and_five_nanos = five_seconds + Duration::new(0, 5);
+///
+/// assert_eq!(five_seconds_and_five_nanos.as_secs(), 5);
+/// assert_eq!(five_seconds_and_five_nanos.subsec_nanos(), 5);
+///
+/// let ten_millis = Duration::from_millis(10);
+/// ```
+#[stable(feature = "duration_core", since = "1.24.0")]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash, Default)]
+pub struct Duration {
+ secs: u64,
+ nanos: u32, // Always 0 <= nanos < NANOS_PER_SEC
+}
+
+impl Duration {
+ /// Creates a new `Duration` from the specified number of whole seconds and
+ /// additional nanoseconds.
+ ///
+ /// If the number of nanoseconds is greater than 1 billion (the number of
+ /// nanoseconds in a second), then it will carry over into the seconds provided.
+ ///
+ /// # Panics
+ ///
+ /// This constructor will panic if the carry from the nanoseconds overflows
+ /// the seconds counter.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::time::Duration;
+ ///
+ /// let five_seconds = Duration::new(5, 0);
+ /// ```
+ #[stable(feature = "duration", since = "1.3.0")]
+ #[inline]
+ pub fn new(secs: u64, nanos: u32) -> Duration {
+ let secs = secs.checked_add((nanos / NANOS_PER_SEC) as u64)
+ .expect("overflow in Duration::new");
+ let nanos = nanos % NANOS_PER_SEC;
+ Duration { secs: secs, nanos: nanos }
+ }
+
+ /// Creates a new `Duration` from the specified number of whole seconds.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::time::Duration;
+ ///
+ /// let duration = Duration::from_secs(5);
+ ///
+ /// assert_eq!(5, duration.as_secs());
+ /// assert_eq!(0, duration.subsec_nanos());
+ /// ```
+ #[stable(feature = "duration", since = "1.3.0")]
+ #[inline]
+ pub const fn from_secs(secs: u64) -> Duration {
+ Duration { secs: secs, nanos: 0 }
+ }
+
+ /// Creates a new `Duration` from the specified number of milliseconds.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::time::Duration;
+ ///
+ /// let duration = Duration::from_millis(2569);
+ ///
+ /// assert_eq!(2, duration.as_secs());
+ /// assert_eq!(569_000_000, duration.subsec_nanos());
+ /// ```
+ #[stable(feature = "duration", since = "1.3.0")]
+ #[inline]
+ pub const fn from_millis(millis: u64) -> Duration {
+ Duration {
+ secs: millis / MILLIS_PER_SEC,
+ nanos: ((millis % MILLIS_PER_SEC) as u32) * NANOS_PER_MILLI,
+ }
+ }
+
+ /// Creates a new `Duration` from the specified number of microseconds.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(duration_from_micros)]
+ /// use std::time::Duration;
+ ///
+ /// let duration = Duration::from_micros(1_000_002);
+ ///
+ /// assert_eq!(1, duration.as_secs());
+ /// assert_eq!(2000, duration.subsec_nanos());
+ /// ```
+ #[unstable(feature = "duration_from_micros", issue = "44400")]
+ #[inline]
+ pub const fn from_micros(micros: u64) -> Duration {
+ Duration {
+ secs: micros / MICROS_PER_SEC,
+ nanos: ((micros % MICROS_PER_SEC) as u32) * NANOS_PER_MICRO,
+ }
+ }
+
+ /// Creates a new `Duration` from the specified number of nanoseconds.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(duration_extras)]
+ /// use std::time::Duration;
+ ///
+ /// let duration = Duration::from_nanos(1_000_000_123);
+ ///
+ /// assert_eq!(1, duration.as_secs());
+ /// assert_eq!(123, duration.subsec_nanos());
+ /// ```
+ #[unstable(feature = "duration_extras", issue = "46507")]
+ #[inline]
+ pub const fn from_nanos(nanos: u64) -> Duration {
+ Duration {
+ secs: nanos / (NANOS_PER_SEC as u64),
+ nanos: (nanos % (NANOS_PER_SEC as u64)) as u32,
+ }
+ }
+
+ /// Returns the number of _whole_ seconds contained by this `Duration`.
+ ///
+ /// The returned value does not include the fractional (nanosecond) part of the
+ /// duration, which can be obtained using [`subsec_nanos`].
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::time::Duration;
+ ///
+ /// let duration = Duration::new(5, 730023852);
+ /// assert_eq!(duration.as_secs(), 5);
+ /// ```
+ ///
+ /// To determine the total number of seconds represented by the `Duration`,
+ /// use `as_secs` in combination with [`subsec_nanos`]:
+ ///
+ /// ```
+ /// use std::time::Duration;
+ ///
+ /// let duration = Duration::new(5, 730023852);
+ ///
+ /// assert_eq!(5.730023852,
+ /// duration.as_secs() as f64
+ /// + duration.subsec_nanos() as f64 * 1e-9);
+ /// ```
+ ///
+ /// [`subsec_nanos`]: #method.subsec_nanos
+ #[stable(feature = "duration", since = "1.3.0")]
+ #[inline]
+ pub fn as_secs(&self) -> u64 { self.secs }
+
+ /// Returns the fractional part of this `Duration`, in milliseconds.
+ ///
+ /// This method does **not** return the length of the duration when
+ /// represented by milliseconds. The returned number always represents a
+ /// fractional portion of a second (i.e. it is less than one thousand).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(duration_extras)]
+ /// use std::time::Duration;
+ ///
+ /// let duration = Duration::from_millis(5432);
+ /// assert_eq!(duration.as_secs(), 5);
+ /// assert_eq!(duration.subsec_millis(), 432);
+ /// ```
+ #[unstable(feature = "duration_extras", issue = "46507")]
+ #[inline]
+ pub fn subsec_millis(&self) -> u32 { self.nanos / NANOS_PER_MILLI }
+
+ /// Returns the fractional part of this `Duration`, in microseconds.
+ ///
+ /// This method does **not** return the length of the duration when
+ /// represented by microseconds. The returned number always represents a
+ /// fractional portion of a second (i.e. it is less than one million).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(duration_extras, duration_from_micros)]
+ /// use std::time::Duration;
+ ///
+ /// let duration = Duration::from_micros(1_234_567);
+ /// assert_eq!(duration.as_secs(), 1);
+ /// assert_eq!(duration.subsec_micros(), 234_567);
+ /// ```
+ #[unstable(feature = "duration_extras", issue = "46507")]
+ #[inline]
+ pub fn subsec_micros(&self) -> u32 { self.nanos / NANOS_PER_MICRO }
+
+ /// Returns the fractional part of this `Duration`, in nanoseconds.
+ ///
+ /// This method does **not** return the length of the duration when
+ /// represented by nanoseconds. The returned number always represents a
+ /// fractional portion of a second (i.e. it is less than one billion).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::time::Duration;
+ ///
+ /// let duration = Duration::from_millis(5010);
+ /// assert_eq!(duration.as_secs(), 5);
+ /// assert_eq!(duration.subsec_nanos(), 10_000_000);
+ /// ```
+ #[stable(feature = "duration", since = "1.3.0")]
+ #[inline]
+ pub fn subsec_nanos(&self) -> u32 { self.nanos }
+
+ /// Checked `Duration` addition. Computes `self + other`, returning [`None`]
+ /// if overflow occurred.
+ ///
+ /// [`None`]: ../../std/option/enum.Option.html#variant.None
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// use std::time::Duration;
+ ///
+ /// assert_eq!(Duration::new(0, 0).checked_add(Duration::new(0, 1)), Some(Duration::new(0, 1)));
+ /// assert_eq!(Duration::new(1, 0).checked_add(Duration::new(std::u64::MAX, 0)), None);
+ /// ```
+ #[stable(feature = "duration_checked_ops", since = "1.16.0")]
+ #[inline]
+ pub fn checked_add(self, rhs: Duration) -> Option<Duration> {
+ if let Some(mut secs) = self.secs.checked_add(rhs.secs) {
+ let mut nanos = self.nanos + rhs.nanos;
+ if nanos >= NANOS_PER_SEC {
+ nanos -= NANOS_PER_SEC;
+ if let Some(new_secs) = secs.checked_add(1) {
+ secs = new_secs;
+ } else {
+ return None;
+ }
+ }
+ debug_assert!(nanos < NANOS_PER_SEC);
+ Some(Duration {
+ secs,
+ nanos,
+ })
+ } else {
+ None
+ }
+ }
+
+ /// Checked `Duration` subtraction. Computes `self - other`, returning [`None`]
+ /// if the result would be negative or if overflow occurred.
+ ///
+ /// [`None`]: ../../std/option/enum.Option.html#variant.None
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// use std::time::Duration;
+ ///
+ /// assert_eq!(Duration::new(0, 1).checked_sub(Duration::new(0, 0)), Some(Duration::new(0, 1)));
+ /// assert_eq!(Duration::new(0, 0).checked_sub(Duration::new(0, 1)), None);
+ /// ```
+ #[stable(feature = "duration_checked_ops", since = "1.16.0")]
+ #[inline]
+ pub fn checked_sub(self, rhs: Duration) -> Option<Duration> {
+ if let Some(mut secs) = self.secs.checked_sub(rhs.secs) {
+ let nanos = if self.nanos >= rhs.nanos {
+ self.nanos - rhs.nanos
+ } else {
+ if let Some(sub_secs) = secs.checked_sub(1) {
+ secs = sub_secs;
+ self.nanos + NANOS_PER_SEC - rhs.nanos
+ } else {
+ return None;
+ }
+ };
+ debug_assert!(nanos < NANOS_PER_SEC);
+ Some(Duration { secs: secs, nanos: nanos })
+ } else {
+ None
+ }
+ }
+
+ /// Checked `Duration` multiplication. Computes `self * other`, returning
+ /// [`None`] if overflow occurred.
+ ///
+ /// [`None`]: ../../std/option/enum.Option.html#variant.None
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// use std::time::Duration;
+ ///
+ /// assert_eq!(Duration::new(0, 500_000_001).checked_mul(2), Some(Duration::new(1, 2)));
+ /// assert_eq!(Duration::new(std::u64::MAX - 1, 0).checked_mul(2), None);
+ /// ```
+ #[stable(feature = "duration_checked_ops", since = "1.16.0")]
+ #[inline]
+ pub fn checked_mul(self, rhs: u32) -> Option<Duration> {
+ // Multiply nanoseconds as u64, because it cannot overflow that way.
+ let total_nanos = self.nanos as u64 * rhs as u64;
+ let extra_secs = total_nanos / (NANOS_PER_SEC as u64);
+ let nanos = (total_nanos % (NANOS_PER_SEC as u64)) as u32;
+ if let Some(secs) = self.secs
+ .checked_mul(rhs as u64)
+ .and_then(|s| s.checked_add(extra_secs)) {
+ debug_assert!(nanos < NANOS_PER_SEC);
+ Some(Duration {
+ secs,
+ nanos,
+ })
+ } else {
+ None
+ }
+ }
+
+ /// Checked `Duration` division. Computes `self / other`, returning [`None`]
+ /// if `other == 0`.
+ ///
+ /// [`None`]: ../../std/option/enum.Option.html#variant.None
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// use std::time::Duration;
+ ///
+ /// assert_eq!(Duration::new(2, 0).checked_div(2), Some(Duration::new(1, 0)));
+ /// assert_eq!(Duration::new(1, 0).checked_div(2), Some(Duration::new(0, 500_000_000)));
+ /// assert_eq!(Duration::new(2, 0).checked_div(0), None);
+ /// ```
+ #[stable(feature = "duration_checked_ops", since = "1.16.0")]
+ #[inline]
+ pub fn checked_div(self, rhs: u32) -> Option<Duration> {
+ if rhs != 0 {
+ let secs = self.secs / (rhs as u64);
+ let carry = self.secs - secs * (rhs as u64);
+ let extra_nanos = carry * (NANOS_PER_SEC as u64) / (rhs as u64);
+ let nanos = self.nanos / rhs + (extra_nanos as u32);
+ debug_assert!(nanos < NANOS_PER_SEC);
+ Some(Duration { secs: secs, nanos: nanos })
+ } else {
+ None
+ }
+ }
+}
+
+#[stable(feature = "duration", since = "1.3.0")]
+impl Add for Duration {
+ type Output = Duration;
+
+ fn add(self, rhs: Duration) -> Duration {
+ self.checked_add(rhs).expect("overflow when adding durations")
+ }
+}
+
+#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
+impl AddAssign for Duration {
+ fn add_assign(&mut self, rhs: Duration) {
+ *self = *self + rhs;
+ }
+}
+
+#[stable(feature = "duration", since = "1.3.0")]
+impl Sub for Duration {
+ type Output = Duration;
+
+ fn sub(self, rhs: Duration) -> Duration {
+ self.checked_sub(rhs).expect("overflow when subtracting durations")
+ }
+}
+
+#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
+impl SubAssign for Duration {
+ fn sub_assign(&mut self, rhs: Duration) {
+ *self = *self - rhs;
+ }
+}
+
+#[stable(feature = "duration", since = "1.3.0")]
+impl Mul<u32> for Duration {
+ type Output = Duration;
+
+ fn mul(self, rhs: u32) -> Duration {
+ self.checked_mul(rhs).expect("overflow when multiplying duration by scalar")
+ }
+}
+
+#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
+impl MulAssign<u32> for Duration {
+ fn mul_assign(&mut self, rhs: u32) {
+ *self = *self * rhs;
+ }
+}
+
+#[stable(feature = "duration", since = "1.3.0")]
+impl Div<u32> for Duration {
+ type Output = Duration;
+
+ fn div(self, rhs: u32) -> Duration {
+ self.checked_div(rhs).expect("divide by zero error when dividing duration by scalar")
+ }
+}
+
+#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
+impl DivAssign<u32> for Duration {
+ fn div_assign(&mut self, rhs: u32) {
+ *self = *self / rhs;
+ }
+}
+
+#[stable(feature = "duration_sum", since = "1.16.0")]
+impl Sum for Duration {
+ fn sum<I: Iterator<Item=Duration>>(iter: I) -> Duration {
+ iter.fold(Duration::new(0, 0), |a, b| a + b)
+ }
+}
+
+#[stable(feature = "duration_sum", since = "1.16.0")]
+impl<'a> Sum<&'a Duration> for Duration {
+ fn sum<I: Iterator<Item=&'a Duration>>(iter: I) -> Duration {
+ iter.fold(Duration::new(0, 0), |a, b| a + *b)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::Duration;
+
+ #[test]
+ fn creation() {
+ assert!(Duration::from_secs(1) != Duration::from_secs(0));
+ assert_eq!(Duration::from_secs(1) + Duration::from_secs(2),
+ Duration::from_secs(3));
+ assert_eq!(Duration::from_millis(10) + Duration::from_secs(4),
+ Duration::new(4, 10 * 1_000_000));
+ assert_eq!(Duration::from_millis(4000), Duration::new(4, 0));
+ }
+
+ #[test]
+ fn secs() {
+ assert_eq!(Duration::new(0, 0).as_secs(), 0);
+ assert_eq!(Duration::from_secs(1).as_secs(), 1);
+ assert_eq!(Duration::from_millis(999).as_secs(), 0);
+ assert_eq!(Duration::from_millis(1001).as_secs(), 1);
+ }
+
+ #[test]
+ fn nanos() {
+ assert_eq!(Duration::new(0, 0).subsec_nanos(), 0);
+ assert_eq!(Duration::new(0, 5).subsec_nanos(), 5);
+ assert_eq!(Duration::new(0, 1_000_000_001).subsec_nanos(), 1);
+ assert_eq!(Duration::from_secs(1).subsec_nanos(), 0);
+ assert_eq!(Duration::from_millis(999).subsec_nanos(), 999 * 1_000_000);
+ assert_eq!(Duration::from_millis(1001).subsec_nanos(), 1 * 1_000_000);
+ }
+
+ #[test]
+ fn add() {
+ assert_eq!(Duration::new(0, 0) + Duration::new(0, 1),
+ Duration::new(0, 1));
+ assert_eq!(Duration::new(0, 500_000_000) + Duration::new(0, 500_000_001),
+ Duration::new(1, 1));
+ }
+
+ #[test]
+ fn checked_add() {
+ assert_eq!(Duration::new(0, 0).checked_add(Duration::new(0, 1)),
+ Some(Duration::new(0, 1)));
+ assert_eq!(Duration::new(0, 500_000_000).checked_add(Duration::new(0, 500_000_001)),
+ Some(Duration::new(1, 1)));
+ assert_eq!(Duration::new(1, 0).checked_add(Duration::new(::u64::MAX, 0)), None);
+ }
+
+ #[test]
+ fn sub() {
+ assert_eq!(Duration::new(0, 1) - Duration::new(0, 0),
+ Duration::new(0, 1));
+ assert_eq!(Duration::new(0, 500_000_001) - Duration::new(0, 500_000_000),
+ Duration::new(0, 1));
+ assert_eq!(Duration::new(1, 0) - Duration::new(0, 1),
+ Duration::new(0, 999_999_999));
+ }
+
+ #[test]
+ fn checked_sub() {
+ let zero = Duration::new(0, 0);
+ let one_nano = Duration::new(0, 1);
+ let one_sec = Duration::new(1, 0);
+ assert_eq!(one_nano.checked_sub(zero), Some(Duration::new(0, 1)));
+ assert_eq!(one_sec.checked_sub(one_nano),
+ Some(Duration::new(0, 999_999_999)));
+ assert_eq!(zero.checked_sub(one_nano), None);
+ assert_eq!(zero.checked_sub(one_sec), None);
+ }
+
+ #[test] #[should_panic]
+ fn sub_bad1() {
+ Duration::new(0, 0) - Duration::new(0, 1);
+ }
+
+ #[test] #[should_panic]
+ fn sub_bad2() {
+ Duration::new(0, 0) - Duration::new(1, 0);
+ }
+
+ #[test]
+ fn mul() {
+ assert_eq!(Duration::new(0, 1) * 2, Duration::new(0, 2));
+ assert_eq!(Duration::new(1, 1) * 3, Duration::new(3, 3));
+ assert_eq!(Duration::new(0, 500_000_001) * 4, Duration::new(2, 4));
+ assert_eq!(Duration::new(0, 500_000_001) * 4000,
+ Duration::new(2000, 4000));
+ }
+
+ #[test]
+ fn checked_mul() {
+ assert_eq!(Duration::new(0, 1).checked_mul(2), Some(Duration::new(0, 2)));
+ assert_eq!(Duration::new(1, 1).checked_mul(3), Some(Duration::new(3, 3)));
+ assert_eq!(Duration::new(0, 500_000_001).checked_mul(4), Some(Duration::new(2, 4)));
+ assert_eq!(Duration::new(0, 500_000_001).checked_mul(4000),
+ Some(Duration::new(2000, 4000)));
+ assert_eq!(Duration::new(::u64::MAX - 1, 0).checked_mul(2), None);
+ }
+
+ #[test]
+ fn div() {
+ assert_eq!(Duration::new(0, 1) / 2, Duration::new(0, 0));
+ assert_eq!(Duration::new(1, 1) / 3, Duration::new(0, 333_333_333));
+ assert_eq!(Duration::new(99, 999_999_000) / 100,
+ Duration::new(0, 999_999_990));
+ }
+
+ #[test]
+ fn checked_div() {
+ assert_eq!(Duration::new(2, 0).checked_div(2), Some(Duration::new(1, 0)));
+ assert_eq!(Duration::new(1, 0).checked_div(2), Some(Duration::new(0, 500_000_000)));
+ assert_eq!(Duration::new(2, 0).checked_div(0), None);
+ }
+}
-Subproject commit 2b4cd1016bdba92becb4f982a4dcb18fe6653bc4
+Subproject commit 56444a4545bd71430d64b86b8a71714cfdbe9f5d
#![feature(libc)]
#![feature(panic_runtime)]
#![feature(staged_api)]
+#![feature(rustc_attrs)]
// Rust's "try" function, but if we're aborting on panics we just call the
// function as there's nothing else we need to do here.
#[no_mangle]
+#[rustc_std_internal_symbol]
pub unsafe extern fn __rust_maybe_catch_panic(f: fn(*mut u8),
data: *mut u8,
_data_ptr: *mut usize,
// will kill us with an illegal instruction, which will do a good enough job for
// now hopefully.
#[no_mangle]
+#[rustc_std_internal_symbol]
pub unsafe extern fn __rust_start_panic(_data: usize, _vtable: usize) -> u32 {
abort();
fmt_macros = { path = "../libfmt_macros" }
graphviz = { path = "../libgraphviz" }
jobserver = "0.1"
-log = "0.4"
+log = { version = "0.4", features = ["release_max_level_info", "std"] }
rustc_apfloat = { path = "../librustc_apfloat" }
rustc_back = { path = "../librustc_back" }
rustc_const_math = { path = "../librustc_const_math" }
backtrace = "0.3.3"
byteorder = { version = "1.1", features = ["i128"]}
-
# Note that these dependencies are a lie, they're just here to get linkage to
# work.
#
- `'gcx` -- the lifetime of the global arena (see `librustc/ty`).
- generics -- the set of generic type parameters defined on a type or item
- ICE -- internal compiler error. When the compiler crashes.
+- ICH -- incremental compilation hash.
- infcx -- the inference context (see `librustc/infer`)
- MIR -- the **Mid-level IR** that is created after type-checking for use by borrowck and trans.
Defined in the `src/librustc/mir/` module, but much of the code that manipulates it is
[] TargetFeaturesEnabled(DefId),
[] InstanceDefSizeEstimate { instance_def: InstanceDef<'tcx> },
+
+ [] GetSymbolExportLevel(DefId),
+
);
trait DepNodeParams<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> : fmt::Debug {
// `match <sub_expr> { ... }`
let arms = hir_vec![pat_arm, break_arm];
- let match_expr = self.expr(e.span,
+ let match_expr = self.expr(sub_expr.span,
hir::ExprMatch(sub_expr,
arms,
hir::MatchSource::WhileLetDesugar),
// expand <head>
let head = self.lower_expr(head);
+ let head_sp = head.span;
let iter = self.str_to_ident("iter");
let next_ident = self.str_to_ident("__next");
- let next_pat = self.pat_ident_binding_mode(e.span,
+ let next_pat = self.pat_ident_binding_mode(pat.span,
next_ident,
hir::BindingAnnotation::Mutable);
// `::std::option::Option::Some(val) => next = val`
let pat_arm = {
let val_ident = self.str_to_ident("val");
- let val_pat = self.pat_ident(e.span, val_ident);
- let val_expr = P(self.expr_ident(e.span, val_ident, val_pat.id));
- let next_expr = P(self.expr_ident(e.span, next_ident, next_pat.id));
- let assign = P(self.expr(e.span,
+ let val_pat = self.pat_ident(pat.span, val_ident);
+ let val_expr = P(self.expr_ident(pat.span, val_ident, val_pat.id));
+ let next_expr = P(self.expr_ident(pat.span, next_ident, next_pat.id));
+ let assign = P(self.expr(pat.span,
hir::ExprAssign(next_expr, val_expr),
ThinVec::new()));
- let some_pat = self.pat_some(e.span, val_pat);
+ let some_pat = self.pat_some(pat.span, val_pat);
self.arm(hir_vec![some_pat], assign)
};
};
// `mut iter`
- let iter_pat = self.pat_ident_binding_mode(e.span,
+ let iter_pat = self.pat_ident_binding_mode(head_sp,
iter,
hir::BindingAnnotation::Mutable);
// `match ::std::iter::Iterator::next(&mut iter) { ... }`
let match_expr = {
- let iter = P(self.expr_ident(e.span, iter, iter_pat.id));
- let ref_mut_iter = self.expr_mut_addr_of(e.span, iter);
+ let iter = P(self.expr_ident(head_sp, iter, iter_pat.id));
+ let ref_mut_iter = self.expr_mut_addr_of(head_sp, iter);
let next_path = &["iter", "Iterator", "next"];
- let next_path = P(self.expr_std_path(e.span, next_path, ThinVec::new()));
- let next_expr = P(self.expr_call(e.span, next_path,
+ let next_path = P(self.expr_std_path(head_sp, next_path, ThinVec::new()));
+ let next_expr = P(self.expr_call(head_sp, next_path,
hir_vec![ref_mut_iter]));
let arms = hir_vec![pat_arm, break_arm];
- P(self.expr(e.span,
+ P(self.expr(head_sp,
hir::ExprMatch(next_expr, arms,
hir::MatchSource::ForLoopDesugar),
ThinVec::new()))
};
- let match_stmt = respan(e.span, hir::StmtExpr(match_expr, self.next_id().node_id));
+ let match_stmt = respan(head_sp, hir::StmtExpr(match_expr, self.next_id().node_id));
- let next_expr = P(self.expr_ident(e.span, next_ident, next_pat.id));
+ let next_expr = P(self.expr_ident(head_sp, next_ident, next_pat.id));
// `let mut __next`
- let next_let = self.stmt_let_pat(e.span,
+ let next_let = self.stmt_let_pat(head_sp,
None,
next_pat,
hir::LocalSource::ForLoopDesugar);
// `let <pat> = __next`
let pat = self.lower_pat(pat);
- let pat_let = self.stmt_let_pat(e.span,
+ let pat_let = self.stmt_let_pat(head_sp,
Some(next_expr),
pat,
hir::LocalSource::ForLoopDesugar);
- let body_block = self.with_loop_scope(e.id,
- |this| this.lower_block(body, false));
+ let body_block = self.with_loop_scope(e.id, |this| this.lower_block(body, false));
let body_expr = P(self.expr_block(body_block, ThinVec::new()));
- let body_stmt = respan(e.span, hir::StmtExpr(body_expr, self.next_id().node_id));
+ let body_stmt = respan(body.span, hir::StmtExpr(body_expr, self.next_id().node_id));
let loop_block = P(self.block_all(e.span,
hir_vec![next_let,
// `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
let into_iter_expr = {
let into_iter_path = &["iter", "IntoIterator", "into_iter"];
- let into_iter = P(self.expr_std_path(e.span, into_iter_path,
+ let into_iter = P(self.expr_std_path(head_sp, into_iter_path,
ThinVec::new()));
- P(self.expr_call(e.span, into_iter, hir_vec![head]))
+ P(self.expr_call(head_sp, into_iter, hir_vec![head]))
};
- let match_expr = P(self.expr_match(e.span,
+ let match_expr = P(self.expr_match(head_sp,
into_iter_expr,
hir_vec![iter_arm],
hir::MatchSource::ForLoopDesugar));
// `sp` only covers `T`, change it so that it covers
// `T:` when appropriate
let sp = if has_lifetimes {
- sp.to(sp.next_point().next_point())
+ sp.to(self.tcx.sess.codemap().next_point(
+ self.tcx.sess.codemap().next_point(sp)))
} else {
sp
};
#![feature(specialization)]
#![feature(unboxed_closures)]
#![feature(underscore_lifetimes)]
+#![feature(universal_impl_trait)]
#![feature(trace_macros)]
#![feature(catch_expr)]
#![feature(test)]
}
hir::ExprAssign(ref l, ref r) => {
- // see comment on lvalues in
- // propagate_through_lvalue_components()
- let succ = self.write_lvalue(&l, succ, ACC_WRITE);
- let succ = self.propagate_through_lvalue_components(&l, succ);
+ // see comment on places in
+ // propagate_through_place_components()
+ let succ = self.write_place(&l, succ, ACC_WRITE);
+ let succ = self.propagate_through_place_components(&l, succ);
self.propagate_through_expr(&r, succ)
}
let succ = self.propagate_through_expr(&l, succ);
self.propagate_through_expr(&r, succ)
} else {
- // see comment on lvalues in
- // propagate_through_lvalue_components()
- let succ = self.write_lvalue(&l, succ, ACC_WRITE|ACC_READ);
+ // see comment on places in
+ // propagate_through_place_components()
+ let succ = self.write_place(&l, succ, ACC_WRITE|ACC_READ);
let succ = self.propagate_through_expr(&r, succ);
- self.propagate_through_lvalue_components(&l, succ)
+ self.propagate_through_place_components(&l, succ)
}
}
hir::ExprInlineAsm(ref ia, ref outputs, ref inputs) => {
let succ = ia.outputs.iter().zip(outputs).rev().fold(succ, |succ, (o, output)| {
- // see comment on lvalues
- // in propagate_through_lvalue_components()
+ // see comment on places
+ // in propagate_through_place_components()
if o.is_indirect {
self.propagate_through_expr(output, succ)
} else {
let acc = if o.is_rw { ACC_WRITE|ACC_READ } else { ACC_WRITE };
- let succ = self.write_lvalue(output, succ, acc);
- self.propagate_through_lvalue_components(output, succ)
+ let succ = self.write_place(output, succ, acc);
+ self.propagate_through_place_components(output, succ)
}
});
}
}
- fn propagate_through_lvalue_components(&mut self,
+ fn propagate_through_place_components(&mut self,
expr: &Expr,
succ: LiveNode)
-> LiveNode {
- // # Lvalues
+ // # Places
//
// In general, the full flow graph structure for an
// assignment/move/etc can be handled in one of two ways,
//
// The two kinds of graphs are:
//
- // Tracked lvalue Untracked lvalue
+ // Tracked place Untracked place
// ----------------------++-----------------------
// ||
// | || |
// (rvalue) || (rvalue)
// | || |
// v || v
- // (write of lvalue) || (lvalue components)
+ // (write of place) || (place components)
// | || |
// v || v
// (succ) || (succ)
//
// I will cover the two cases in turn:
//
- // # Tracked lvalues
+ // # Tracked places
//
- // A tracked lvalue is a local variable/argument `x`. In
+ // A tracked place is a local variable/argument `x`. In
// these cases, the link_node where the write occurs is linked
- // to node id of `x`. The `write_lvalue()` routine generates
+ // to node id of `x`. The `write_place()` routine generates
// the contents of this node. There are no subcomponents to
// consider.
//
- // # Non-tracked lvalues
+ // # Non-tracked places
//
- // These are lvalues like `x[5]` or `x.f`. In that case, we
+ // These are places like `x[5]` or `x.f`. In that case, we
// basically ignore the value which is written to but generate
// reads for the components---`x` in these two examples. The
// components reads are generated by
- // `propagate_through_lvalue_components()` (this fn).
+ // `propagate_through_place_components()` (this fn).
//
- // # Illegal lvalues
+ // # Illegal places
//
- // It is still possible to observe assignments to non-lvalues;
+ // It is still possible to observe assignments to non-places;
// these errors are detected in the later pass borrowck. We
// just ignore such cases and treat them as reads.
}
}
- // see comment on propagate_through_lvalue()
- fn write_lvalue(&mut self, expr: &Expr, succ: LiveNode, acc: u32)
+ // see comment on propagate_through_place()
+ fn write_place(&mut self, expr: &Expr, succ: LiveNode, acc: u32)
-> LiveNode {
match expr.node {
hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
self.access_path(expr.id, path, succ, acc)
}
- // We do not track other lvalues, so just propagate through
+ // We do not track other places, so just propagate through
// to their subcomponents. Also, it may happen that
- // non-lvalues occur here, because those are detected in the
+ // non-places occur here, because those are detected in the
// later pass borrowck.
_ => succ
}
fn check_expr<'a, 'tcx>(this: &mut Liveness<'a, 'tcx>, expr: &'tcx Expr) {
match expr.node {
hir::ExprAssign(ref l, _) => {
- this.check_lvalue(&l);
+ this.check_place(&l);
intravisit::walk_expr(this, expr);
}
hir::ExprAssignOp(_, ref l, _) => {
if !this.tables.is_method_call(expr) {
- this.check_lvalue(&l);
+ this.check_place(&l);
}
intravisit::walk_expr(this, expr);
this.visit_expr(input);
}
- // Output operands must be lvalues
+ // Output operands must be places
for (o, output) in ia.outputs.iter().zip(outputs) {
if !o.is_indirect {
- this.check_lvalue(output);
+ this.check_place(output);
}
this.visit_expr(output);
}
}
impl<'a, 'tcx> Liveness<'a, 'tcx> {
- fn check_lvalue(&mut self, expr: &'tcx Expr) {
+ fn check_place(&mut self, expr: &'tcx Expr) {
match expr.node {
hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
if let Def::Local(nid) = path.def {
}
}
_ => {
- // For other kinds of lvalues, no checks are required,
+ // For other kinds of places, no checks are required,
// and any embedded expressions are actually rvalues
intravisit::walk_expr(self, expr);
}
//! | 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 an lvalue, then this
-//! is the address of the lvalue. 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)
pub id: ast::NodeId, // id of expr/pat producing this value
pub span: Span, // span of same expr/pat
pub cat: Categorization<'tcx>, // categorization of expr
- pub mutbl: MutabilityCategory, // mutability of expr as lvalue
+ pub mutbl: MutabilityCategory, // mutability of expr as place
pub ty: Ty<'tcx>, // type of the expr (*see WARNING above*)
pub note: Note, // Note about the provenance of this cmt
}
// a bind-by-ref means that the base_ty will be the type of the ident itself,
// but what we want here is the type of the underlying value being borrowed.
// So peel off one-level, turning the &T into T.
- match base_ty.builtin_deref(false, ty::NoPreference) {
+ match base_ty.builtin_deref(false) {
Some(t) => t.ty,
None => {
debug!("By-ref binding of non-derefable type {:?}", base_ty);
match expr.node {
hir::ExprUnary(hir::UnDeref, ref e_base) => {
if self.tables.is_method_call(expr) {
- self.cat_overloaded_lvalue(expr, e_base, false)
+ self.cat_overloaded_place(expr, e_base, false)
} else {
let base_cmt = self.cat_expr(&e_base)?;
self.cat_deref(expr, base_cmt, false)
// The call to index() returns a `&T` value, which
// is an rvalue. That is what we will be
// dereferencing.
- self.cat_overloaded_lvalue(expr, base, true)
+ self.cat_overloaded_place(expr, base, true)
} else {
let base_cmt = self.cat_expr(&base)?;
self.cat_index(expr, base_cmt, expr_ty, InteriorOffsetKind::Index)
ret
}
- fn cat_overloaded_lvalue(&self,
+ fn cat_overloaded_place(&self,
expr: &hir::Expr,
base: &hir::Expr,
implicit: bool)
-> McResult<cmt<'tcx>> {
- debug!("cat_overloaded_lvalue: implicit={}", implicit);
+ debug!("cat_overloaded_place: implicit={}", implicit);
// Reconstruct the output assuming it's a reference with the
// same region and mutability as the receiver. This holds for
// `Deref(Mut)::Deref(_mut)` and `Index(Mut)::index(_mut)`.
- let lvalue_ty = self.expr_ty(expr)?;
+ let place_ty = self.expr_ty(expr)?;
let base_ty = self.expr_ty_adjusted(base)?;
let (region, mutbl) = match base_ty.sty {
ty::TyRef(region, mt) => (region, mt.mutbl),
_ => {
- span_bug!(expr.span, "cat_overloaded_lvalue: base is not a reference")
+ span_bug!(expr.span, "cat_overloaded_place: base is not a reference")
}
};
let ref_ty = self.tcx.mk_ref(region, ty::TypeAndMut {
- ty: lvalue_ty,
+ ty: place_ty,
mutbl,
});
debug!("cat_deref: base_cmt={:?}", base_cmt);
let base_cmt_ty = base_cmt.ty;
- let deref_ty = match base_cmt_ty.builtin_deref(true, ty::NoPreference) {
+ let deref_ty = match base_cmt_ty.builtin_deref(true) {
Some(mt) => mt.ty,
None => {
debug!("Explicit deref of non-derefable type: {:?}",
}
}
- /// Returns `FreelyAliasable(_)` if this lvalue represents a freely aliasable pointer type.
+ /// Returns `FreelyAliasable(_)` if this place represents a freely aliasable pointer type.
pub fn freely_aliasable(&self) -> Aliasability {
// Maybe non-obvious: copied upvars can only be considered
// non-aliasable in once closures, since any other kind can be
"static item".to_string()
}
Categorization::Rvalue(..) => {
- "non-lvalue".to_string()
+ "non-place".to_string()
}
Categorization::Local(vid) => {
if tcx.hir.is_argument(vid) {
// I mean that creating a binding into a ref-counted or managed value
// would still count.)
//
- // 3. `ET`, which matches both rvalues like `foo()` as well as lvalues
+ // 3. `ET`, which matches both rvalues like `foo()` as well as places
// based on rvalues like `foo().x[2].y`.
//
// A subexpression `<rvalue>` that appears in a let initializer
/// | (ET)
/// | <rvalue>
///
- /// Note: ET is intended to match "rvalues or lvalues based on rvalues".
+ /// Note: ET is intended to match "rvalues or places based on rvalues".
fn record_rvalue_scope<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'a, 'tcx>,
expr: &hir::Expr,
blk_scope: Option<Scope>) {
},
/// Drop the Place and assign the new value over it. This ensures
- /// that the assignment to LV occurs *even if* the destructor for
+ /// that the assignment to `P` occurs *even if* the destructor for
/// place unwinds. Its semantics are best explained by by the
/// elaboration:
///
/// ```
/// BB0 {
- /// DropAndReplace(LV <- RV, goto BB1, unwind BB2)
+ /// DropAndReplace(P <- V, goto BB1, unwind BB2)
/// }
/// ```
///
///
/// ```
/// BB0 {
- /// Drop(LV, goto BB1, unwind BB2)
+ /// Drop(P, goto BB1, unwind BB2)
/// }
/// BB1 {
- /// // LV is now unitialized
- /// LV <- RV
+ /// // P is now unitialized
+ /// P <- V
/// }
/// BB2 {
- /// // LV is now unitialized -- its dtor panicked
- /// LV <- RV
+ /// // P is now unitialized -- its dtor panicked
+ /// P <- V
/// }
/// ```
DropAndReplace {
match *elem {
ProjectionElem::Deref => {
let ty = self.to_ty(tcx)
- .builtin_deref(true, ty::LvaluePreference::NoPreference)
+ .builtin_deref(true)
.unwrap_or_else(|| {
bug!("deref projection of non-dereferencable ty {:?}", self)
})
dep_info_omit_d_target: bool = (false, parse_bool, [TRACKED],
"in dep-info output, omit targets for tracking dependencies of the dep-info files \
themselves"),
+ approximate_suggestions: bool = (false, parse_bool, [UNTRACKED],
+ "include machine-applicability of suggestions in JSON output"),
unpretty: Option<String> = (None, parse_unpretty, [UNTRACKED],
"Present the input source, unstable (and less-pretty) variants;
valid types are any of the types for `--pretty`, as well as:
let emitter: Box<Emitter> = match (sopts.error_format, emitter_dest) {
(config::ErrorOutputType::HumanReadable(color_config), None) => {
- Box::new(EmitterWriter::stderr(color_config, Some(codemap.clone()), false))
+ Box::new(EmitterWriter::stderr(color_config,
+ Some(codemap.clone()),
+ false,
+ sopts.debugging_opts.teach))
}
(config::ErrorOutputType::HumanReadable(_), Some(dst)) => {
- Box::new(EmitterWriter::new(dst, Some(codemap.clone()), false))
+ Box::new(EmitterWriter::new(dst, Some(codemap.clone()), false, false))
}
(config::ErrorOutputType::Json(pretty), None) => {
- Box::new(JsonEmitter::stderr(Some(registry), codemap.clone(), pretty))
+ Box::new(JsonEmitter::stderr(Some(registry), codemap.clone(),
+ pretty, sopts.debugging_opts.approximate_suggestions))
}
(config::ErrorOutputType::Json(pretty), Some(dst)) => {
- Box::new(JsonEmitter::new(dst, Some(registry), codemap.clone(), pretty))
+ Box::new(JsonEmitter::new(dst, Some(registry), codemap.clone(),
+ pretty, sopts.debugging_opts.approximate_suggestions))
}
(config::ErrorOutputType::Short(color_config), None) => {
- Box::new(EmitterWriter::stderr(color_config, Some(codemap.clone()), true))
+ Box::new(EmitterWriter::stderr(color_config, Some(codemap.clone()), true, false))
}
(config::ErrorOutputType::Short(_), Some(dst)) => {
- Box::new(EmitterWriter::new(dst, Some(codemap.clone()), true))
+ Box::new(EmitterWriter::new(dst, Some(codemap.clone()), true, false))
}
};
pub fn early_error(output: config::ErrorOutputType, msg: &str) -> ! {
let emitter: Box<Emitter> = match output {
config::ErrorOutputType::HumanReadable(color_config) => {
- Box::new(EmitterWriter::stderr(color_config, None, false))
+ Box::new(EmitterWriter::stderr(color_config, None, false, false))
}
config::ErrorOutputType::Json(pretty) => Box::new(JsonEmitter::basic(pretty)),
config::ErrorOutputType::Short(color_config) => {
- Box::new(EmitterWriter::stderr(color_config, None, true))
+ Box::new(EmitterWriter::stderr(color_config, None, true, false))
}
};
let handler = errors::Handler::with_emitter(true, false, emitter);
pub fn early_warn(output: config::ErrorOutputType, msg: &str) {
let emitter: Box<Emitter> = match output {
config::ErrorOutputType::HumanReadable(color_config) => {
- Box::new(EmitterWriter::stderr(color_config, None, false))
+ Box::new(EmitterWriter::stderr(color_config, None, false, false))
}
config::ErrorOutputType::Json(pretty) => Box::new(JsonEmitter::basic(pretty)),
config::ErrorOutputType::Short(color_config) => {
- Box::new(EmitterWriter::stderr(color_config, None, true))
+ Box::new(EmitterWriter::stderr(color_config, None, true, false))
}
};
let handler = errors::Handler::with_emitter(true, false, emitter);
use ty::fold::TypeFoldable;
use ty::subst::Subst;
-use infer::{InferCtxt, InferOk};
+use infer::{InferOk};
/// Whether we do the orphan check relative to this crate or
/// to some remote crate.
pub intercrate_ambiguity_causes: Vec<IntercrateAmbiguityCause>,
}
-/// If there are types that satisfy both impls, returns a suitably-freshened
-/// `ImplHeader` with those types substituted
-pub fn overlapping_impls<'cx, 'gcx, 'tcx>(infcx: &InferCtxt<'cx, 'gcx, 'tcx>,
- impl1_def_id: DefId,
- impl2_def_id: DefId,
- intercrate_mode: IntercrateMode)
- -> Option<OverlapResult<'tcx>>
+/// If there are types that satisfy both impls, invokes `on_overlap`
+/// with a suitably-freshened `ImplHeader` with those types
+/// substituted. Otherwise, invokes `no_overlap`.
+pub fn overlapping_impls<'gcx, F1, F2, R>(
+ tcx: TyCtxt<'_, 'gcx, 'gcx>,
+ impl1_def_id: DefId,
+ impl2_def_id: DefId,
+ intercrate_mode: IntercrateMode,
+ on_overlap: F1,
+ no_overlap: F2,
+) -> R
+where
+ F1: FnOnce(OverlapResult<'_>) -> R,
+ F2: FnOnce() -> R,
{
debug!("impl_can_satisfy(\
impl1_def_id={:?}, \
impl2_def_id,
intercrate_mode);
- let selcx = &mut SelectionContext::intercrate(infcx, intercrate_mode);
- overlap(selcx, impl1_def_id, impl2_def_id)
+ let overlaps = tcx.infer_ctxt().enter(|infcx| {
+ let selcx = &mut SelectionContext::intercrate(&infcx, intercrate_mode);
+ overlap(selcx, impl1_def_id, impl2_def_id).is_some()
+ });
+
+ if !overlaps {
+ return no_overlap();
+ }
+
+ // In the case where we detect an error, run the check again, but
+ // this time tracking intercrate ambuiguity causes for better
+ // diagnostics. (These take time and can lead to false errors.)
+ tcx.infer_ctxt().enter(|infcx| {
+ let selcx = &mut SelectionContext::intercrate(&infcx, intercrate_mode);
+ selcx.enable_tracking_intercrate_ambiguity_causes();
+ on_overlap(overlap(selcx, impl1_def_id, impl2_def_id).unwrap())
+ })
}
fn with_fresh_ty_vars<'cx, 'gcx, 'tcx>(selcx: &mut SelectionContext<'cx, 'gcx, 'tcx>,
return None
}
- Some(OverlapResult {
- impl_header: selcx.infcx().resolve_type_vars_if_possible(&a_impl_header),
- intercrate_ambiguity_causes: selcx.intercrate_ambiguity_causes().to_vec(),
- })
+ let impl_header = selcx.infcx().resolve_type_vars_if_possible(&a_impl_header);
+ let intercrate_ambiguity_causes = selcx.take_intercrate_ambiguity_causes();
+ debug!("overlap: intercrate_ambiguity_causes={:#?}", intercrate_ambiguity_causes);
+ Some(OverlapResult { impl_header, intercrate_ambiguity_causes })
}
pub fn trait_ref_is_knowable<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
span,
node: hir::ImplItemKind::Method(hir::MethodSig { ref decl, .. }, _),
..
+ }) |
+ hir::map::NodeTraitItem(&hir::TraitItem {
+ span,
+ node: hir::TraitItemKind::Method(hir::MethodSig { ref decl, .. }, _),
+ ..
}) => {
(self.tcx.sess.codemap().def_span(span), decl.inputs.iter()
.map(|arg| match arg.clone().into_inner().node {
inferred_obligations: SnapshotVec<InferredObligationsSnapshotVecDelegate<'tcx>>,
- intercrate_ambiguity_causes: Vec<IntercrateAmbiguityCause>,
+ intercrate_ambiguity_causes: Option<Vec<IntercrateAmbiguityCause>>,
}
-#[derive(Clone)]
+#[derive(Clone, Debug)]
pub enum IntercrateAmbiguityCause {
DownstreamCrate {
trait_desc: String,
freshener: infcx.freshener(),
intercrate: None,
inferred_obligations: SnapshotVec::new(),
- intercrate_ambiguity_causes: Vec::new(),
+ intercrate_ambiguity_causes: None,
}
}
freshener: infcx.freshener(),
intercrate: Some(mode),
inferred_obligations: SnapshotVec::new(),
- intercrate_ambiguity_causes: Vec::new(),
+ intercrate_ambiguity_causes: None,
}
}
+ /// Enables tracking of intercrate ambiguity causes. These are
+ /// used in coherence to give improved diagnostics. We don't do
+ /// this until we detect a coherence error because it can lead to
+ /// false overflow results (#47139) and because it costs
+ /// computation time.
+ pub fn enable_tracking_intercrate_ambiguity_causes(&mut self) {
+ assert!(self.intercrate.is_some());
+ assert!(self.intercrate_ambiguity_causes.is_none());
+ self.intercrate_ambiguity_causes = Some(vec![]);
+ debug!("selcx: enable_tracking_intercrate_ambiguity_causes");
+ }
+
+ /// Gets the intercrate ambiguity causes collected since tracking
+ /// was enabled and disables tracking at the same time. If
+ /// tracking is not enabled, just returns an empty vector.
+ pub fn take_intercrate_ambiguity_causes(&mut self) -> Vec<IntercrateAmbiguityCause> {
+ assert!(self.intercrate.is_some());
+ self.intercrate_ambiguity_causes.take().unwrap_or(vec![])
+ }
+
pub fn infcx(&self) -> &'cx InferCtxt<'cx, 'gcx, 'tcx> {
self.infcx
}
self.infcx
}
- pub fn intercrate_ambiguity_causes(&self) -> &[IntercrateAmbiguityCause] {
- &self.intercrate_ambiguity_causes
- }
-
/// Wraps the inference context's in_snapshot s.t. snapshot handling is only from the selection
/// context's self.
fn in_snapshot<R, F>(&mut self, f: F) -> R
debug!("evaluate_stack({:?}) --> unbound argument, intercrate --> ambiguous",
stack.fresh_trait_ref);
// Heuristics: show the diagnostics when there are no candidates in crate.
- if let Ok(candidate_set) = self.assemble_candidates(stack) {
- if !candidate_set.ambiguous && candidate_set.vec.is_empty() {
- let trait_ref = stack.obligation.predicate.skip_binder().trait_ref;
- let self_ty = trait_ref.self_ty();
- let cause = IntercrateAmbiguityCause::DownstreamCrate {
- trait_desc: trait_ref.to_string(),
- self_desc: if self_ty.has_concrete_skeleton() {
- Some(self_ty.to_string())
- } else {
- None
- },
- };
- self.intercrate_ambiguity_causes.push(cause);
+ if self.intercrate_ambiguity_causes.is_some() {
+ debug!("evaluate_stack: intercrate_ambiguity_causes is some");
+ if let Ok(candidate_set) = self.assemble_candidates(stack) {
+ if !candidate_set.ambiguous && candidate_set.vec.is_empty() {
+ let trait_ref = stack.obligation.predicate.skip_binder().trait_ref;
+ let self_ty = trait_ref.self_ty();
+ let cause = IntercrateAmbiguityCause::DownstreamCrate {
+ trait_desc: trait_ref.to_string(),
+ self_desc: if self_ty.has_concrete_skeleton() {
+ Some(self_ty.to_string())
+ } else {
+ None
+ },
+ };
+ debug!("evaluate_stack: pushing cause = {:?}", cause);
+ self.intercrate_ambiguity_causes.as_mut().unwrap().push(cause);
+ }
}
}
return EvaluatedToAmbig;
None => {}
Some(conflict) => {
debug!("coherence stage: not knowable");
- // Heuristics: show the diagnostics when there are no candidates in crate.
- let candidate_set = self.assemble_candidates(stack)?;
- if !candidate_set.ambiguous && candidate_set.vec.iter().all(|c| {
- !self.evaluate_candidate(stack, &c).may_apply()
- }) {
- let trait_ref = stack.obligation.predicate.skip_binder().trait_ref;
- let self_ty = trait_ref.self_ty();
- let trait_desc = trait_ref.to_string();
- let self_desc = if self_ty.has_concrete_skeleton() {
- Some(self_ty.to_string())
- } else {
- None
- };
- let cause = if let Conflict::Upstream = conflict {
- IntercrateAmbiguityCause::UpstreamCrateUpdate { trait_desc, self_desc }
- } else {
- IntercrateAmbiguityCause::DownstreamCrate { trait_desc, self_desc }
- };
- self.intercrate_ambiguity_causes.push(cause);
+ if self.intercrate_ambiguity_causes.is_some() {
+ debug!("evaluate_stack: intercrate_ambiguity_causes is some");
+ // Heuristics: show the diagnostics when there are no candidates in crate.
+ let candidate_set = self.assemble_candidates(stack)?;
+ if !candidate_set.ambiguous && candidate_set.vec.iter().all(|c| {
+ !self.evaluate_candidate(stack, &c).may_apply()
+ }) {
+ let trait_ref = stack.obligation.predicate.skip_binder().trait_ref;
+ let self_ty = trait_ref.self_ty();
+ let trait_desc = trait_ref.to_string();
+ let self_desc = if self_ty.has_concrete_skeleton() {
+ Some(self_ty.to_string())
+ } else {
+ None
+ };
+ let cause = if let Conflict::Upstream = conflict {
+ IntercrateAmbiguityCause::UpstreamCrateUpdate { trait_desc, self_desc }
+ } else {
+ IntercrateAmbiguityCause::DownstreamCrate { trait_desc, self_desc }
+ };
+ debug!("evaluate_stack: pushing cause = {:?}", cause);
+ self.intercrate_ambiguity_causes.as_mut().unwrap().push(cause);
+ }
}
return Ok(None);
}
};
let tcx = tcx.global_tcx();
- let (le, ge) = tcx.infer_ctxt().enter(|infcx| {
- let overlap = traits::overlapping_impls(&infcx,
- possible_sibling,
- impl_def_id,
- traits::IntercrateMode::Issue43355);
- if let Some(overlap) = overlap {
+ let (le, ge) = traits::overlapping_impls(
+ tcx,
+ possible_sibling,
+ impl_def_id,
+ traits::IntercrateMode::Issue43355,
+ |overlap| {
if tcx.impls_are_allowed_to_overlap(impl_def_id, possible_sibling) {
return Ok((false, false));
}
} else {
Ok((le, ge))
}
- } else {
- Ok((false, false))
- }
- })?;
+ },
+ || Ok((false, false)),
+ )?;
if le && !ge {
debug!("descending as child of TraitRef {:?}",
return Ok(Inserted::Replaced(possible_sibling));
} else {
if !tcx.impls_are_allowed_to_overlap(impl_def_id, possible_sibling) {
- tcx.infer_ctxt().enter(|infcx| {
- if let Some(overlap) = traits::overlapping_impls(
- &infcx,
- possible_sibling,
- impl_def_id,
- traits::IntercrateMode::Fixed)
- {
- last_lint = Some(overlap_error(overlap));
- }
- });
+ traits::overlapping_impls(
+ tcx,
+ possible_sibling,
+ impl_def_id,
+ traits::IntercrateMode::Fixed,
+ |overlap| last_lint = Some(overlap_error(overlap)),
+ || (),
+ );
}
// no overlap (error bailed already via ?)
/// Go from a mut raw pointer to a const raw pointer.
MutToConstPointer,
- /// Dereference once, producing an lvalue.
+ /// Dereference once, producing a place.
Deref(Option<OverloadedDeref<'tcx>>),
/// Take the address and produce either a `&` or `*` pointer.
-> (Arc<DefIdSet>, Arc<Vec<Arc<CodegenUnit<'tcx>>>>),
[] fn export_name: ExportName(DefId) -> Option<Symbol>,
[] fn contains_extern_indicator: ContainsExternIndicator(DefId) -> bool,
+ [] fn symbol_export_level: GetSymbolExportLevel(DefId) -> SymbolExportLevel,
[] fn is_translated_function: IsTranslatedFunction(DefId) -> bool,
[] fn codegen_unit: CodegenUnit(InternedString) -> Arc<CodegenUnit<'tcx>>,
[] fn compile_codegen_unit: CompileCodegenUnit(InternedString) -> Stats,
DepKind::TargetFeaturesWhitelist => { force!(target_features_whitelist, LOCAL_CRATE); }
DepKind::TargetFeaturesEnabled => { force!(target_features_enabled, def_id!()); }
+
+ DepKind::GetSymbolExportLevel => { force!(symbol_export_level, def_id!()); }
}
true
pub use self::AssociatedItemContainer::*;
pub use self::BorrowKind::*;
pub use self::IntVarValue::*;
-pub use self::LvaluePreference::*;
pub use self::fold::TypeFoldable;
use hir::{map as hir_map, FreevarMap, TraitMap};
}
}
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum LvaluePreference {
- PreferMutLvalue,
- NoPreference
-}
-
-impl LvaluePreference {
- pub fn from_mutbl(m: hir::Mutability) -> Self {
- match m {
- hir::MutMutable => PreferMutLvalue,
- hir::MutImmutable => NoPreference,
- }
- }
-}
-
impl BorrowKind {
pub fn from_mutbl(m: hir::Mutability) -> BorrowKind {
match m {
}
}
- pub fn expr_is_lval(self, expr: &hir::Expr) -> bool {
- match expr.node {
- hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
- match path.def {
- Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
- _ => false,
- }
- }
-
- hir::ExprType(ref e, _) => {
- self.expr_is_lval(e)
- }
-
- hir::ExprUnary(hir::UnDeref, _) |
- hir::ExprField(..) |
- hir::ExprTupField(..) |
- hir::ExprIndex(..) => {
- true
- }
-
- // Partially qualified paths in expressions can only legally
- // refer to associated items which are always rvalues.
- hir::ExprPath(hir::QPath::TypeRelative(..)) |
-
- hir::ExprCall(..) |
- hir::ExprMethodCall(..) |
- hir::ExprStruct(..) |
- hir::ExprTup(..) |
- hir::ExprIf(..) |
- hir::ExprMatch(..) |
- hir::ExprClosure(..) |
- hir::ExprBlock(..) |
- hir::ExprRepeat(..) |
- hir::ExprArray(..) |
- hir::ExprBreak(..) |
- hir::ExprAgain(..) |
- hir::ExprRet(..) |
- hir::ExprWhile(..) |
- hir::ExprLoop(..) |
- hir::ExprAssign(..) |
- hir::ExprInlineAsm(..) |
- hir::ExprAssignOp(..) |
- hir::ExprLit(_) |
- hir::ExprUnary(..) |
- hir::ExprBox(..) |
- hir::ExprAddrOf(..) |
- hir::ExprBinary(..) |
- hir::ExprYield(..) |
- hir::ExprCast(..) => {
- false
- }
- }
- }
-
pub fn provided_trait_methods(self, id: DefId) -> Vec<AssociatedItem> {
self.associated_items(id)
.filter(|item| item.kind == AssociatedKind::Method && item.defaultness.has_value())
///
/// The parameter `explicit` indicates if this is an *explicit* dereference.
/// Some types---notably unsafe ptrs---can only be dereferenced explicitly.
- pub fn builtin_deref(&self, explicit: bool, pref: ty::LvaluePreference)
- -> Option<TypeAndMut<'tcx>>
- {
+ pub fn builtin_deref(&self, explicit: bool) -> Option<TypeAndMut<'tcx>> {
match self.sty {
TyAdt(def, _) if def.is_box() => {
Some(TypeAndMut {
ty: self.boxed_ty(),
- mutbl: if pref == ty::PreferMutLvalue {
- hir::MutMutable
- } else {
- hir::MutImmutable
- },
+ mutbl: hir::MutImmutable,
})
},
TyRef(_, mt) => Some(mt),
max_atomic_width: Some(32),
post_link_args: args,
target_family: Some("unix".to_string()),
+ codegen_backend: "emscripten".to_string(),
.. Default::default()
};
Ok(Target {
// except according to those terms.
use LinkerFlavor;
-use target::{Target, TargetOptions, TargetResult};
+use target::{Target, TargetResult};
pub fn target() -> TargetResult {
+ let mut base = super::linux_musl_base::opts();
+ base.cpu = "mips32r2".to_string();
+ base.features = "+mips32r2,+soft-float".to_string();
+ base.max_atomic_width = Some(32);
+ // see #36994
+ base.exe_allocation_crate = None;
+ base.crt_static_default = false;
Ok(Target {
llvm_target: "mips-unknown-linux-musl".to_string(),
target_endian: "big".to_string(),
target_env: "musl".to_string(),
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
- options: TargetOptions {
- cpu: "mips32r2".to_string(),
- features: "+mips32r2,+soft-float".to_string(),
- max_atomic_width: Some(32),
-
- // see #36994
- exe_allocation_crate: None,
-
- ..super::linux_base::opts()
- }
+ options: base,
})
}
// except according to those terms.
use LinkerFlavor;
-use target::{Target, TargetOptions, TargetResult};
+use target::{Target, TargetResult};
pub fn target() -> TargetResult {
+ let mut base = super::linux_musl_base::opts();
+ base.cpu = "mips32".to_string();
+ base.features = "+mips32,+soft-float".to_string();
+ base.max_atomic_width = Some(32);
+ // see #36994
+ base.exe_allocation_crate = None;
+ base.crt_static_default = false;
Ok(Target {
llvm_target: "mipsel-unknown-linux-musl".to_string(),
target_endian: "little".to_string(),
target_env: "musl".to_string(),
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
- options: TargetOptions {
- cpu: "mips32".to_string(),
- features: "+mips32,+soft-float".to_string(),
- max_atomic_width: Some(32),
-
- // see #36994
- exe_allocation_crate: None,
-
- ..super::linux_base::opts()
- }
+ options: base,
})
}
/// 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,
+
+ /// The codegen backend to use for this target, typically "llvm"
+ pub codegen_backend: String,
+
+ /// The default visibility for symbols in this target should be "hidden"
+ /// rather than "default"
+ pub default_hidden_visibility: bool,
}
impl Default for TargetOptions {
singlethread: false,
no_builtins: false,
i128_lowering: false,
+ codegen_backend: "llvm".to_string(),
+ default_hidden_visibility: false,
}
}
}
key!(requires_lto, bool);
key!(singlethread, bool);
key!(no_builtins, bool);
+ key!(codegen_backend);
+ key!(default_hidden_visibility, bool);
if let Some(array) = obj.find("abi-blacklist").and_then(Json::as_array) {
for name in array.iter().filter_map(|abi| abi.as_string()) {
target_option_val!(requires_lto);
target_option_val!(singlethread);
target_option_val!(no_builtins);
+ target_option_val!(codegen_backend);
+ target_option_val!(default_hidden_visibility);
if default.abi_blacklist != self.options.abi_blacklist {
d.insert("abi-blacklist".to_string(), self.options.abi_blacklist.iter()
// don't want to invoke that many gcc instances.
default_codegen_units: Some(1),
+ // Since MSP430 doesn't meaningfully support faulting on illegal
+ // instructions, LLVM generates a call to abort() function instead
+ // of a trap instruction. Such calls are 4 bytes long, and that is
+ // too much overhead for such small target.
+ trap_unreachable: false,
+
.. Default::default( )
}
})
max_atomic_width: Some(32),
post_link_args,
target_family: Some("unix".to_string()),
+ codegen_backend: "emscripten".to_string(),
.. Default::default()
};
Ok(Target {
// performing LTO with compiler-builtins.
no_builtins: true,
+ // no dynamic linking, no need for default visibility!
+ default_hidden_visibility: true,
+
.. Default::default()
};
Ok(Target {
# Formal model
Throughout the docs we'll consider a simple subset of Rust in which
-you can only borrow from lvalues, defined like so:
+you can only borrow from places, defined like so:
```text
-LV = x | LV.f | *LV
+P = x | P.f | *P
```
-Here `x` represents some variable, `LV.f` is a field reference,
-and `*LV` is a pointer dereference. There is no auto-deref or other
+Here `x` represents some variable, `P.f` is a field reference,
+and `*P` is a pointer dereference. There is no auto-deref or other
niceties. This means that if you have a type like:
```rust
```
and a variable `a: Box<S>`, then the rust expression `a.f` would correspond
-to an `LV` of `(*a).f`.
+to an `P` of `(*a).f`.
Here is the formal grammar for the types we'll consider:
#### Loans and restrictions
The way the borrow checker works is that it analyzes each borrow
-expression (in our simple model, that's stuff like `&LV`, though in
+expression (in our simple model, that's stuff like `&P`, though in
real life there are a few other cases to consider). For each borrow
expression, it computes a `Loan`, which is a data structure that
records (1) the value being borrowed, (2) the mutability and scope of
follows:
```text
-LOAN = (LV, LT, MQ, RESTRICTION*)
-RESTRICTION = (LV, ACTION*)
+LOAN = (P, LT, MQ, RESTRICTION*)
+RESTRICTION = (P, ACTION*)
ACTION = MUTATE | CLAIM | FREEZE
```
-Here the `LOAN` tuple defines the lvalue `LV` being borrowed; the
+Here the `LOAN` tuple defines the place `P` being borrowed; the
lifetime `LT` of that borrow; the mutability `MQ` of the borrow; and a
list of restrictions. The restrictions indicate actions which, if
taken, could invalidate the loan and lead to type safety violations.
-Each `RESTRICTION` is a pair of a restrictive lvalue `LV` (which will
+Each `RESTRICTION` is a pair of a restrictive place `P` (which will
either be the path that was borrowed or some prefix of the path that
was borrowed) and a set of restricted actions. There are three kinds
-of actions that may be restricted for the path `LV`:
+of actions that may be restricted for the path `P`:
-- `MUTATE` means that `LV` cannot be assigned to;
-- `CLAIM` means that the `LV` cannot be borrowed mutably;
-- `FREEZE` means that the `LV` cannot be borrowed immutably;
+- `MUTATE` means that `P` cannot be assigned to;
+- `CLAIM` means that the `P` cannot be borrowed mutably;
+- `FREEZE` means that the `P` cannot be borrowed immutably;
-Finally, it is never possible to move from an lvalue that appears in a
-restriction. This implies that the "empty restriction" `(LV, [])`,
+Finally, it is never possible to move from a place that appears in a
+restriction. This implies that the "empty restriction" `(P, [])`,
which contains an empty set of actions, still has a purpose---it
-prevents moves from `LV`. I chose not to make `MOVE` a fourth kind of
+prevents moves from `P`. I chose not to make `MOVE` a fourth kind of
action because that would imply that sometimes moves are permitted
from restricted values, which is not the case.
We start with the `gather_loans` pass, which walks the AST looking for
borrows. For each borrow, there are three bits of information: the
-lvalue `LV` being borrowed and the mutability `MQ` and lifetime `LT`
+place `P` being borrowed and the mutability `MQ` and lifetime `LT`
of the resulting pointer. Given those, `gather_loans` applies four
validity tests:
-1. `MUTABILITY(LV, MQ)`: The mutability of the reference is
-compatible with the mutability of `LV` (i.e., not borrowing immutable
+1. `MUTABILITY(P, MQ)`: The mutability of the reference is
+compatible with the mutability of `P` (i.e., not borrowing immutable
data as mutable).
-2. `ALIASABLE(LV, MQ)`: The aliasability of the reference is
-compatible with the aliasability of `LV`. The goal is to prevent
+2. `ALIASABLE(P, MQ)`: The aliasability of the reference is
+compatible with the aliasability of `P`. The goal is to prevent
`&mut` borrows of aliasability data.
-3. `LIFETIME(LV, LT, MQ)`: The lifetime of the borrow does not exceed
+3. `LIFETIME(P, LT, MQ)`: The lifetime of the borrow does not exceed
the lifetime of the value being borrowed.
-4. `RESTRICTIONS(LV, LT, ACTIONS) = RS`: This pass checks and computes the
+4. `RESTRICTIONS(P, LT, ACTIONS) = RS`: This pass checks and computes the
restrictions to maintain memory safety. These are the restrictions
that will go into the final loan. We'll discuss in more detail below.
Checking mutability is fairly straightforward. We just want to prevent
immutable data from being borrowed as mutable. Note that it is ok to borrow
mutable data as immutable, since that is simply a freeze. The judgement
-`MUTABILITY(LV, MQ)` means the mutability of `LV` is compatible with a borrow
+`MUTABILITY(P, MQ)` means the mutability of `P` is compatible with a borrow
of mutability `MQ`. The Rust code corresponding to this predicate is the
function `check_mutability` in `middle::borrowck::gather_loans`.
Fields and boxes inherit their mutability from
their base expressions, so both of their rules basically
-delegate the check to the base expression `LV`:
+delegate the check to the base expression `P`:
```text
-MUTABILITY(LV.f, MQ) // M-Field
- MUTABILITY(LV, MQ)
+MUTABILITY(P.f, MQ) // M-Field
+ MUTABILITY(P, MQ)
-MUTABILITY(*LV, MQ) // M-Deref-Unique
- TYPE(LV) = Box<Ty>
- MUTABILITY(LV, MQ)
+MUTABILITY(*P, MQ) // M-Deref-Unique
+ TYPE(P) = Box<Ty>
+ MUTABILITY(P, MQ)
```
### Checking mutability of immutable pointer types
be borrowed if MQ is immutable:
```text
-MUTABILITY(*LV, imm) // M-Deref-Borrowed-Imm
- TYPE(LV) = &Ty
+MUTABILITY(*P, imm) // M-Deref-Borrowed-Imm
+ TYPE(P) = &Ty
```
### Checking mutability of mutable pointer types
`&mut T` can be frozen, so it is acceptable to borrow it as either imm or mut:
```text
-MUTABILITY(*LV, MQ) // M-Deref-Borrowed-Mut
- TYPE(LV) = &mut Ty
+MUTABILITY(*P, MQ) // M-Deref-Borrowed-Mut
+ TYPE(P) = &mut Ty
```
## Checking aliasability
The goal of the aliasability check is to ensure that we never permit `&mut`
-borrows of aliasable data. The judgement `ALIASABLE(LV, MQ)` means the
-aliasability of `LV` is compatible with a borrow of mutability `MQ`. The Rust
+borrows of aliasable data. The judgement `ALIASABLE(P, MQ)` means the
+aliasability of `P` is compatible with a borrow of mutability `MQ`. The Rust
code corresponding to this predicate is the function `check_aliasability()` in
`middle::borrowck::gather_loans`.
Owned content is aliasable if it is found in an aliasable location:
```text
-ALIASABLE(LV.f, MQ) // M-Field
- ALIASABLE(LV, MQ)
+ALIASABLE(P.f, MQ) // M-Field
+ ALIASABLE(P, MQ)
-ALIASABLE(*LV, MQ) // M-Deref-Unique
- ALIASABLE(LV, MQ)
+ALIASABLE(*P, MQ) // M-Deref-Unique
+ ALIASABLE(P, MQ)
```
### Checking aliasability of immutable pointer types
borrowed immutably:
```text
-ALIASABLE(*LV, imm) // M-Deref-Borrowed-Imm
- TYPE(LV) = &Ty
+ALIASABLE(*P, imm) // M-Deref-Borrowed-Imm
+ TYPE(P) = &Ty
```
### Checking aliasability of mutable pointer types
`&mut T` can be frozen, so it is acceptable to borrow it as either imm or mut:
```text
-ALIASABLE(*LV, MQ) // M-Deref-Borrowed-Mut
- TYPE(LV) = &mut Ty
+ALIASABLE(*P, MQ) // M-Deref-Borrowed-Mut
+ TYPE(P) = &mut Ty
```
## Checking lifetime
These rules aim to ensure that no data is borrowed for a scope that exceeds
its lifetime. These two computations wind up being intimately related.
-Formally, we define a predicate `LIFETIME(LV, LT, MQ)`, which states that
-"the lvalue `LV` can be safely borrowed for the lifetime `LT` with mutability
+Formally, we define a predicate `LIFETIME(P, LT, MQ)`, which states that
+"the place `P` can be safely borrowed for the lifetime `LT` with mutability
`MQ`". The Rust code corresponding to this predicate is the module
`middle::borrowck::gather_loans::lifetime`.
of its owner:
```text
-LIFETIME(LV.f, LT, MQ) // L-Field
- LIFETIME(LV, LT, MQ)
+LIFETIME(P.f, LT, MQ) // L-Field
+ LIFETIME(P, LT, MQ)
-LIFETIME(*LV, LT, MQ) // L-Deref-Send
- TYPE(LV) = Box<Ty>
- LIFETIME(LV, LT, MQ)
+LIFETIME(*P, LT, MQ) // L-Deref-Send
+ TYPE(P) = Box<Ty>
+ LIFETIME(P, LT, MQ)
```
### Checking lifetime for derefs of references
itself:
```text
-LIFETIME(*LV, LT, MQ) // L-Deref-Borrowed
- TYPE(LV) = <' Ty OR <' mut Ty
+LIFETIME(*P, LT, MQ) // L-Deref-Borrowed
+ TYPE(P) = <' Ty OR <' mut Ty
LT <= LT'
```
The final rules govern the computation of *restrictions*, meaning that
we compute the set of actions that will be illegal for the life of the
-loan. The predicate is written `RESTRICTIONS(LV, LT, ACTIONS) =
+loan. The predicate is written `RESTRICTIONS(P, LT, ACTIONS) =
RESTRICTION*`, which can be read "in order to prevent `ACTIONS` from
-occurring on `LV`, the restrictions `RESTRICTION*` must be respected
+occurring on `P`, the restrictions `RESTRICTION*` must be respected
for the lifetime of the loan".
Note that there is an initial set of restrictions: these restrictions
are computed based on the kind of borrow:
```text
-&mut LV => RESTRICTIONS(LV, LT, MUTATE|CLAIM|FREEZE)
-&LV => RESTRICTIONS(LV, LT, MUTATE|CLAIM)
+&mut P => RESTRICTIONS(P, LT, MUTATE|CLAIM|FREEZE)
+&P => RESTRICTIONS(P, LT, MUTATE|CLAIM)
```
The reasoning here is that a mutable borrow must be the only writer,
field:
```text
-RESTRICTIONS(LV.f, LT, ACTIONS) = RS, (LV.f, ACTIONS) // R-Field
- RESTRICTIONS(LV, LT, ACTIONS) = RS
+RESTRICTIONS(P.f, LT, ACTIONS) = RS, (P.f, ACTIONS) // R-Field
+ RESTRICTIONS(P, LT, ACTIONS) = RS
```
The reasoning here is as follows. If the field must not be mutated,
Because the mutability of owned referents is inherited, restricting an
owned referent is similar to restricting a field, in that it implies
restrictions on the pointer. However, boxes have an important
-twist: if the owner `LV` is mutated, that causes the owned referent
-`*LV` to be freed! So whenever an owned referent `*LV` is borrowed, we
-must prevent the box `LV` from being mutated, which means
+twist: if the owner `P` is mutated, that causes the owned referent
+`*P` to be freed! So whenever an owned referent `*P` is borrowed, we
+must prevent the box `P` from being mutated, which means
that we always add `MUTATE` and `CLAIM` to the restriction set imposed
-on `LV`:
+on `P`:
```text
-RESTRICTIONS(*LV, LT, ACTIONS) = RS, (*LV, ACTIONS) // R-Deref-Send-Pointer
- TYPE(LV) = Box<Ty>
- RESTRICTIONS(LV, LT, ACTIONS|MUTATE|CLAIM) = RS
+RESTRICTIONS(*P, LT, ACTIONS) = RS, (*P, ACTIONS) // R-Deref-Send-Pointer
+ TYPE(P) = Box<Ty>
+ RESTRICTIONS(P, LT, ACTIONS|MUTATE|CLAIM) = RS
```
### Restrictions for loans of immutable borrowed referents
Immutable borrowed referents are freely aliasable, meaning that
the compiler does not prevent you from copying the pointer. This
implies that issuing restrictions is useless. We might prevent the
-user from acting on `*LV` itself, but there could be another path
-`*LV1` that refers to the exact same memory, and we would not be
+user from acting on `*P` itself, but there could be another path
+`*P1` that refers to the exact same memory, and we would not be
restricting that path. Therefore, the rule for `&Ty` pointers
always returns an empty set of restrictions, and it only permits
restricting `MUTATE` and `CLAIM` actions:
```text
-RESTRICTIONS(*LV, LT, ACTIONS) = [] // R-Deref-Imm-Borrowed
- TYPE(LV) = <' Ty
+RESTRICTIONS(*P, LT, ACTIONS) = [] // R-Deref-Imm-Borrowed
+ TYPE(P) = <' Ty
LT <= LT' // (1)
ACTIONS subset of [MUTATE, CLAIM]
```
(`*point : &'b Point`) is enough to guarantee the memory is immutable
and valid for the lifetime `'b`. This is reflected in
`RESTRICTIONS()` by the fact that we do not recurse (i.e., we impose
-no restrictions on `LV`, which in this particular case is the pointer
+no restrictions on `P`, which in this particular case is the pointer
`point : &'a &'b Point`).
#### Why both `LIFETIME()` and `RESTRICTIONS()`?
The rule for mutable borrowed pointers is as follows:
```text
-RESTRICTIONS(*LV, LT, ACTIONS) = RS, (*LV, ACTIONS) // R-Deref-Mut-Borrowed
- TYPE(LV) = <' mut Ty
+RESTRICTIONS(*P, LT, ACTIONS) = RS, (*P, ACTIONS) // R-Deref-Mut-Borrowed
+ TYPE(P) = <' mut Ty
LT <= LT' // (1)
- RESTRICTIONS(LV, LT, ACTIONS) = RS // (2)
+ RESTRICTIONS(P, LT, ACTIONS) = RS // (2)
```
Let's examine the two numbered clauses:
Remember that `&mut` pointers are linear, and hence `let t1 = t0` is a
move of `t0` -- or would be, if it were legal. Instead, we get an
-error, because clause (2) imposes restrictions on `LV` (`t0`, here),
+error, because clause (2) imposes restrictions on `P` (`t0`, here),
and any restrictions on a path make it impossible to move from that
path.
The `MovePath` tree tracks every path that is moved or assigned to.
These paths have the same form as the `LoanPath` data structure, which
-in turn is the "real world version of the lvalues `LV` that we
+in turn is the "real world version of the places `P` that we
introduced earlier. The difference between a `MovePath` and a `LoanPath`
is that move paths are:
While writing up these docs, I encountered some rules I believe to be
stricter than necessary:
-- I think restricting the `&mut` LV against moves and `ALIAS` is sufficient,
+- I think restricting the `&mut` P against moves and `ALIAS` is sufficient,
`MUTATE` and `CLAIM` are overkill. `MUTATE` was necessary when swap was
a built-in operator, but as it is not, it is implied by `CLAIM`,
and `CLAIM` is implied by `ALIAS`. The only net effect of this is an
// 3. Where does old loan expire.
let previous_end_span =
- Some(old_loan.kill_scope.span(self.tcx(), &self.bccx.region_scope_tree)
- .end_point());
+ Some(self.tcx().sess.codemap().end_point(
+ old_loan.kill_scope.span(self.tcx(), &self.bccx.region_scope_tree)));
let mut err = match (new_loan.kind, old_loan.kind) {
(ty::MutBorrow, ty::MutBorrow) =>
fn scope(&self, cmt: &mc::cmt<'tcx>) -> ty::Region<'tcx> {
//! Returns the maximal region scope for the which the
- //! lvalue `cmt` is guaranteed to be valid without any
+ //! place `cmt` is guaranteed to be valid without any
//! rooting etc, and presuming `cmt` is not mutated.
match cmt.cat {
if !force_analysis && move_data.is_empty() && all_loans.is_empty() {
// large arrays of data inserted as constants can take a lot of
// time and memory to borrow-check - see issue #36799. However,
- // they don't have lvalues, so no borrow-check is actually needed.
+ // they don't have places, so no borrow-check is actually needed.
// Recognize that case and skip borrow-checking.
debug!("skipping loan propagation for {:?} because of no loans", body_id);
return None;
}
// This can be:
-// - a pointer dereference (`*LV` in README.md)
+// - a pointer dereference (`*P` in README.md)
// - a field reference, with an optional definition of the containing
-// enum variant (`LV.f` in README.md)
+// enum variant (`P.f` in README.md)
// `DefId` is present when the field is part of struct that is in
// a variant of an enum. For instance in:
// `enum E { X { foo: u32 }, Y { foo: u32 }}`
fn region_end_span(&self, region: ty::Region<'tcx>) -> Option<Span> {
match *region {
ty::ReScope(scope) => {
- Some(scope.span(self.tcx, &self.region_scope_tree).end_point())
+ Some(self.tcx.sess.codemap().end_point(
+ scope.span(self.tcx, &self.region_scope_tree)))
}
_ => None
}
/// span of node where assignment occurs
pub span: Span,
- /// id for l-value expression on lhs of assignment
+ /// id for place expression on lhs of assignment
pub assignee_id: hir::ItemLocalId,
}
continue
}
- let mut_span = tcx.sess.codemap().span_until_char(ids[0].2, ' ');
+ let mut_span = tcx.sess.codemap().span_until_non_whitespace(ids[0].2);
// Ok, every name wasn't used mutably, so issue a warning that this
// didn't need to be mutable.
}
}
+
impl<'a, 'tcx> PatternContext<'a, 'tcx> {
fn report_inlining_errors(&self, pat_span: Span) {
for error in &self.errors {
match *error {
PatternError::StaticInPattern(span) => {
- span_err!(self.tcx.sess, span, E0158,
- "statics cannot be referenced in patterns");
+ self.span_e0158(span, "statics cannot be referenced in patterns")
+ }
+ PatternError::AssociatedConstInPattern(span) => {
+ self.span_e0158(span, "associated consts cannot be referenced in patterns")
}
PatternError::ConstEval(ref err) => {
err.report(self.tcx, pat_span, "pattern");
}
}
}
+
+ fn span_e0158(&self, span: Span, text: &str) {
+ span_err!(self.tcx.sess, span, E0158, "{}", text)
+ }
}
impl<'a, 'tcx> MatchVisitor<'a, 'tcx> {
#[derive(Clone, Debug)]
pub enum PatternError<'tcx> {
+ AssociatedConstInPattern(Span),
StaticInPattern(Span),
ConstEval(ConstEvalErr<'tcx>),
}
-> Pattern<'tcx> {
let ty = self.tables.node_id_to_type(id);
let def = self.tables.qpath_def(qpath, id);
+ let is_associated_const = match def {
+ Def::AssociatedConst(_) => true,
+ _ => false,
+ };
let kind = match def {
Def::Const(def_id) | Def::AssociatedConst(def_id) => {
let substs = self.tables.node_substs(id);
return pat;
}
None => {
- self.errors.push(PatternError::StaticInPattern(span));
+ self.errors.push(if is_associated_const {
+ PatternError::AssociatedConstInPattern(span)
+ } else {
+ PatternError::StaticInPattern(span)
+ });
PatternKind::Wild
}
}
new_value != value
}
+ /// Returns true if the bit has changed.
+ #[inline]
+ pub fn remove(&mut self, bit: usize) -> bool {
+ let (word, mask) = word_mask(bit);
+ let data = &mut self.data[word];
+ let value = *data;
+ let new_value = value & !mask;
+ *data = new_value;
+ new_value != value
+ }
+
#[inline]
pub fn insert_all(&mut self, all: &BitVector) -> bool {
assert!(self.data.len() == all.data.len());
[dependencies]
arena = { path = "../libarena" }
graphviz = { path = "../libgraphviz" }
-log = { version = "0.4", features = ["release_max_level_info"] }
+log = "0.4"
env_logger = { version = "0.4", default-features = false }
rustc = { path = "../librustc" }
rustc_allocator = { path = "../librustc_allocator" }
rustc_privacy = { path = "../librustc_privacy" }
rustc_resolve = { path = "../librustc_resolve" }
rustc_save_analysis = { path = "../librustc_save_analysis" }
-rustc_trans = { path = "../librustc_trans", optional = true }
rustc_trans_utils = { path = "../librustc_trans_utils" }
rustc_typeck = { path = "../librustc_typeck" }
serialize = { path = "../libserialize" }
syntax_pos = { path = "../libsyntax_pos" }
ar = "0.3.0"
-
-[features]
-llvm = ["rustc_trans"]
extern crate rustc_mir;
extern crate rustc_resolve;
extern crate rustc_save_analysis;
-#[cfg(feature="llvm")]
-pub extern crate rustc_trans;
extern crate rustc_trans_utils;
extern crate rustc_typeck;
extern crate serialize;
use rustc::session::CompileIncomplete;
use rustc::session::config::{Input, PrintRequest, ErrorOutputType};
use rustc::session::config::nightly_options;
+use rustc::session::filesearch;
use rustc::session::{early_error, early_warn};
use rustc::lint::Lint;
use rustc::lint;
use rustc::middle::cstore::CrateStore;
use rustc_metadata::locator;
use rustc_metadata::cstore::CStore;
+use rustc_metadata::dynamic_lib::DynamicLibrary;
use rustc::util::common::{time, ErrorReported};
use rustc_trans_utils::trans_crate::TransCrate;
use serialize::json::ToJson;
use std::any::Any;
-use std::cmp::max;
use std::cmp::Ordering::Equal;
+use std::cmp::max;
use std::default::Default;
+use std::env::consts::{DLL_PREFIX, DLL_SUFFIX};
use std::env;
use std::ffi::OsString;
use std::io::{self, Read, Write};
use std::iter::repeat;
+use std::mem;
use std::panic;
-use std::path::PathBuf;
+use std::path::{PathBuf, Path};
use std::process::{self, Command, Stdio};
use std::rc::Rc;
use std::str;
+use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
+use std::sync::{Once, ONCE_INIT};
use std::thread;
use syntax::ast;
let emitter =
errors::emitter::EmitterWriter::stderr(errors::ColorConfig::Auto,
None,
- true);
+ true,
+ false);
let handler = errors::Handler::with_emitter(true, false, Box::new(emitter));
handler.emit(&MultiSpan::new(),
"aborting due to previous error(s)",
0
}
-#[cfg(not(feature="llvm"))]
-pub use rustc_trans_utils::trans_crate::MetadataOnlyTransCrate as DefaultTransCrate;
-#[cfg(feature="llvm")]
-pub use rustc_trans::LlvmTransCrate as DefaultTransCrate;
+fn load_backend_from_dylib(path: &Path) -> fn() -> Box<TransCrate> {
+ // Note that we're specifically using `open_global_now` here rather than
+ // `open`, namely we want the behavior on Unix of RTLD_GLOBAL and RTLD_NOW,
+ // where NOW means "bind everything right now" because we don't want
+ // surprises later on and RTLD_GLOBAL allows the symbols to be made
+ // available for future dynamic libraries opened. This is currently used by
+ // loading LLVM and then making its symbols available for other dynamic
+ // libraries.
+ let lib = match DynamicLibrary::open_global_now(path) {
+ Ok(lib) => lib,
+ Err(err) => {
+ let err = format!("couldn't load codegen backend {:?}: {:?}",
+ path,
+ err);
+ early_error(ErrorOutputType::default(), &err);
+ }
+ };
+ unsafe {
+ match lib.symbol("__rustc_codegen_backend") {
+ Ok(f) => {
+ mem::forget(lib);
+ mem::transmute::<*mut u8, _>(f)
+ }
+ Err(e) => {
+ let err = format!("couldn't load codegen backend as it \
+ doesn't export the `__rustc_codegen_backend` \
+ symbol: {:?}", e);
+ early_error(ErrorOutputType::default(), &err);
+ }
+ }
+ }
+}
-#[cfg(not(feature="llvm"))]
-pub mod rustc_trans {
- pub use rustc_trans_utils::trans_crate::MetadataOnlyTransCrate as LlvmTransCrate;
+pub fn get_trans(sess: &Session) -> Box<TransCrate> {
+ static INIT: Once = ONCE_INIT;
+ static mut LOAD: fn() -> Box<TransCrate> = || unreachable!();
+
+ INIT.call_once(|| {
+ let trans_name = sess.opts.debugging_opts.codegen_backend.as_ref()
+ .unwrap_or(&sess.target.target.options.codegen_backend);
+ let backend = match &trans_name[..] {
+ "metadata_only" => {
+ rustc_trans_utils::trans_crate::MetadataOnlyTransCrate::new
+ }
+ filename if filename.contains(".") => {
+ load_backend_from_dylib(filename.as_ref())
+ }
+ trans_name => get_trans_sysroot(trans_name),
+ };
- pub fn print_version() {}
- pub fn print_passes() {}
+ unsafe {
+ LOAD = backend;
+ }
+ });
+ let backend = unsafe { LOAD() };
+ backend.init(sess);
+ backend
}
-fn load_backend_from_dylib(sess: &Session, backend_name: &str) -> Box<TransCrate> {
- use std::path::Path;
- use rustc_metadata::dynamic_lib::DynamicLibrary;
-
- match DynamicLibrary::open(Some(Path::new(backend_name))) {
- Ok(lib) => {
- unsafe {
- let trans = {
- let __rustc_codegen_backend: unsafe fn(&Session) -> Box<TransCrate>;
- __rustc_codegen_backend = match lib.symbol("__rustc_codegen_backend") {
- Ok(f) => ::std::mem::transmute::<*mut u8, _>(f),
- Err(e) => sess.fatal(&format!("Couldnt load codegen backend as it\
- doesn't export the __rustc_backend_new symbol: {:?}", e)),
- };
- __rustc_codegen_backend(sess)
- };
- ::std::mem::forget(lib);
- trans
+fn get_trans_sysroot(backend_name: &str) -> fn() -> Box<TransCrate> {
+ // For now we only allow this function to be called once as it'll dlopen a
+ // few things, which seems to work best if we only do that once. In
+ // general this assertion never trips due to the once guard in `get_trans`,
+ // but there's a few manual calls to this function in this file we protect
+ // against.
+ static LOADED: AtomicBool = ATOMIC_BOOL_INIT;
+ assert!(!LOADED.fetch_or(true, Ordering::SeqCst),
+ "cannot load the default trans backend twice");
+
+ // When we're compiling this library with `--test` it'll run as a binary but
+ // not actually exercise much functionality. As a result most of the logic
+ // here is defunkt (it assumes we're a dynamic library in a sysroot) so
+ // let's just return a dummy creation function which won't be used in
+ // general anyway.
+ if cfg!(test) {
+ return rustc_trans_utils::trans_crate::MetadataOnlyTransCrate::new
+ }
+
+ let target = session::config::host_triple();
+ let mut sysroot_candidates = vec![filesearch::get_or_default_sysroot()];
+ let path = current_dll_path()
+ .and_then(|s| s.canonicalize().ok());
+ if let Some(dll) = path {
+ // use `parent` twice to chop off the file name and then also the
+ // directory containing the dll which should be either `lib` or `bin`.
+ if let Some(path) = dll.parent().and_then(|p| p.parent()) {
+ // The original `path` pointed at the `rustc_driver` crate's dll.
+ // Now that dll should only be in one of two locations. The first is
+ // in the compiler's libdir, for example `$sysroot/lib/*.dll`. The
+ // other is the target's libdir, for example
+ // `$sysroot/lib/rustlib/$target/lib/*.dll`.
+ //
+ // We don't know which, so let's assume that if our `path` above
+ // ends in `$target` we *could* be in the target libdir, and always
+ // assume that we may be in the main libdir.
+ sysroot_candidates.push(path.to_owned());
+
+ if path.ends_with(target) {
+ sysroot_candidates.extend(path.parent() // chop off `$target`
+ .and_then(|p| p.parent()) // chop off `rustlib`
+ .and_then(|p| p.parent()) // chop off `lib`
+ .map(|s| s.to_owned()));
}
}
- Err(err) => {
- sess.fatal(&format!("Couldnt load codegen backend {:?}: {:?}", backend_name, err));
+ }
+
+ let sysroot = sysroot_candidates.iter()
+ .map(|sysroot| {
+ let libdir = filesearch::relative_target_lib_path(&sysroot, &target);
+ sysroot.join(libdir).with_file_name("codegen-backends")
+ })
+ .filter(|f| {
+ info!("codegen backend candidate: {}", f.display());
+ f.exists()
+ })
+ .next();
+ let sysroot = match sysroot {
+ Some(path) => path,
+ None => {
+ let candidates = sysroot_candidates.iter()
+ .map(|p| p.display().to_string())
+ .collect::<Vec<_>>()
+ .join("\n* ");
+ let err = format!("failed to find a `codegen-backends` folder \
+ in the sysroot candidates:\n* {}", candidates);
+ early_error(ErrorOutputType::default(), &err);
+ }
+ };
+ info!("probing {} for a codegen backend", sysroot.display());
+
+ let d = match sysroot.read_dir() {
+ Ok(d) => d,
+ Err(e) => {
+ let err = format!("failed to load default codegen backend, couldn't \
+ read `{}`: {}", sysroot.display(), e);
+ early_error(ErrorOutputType::default(), &err);
+ }
+ };
+
+ let mut file: Option<PathBuf> = None;
+
+ let expected_name = format!("rustc_trans-{}", backend_name);
+ for entry in d.filter_map(|e| e.ok()) {
+ let path = entry.path();
+ let filename = match path.file_name().and_then(|s| s.to_str()) {
+ Some(s) => s,
+ None => continue,
+ };
+ if !(filename.starts_with(DLL_PREFIX) && filename.ends_with(DLL_SUFFIX)) {
+ continue
+ }
+ let name = &filename[DLL_PREFIX.len() .. filename.len() - DLL_SUFFIX.len()];
+ if name != expected_name {
+ continue
}
+ if let Some(ref prev) = file {
+ let err = format!("duplicate codegen backends found\n\
+ first: {}\n\
+ second: {}\n\
+ ", prev.display(), path.display());
+ early_error(ErrorOutputType::default(), &err);
+ }
+ file = Some(path.clone());
}
-}
-pub fn get_trans(sess: &Session) -> Box<TransCrate> {
- let trans_name = sess.opts.debugging_opts.codegen_backend.clone();
- match trans_name.as_ref().map(|s|&**s) {
- None => DefaultTransCrate::new(&sess),
- Some("llvm") => rustc_trans::LlvmTransCrate::new(&sess),
- Some("metadata_only") => {
- rustc_trans_utils::trans_crate::MetadataOnlyTransCrate::new(&sess)
+ match file {
+ Some(ref s) => return load_backend_from_dylib(s),
+ None => {
+ let err = format!("failed to load default codegen backend for `{}`, \
+ no appropriate codegen dylib found in `{}`",
+ backend_name, sysroot.display());
+ early_error(ErrorOutputType::default(), &err);
+ }
+ }
+
+ #[cfg(unix)]
+ fn current_dll_path() -> Option<PathBuf> {
+ use std::ffi::{OsStr, CStr};
+ use std::os::unix::prelude::*;
+
+ unsafe {
+ let addr = current_dll_path as usize as *mut _;
+ let mut info = mem::zeroed();
+ if libc::dladdr(addr, &mut info) == 0 {
+ info!("dladdr failed");
+ return None
+ }
+ if info.dli_fname.is_null() {
+ info!("dladdr returned null pointer");
+ return None
+ }
+ let bytes = CStr::from_ptr(info.dli_fname).to_bytes();
+ let os = OsStr::from_bytes(bytes);
+ Some(PathBuf::from(os))
}
- Some(filename) if filename.contains(".") => {
- load_backend_from_dylib(&sess, &filename)
+ }
+
+ #[cfg(windows)]
+ fn current_dll_path() -> Option<PathBuf> {
+ use std::ffi::OsString;
+ use std::os::windows::prelude::*;
+
+ extern "system" {
+ fn GetModuleHandleExW(dwFlags: u32,
+ lpModuleName: usize,
+ phModule: *mut usize) -> i32;
+ fn GetModuleFileNameW(hModule: usize,
+ lpFilename: *mut u16,
+ nSize: u32) -> u32;
+ }
+
+ const GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS: u32 = 0x00000004;
+
+ unsafe {
+ let mut module = 0;
+ let r = GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+ current_dll_path as usize,
+ &mut module);
+ if r == 0 {
+ info!("GetModuleHandleExW failed: {}", io::Error::last_os_error());
+ return None
+ }
+ let mut space = Vec::with_capacity(1024);
+ let r = GetModuleFileNameW(module,
+ space.as_mut_ptr(),
+ space.capacity() as u32);
+ if r == 0 {
+ info!("GetModuleFileNameW failed: {}", io::Error::last_os_error());
+ return None
+ }
+ let r = r as usize;
+ if r >= space.capacity() {
+ info!("our buffer was too small? {}",
+ io::Error::last_os_error());
+ return None
+ }
+ space.set_len(r);
+ let os = OsString::from_wide(&space);
+ Some(PathBuf::from(os))
}
- Some(trans_name) => sess.fatal(&format!("Unknown codegen backend {}", trans_name)),
}
}
None);
let (odir, ofile) = make_output(&matches);
- let (input, input_file_path) = match make_input(&matches.free) {
- Some((input, input_file_path)) => callbacks.some_input(input, input_file_path),
+ let (input, input_file_path, input_err) = match make_input(&matches.free) {
+ Some((input, input_file_path, input_err)) => {
+ let (input, input_file_path) = callbacks.some_input(input, input_file_path);
+ (input, input_file_path, input_err)
+ },
None => match callbacks.no_input(&matches, &sopts, &cfg, &odir, &ofile, &descriptions) {
- Some((input, input_file_path)) => (input, input_file_path),
+ Some((input, input_file_path)) => (input, input_file_path, None),
None => return (Ok(()), None),
},
};
sopts, input_file_path.clone(), descriptions, codemap, emitter_dest,
);
+ if let Some(err) = input_err {
+ // Immediately stop compilation if there was an issue reading
+ // the input (for example if the input stream is not UTF-8).
+ sess.err(&format!("{}", err));
+ return (Err(CompileIncomplete::Stopped), Some(sess));
+ }
+
let trans = get_trans(&sess);
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
}
// Extract input (string or file and optional path) from matches.
-fn make_input(free_matches: &[String]) -> Option<(Input, Option<PathBuf>)> {
+fn make_input(free_matches: &[String]) -> Option<(Input, Option<PathBuf>, Option<io::Error>)> {
if free_matches.len() == 1 {
let ifile = &free_matches[0];
if ifile == "-" {
let mut src = String::new();
- io::stdin().read_to_string(&mut src).unwrap();
+ let err = if io::stdin().read_to_string(&mut src).is_err() {
+ Some(io::Error::new(io::ErrorKind::InvalidData,
+ "couldn't read from stdin, as it did not contain valid UTF-8"))
+ } else {
+ None
+ };
Some((Input::Str { name: FileName::Anon, input: src },
- None))
+ None, err))
} else {
Some((Input::File(PathBuf::from(ifile)),
- Some(PathBuf::from(ifile))))
+ Some(PathBuf::from(ifile)), None))
}
} else {
None
println!("commit-date: {}", unw(commit_date_str()));
println!("host: {}", config::host_triple());
println!("release: {}", unw(release_str()));
- rustc_trans::print_version();
+ get_trans_sysroot("llvm")().print_version();
}
}
}
if cg_flags.contains(&"passes=list".to_string()) {
- rustc_trans::print_passes();
+ get_trans_sysroot("llvm")().print_passes();
return None;
}
let emitter =
Box::new(errors::emitter::EmitterWriter::stderr(errors::ColorConfig::Auto,
None,
+ false,
false));
let handler = errors::Handler::with_emitter(true, false, emitter);
all_errors.extend_from_slice(&rustc_typeck::DIAGNOSTICS);
all_errors.extend_from_slice(&rustc_resolve::DIAGNOSTICS);
all_errors.extend_from_slice(&rustc_privacy::DIAGNOSTICS);
- #[cfg(feature="llvm")]
- all_errors.extend_from_slice(&rustc_trans::DIAGNOSTICS);
+ // FIXME: need to figure out a way to get these back in here
+ // all_errors.extend_from_slice(get_trans(sess).diagnostics());
all_errors.extend_from_slice(&rustc_trans_utils::DIAGNOSTICS);
all_errors.extend_from_slice(&rustc_const_eval::DIAGNOSTICS);
all_errors.extend_from_slice(&rustc_metadata::DIAGNOSTICS);
}
PpmTyped => {
let control = &driver::CompileController::basic();
- abort_on_err(driver::phase_3_run_analysis_passes(&*::DefaultTransCrate::new(&sess),
+ let trans = ::get_trans(sess);
+ abort_on_err(driver::phase_3_run_analysis_passes(&*trans,
control,
sess,
cstore,
let mut out = Vec::new();
let control = &driver::CompileController::basic();
- abort_on_err(driver::phase_3_run_analysis_passes(&*::DefaultTransCrate::new(&sess),
+ let trans = ::get_trans(sess);
+ abort_on_err(driver::phase_3_run_analysis_passes(&*trans,
control,
sess,
cstore,
}],
msg: msg.to_owned(),
show_code_when_inline: false,
+ approximate: false,
});
self
}
}],
msg: msg.to_owned(),
show_code_when_inline: true,
+ approximate: false,
});
self
}
}).collect(),
msg: msg.to_owned(),
show_code_when_inline: true,
+ approximate: false,
+ });
+ self
+ }
+
+ /// This is a suggestion that may contain mistakes or fillers and should
+ /// be read and understood by a human.
+ pub fn span_approximate_suggestion(&mut self, sp: Span, msg: &str,
+ suggestion: String) -> &mut Self {
+ self.suggestions.push(CodeSuggestion {
+ substitutions: vec![Substitution {
+ parts: vec![SubstitutionPart {
+ snippet: suggestion,
+ span: sp,
+ }],
+ }],
+ msg: msg.to_owned(),
+ show_code_when_inline: true,
+ approximate: true,
+ });
+ self
+ }
+
+ pub fn span_approximate_suggestions(&mut self, sp: Span, msg: &str,
+ suggestions: Vec<String>) -> &mut Self {
+ self.suggestions.push(CodeSuggestion {
+ substitutions: suggestions.into_iter().map(|snippet| Substitution {
+ parts: vec![SubstitutionPart {
+ snippet,
+ span: sp,
+ }],
+ }).collect(),
+ msg: msg.to_owned(),
+ show_code_when_inline: true,
+ approximate: true,
});
self
}
msg: &str,
suggestions: Vec<String>)
-> &mut Self);
+ forward!(pub fn span_approximate_suggestion(&mut self,
+ sp: Span,
+ msg: &str,
+ suggestion: String)
+ -> &mut Self);
+ forward!(pub fn span_approximate_suggestions(&mut self,
+ sp: Span,
+ msg: &str,
+ suggestions: Vec<String>)
+ -> &mut 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);
dst: Destination,
cm: Option<Rc<CodeMapper>>,
short_message: bool,
+ teach: bool,
}
struct FileWithAnnotatedLines {
impl EmitterWriter {
pub fn stderr(color_config: ColorConfig,
code_map: Option<Rc<CodeMapper>>,
- short_message: bool)
+ short_message: bool,
+ teach: bool)
-> EmitterWriter {
if color_config.use_color() {
let dst = Destination::from_stderr();
EmitterWriter {
dst,
cm: code_map,
- short_message: short_message,
+ short_message,
+ teach,
}
} else {
EmitterWriter {
dst: Raw(Box::new(io::stderr())),
cm: code_map,
- short_message: short_message,
+ short_message,
+ teach,
}
}
}
pub fn new(dst: Box<Write + Send>,
code_map: Option<Rc<CodeMapper>>,
- short_message: bool)
+ short_message: bool,
+ teach: bool)
-> EmitterWriter {
EmitterWriter {
dst: Raw(dst),
cm: code_map,
- short_message: short_message,
+ short_message,
+ teach,
}
}
line: &Line,
width_offset: usize,
code_offset: usize) -> Vec<(usize, Style)> {
+ if line.line_index == 0 {
+ return Vec::new();
+ }
+
let source_string = match file.get_line(line.line_index - 1) {
Some(s) => s,
None => return Vec::new(),
code_offset + annotation.start_col,
style);
}
- _ => (),
+ _ if self.teach => {
+ buffer.set_style_range(line_offset,
+ code_offset + annotation.start_col,
+ code_offset + annotation.end_col,
+ style,
+ annotation.is_primary);
+ }
+ _ => {}
}
}
}
// Check to make sure we're not in any <*macros>
if !cm.span_to_filename(def_site).is_macros() &&
+ !trace.macro_decl_name.starts_with("desugaring of ") &&
!trace.macro_decl_name.starts_with("#[") ||
always_backtrace {
new_labels.push((trace.call_site,
// Then, the secondary file indicator
buffer.prepend(buffer_msg_line_offset + 1, "::: ", Style::LineNumber);
+ let loc = if let Some(first_line) = annotated_file.lines.first() {
+ let col = if let Some(first_annotation) = first_line.annotations.first() {
+ format!(":{}", first_annotation.start_col + 1)
+ } else {
+ "".to_string()
+ };
+ format!("{}:{}{}",
+ annotated_file.file.name,
+ cm.doctest_offset_line(first_line.line_index),
+ col)
+ } else {
+ annotated_file.file.name.to_string()
+ };
buffer.append(buffer_msg_line_offset + 1,
- &annotated_file.file.name.to_string(),
+ &loc,
Style::LineAndColumn);
for _ in 0..max_line_num_len {
buffer.prepend(buffer_msg_line_offset + 1, " ", Style::NoStyle);
pub substitutions: Vec<Substitution>,
pub msg: String,
pub show_code_when_inline: bool,
+ /// Whether or not the suggestion is approximate
+ ///
+ /// Sometimes we may show suggestions with placeholders,
+ /// which are useful for users but not useful for
+ /// tools like rustfix
+ pub approximate: bool,
}
#[derive(Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)]
cm: Option<Rc<CodeMapper>>,
flags: HandlerFlags)
-> Handler {
- let emitter = Box::new(EmitterWriter::stderr(color_config, cm, false));
+ let emitter = Box::new(EmitterWriter::stderr(color_config, cm, false, false));
Handler::with_emitter_and_flags(emitter, flags)
}
/// The "primary file", if any, gets a `-->` marker instead of
/// `>>>`, and has a line-number/column printed and not just a
- /// filename. It appears first in the listing. It is known to
+ /// filename (other files are not guaranteed to have line numbers
+ /// or columns). It appears first in the listing. It is known to
/// contain at least one primary span, though primary spans (which
/// are designated with `^^^`) may also occur in other files.
primary_span: Option<Span>,
pub fn num_lines(&self) -> usize {
self.text.len()
}
+
+ pub fn set_style_range(&mut self,
+ line: usize,
+ col_start: usize,
+ col_end: usize,
+ style: Style,
+ overwrite: bool) {
+ for col in col_start..col_end {
+ self.set_style(line, col, style, overwrite);
+ }
+ }
+
+ pub fn set_style(&mut self, line: usize, col: usize, style: Style, overwrite: bool) {
+ if let Some(ref mut line) = self.styles.get_mut(line) {
+ if let Some(s) = line.get_mut(col) {
+ if *s == Style::NoStyle || *s == Style::Quotation || overwrite {
+ *s = style;
+ }
+ }
+ }
+ }
}
[lib]
name = "rustc_llvm"
path = "lib.rs"
-crate-type = ["dylib"]
[features]
static-libstdcpp = []
+emscripten = []
[dependencies]
bitflags = "1.0"
+libc = "0.2"
rustc_cratesio_shim = { path = "../librustc_cratesio_shim" }
[build-dependencies]
cfg.define(&flag, None);
}
+ println!("cargo:rerun-if-changed-env=LLVM_RUSTLLVM");
if env::var_os("LLVM_RUSTLLVM").is_some() {
cfg.define("LLVM_RUSTLLVM", None);
}
// run.
match maybe_library {
Err(err) => Err(err),
- Ok(handle) => Ok(DynamicLibrary { handle: handle })
+ Ok(handle) => Ok(DynamicLibrary { handle })
+ }
+ }
+
+ /// Load 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());
+ match maybe_library {
+ Err(err) => Err(err),
+ Ok(handle) => Ok(DynamicLibrary { handle })
}
}
})
}
- const LAZY: libc::c_int = 1;
+ pub fn open_global_now(filename: &OsStr) -> Result<*mut u8, String> {
+ check_for_errors_in(|| unsafe {
+ let s = CString::new(filename.as_bytes()).unwrap();
+ libc::dlopen(s.as_ptr(), libc::RTLD_GLOBAL | libc::RTLD_NOW) as *mut u8
+ })
+ }
unsafe fn open_external(filename: &OsStr) -> *mut u8 {
let s = CString::new(filename.as_bytes()).unwrap();
- libc::dlopen(s.as_ptr(), LAZY) as *mut u8
+ libc::dlopen(s.as_ptr(), libc::RTLD_LAZY) as *mut u8
}
unsafe fn open_internal() -> *mut u8 {
- libc::dlopen(ptr::null(), LAZY) as *mut u8
+ libc::dlopen(ptr::null(), libc::RTLD_LAZY) as *mut u8
}
pub fn check_for_errors_in<T, F>(f: F) -> Result<T, String> where
fn FreeLibrary(handle: HMODULE) -> BOOL;
}
+ pub fn open_global_now(filename: &OsStr) -> Result<*mut u8, String> {
+ open(Some(filename))
+ }
+
pub fn open(filename: Option<&OsStr>) -> Result<*mut u8, String> {
// disable "dll load failed" error dialog.
let prev_error_mode = unsafe {
use rustc::mir::{BasicBlock, Location};
-use dataflow::{MaybeInitializedLvals, MaybeUninitializedLvals};
-use dataflow::{EverInitializedLvals, MovingOutStatements};
+use dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces};
+use dataflow::{EverInitializedPlaces, MovingOutStatements};
use dataflow::{ActiveBorrows, FlowAtLocation, FlowsAtLocation};
use dataflow::move_paths::HasMoveData;
use std::fmt;
// (forced to be `pub` due to its use as an associated type below.)
pub(crate) struct Flows<'b, 'gcx: 'tcx, 'tcx: 'b> {
pub borrows: FlowAtLocation<ActiveBorrows<'b, 'gcx, 'tcx>>,
- pub inits: FlowAtLocation<MaybeInitializedLvals<'b, 'gcx, 'tcx>>,
- pub uninits: FlowAtLocation<MaybeUninitializedLvals<'b, 'gcx, 'tcx>>,
+ pub inits: FlowAtLocation<MaybeInitializedPlaces<'b, 'gcx, 'tcx>>,
+ pub uninits: FlowAtLocation<MaybeUninitializedPlaces<'b, 'gcx, 'tcx>>,
pub move_outs: FlowAtLocation<MovingOutStatements<'b, 'gcx, 'tcx>>,
- pub ever_inits: FlowAtLocation<EverInitializedLvals<'b, 'gcx, 'tcx>>,
+ pub ever_inits: FlowAtLocation<EverInitializedPlaces<'b, 'gcx, 'tcx>>,
}
impl<'b, 'gcx, 'tcx> Flows<'b, 'gcx, 'tcx> {
pub fn new(
borrows: FlowAtLocation<ActiveBorrows<'b, 'gcx, 'tcx>>,
- inits: FlowAtLocation<MaybeInitializedLvals<'b, 'gcx, 'tcx>>,
- uninits: FlowAtLocation<MaybeUninitializedLvals<'b, 'gcx, 'tcx>>,
+ inits: FlowAtLocation<MaybeInitializedPlaces<'b, 'gcx, 'tcx>>,
+ uninits: FlowAtLocation<MaybeUninitializedPlaces<'b, 'gcx, 'tcx>>,
move_outs: FlowAtLocation<MovingOutStatements<'b, 'gcx, 'tcx>>,
- ever_inits: FlowAtLocation<EverInitializedLvals<'b, 'gcx, 'tcx>>,
+ ever_inits: FlowAtLocation<EverInitializedPlaces<'b, 'gcx, 'tcx>>,
) -> Self {
Flows {
borrows,
use dataflow::FlowAtLocation;
use dataflow::MoveDataParamEnv;
use dataflow::{DataflowAnalysis, DataflowResultsConsumer};
-use dataflow::{MaybeInitializedLvals, MaybeUninitializedLvals};
-use dataflow::{EverInitializedLvals, MovingOutStatements};
+use dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces};
+use dataflow::{EverInitializedPlaces, MovingOutStatements};
use dataflow::{BorrowData, Borrows, ReserveOrActivateIndex};
use dataflow::{ActiveBorrows, Reservations};
use dataflow::indexes::BorrowIndex;
id,
&attributes,
&dead_unwinds,
- MaybeInitializedLvals::new(tcx, mir, &mdpe),
+ MaybeInitializedPlaces::new(tcx, mir, &mdpe),
|bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]),
));
let flow_uninits = FlowAtLocation::new(do_dataflow(
id,
&attributes,
&dead_unwinds,
- MaybeUninitializedLvals::new(tcx, mir, &mdpe),
+ MaybeUninitializedPlaces::new(tcx, mir, &mdpe),
|bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]),
));
let flow_move_outs = FlowAtLocation::new(do_dataflow(
id,
&attributes,
&dead_unwinds,
- EverInitializedLvals::new(tcx, mir, &mdpe),
+ EverInitializedPlaces::new(tcx, mir, &mdpe),
|bd, i| DebugFormatted::new(&bd.move_data().inits[i]),
));
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
enum ShallowOrDeep {
/// From the RFC: "A *shallow* access means that the immediate
- /// fields reached at LV are accessed, but references or pointers
+ /// fields reached at P are accessed, but references or pointers
/// found within are not dereferenced. Right now, the only access
/// that is shallow is an assignment like `x = ...;`, which would
/// be a *shallow write* of `x`."
debug!("check_for_invalidation_at_exit({:?}): INVALID", place);
// FIXME: should be talking about the region lifetime instead
// of just a span here.
+ let span = self.tcx.sess.codemap().end_point(span);
self.report_borrowed_value_does_not_live_long_enough(
context,
borrow,
- span.end_point(),
+ span,
flow_state.borrows.operator(),
)
}
use transform::MirSource;
use util::liveness::{LivenessResults, LocalSet};
use dataflow::FlowAtLocation;
-use dataflow::MaybeInitializedLvals;
+use dataflow::MaybeInitializedPlaces;
use dataflow::move_paths::MoveData;
use util as mir_util;
universal_regions: UniversalRegions<'tcx>,
mir: &Mir<'tcx>,
param_env: ty::ParamEnv<'gcx>,
- flow_inits: &mut FlowAtLocation<MaybeInitializedLvals<'cx, 'gcx, 'tcx>>,
+ flow_inits: &mut FlowAtLocation<MaybeInitializedPlaces<'cx, 'gcx, 'tcx>>,
move_data: &MoveData<'tcx>,
) -> (
RegionInferenceContext<'tcx>,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::collections::HashMap;
+
use super::universal_regions::UniversalRegions;
use rustc::hir::def_id::DefId;
use rustc::infer::InferCtxt;
use rustc::traits::ObligationCause;
use rustc::ty::{self, RegionVid, Ty, TypeFoldable};
use rustc::util::common::ErrorReported;
+use rustc_data_structures::bitvec::BitVector;
use rustc_data_structures::indexed_vec::IndexVec;
use rustc_errors::DiagnosticBuilder;
use std::fmt;
/// satisfied. Note that some values may grow **too** large to be
/// feasible, but we check this later.
fn propagate_constraints(&mut self, mir: &Mir<'tcx>) {
- let mut changed = true;
-
debug!("propagate_constraints()");
debug!("propagate_constraints: constraints={:#?}", {
let mut constraints: Vec<_> = self.constraints.iter().collect();
// constraints we have accumulated.
let mut inferred_values = self.liveness_constraints.clone();
- while changed {
- changed = false;
- debug!("propagate_constraints: --------------------");
- for constraint in &self.constraints {
- debug!("propagate_constraints: constraint={:?}", constraint);
-
- // Grow the value as needed to accommodate the
- // outlives constraint.
- let Ok(made_changes) = self.dfs(
- mir,
- CopyFromSourceToTarget {
- source_region: constraint.sub,
- target_region: constraint.sup,
- inferred_values: &mut inferred_values,
- constraint_point: constraint.point,
- constraint_span: constraint.span,
- },
- );
+ let dependency_map = self.build_dependency_map();
+
+ // Constraints that may need to be repropagated (initially all):
+ let mut dirty_list: Vec<_> = (0..self.constraints.len()).collect();
+
+ // Set to 0 for each constraint that is on the dirty list:
+ let mut clean_bit_vec = BitVector::new(dirty_list.len());
+
+ debug!("propagate_constraints: --------------------");
+ while let Some(constraint_idx) = dirty_list.pop() {
+ clean_bit_vec.insert(constraint_idx);
+
+ let constraint = &self.constraints[constraint_idx];
+ debug!("propagate_constraints: constraint={:?}", constraint);
- if made_changes {
- debug!("propagate_constraints: sub={:?}", constraint.sub);
- debug!("propagate_constraints: sup={:?}", constraint.sup);
- changed = true;
+ // Grow the value as needed to accommodate the
+ // outlives constraint.
+ let Ok(made_changes) = self.dfs(
+ mir,
+ CopyFromSourceToTarget {
+ source_region: constraint.sub,
+ target_region: constraint.sup,
+ inferred_values: &mut inferred_values,
+ constraint_point: constraint.point,
+ constraint_span: constraint.span,
+ },
+ );
+
+ if made_changes {
+ debug!("propagate_constraints: sub={:?}", constraint.sub);
+ debug!("propagate_constraints: sup={:?}", constraint.sup);
+
+ for &dep_idx in dependency_map.get(&constraint.sup).unwrap_or(&vec![]) {
+ if clean_bit_vec.remove(dep_idx) {
+ dirty_list.push(dep_idx);
+ }
}
}
+
debug!("\n");
}
self.inferred_values = Some(inferred_values);
}
+ /// Builds up a map from each region variable X to a vector with the
+ /// indices of constraints that need to be re-evaluated when X changes.
+ /// These are constraints like Y: X @ P -- so if X changed, we may
+ /// need to grow Y.
+ fn build_dependency_map(&self) -> HashMap<RegionVid, Vec<usize>> {
+ let mut map = HashMap::new();
+
+ for (idx, constraint) in self.constraints.iter().enumerate() {
+ map.entry(constraint.sub).or_insert(Vec::new()).push(idx);
+ }
+
+ map
+ }
+
/// Once regions have been propagated, this method is used to see
/// whether the "type tests" produced by typeck were satisfied;
/// type tests encode type-outlives relationships like `T:
use dataflow::{FlowAtLocation, FlowsAtLocation};
use borrow_check::nll::region_infer::Cause;
-use dataflow::MaybeInitializedLvals;
+use dataflow::MaybeInitializedPlaces;
use dataflow::move_paths::{HasMoveData, MoveData};
use rustc::mir::{BasicBlock, Location, Mir};
use rustc::mir::Local;
cx: &mut TypeChecker<'_, 'gcx, 'tcx>,
mir: &Mir<'tcx>,
liveness: &LivenessResults,
- flow_inits: &mut FlowAtLocation<MaybeInitializedLvals<'_, 'gcx, 'tcx>>,
+ flow_inits: &mut FlowAtLocation<MaybeInitializedPlaces<'_, 'gcx, 'tcx>>,
move_data: &MoveData<'tcx>,
) {
let tcx = cx.tcx();
tcx: TyCtxt<'typeck, 'gcx, 'tcx>,
mir: &'gen Mir<'tcx>,
liveness: &'gen LivenessResults,
- flow_inits: &'gen mut FlowAtLocation<MaybeInitializedLvals<'flow, 'gcx, 'tcx>>,
+ flow_inits: &'gen mut FlowAtLocation<MaybeInitializedPlaces<'flow, 'gcx, 'tcx>>,
move_data: &'gen MoveData<'tcx>,
}
use borrow_check::nll::region_infer::ClosureRegionRequirementsExt;
use borrow_check::nll::universal_regions::UniversalRegions;
use dataflow::FlowAtLocation;
-use dataflow::MaybeInitializedLvals;
+use dataflow::MaybeInitializedPlaces;
use dataflow::move_paths::MoveData;
use rustc::hir::def_id::DefId;
use rustc::infer::{InferCtxt, InferOk, InferResult, LateBoundRegionConversionTime, UnitResult};
mir_def_id: DefId,
universal_regions: &UniversalRegions<'tcx>,
liveness: &LivenessResults,
- flow_inits: &mut FlowAtLocation<MaybeInitializedLvals<'_, 'gcx, 'tcx>>,
+ flow_inits: &mut FlowAtLocation<MaybeInitializedPlaces<'_, 'gcx, 'tcx>>,
move_data: &MoveData<'tcx>,
) -> MirTypeckRegionConstraints<'tcx> {
let body_id = infcx.tcx.hir.as_local_node_id(mir_def_id).unwrap();
let base_ty = base.to_ty(tcx);
match *pi {
ProjectionElem::Deref => {
- let deref_ty = base_ty.builtin_deref(true, ty::LvaluePreference::NoPreference);
+ let deref_ty = base_ty.builtin_deref(true);
PlaceTy::Ty {
ty: deref_ty.map(|t| t.ty).unwrap_or_else(|| {
span_mirbug_and_err!(self, place, "deref of non-pointer {:?}", base_ty)
if let Some(expr) = expr {
unpack!(block = this.into(destination, block, expr));
} else {
- this.cfg.push_assign_unit(block, source_info, destination);
+ // If a block has no trailing expression, then it is given an implicit return type.
+ // This return type is usually `()`, unless the block is diverging, in which case the
+ // return type is `!`. For the unit type, we need to actually return the unit, but in
+ // the case of `!`, no return value is required, as the block will never return.
+ let tcx = this.hir.tcx();
+ let ty = destination.ty(&this.local_decls, tcx).to_ty(tcx);
+ if ty.is_nil() {
+ // We only want to assign an implicit `()` as the return value of the block if the
+ // block does not diverge. (Otherwise, we may try to assign a unit to a `!`-type.)
+ this.cfg.push_assign_unit(block, source_info, destination);
+ }
}
// Finally, we pop all the let scopes before exiting out from the scope of block
// itself.
ExprKind::Continue { .. } |
ExprKind::Break { .. } |
ExprKind::InlineAsm { .. } |
- ExprKind::Return {.. } => {
+ ExprKind::Return { .. } => {
unpack!(block = this.stmt_expr(block, expr));
this.cfg.push_assign_unit(block, source_info, destination);
block.unit()
if let DropKind::Value { .. } = drop_kind {
scope.needs_cleanup = true;
}
+
let region_scope_span = region_scope.span(self.hir.tcx(),
&self.hir.region_scope_tree);
- // Attribute scope exit drops to scope's closing brace
- let scope_end = region_scope_span.with_lo(region_scope_span.hi());
+ // Attribute scope exit drops to scope's closing brace.
+ let scope_end = self.hir.tcx().sess.codemap().end_point(region_scope_span);
+
scope.drops.push(DropData {
span: scope_end,
location: place.clone(),
Some(_) => None,
None => {
match self.0.region_span_map.get(region) {
- Some(span) => Some(span.end_point()),
- None => Some(self.0.mir.span.end_point())
+ Some(span) => Some(self.0.tcx.sess.codemap().end_point(*span)),
+ None => Some(self.0.tcx.sess.codemap().end_point(self.0.mir.span))
}
}
}
/// has a reservation at the time).
fn is_potential_use(context: PlaceContext) -> bool {
match context {
- // storage effects on an place do not activate it
+ // storage effects on a place do not activate it
PlaceContext::StorageLive | PlaceContext::StorageDead => false,
- // validation effects do not activate an place
+ // validation effects do not activate a place
//
// FIXME: Should they? Is it just another read? Or can we
// guarantee it won't dereference the stored address? How
// AsmOutput existed, but it's not necessarily a pure overwrite.
// so it's possible this should activate the place.
PlaceContext::AsmOutput |
- // pure overwrites of an place do not activate it. (note
+ // pure overwrites of a place do not activate it. (note
// PlaceContext::Call is solely about dest place)
PlaceContext::Store | PlaceContext::Call => false,
- // reads of an place *do* activate it
+ // reads of a place *do* activate it
PlaceContext::Move |
PlaceContext::Copy |
PlaceContext::Drop |
#[allow(dead_code)]
pub(super) mod borrows;
-/// `MaybeInitializedLvals` tracks all l-values that might be
+/// `MaybeInitializedPlaces` tracks all places that might be
/// initialized upon reaching a particular point in the control flow
/// for a function.
///
/// }
/// ```
///
-/// To determine whether an l-value *must* be initialized at a
+/// To determine whether a place *must* be initialized at a
/// particular control-flow point, one can take the set-difference
-/// between this data and the data from `MaybeUninitializedLvals` at the
+/// between this data and the data from `MaybeUninitializedPlaces` at the
/// corresponding control-flow point.
///
/// Similarly, at a given `drop` statement, the set-intersection
-/// between this data and `MaybeUninitializedLvals` yields the set of
-/// l-values that would require a dynamic drop-flag at that statement.
-pub struct MaybeInitializedLvals<'a, 'gcx: 'tcx, 'tcx: 'a> {
+/// between this data and `MaybeUninitializedPlaces` yields the set of
+/// places that would require a dynamic drop-flag at that statement.
+pub struct MaybeInitializedPlaces<'a, 'gcx: 'tcx, 'tcx: 'a> {
tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
mdpe: &'a MoveDataParamEnv<'gcx, 'tcx>,
}
-impl<'a, 'gcx: 'tcx, 'tcx> MaybeInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx: 'tcx, 'tcx> MaybeInitializedPlaces<'a, 'gcx, 'tcx> {
pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
mdpe: &'a MoveDataParamEnv<'gcx, 'tcx>)
-> Self
{
- MaybeInitializedLvals { tcx: tcx, mir: mir, mdpe: mdpe }
+ MaybeInitializedPlaces { tcx: tcx, mir: mir, mdpe: mdpe }
}
}
-impl<'a, 'gcx, 'tcx> HasMoveData<'tcx> for MaybeInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> HasMoveData<'tcx> for MaybeInitializedPlaces<'a, 'gcx, 'tcx> {
fn move_data(&self) -> &MoveData<'tcx> { &self.mdpe.move_data }
}
-/// `MaybeUninitializedLvals` tracks all l-values that might be
+/// `MaybeUninitializedPlaces` tracks all places that might be
/// uninitialized upon reaching a particular point in the control flow
/// for a function.
///
/// }
/// ```
///
-/// To determine whether an l-value *must* be uninitialized at a
+/// To determine whether a place *must* be uninitialized at a
/// particular control-flow point, one can take the set-difference
-/// between this data and the data from `MaybeInitializedLvals` at the
+/// between this data and the data from `MaybeInitializedPlaces` at the
/// corresponding control-flow point.
///
/// Similarly, at a given `drop` statement, the set-intersection
-/// between this data and `MaybeInitializedLvals` yields the set of
-/// l-values that would require a dynamic drop-flag at that statement.
-pub struct MaybeUninitializedLvals<'a, 'gcx: 'tcx, 'tcx: 'a> {
+/// between this data and `MaybeInitializedPlaces` yields the set of
+/// places that would require a dynamic drop-flag at that statement.
+pub struct MaybeUninitializedPlaces<'a, 'gcx: 'tcx, 'tcx: 'a> {
tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
mdpe: &'a MoveDataParamEnv<'gcx, 'tcx>,
}
-impl<'a, 'gcx, 'tcx> MaybeUninitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> MaybeUninitializedPlaces<'a, 'gcx, 'tcx> {
pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
mdpe: &'a MoveDataParamEnv<'gcx, 'tcx>)
-> Self
{
- MaybeUninitializedLvals { tcx: tcx, mir: mir, mdpe: mdpe }
+ MaybeUninitializedPlaces { tcx: tcx, mir: mir, mdpe: mdpe }
}
}
-impl<'a, 'gcx, 'tcx> HasMoveData<'tcx> for MaybeUninitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> HasMoveData<'tcx> for MaybeUninitializedPlaces<'a, 'gcx, 'tcx> {
fn move_data(&self) -> &MoveData<'tcx> { &self.mdpe.move_data }
}
-/// `DefinitelyInitializedLvals` tracks all l-values that are definitely
+/// `DefinitelyInitializedPlaces` tracks all places that are definitely
/// 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 MaybeUninitializedLvals; thus we can get rid
+/// 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
-/// MaybeUninitializedLvals, simply because the sets will tend to be
+/// MaybeUninitializedPlaces, simply because the sets will tend to be
/// smaller in this analysis and thus easier for humans to process
/// when debugging.
///
/// }
/// ```
///
-/// To determine whether an l-value *may* be uninitialized at a
+/// To determine whether a place *may* be uninitialized at a
/// particular control-flow point, one can take the set-complement
/// of this data.
///
/// Similarly, at a given `drop` statement, the set-difference between
-/// this data and `MaybeInitializedLvals` yields the set of l-values
+/// this data and `MaybeInitializedPlaces` yields the set of places
/// that would require a dynamic drop-flag at that statement.
-pub struct DefinitelyInitializedLvals<'a, 'gcx: 'tcx, 'tcx: 'a> {
+pub struct DefinitelyInitializedPlaces<'a, 'gcx: 'tcx, 'tcx: 'a> {
tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
mdpe: &'a MoveDataParamEnv<'gcx, 'tcx>,
}
-impl<'a, 'gcx, 'tcx: 'a> DefinitelyInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx: 'a> DefinitelyInitializedPlaces<'a, 'gcx, 'tcx> {
pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
mdpe: &'a MoveDataParamEnv<'gcx, 'tcx>)
-> Self
{
- DefinitelyInitializedLvals { tcx: tcx, mir: mir, mdpe: mdpe }
+ DefinitelyInitializedPlaces { tcx: tcx, mir: mir, mdpe: mdpe }
}
}
-impl<'a, 'gcx, 'tcx: 'a> HasMoveData<'tcx> for DefinitelyInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx: 'a> HasMoveData<'tcx> for DefinitelyInitializedPlaces<'a, 'gcx, 'tcx> {
fn move_data(&self) -> &MoveData<'tcx> { &self.mdpe.move_data }
}
/// `MovingOutStatements` tracks the statements that perform moves out
-/// of particular l-values. More precisely, it tracks whether the
+/// of particular places. More precisely, it tracks whether the
/// *effect* of such moves (namely, the uninitialization of the
-/// l-value in question) can reach some point in the control-flow of
+/// place in question) can reach some point in the control-flow of
/// the function, or if that effect is "killed" by some intervening
-/// operation reinitializing that l-value.
+/// operation reinitializing that place.
///
/// The resulting dataflow is a more enriched version of
-/// `MaybeUninitializedLvals`. Both structures on their own only tell
-/// you if an l-value *might* be uninitialized at a given point in the
+/// `MaybeUninitializedPlaces`. Both structures on their own only tell
+/// you if a place *might* be uninitialized at a given point in the
/// control flow. But `MovingOutStatements` also includes the added
/// data of *which* particular statement causing the deinitialization
/// that the borrow checker's error message may need to report.
fn move_data(&self) -> &MoveData<'tcx> { &self.mdpe.move_data }
}
-/// `EverInitializedLvals` tracks all l-values that might have ever been
+/// `EverInitializedPlaces` tracks all places that might have ever been
/// initialized upon reaching a particular point in the control flow
/// for a function, without an intervening `Storage Dead`.
///
/// c = S; // {a, b, c, d }
/// }
/// ```
-pub struct EverInitializedLvals<'a, 'gcx: 'tcx, 'tcx: 'a> {
+pub struct EverInitializedPlaces<'a, 'gcx: 'tcx, 'tcx: 'a> {
tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
mdpe: &'a MoveDataParamEnv<'gcx, 'tcx>,
}
-impl<'a, 'gcx: 'tcx, 'tcx: 'a> EverInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx: 'tcx, 'tcx: 'a> EverInitializedPlaces<'a, 'gcx, 'tcx> {
pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
mdpe: &'a MoveDataParamEnv<'gcx, 'tcx>)
-> Self
{
- EverInitializedLvals { tcx: tcx, mir: mir, mdpe: mdpe }
+ EverInitializedPlaces { tcx: tcx, mir: mir, mdpe: mdpe }
}
}
-impl<'a, 'gcx, 'tcx> HasMoveData<'tcx> for EverInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> HasMoveData<'tcx> for EverInitializedPlaces<'a, 'gcx, 'tcx> {
fn move_data(&self) -> &MoveData<'tcx> { &self.mdpe.move_data }
}
-impl<'a, 'gcx, 'tcx> MaybeInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> MaybeInitializedPlaces<'a, 'gcx, 'tcx> {
fn update_bits(sets: &mut BlockSets<MovePathIndex>, path: MovePathIndex,
state: DropFlagState)
{
}
}
-impl<'a, 'gcx, 'tcx> MaybeUninitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> MaybeUninitializedPlaces<'a, 'gcx, 'tcx> {
fn update_bits(sets: &mut BlockSets<MovePathIndex>, path: MovePathIndex,
state: DropFlagState)
{
}
}
-impl<'a, 'gcx, 'tcx> DefinitelyInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> DefinitelyInitializedPlaces<'a, 'gcx, 'tcx> {
fn update_bits(sets: &mut BlockSets<MovePathIndex>, path: MovePathIndex,
state: DropFlagState)
{
}
}
-impl<'a, 'gcx, 'tcx> BitDenotation for MaybeInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> BitDenotation for MaybeInitializedPlaces<'a, 'gcx, 'tcx> {
type Idx = MovePathIndex;
fn name() -> &'static str { "maybe_init" }
fn bits_per_block(&self) -> usize {
}
}
-impl<'a, 'gcx, 'tcx> BitDenotation for MaybeUninitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> BitDenotation for MaybeUninitializedPlaces<'a, 'gcx, 'tcx> {
type Idx = MovePathIndex;
fn name() -> &'static str { "maybe_uninit" }
fn bits_per_block(&self) -> usize {
}
}
-impl<'a, 'gcx, 'tcx> BitDenotation for DefinitelyInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> BitDenotation for DefinitelyInitializedPlaces<'a, 'gcx, 'tcx> {
type Idx = MovePathIndex;
fn name() -> &'static str { "definite_init" }
fn bits_per_block(&self) -> usize {
}
}
-impl<'a, 'gcx, 'tcx> BitDenotation for EverInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> BitDenotation for EverInitializedPlaces<'a, 'gcx, 'tcx> {
type Idx = InitIndex;
fn name() -> &'static str { "ever_init" }
fn bits_per_block(&self) -> usize {
}
}
-impl<'a, 'gcx, 'tcx> BitwiseOperator for MaybeInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> BitwiseOperator for MaybeInitializedPlaces<'a, 'gcx, 'tcx> {
#[inline]
fn join(&self, pred1: usize, pred2: usize) -> usize {
pred1 | pred2 // "maybe" means we union effects of both preds
}
}
-impl<'a, 'gcx, 'tcx> BitwiseOperator for MaybeUninitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> BitwiseOperator for MaybeUninitializedPlaces<'a, 'gcx, 'tcx> {
#[inline]
fn join(&self, pred1: usize, pred2: usize) -> usize {
pred1 | pred2 // "maybe" means we union effects of both preds
}
}
-impl<'a, 'gcx, 'tcx> BitwiseOperator for DefinitelyInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> BitwiseOperator for DefinitelyInitializedPlaces<'a, 'gcx, 'tcx> {
#[inline]
fn join(&self, pred1: usize, pred2: usize) -> usize {
pred1 & pred2 // "definitely" means we intersect effects of both preds
}
}
-impl<'a, 'gcx, 'tcx> BitwiseOperator for EverInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> BitwiseOperator for EverInitializedPlaces<'a, 'gcx, 'tcx> {
#[inline]
fn join(&self, pred1: usize, pred2: usize) -> usize {
pred1 | pred2 // inits from both preds are in scope
// propagating, or you start at all-ones and then use Intersect as
// your merge when propagating.
-impl<'a, 'gcx, 'tcx> InitialFlow for MaybeInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> InitialFlow for MaybeInitializedPlaces<'a, 'gcx, 'tcx> {
#[inline]
fn bottom_value() -> bool {
false // bottom = uninitialized
}
}
-impl<'a, 'gcx, 'tcx> InitialFlow for MaybeUninitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> InitialFlow for MaybeUninitializedPlaces<'a, 'gcx, 'tcx> {
#[inline]
fn bottom_value() -> bool {
false // bottom = initialized (start_block_effect counters this at outset)
}
}
-impl<'a, 'gcx, 'tcx> InitialFlow for DefinitelyInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> InitialFlow for DefinitelyInitializedPlaces<'a, 'gcx, 'tcx> {
#[inline]
fn bottom_value() -> bool {
true // bottom = initialized (start_block_effect counters this at outset)
}
}
-impl<'a, 'gcx, 'tcx> InitialFlow for EverInitializedLvals<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> InitialFlow for EverInitializedPlaces<'a, 'gcx, 'tcx> {
#[inline]
fn bottom_value() -> bool {
false // bottom = no initialized variables by default
use std::usize;
pub use self::impls::{MaybeStorageLive};
-pub use self::impls::{MaybeInitializedLvals, MaybeUninitializedLvals};
-pub use self::impls::{DefinitelyInitializedLvals, MovingOutStatements};
-pub use self::impls::EverInitializedLvals;
+pub use self::impls::{MaybeInitializedPlaces, MaybeUninitializedPlaces};
+pub use self::impls::{DefinitelyInitializedPlaces, MovingOutStatements};
+pub use self::impls::EverInitializedPlaces;
pub use self::impls::borrows::{Borrows, BorrowData};
pub(crate) use self::impls::borrows::{ActiveBorrows, Reservations, ReserveOrActivateIndex};
pub use self::at_location::{FlowAtLocation, FlowsAtLocation};
/// It follows a tree structure.
///
/// Given `struct X { m: M, n: N }` and `x: X`, moves like `drop x.m;`
-/// move *out* of the l-value `x.m`.
+/// move *out* of the place `x.m`.
///
/// The MovePaths representing `x.m` and `x.n` are siblings (that is,
/// one of them will link to the other via the `next_sibling` field,
}
}
-/// Tables mapping from an l-value to its MovePathIndex.
+/// Tables mapping from a place to its MovePathIndex.
#[derive(Debug)]
pub struct MovePathLookup<'tcx> {
locals: IndexVec<Local, MovePathIndex>,
impl<'tcx> MovePathLookup<'tcx> {
// Unlike the builder `fn move_path_for` below, this lookup
// alternative will *not* create a MovePath on the fly for an
- // unknown l-value, but will rather return the nearest available
+ // unknown place, but will rather return the nearest available
// parent.
pub fn find(&self, place: &Place<'tcx>) -> LookupResult {
match *place {
#[derive(Copy, Clone, Debug)]
pub enum Place {
- /// An place referring to a value allocated in the `Memory` system.
+ /// A place referring to a value allocated in the `Memory` system.
Ptr {
- /// An place may have an invalid (integral or undef) pointer,
+ /// A place may have an invalid (integral or undef) pointer,
/// since it might be turned back into a reference
/// before ever being dereferenced.
ptr: Pointer,
extra: PlaceExtra,
},
- /// An place referring to a value on the stack. Represented by a stack frame index paired with
+ /// A place referring to a value on the stack. Represented by a stack frame index paired with
/// a Mir local index.
Local { frame: usize, local: mir::Local },
}
}
impl<'tcx> Place {
- /// Produces an Place that will error if attempted to be read from
+ /// Produces a Place that will error if attempted to be read from
pub fn undef() -> Self {
Self::from_primval_ptr(PrimVal::Undef.into(), Align::from_bytes(1, 1).unwrap())
}
use rustc::hir::def_id::DefId;
use rustc::hir::map::DefPathData;
use rustc::mir::mono::{Linkage, Visibility};
+use rustc::middle::exported_symbols::SymbolExportLevel;
use rustc::ty::{self, TyCtxt, InstanceDef};
use rustc::ty::item_path::characteristic_def_id_of_type;
use rustc::util::nodemap::{FxHashMap, FxHashSet};
.or_insert_with(make_codegen_unit);
let mut can_be_internalized = true;
- let (linkage, visibility) = match trans_item.explicit_linkage(tcx) {
+ let default_visibility = |id: DefId| {
+ if tcx.sess.target.target.options.default_hidden_visibility &&
+ tcx.symbol_export_level(id) != SymbolExportLevel::C
+ {
+ Visibility::Hidden
+ } else {
+ Visibility::Default
+ }
+ };
+ let (linkage, mut visibility) = match trans_item.explicit_linkage(tcx) {
Some(explicit_linkage) => (explicit_linkage, Visibility::Default),
None => {
match trans_item {
Visibility::Hidden
} else if def_id.is_local() {
if tcx.is_exported_symbol(def_id) {
- Visibility::Default
+ can_be_internalized = false;
+ default_visibility(def_id)
} else {
Visibility::Hidden
}
MonoItem::GlobalAsm(node_id) => {
let def_id = tcx.hir.local_def_id(node_id);
let visibility = if tcx.is_exported_symbol(def_id) {
- Visibility::Default
+ can_be_internalized = false;
+ default_visibility(def_id)
} else {
Visibility::Hidden
};
// except according to those terms.
use dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex, LookupResult};
-use dataflow::{MaybeInitializedLvals, MaybeUninitializedLvals};
+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};
let dead_unwinds = find_dead_unwinds(tcx, mir, id, &env);
let flow_inits =
do_dataflow(tcx, mir, id, &[], &dead_unwinds,
- MaybeInitializedLvals::new(tcx, mir, &env),
+ MaybeInitializedPlaces::new(tcx, mir, &env),
|bd, p| DebugFormatted::new(&bd.move_data().move_paths[p]));
let flow_uninits =
do_dataflow(tcx, mir, id, &[], &dead_unwinds,
- MaybeUninitializedLvals::new(tcx, mir, &env),
+ MaybeUninitializedPlaces::new(tcx, mir, &env),
|bd, p| DebugFormatted::new(&bd.move_data().move_paths[p]));
ElaborateDropsCtxt {
let mut dead_unwinds = IdxSetBuf::new_empty(mir.basic_blocks().len());
let flow_inits =
do_dataflow(tcx, mir, id, &[], &dead_unwinds,
- MaybeInitializedLvals::new(tcx, mir, &env),
+ MaybeInitializedPlaces::new(tcx, mir, &env),
|bd, p| DebugFormatted::new(&bd.move_data().move_paths[p]));
for (bb, bb_data) in mir.basic_blocks().iter_enumerated() {
let location = match bb_data.terminator().kind {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
mir: &'a Mir<'tcx>,
env: &'a MoveDataParamEnv<'tcx, 'tcx>,
- flow_inits: DataflowResults<MaybeInitializedLvals<'a, 'tcx, 'tcx>>,
- flow_uninits: DataflowResults<MaybeUninitializedLvals<'a, 'tcx, 'tcx>>,
+ flow_inits: DataflowResults<MaybeInitializedPlaces<'a, 'tcx, 'tcx>>,
+ flow_uninits: DataflowResults<MaybeUninitializedPlaces<'a, 'tcx, 'tcx>>,
drop_flags: FxHashMap<MovePathIndex, Local>,
patch: MirPatch<'tcx>,
}
use dataflow::MoveDataParamEnv;
use dataflow::BitDenotation;
use dataflow::DataflowResults;
-use dataflow::{DefinitelyInitializedLvals, MaybeInitializedLvals, MaybeUninitializedLvals};
+use dataflow::{DefinitelyInitializedPlaces, MaybeInitializedPlaces, MaybeUninitializedPlaces};
use dataflow::move_paths::{MovePathIndex, LookupResult};
use dataflow::move_paths::{HasMoveData, MoveData};
use dataflow;
let dead_unwinds = IdxSetBuf::new_empty(mir.basic_blocks().len());
let flow_inits =
do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
- MaybeInitializedLvals::new(tcx, mir, &mdpe),
+ MaybeInitializedPlaces::new(tcx, mir, &mdpe),
|bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]));
let flow_uninits =
do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
- MaybeUninitializedLvals::new(tcx, mir, &mdpe),
+ MaybeUninitializedPlaces::new(tcx, mir, &mdpe),
|bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]));
let flow_def_inits =
do_dataflow(tcx, mir, id, &attributes, &dead_unwinds,
- DefinitelyInitializedLvals::new(tcx, mir, &mdpe),
+ DefinitelyInitializedPlaces::new(tcx, mir, &mdpe),
|bd, i| DebugFormatted::new(&bd.move_data().move_paths[i]));
if has_rustc_mir_with(&attributes, "rustc_peek_maybe_init").is_some() {
/// ptr = cur
/// cur = cur.offset(1)
/// } else {
- /// ptr = &mut LV[cur]
+ /// ptr = &mut P[cur]
/// cur = cur + 1
/// }
/// drop(ptr)
if ptr_based {
let tmp_ty = tcx.mk_mut_ptr(self.place_ty(self.place));
let tmp = Place::Local(self.new_temp(tmp_ty));
- // tmp = &LV;
+ // tmp = &P;
// cur = tmp as *mut T;
// end = Offset(cur, len);
drop_block_stmts.push(self.assign(&tmp, Rvalue::Ref(
if let Some(sp) = self.current_type_ascription.last() {
let mut sp = *sp;
loop { // try to find the `:`, bail on first non-':'/non-whitespace
- sp = sp.next_point();
- if let Ok(snippet) = cm.span_to_snippet(sp.to(sp.next_point())) {
+ sp = cm.next_point(sp);
+ if let Ok(snippet) = cm.span_to_snippet(sp.to(cm.next_point(sp))) {
debug!("snippet {:?}", snippet);
let line_sp = cm.lookup_char_pos(sp.hi()).line;
let line_base_sp = cm.lookup_char_pos(base_span.lo()).line;
container));
err.span_label(span, format!("`{}` re{} here", name, new_participle));
- if old_binding.span != syntax_pos::DUMMY_SP {
+ if old_binding.span != DUMMY_SP {
err.span_label(self.session.codemap().def_span(old_binding.span),
format!("previous {} of the {} `{}` here", old_noun, old_kind, name));
}
// See https://github.com/rust-lang/rust/issues/32354
if old_binding.is_import() || new_binding.is_import() {
- let binding = if new_binding.is_import() {
+ let binding = if new_binding.is_import() && new_binding.span != DUMMY_SP {
new_binding
} else {
old_binding
if let (Ok(snippet), false) = (cm.span_to_snippet(binding.span),
binding.is_renamed_extern_crate()) {
+ let suggested_name = if name.as_str().chars().next().unwrap().is_uppercase() {
+ format!("Other{}", name)
+ } else {
+ format!("other_{}", name)
+ };
+
err.span_suggestion(binding.span,
rename_msg,
- format!("{} as Other{}", snippet, name));
+ if snippet.ends_with(';') {
+ format!("{} as {};",
+ &snippet[..snippet.len()-1],
+ suggested_name)
+ } else {
+ format!("{} as {}", snippet, suggested_name)
+ });
} else {
err.span_label(binding.span, rename_msg);
}
bitflags = "1.0"
flate2 = "1.0"
jobserver = "0.1.5"
+libc = "0.2"
log = "0.4"
num_cpus = "1.0"
rustc = { path = "../librustc" }
[target."cfg(windows)".dependencies]
cc = "1.0.1"
+
+[features]
+# Used to communicate the feature to `rustc_back` in the same manner that the
+# `rustc` driver script communicate this.
+jemalloc = ["rustc_back/jemalloc"]
+
+# This is used to convince Cargo to separately cache builds of `rustc_trans`
+# when this option is enabled or not. That way we can build two, cache two
+# artifacts, and have nice speedy rebuilds.
+emscripten = ["rustc_llvm/emscripten"]
self.mode == PassMode::Ignore
}
- /// Get the LLVM type for an place of the original Rust type of
+ /// Get the LLVM type for a place of the original Rust type of
/// this argument/return, i.e. the result of `type_of::type_of`.
pub fn memory_ty(&self, cx: &CodegenCx<'a, 'tcx>) -> Type {
self.layout.llvm_type(cx)
_ => bug!("FnType::new_vtable: non-pair self {:?}", self_arg)
}
- let pointee = self_arg.layout.ty.builtin_deref(true, ty::NoPreference)
+ let pointee = self_arg.layout.ty.builtin_deref(true)
.unwrap_or_else(|| {
bug!("FnType::new_vtable: non-pointer self {:?}", self_arg)
}).ty;
name.as_ptr(),
ty);
+ if tcx.sess.target.target.options.default_hidden_visibility {
+ llvm::LLVMRustSetVisibility(llfn, llvm::Visibility::Hidden);
+ }
+
let callee = CString::new(kind.fn_name(method.name)).unwrap();
let callee = llvm::LLVMRustGetOrInsertFunction(llmod,
callee.as_ptr(),
// Default per-arch clobbers
// Basically what clang does
let arch_clobbers = match &bx.sess().target.target.arch[..] {
- "x86" | "x86_64" => vec!["~{dirflag}", "~{fpsr}", "~{flags}"],
- _ => Vec::new()
+ "x86" | "x86_64" => vec!["~{dirflag}", "~{fpsr}", "~{flags}"],
+ "mips" | "mips64" => vec!["~{$1}"],
+ _ => Vec::new()
};
let all_constraints =
Arc::new(local_crate)
};
+
+ providers.symbol_export_level = export_level;
}
pub fn provide_extern(providers: &mut Providers) {
Arc::new(crate_exports)
};
+ providers.symbol_export_level = export_level;
}
fn export_level(tcx: TyCtxt, sym_def_id: DefId) -> SymbolExportLevel {
if cgcx.debuginfo != config::NoDebugInfo {
options.debuginfo(true);
}
- if cgcx.crate_types.contains(&config::CrateTypeExecutable) {
- options.start("main");
- }
+
options.stack(1024 * 1024);
options.import_memory(cgcx.wasm_import_memory);
let assembled = input.and_then(|input| {
target_pointer_width: tcx.sess.target.target.target_pointer_width.clone(),
binaryen_linker: tcx.sess.linker_flavor() == LinkerFlavor::Binaryen,
debuginfo: tcx.sess.opts.debuginfo,
- wasm_import_memory: wasm_import_memory,
+ wasm_import_memory,
assembler_cmd,
};
use back::bytecode::RLIB_BYTECODE_EXTENSION;
-pub use llvm_util::{target_features, print_version, print_passes};
+pub use llvm_util::target_features;
use std::any::Any;
use std::path::PathBuf;
impl !Sync for LlvmTransCrate {}
impl LlvmTransCrate {
- pub fn new(sess: &Session) -> Box<TransCrate> {
- llvm_util::init(sess); // Make sure llvm is inited
+ pub fn new() -> Box<TransCrate> {
box LlvmTransCrate(())
}
}
impl TransCrate for LlvmTransCrate {
+ fn init(&self, sess: &Session) {
+ llvm_util::init(sess); // Make sure llvm is inited
+ }
+
fn print(&self, req: PrintRequest, sess: &Session) {
match req {
PrintRequest::RelocationModels => {
}
}
+ fn print_passes(&self) {
+ llvm_util::print_passes();
+ }
+
+ fn print_version(&self) {
+ llvm_util::print_version();
+ }
+
+ #[cfg(not(stage0))]
+ fn diagnostics(&self) -> &[(&'static str, &'static str)] {
+ &DIAGNOSTICS
+ }
+
fn target_features(&self, sess: &Session) -> Vec<Symbol> {
target_features(sess)
}
/// This is the entrypoint for a hot plugged rustc_trans
#[no_mangle]
-pub fn __rustc_codegen_backend(sess: &Session) -> Box<TransCrate> {
- LlvmTransCrate::new(sess)
+pub fn __rustc_codegen_backend() -> Box<TransCrate> {
+ LlvmTransCrate::new()
}
struct ModuleTranslation {
// detection code will walk past the end of the feature array,
// leading to crashes.
-const ARM_WHITELIST: &'static [&'static str] = &["neon\0", "vfp2\0", "vfp3\0", "vfp4\0"];
+const ARM_WHITELIST: &'static [&'static str] = &["neon\0", "v7\0", "vfp2\0", "vfp3\0", "vfp4\0"];
-const AARCH64_WHITELIST: &'static [&'static str] = &["neon\0"];
+const AARCH64_WHITELIST: &'static [&'static str] = &["neon\0", "v7\0"];
const X86_WHITELIST: &'static [&'static str] = &["avx\0", "avx2\0", "bmi\0", "bmi2\0", "sse\0",
"sse2\0", "sse3\0", "sse4.1\0", "sse4.2\0",
"ssse3\0", "tbm\0", "lzcnt\0", "popcnt\0",
"sse4a\0", "rdrnd\0", "rdseed\0", "fma\0",
"xsave\0", "xsaveopt\0", "xsavec\0",
- "xsaves\0",
+ "xsaves\0", "aes\0",
"avx512bw\0", "avx512cd\0",
"avx512dq\0", "avx512er\0",
"avx512f\0", "avx512ifma\0",
}
}
_ => {
- const_get_elt(self.llval, layout.llvm_field_index(i))
+ match layout.fields {
+ layout::FieldPlacement::Union(_) => self.llval,
+ _ => const_get_elt(self.llval, layout.llvm_field_index(i)),
+ }
}
}
}
Static(ValueRef)
}
-/// An place as seen from a constant.
+/// A place as seen from a constant.
#[derive(Copy, Clone)]
struct ConstPlace<'tcx> {
base: Base,
operand.llval
}
mir::CastKind::Unsize => {
- let pointee_ty = operand.ty.builtin_deref(true, ty::NoPreference)
+ let pointee_ty = operand.ty.builtin_deref(true)
.expect("consts: unsizing got non-pointer type").ty;
let (base, old_info) = if !self.cx.type_is_sized(pointee_ty) {
// Normally, the source is a thin pointer and we are
(operand.llval, None)
};
- let unsized_ty = cast_ty.builtin_deref(true, ty::NoPreference)
+ let unsized_ty = cast_ty.builtin_deref(true)
.expect("consts: unsizing got non-pointer target type").ty;
let ptr_ty = self.cx.layout_of(unsized_ty).llvm_type(self.cx).ptr_to();
let base = consts::ptrcast(base, ptr_ty);
// except according to those terms.
use llvm::ValueRef;
-use rustc::ty;
use rustc::ty::layout::{self, Align, LayoutOf, TyLayout};
use rustc::mir;
use rustc_data_structures::indexed_vec::Idx;
}
pub fn deref(self, cx: &CodegenCx<'a, 'tcx>) -> PlaceRef<'tcx> {
- let projected_ty = self.layout.ty.builtin_deref(true, ty::NoPreference)
+ let projected_ty = self.layout.ty.builtin_deref(true)
.unwrap_or_else(|| bug!("deref of non-pointer {:?}", self)).ty;
let (llptr, llextra) = match self.val {
OperandValue::Immediate(llptr) => (llptr, ptr::null_mut()),
ty::TyClosure(..) |
ty::TyGenerator(..) |
ty::TyAdt(..) |
- ty::TyDynamic(..) |
+ // FIXME(eddyb) producing readable type names for trait objects can result
+ // in problematically distinct types due to HRTB and subtyping (see #47638).
+ // ty::TyDynamic(..) |
ty::TyForeign(..) |
ty::TyStr => {
let mut name = String::with_capacity(32);
use link::{build_link_meta, out_filename};
pub trait TransCrate {
+ fn init(&self, _sess: &Session) {}
fn print(&self, _req: PrintRequest, _sess: &Session) {}
fn target_features(&self, _sess: &Session) -> Vec<Symbol> { vec![] }
+ fn print_passes(&self) {}
+ fn print_version(&self) {}
+ fn diagnostics(&self) -> &[(&'static str, &'static str)] { &[] }
fn metadata_loader(&self) -> Box<MetadataLoader>;
fn provide(&self, _providers: &mut Providers);
}
impl MetadataOnlyTransCrate {
- pub fn new(sess: &Session) -> Box<TransCrate> {
+ pub fn new() -> Box<TransCrate> {
+ box MetadataOnlyTransCrate(())
+ }
+}
+
+impl TransCrate for MetadataOnlyTransCrate {
+ fn init(&self, sess: &Session) {
for cty in sess.opts.crate_types.iter() {
match *cty {
CrateType::CrateTypeRlib | CrateType::CrateTypeDylib |
},
}
}
-
- box MetadataOnlyTransCrate(())
}
-}
-impl TransCrate for MetadataOnlyTransCrate {
fn metadata_loader(&self) -> Box<MetadataLoader> {
box NoLlvmMetadataLoader
}
use rustc::infer;
use rustc::infer::type_variable::TypeVariableOrigin;
use rustc::traits::ObligationCauseCode;
-use rustc::ty::{self, Ty, TypeFoldable, LvaluePreference};
-use check::{FnCtxt, Expectation, Diverges};
+use rustc::ty::{self, Ty, TypeFoldable};
+use check::{FnCtxt, Expectation, Diverges, Needs};
use check::coercion::CoerceMany;
use util::nodemap::FxHashMap;
pub fn check_dereferencable(&self, span: Span, expected: Ty<'tcx>, inner: &hir::Pat) -> bool {
if let PatKind::Binding(..) = inner.node {
- if let Some(mt) = self.shallow_resolve(expected).builtin_deref(true, ty::NoPreference) {
+ if let Some(mt) = self.shallow_resolve(expected).builtin_deref(true) {
if let ty::TyDynamic(..) = mt.ty.sty {
// This is "x = SomeTrait" being reduced from
// "let &x = &SomeTrait" or "let box x = Box<SomeTrait>", an error.
});
let discrim_ty;
if let Some(m) = contains_ref_bindings {
- discrim_ty = self.check_expr_with_lvalue_pref(discrim, LvaluePreference::from_mutbl(m));
+ discrim_ty = self.check_expr_with_needs(discrim, Needs::maybe_mut_place(m));
} else {
// ...but otherwise we want to use any supertype of the
// discriminant. This is sort of a workaround, see note (*) in
use astconv::AstConv;
-use super::{FnCtxt, LvalueOp};
+use super::{FnCtxt, PlaceOp, Needs};
use super::method::MethodCallee;
use rustc::infer::InferOk;
use rustc::traits;
use rustc::ty::{self, Ty, TraitRef};
use rustc::ty::{ToPredicate, TypeFoldable};
-use rustc::ty::{LvaluePreference, NoPreference};
use rustc::ty::adjustment::{Adjustment, Adjust, OverloadedDeref};
use syntax_pos::Span;
// Otherwise, deref if type is derefable:
let (kind, new_ty) =
- if let Some(mt) = self.cur_ty.builtin_deref(self.include_raw_pointers, NoPreference) {
+ if let Some(mt) = self.cur_ty.builtin_deref(self.include_raw_pointers) {
(AutoderefKind::Builtin, mt.ty)
} else {
let ty = self.overloaded_deref_ty(self.cur_ty)?;
}
/// Returns the adjustment steps.
- pub fn adjust_steps(&self, pref: LvaluePreference)
+ pub fn adjust_steps(&self, needs: Needs)
-> Vec<Adjustment<'tcx>> {
- self.fcx.register_infer_ok_obligations(self.adjust_steps_as_infer_ok(pref))
+ self.fcx.register_infer_ok_obligations(self.adjust_steps_as_infer_ok(needs))
}
- pub fn adjust_steps_as_infer_ok(&self, pref: LvaluePreference)
+ pub fn adjust_steps_as_infer_ok(&self, needs: Needs)
-> InferOk<'tcx, Vec<Adjustment<'tcx>>> {
let mut obligations = vec![];
let targets = self.steps.iter().skip(1).map(|&(ty, _)| ty)
.chain(iter::once(self.cur_ty));
let steps: Vec<_> = self.steps.iter().map(|&(source, kind)| {
if let AutoderefKind::Overloaded = kind {
- self.fcx.try_overloaded_deref(self.span, source, pref)
+ self.fcx.try_overloaded_deref(self.span, source, needs)
.and_then(|InferOk { value: method, obligations: o }| {
obligations.extend(o);
if let ty::TyRef(region, mt) = method.sig.output().sty {
pub fn try_overloaded_deref(&self,
span: Span,
base_ty: Ty<'tcx>,
- pref: LvaluePreference)
+ needs: Needs)
-> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
- self.try_overloaded_lvalue_op(span, base_ty, &[], pref, LvalueOp::Deref)
+ self.try_overloaded_place_op(span, base_ty, &[], needs, PlaceOp::Deref)
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::{Expectation, FnCtxt, TupleArgumentsFlag};
+use super::{Expectation, FnCtxt, Needs, TupleArgumentsFlag};
use super::autoderef::Autoderef;
use super::method::MethodCallee;
use hir::def::Def;
use hir::def_id::{DefId, LOCAL_CRATE};
use rustc::{infer, traits};
-use rustc::ty::{self, TyCtxt, TypeFoldable, LvaluePreference, Ty};
+use rustc::ty::{self, TyCtxt, TypeFoldable, Ty};
use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow};
use syntax::abi;
use syntax::symbol::Symbol;
// If the callee is a bare function or a closure, then we're all set.
match adjusted_ty.sty {
ty::TyFnDef(..) | ty::TyFnPtr(_) => {
- let adjustments = autoderef.adjust_steps(LvaluePreference::NoPreference);
+ let adjustments = autoderef.adjust_steps(Needs::None);
self.apply_adjustments(callee_expr, adjustments);
return Some(CallStep::Builtin(adjusted_ty));
}
infer::FnCall,
&closure_ty)
.0;
- let adjustments = autoderef.adjust_steps(LvaluePreference::NoPreference);
+ let adjustments = autoderef.adjust_steps(Needs::None);
self.record_deferred_call_resolution(def_id, DeferredCallResolution {
call_expr,
callee_expr,
}
self.try_overloaded_call_traits(call_expr, adjusted_ty).map(|(autoref, method)| {
- let mut adjustments = autoderef.adjust_steps(LvaluePreference::NoPreference);
+ let mut adjustments = autoderef.adjust_steps(Needs::None);
adjustments.extend(autoref);
self.apply_adjustments(callee_expr, adjustments);
CallStep::Overloaded(method)
//! 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::{Diverges, FnCtxt};
+use check::{Diverges, FnCtxt, Needs};
use rustc::hir;
use rustc::hir::def_id::DefId;
use rustc::lint;
use rustc::traits::{self, ObligationCause, ObligationCauseCode};
use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow};
-use rustc::ty::{self, LvaluePreference, TypeAndMut,
- Ty, ClosureSubsts};
+use rustc::ty::{self, TypeAndMut, Ty, ClosureSubsts};
use rustc::ty::fold::TypeFoldable;
use rustc::ty::error::TypeError;
use rustc::ty::relate::RelateResult;
return success(vec![], ty, obligations);
}
- let pref = LvaluePreference::from_mutbl(mt_b.mutbl);
+ let needs = Needs::maybe_mut_place(mt_b.mutbl);
let InferOk { value: mut adjustments, obligations: o }
- = autoderef.adjust_steps_as_infer_ok(pref);
+ = autoderef.adjust_steps_as_infer_ok(needs);
obligations.extend(o);
obligations.extend(autoderef.into_obligations());
use super::{probe, MethodCallee};
use astconv::AstConv;
-use check::{FnCtxt, LvalueOp, callee};
+use check::{FnCtxt, PlaceOp, callee, Needs};
use hir::def_id::DefId;
use rustc::ty::subst::Substs;
use rustc::traits;
-use rustc::ty::{self, LvaluePreference, NoPreference, PreferMutLvalue, Ty};
+use rustc::ty::{self, Ty};
use rustc::ty::subst::Subst;
use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow, OverloadedDeref};
use rustc::ty::fold::TypeFoldable;
};
if let Some(hir::MutMutable) = pick.autoref {
- self.convert_lvalue_derefs_to_mutable();
+ self.convert_place_derefs_to_mutable();
}
ConfirmResult { callee, illegal_sized_bound }
let (_, n) = autoderef.nth(pick.autoderefs).unwrap();
assert_eq!(n, pick.autoderefs);
- let mut adjustments = autoderef.adjust_steps(LvaluePreference::NoPreference);
+ let mut adjustments = autoderef.adjust_steps(Needs::None);
let mut target = autoderef.unambiguous_final_ty();
/// When we select a method with a mutable autoref, we have to go convert any
/// auto-derefs, indices, etc from `Deref` and `Index` into `DerefMut` and `IndexMut`
/// respectively.
- fn convert_lvalue_derefs_to_mutable(&self) {
+ fn convert_place_derefs_to_mutable(&self) {
// Gather up expressions we want to munge.
let mut exprs = Vec::new();
exprs.push(self.self_expr);
}
}
- debug!("convert_lvalue_derefs_to_mutable: exprs={:?}", exprs);
+ debug!("convert_place_derefs_to_mutable: exprs={:?}", exprs);
// Fix up autoderefs and derefs.
for (i, &expr) in exprs.iter().rev().enumerate() {
- debug!("convert_lvalue_derefs_to_mutable: i={} expr={:?}", i, expr);
+ debug!("convert_place_derefs_to_mutable: i={} expr={:?}", i, expr);
// Fix up the autoderefs. Autorefs can only occur immediately preceding
- // overloaded lvalue ops, and will be fixed by them in order to get
+ // overloaded place ops, and will be fixed by them in order to get
// the correct region.
let mut source = self.node_ty(expr.hir_id);
// Do not mutate adjustments in place, but rather take them,
.adjustments_mut()
.remove(expr.hir_id);
if let Some(mut adjustments) = previous_adjustments {
- let pref = LvaluePreference::PreferMutLvalue;
+ let needs = Needs::MutPlace;
for adjustment in &mut adjustments {
if let Adjust::Deref(Some(ref mut deref)) = adjustment.kind {
- if let Some(ok) = self.try_overloaded_deref(expr.span, source, pref) {
+ if let Some(ok) = self.try_overloaded_deref(expr.span, source, needs) {
let method = self.register_infer_ok_obligations(ok);
if let ty::TyRef(region, mt) = method.sig.output().sty {
*deref = OverloadedDeref {
match expr.node {
hir::ExprIndex(ref base_expr, ref index_expr) => {
let index_expr_ty = self.node_ty(index_expr.hir_id);
- self.convert_lvalue_op_to_mutable(
- LvalueOp::Index, expr, base_expr, &[index_expr_ty]);
+ self.convert_place_op_to_mutable(
+ PlaceOp::Index, expr, base_expr, &[index_expr_ty]);
}
hir::ExprUnary(hir::UnDeref, ref base_expr) => {
- self.convert_lvalue_op_to_mutable(
- LvalueOp::Deref, expr, base_expr, &[]);
+ self.convert_place_op_to_mutable(
+ PlaceOp::Deref, expr, base_expr, &[]);
}
_ => {}
}
}
}
- fn convert_lvalue_op_to_mutable(&self,
- op: LvalueOp,
+ fn convert_place_op_to_mutable(&self,
+ op: PlaceOp,
expr: &hir::Expr,
base_expr: &hir::Expr,
arg_tys: &[Ty<'tcx>])
{
- debug!("convert_lvalue_op_to_mutable({:?}, {:?}, {:?}, {:?})",
+ debug!("convert_place_op_to_mutable({:?}, {:?}, {:?}, {:?})",
op, expr, base_expr, arg_tys);
if !self.tables.borrow().is_method_call(expr) {
- debug!("convert_lvalue_op_to_mutable - builtin, nothing to do");
+ debug!("convert_place_op_to_mutable - builtin, nothing to do");
return
}
.map_or_else(|| self.node_ty(expr.hir_id), |adj| adj.target);
let base_ty = self.resolve_type_vars_if_possible(&base_ty);
- // Need to deref because overloaded lvalue ops take self by-reference.
- let base_ty = base_ty.builtin_deref(false, NoPreference)
- .expect("lvalue op takes something that is not a ref")
+ // Need to deref because overloaded place ops take self by-reference.
+ let base_ty = base_ty.builtin_deref(false)
+ .expect("place op takes something that is not a ref")
.ty;
- let method = self.try_overloaded_lvalue_op(
- expr.span, base_ty, arg_tys, PreferMutLvalue, op);
+ let method = self.try_overloaded_place_op(
+ expr.span, base_ty, arg_tys, Needs::MutPlace, op);
let method = match method {
Some(ok) => self.register_infer_ok_obligations(ok),
None => return self.tcx.sess.delay_span_bug(expr.span, "re-trying op failed")
};
- debug!("convert_lvalue_op_to_mutable: method={:?}", method);
+ debug!("convert_place_op_to_mutable: method={:?}", method);
self.write_method_call(expr.hir_id, method);
let (region, mutbl) = if let ty::TyRef(r, mt) = method.sig.inputs()[0].sty {
(r, mt.mutbl)
} else {
- span_bug!(expr.span, "input to lvalue op is not a ref?");
+ span_bug!(expr.span, "input to place op is not a ref?");
};
// Convert the autoref in the base expr to mutable with the correct
let mut source = base_expr_ty;
for adjustment in &mut adjustments[..] {
if let Adjust::Borrow(AutoBorrow::Ref(..)) = adjustment.kind {
- debug!("convert_lvalue_op_to_mutable: converting autoref {:?}", adjustment);
+ debug!("convert_place_op_to_mutable: converting autoref {:?}", adjustment);
adjustment.kind = Adjust::Borrow(AutoBorrow::Ref(region, mutbl));
adjustment.target = self.tcx.mk_ref(region, ty::TypeAndMut {
ty: source,
use rustc::middle::region;
use rustc::ty::subst::{Kind, Subst, Substs};
use rustc::traits::{self, FulfillmentContext, ObligationCause, ObligationCauseCode};
-use rustc::ty::{ParamTy, LvaluePreference, NoPreference, PreferMutLvalue};
use rustc::ty::{self, Ty, TyCtxt, Visibility, ToPredicate};
use rustc::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
use rustc::ty::fold::TypeFoldable;
}
}
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum Needs {
+ MutPlace,
+ None
+}
+
+impl Needs {
+ fn maybe_mut_place(m: hir::Mutability) -> Self {
+ match m {
+ hir::MutMutable => Needs::MutPlace,
+ hir::MutImmutable => Needs::None,
+ }
+ }
+}
+
#[derive(Copy, Clone)]
pub struct UnsafetyState {
pub def: ast::NodeId,
}
#[derive(Debug, Copy, Clone)]
-pub enum LvalueOp {
+pub enum PlaceOp {
Deref,
Index
}
/// foo();}` or `{return; 22}`, where we would warn on the
/// `foo()` or `22`.
///
- /// - To permit assignment into a local variable or other lvalue
+ /// - To permit assignment into a local variable or other place
/// (including the "return slot") of type `!`. This is allowed
/// if **either** the type of value being assigned is `!`, which
/// means the current code is dead, **or** the expression's
}
}
- /// For the overloaded lvalue expressions (`*x`, `x[3]`), the trait
+ fn is_place_expr(&self, expr: &hir::Expr) -> bool {
+ match expr.node {
+ hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {
+ match path.def {
+ Def::Local(..) | Def::Upvar(..) | Def::Static(..) | Def::Err => true,
+ _ => false,
+ }
+ }
+
+ hir::ExprType(ref e, _) => {
+ self.is_place_expr(e)
+ }
+
+ hir::ExprUnary(hir::UnDeref, _) |
+ hir::ExprField(..) |
+ hir::ExprTupField(..) |
+ hir::ExprIndex(..) => {
+ true
+ }
+
+ // Partially qualified paths in expressions can only legally
+ // refer to associated items which are always rvalues.
+ hir::ExprPath(hir::QPath::TypeRelative(..)) |
+
+ hir::ExprCall(..) |
+ hir::ExprMethodCall(..) |
+ hir::ExprStruct(..) |
+ hir::ExprTup(..) |
+ hir::ExprIf(..) |
+ hir::ExprMatch(..) |
+ hir::ExprClosure(..) |
+ hir::ExprBlock(..) |
+ hir::ExprRepeat(..) |
+ hir::ExprArray(..) |
+ hir::ExprBreak(..) |
+ hir::ExprAgain(..) |
+ hir::ExprRet(..) |
+ hir::ExprWhile(..) |
+ hir::ExprLoop(..) |
+ hir::ExprAssign(..) |
+ hir::ExprInlineAsm(..) |
+ hir::ExprAssignOp(..) |
+ hir::ExprLit(_) |
+ hir::ExprUnary(..) |
+ hir::ExprBox(..) |
+ hir::ExprAddrOf(..) |
+ hir::ExprBinary(..) |
+ hir::ExprYield(..) |
+ hir::ExprCast(..) => {
+ false
+ }
+ }
+ }
+
+ /// For the overloaded place expressions (`*x`, `x[3]`), the trait
/// returns a type of `&T`, but the actual type we assign to the
/// *expression* is `T`. So this function just peels off the return
/// type by one layer to yield `T`.
- fn make_overloaded_lvalue_return_type(&self,
+ fn make_overloaded_place_return_type(&self,
method: MethodCallee<'tcx>)
-> ty::TypeAndMut<'tcx>
{
let ret_ty = method.sig.output();
// method returns &T, but the type as visible to user is T, so deref
- ret_ty.builtin_deref(true, NoPreference).unwrap()
+ ret_ty.builtin_deref(true).unwrap()
}
fn lookup_indexing(&self,
base_expr: &'gcx hir::Expr,
base_ty: Ty<'tcx>,
idx_ty: Ty<'tcx>,
- lvalue_pref: LvaluePreference)
+ needs: Needs)
-> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
{
// FIXME(#18741) -- this is almost but not quite the same as the
let mut autoderef = self.autoderef(base_expr.span, base_ty);
let mut result = None;
while result.is_none() && autoderef.next().is_some() {
- result = self.try_index_step(expr, base_expr, &autoderef, lvalue_pref, idx_ty);
+ result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
}
autoderef.finalize();
result
expr: &hir::Expr,
base_expr: &hir::Expr,
autoderef: &Autoderef<'a, 'gcx, 'tcx>,
- lvalue_pref: LvaluePreference,
+ needs: Needs,
index_ty: Ty<'tcx>)
-> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
{
// type from the method signature.
// If some lookup succeeded, install method in table
let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
- let method = self.try_overloaded_lvalue_op(
- expr.span, self_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
+ let method = self.try_overloaded_place_op(
+ expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
let result = method.map(|ok| {
debug!("try_index_step: success, using overloaded indexing");
let method = self.register_infer_ok_obligations(ok);
- let mut adjustments = autoderef.adjust_steps(lvalue_pref);
+ let mut adjustments = autoderef.adjust_steps(needs);
if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
adjustments.push(Adjustment {
kind: Adjust::Borrow(AutoBorrow::Ref(region, mt.mutbl)),
self.apply_adjustments(base_expr, adjustments);
self.write_method_call(expr.hir_id, method);
- (input_ty, self.make_overloaded_lvalue_return_type(method).ty)
+ (input_ty, self.make_overloaded_place_return_type(method).ty)
});
if result.is_some() {
return result;
None
}
- fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
+ fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, Symbol) {
let (tr, name) = match (op, is_mut) {
- (LvalueOp::Deref, false) =>
+ (PlaceOp::Deref, false) =>
(self.tcx.lang_items().deref_trait(), "deref"),
- (LvalueOp::Deref, true) =>
+ (PlaceOp::Deref, true) =>
(self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
- (LvalueOp::Index, false) =>
+ (PlaceOp::Index, false) =>
(self.tcx.lang_items().index_trait(), "index"),
- (LvalueOp::Index, true) =>
+ (PlaceOp::Index, true) =>
(self.tcx.lang_items().index_mut_trait(), "index_mut"),
};
(tr, Symbol::intern(name))
}
- fn try_overloaded_lvalue_op(&self,
+ fn try_overloaded_place_op(&self,
span: Span,
base_ty: Ty<'tcx>,
arg_tys: &[Ty<'tcx>],
- lvalue_pref: LvaluePreference,
- op: LvalueOp)
+ needs: Needs,
+ op: PlaceOp)
-> Option<InferOk<'tcx, MethodCallee<'tcx>>>
{
- debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
+ debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
span,
base_ty,
- lvalue_pref,
+ needs,
op);
- // Try Mut first, if preferred.
- let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
- let method = match (lvalue_pref, mut_tr) {
- (PreferMutLvalue, Some(trait_did)) => {
+ // Try Mut first, if needed.
+ let (mut_tr, mut_op) = self.resolve_place_op(op, true);
+ let method = match (needs, mut_tr) {
+ (Needs::MutPlace, Some(trait_did)) => {
self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
}
_ => None,
};
// Otherwise, fall back to the immutable version.
- let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
+ let (imm_tr, imm_op) = self.resolve_place_op(op, false);
let method = match (method, imm_tr) {
(None, Some(trait_did)) => {
self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
err.span_label(def_s, "defined here");
}
if sugg_unit {
- let sugg_span = expr_sp.end_point();
+ let sugg_span = sess.codemap().end_point(expr_sp);
// remove closing `)` from the span
let sugg_span = sugg_span.with_hi(sugg_span.lo());
err.span_suggestion(
fn check_expr_coercable_to_type(&self,
expr: &'gcx hir::Expr,
expected: Ty<'tcx>) -> Ty<'tcx> {
- self.check_expr_coercable_to_type_with_lvalue_pref(expr, expected, NoPreference)
+ self.check_expr_coercable_to_type_with_needs(expr, expected, Needs::None)
}
- fn check_expr_coercable_to_type_with_lvalue_pref(&self,
- expr: &'gcx hir::Expr,
- expected: Ty<'tcx>,
- lvalue_pref: LvaluePreference)
- -> Ty<'tcx> {
- let ty = self.check_expr_with_expectation_and_lvalue_pref(
+ fn check_expr_coercable_to_type_with_needs(&self,
+ expr: &'gcx hir::Expr,
+ expected: Ty<'tcx>,
+ needs: Needs)
+ -> Ty<'tcx> {
+ let ty = self.check_expr_with_expectation_and_needs(
expr,
ExpectHasType(expected),
- lvalue_pref);
+ needs);
self.demand_coerce(expr, ty, expected)
}
fn check_expr_with_expectation(&self,
expr: &'gcx hir::Expr,
expected: Expectation<'tcx>) -> Ty<'tcx> {
- self.check_expr_with_expectation_and_lvalue_pref(expr, expected, NoPreference)
+ self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
}
fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
self.check_expr_with_expectation(expr, NoExpectation)
}
- fn check_expr_with_lvalue_pref(&self, expr: &'gcx hir::Expr,
- lvalue_pref: LvaluePreference) -> Ty<'tcx> {
- self.check_expr_with_expectation_and_lvalue_pref(expr, NoExpectation, lvalue_pref)
+ fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
+ self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
}
// determine the `self` type, using fresh variables for all variables
span: Span,
args: &'gcx [hir::Expr],
expected: Expectation<'tcx>,
- lvalue_pref: LvaluePreference) -> Ty<'tcx> {
+ needs: Needs) -> Ty<'tcx> {
let rcvr = &args[0];
- let rcvr_t = self.check_expr_with_lvalue_pref(&rcvr, lvalue_pref);
+ let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
// no need to check for bot/err -- callee does that
let rcvr_t = self.structurally_resolved_type(expr.span, rcvr_t);
// Check field access expressions
fn check_field(&self,
expr: &'gcx hir::Expr,
- lvalue_pref: LvaluePreference,
+ needs: Needs,
base: &'gcx hir::Expr,
field: &Spanned<ast::Name>) -> Ty<'tcx> {
- let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
+ let expr_t = self.check_expr_with_needs(base, needs);
let expr_t = self.structurally_resolved_type(expr.span,
expr_t);
let mut private_candidate = None;
if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
let field_ty = self.field_ty(expr.span, field, substs);
if field.vis.is_accessible_from(def_scope, self.tcx) {
- let adjustments = autoderef.adjust_steps(lvalue_pref);
+ let adjustments = autoderef.adjust_steps(needs);
self.apply_adjustments(base, adjustments);
autoderef.finalize();
// Check tuple index expressions
fn check_tup_field(&self,
expr: &'gcx hir::Expr,
- lvalue_pref: LvaluePreference,
+ needs: Needs,
base: &'gcx hir::Expr,
idx: codemap::Spanned<usize>) -> Ty<'tcx> {
- let expr_t = self.check_expr_with_lvalue_pref(base, lvalue_pref);
+ let expr_t = self.check_expr_with_needs(base, needs);
let expr_t = self.structurally_resolved_type(expr.span,
expr_t);
let mut private_candidate = None;
};
if let Some(field_ty) = field {
- let adjustments = autoderef.adjust_steps(lvalue_pref);
+ let adjustments = autoderef.adjust_steps(needs);
self.apply_adjustments(base, adjustments);
autoderef.finalize();
return field_ty;
/// Note that inspecting a type's structure *directly* may expose the fact
/// that there are actually multiple representations for `TyError`, so avoid
/// that when err needs to be handled differently.
- fn check_expr_with_expectation_and_lvalue_pref(&self,
+ fn check_expr_with_expectation_and_needs(&self,
expr: &'gcx hir::Expr,
expected: Expectation<'tcx>,
- lvalue_pref: LvaluePreference) -> Ty<'tcx> {
+ needs: Needs) -> Ty<'tcx> {
debug!(">> typechecking: expr={:?} expected={:?}",
expr, expected);
self.diverges.set(Diverges::Maybe);
self.has_errors.set(false);
- let ty = self.check_expr_kind(expr, expected, lvalue_pref);
+ let ty = self.check_expr_kind(expr, expected, needs);
// Warn for non-block expressions with diverging children.
match expr.node {
fn check_expr_kind(&self,
expr: &'gcx hir::Expr,
expected: Expectation<'tcx>,
- lvalue_pref: LvaluePreference) -> Ty<'tcx> {
+ needs: Needs) -> Ty<'tcx> {
let tcx = self.tcx;
let id = expr.id;
match expr.node {
NoExpectation
}
};
- let lvalue_pref = match unop {
- hir::UnDeref => lvalue_pref,
- _ => NoPreference
+ let needs = match unop {
+ hir::UnDeref => needs,
+ _ => Needs::None
};
- let mut oprnd_t = self.check_expr_with_expectation_and_lvalue_pref(&oprnd,
+ let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
expected_inner,
- lvalue_pref);
+ needs);
if !oprnd_t.references_error() {
oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
match unop {
hir::UnDeref => {
- if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
+ if let Some(mt) = oprnd_t.builtin_deref(true) {
oprnd_t = mt.ty;
} else if let Some(ok) = self.try_overloaded_deref(
- expr.span, oprnd_t, lvalue_pref) {
+ expr.span, oprnd_t, needs) {
let method = self.register_infer_ok_obligations(ok);
if let ty::TyRef(region, mt) = method.sig.inputs()[0].sty {
self.apply_adjustments(oprnd, vec![Adjustment {
target: method.sig.inputs()[0]
}]);
}
- oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
+ oprnd_t = self.make_overloaded_place_return_type(method).ty;
self.write_method_call(expr.hir_id, method);
} else {
type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
match ty.sty {
ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => {
- if self.tcx.expr_is_lval(&oprnd) {
- // Lvalues may legitimately have unsized types.
+ if self.is_place_expr(&oprnd) {
+ // Places may legitimately have unsized types.
// For example, dereferences of a fat pointer and
// the last field of a struct can be unsized.
ExpectHasType(mt.ty)
_ => NoExpectation
}
});
- let lvalue_pref = LvaluePreference::from_mutbl(mutbl);
- let ty = self.check_expr_with_expectation_and_lvalue_pref(&oprnd, hint, lvalue_pref);
+ let needs = Needs::maybe_mut_place(mutbl);
+ let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
if tm.ty.references_error() {
tcx.types.never
}
hir::ExprAssign(ref lhs, ref rhs) => {
- let lhs_ty = self.check_expr_with_lvalue_pref(&lhs, PreferMutLvalue);
+ let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
_ => {
// Only check this if not in an `if` condition, as the
// mistyped comparison help is more appropriate.
- if !self.tcx.expr_is_lval(&lhs) {
+ if !self.is_place_expr(&lhs) {
struct_span_err!(self.tcx.sess, expr.span, E0070,
"invalid left-hand side expression")
.span_label(expr.span, "left-hand of expression not valid")
self.check_call(expr, &callee, args, expected)
}
hir::ExprMethodCall(ref segment, span, ref args) => {
- self.check_method_call(expr, segment, span, args, expected, lvalue_pref)
+ self.check_method_call(expr, segment, span, args, expected, needs)
}
hir::ExprCast(ref e, ref t) => {
// Find the type of `e`. Supply hints based on the type we are casting to,
self.check_expr_struct(expr, expected, qpath, fields, base_expr)
}
hir::ExprField(ref base, ref field) => {
- self.check_field(expr, lvalue_pref, &base, field)
+ self.check_field(expr, needs, &base, field)
}
hir::ExprTupField(ref base, idx) => {
- self.check_tup_field(expr, lvalue_pref, &base, idx)
+ self.check_tup_field(expr, needs, &base, idx)
}
hir::ExprIndex(ref base, ref idx) => {
- let base_t = self.check_expr_with_lvalue_pref(&base, lvalue_pref);
+ let base_t = self.check_expr_with_needs(&base, needs);
let idx_t = self.check_expr(&idx);
if base_t.references_error() {
idx_t
} else {
let base_t = self.structurally_resolved_type(expr.span, base_t);
- match self.lookup_indexing(expr, base, base_t, idx_t, lvalue_pref) {
+ match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
Some((index_ty, element_ty)) => {
self.demand_coerce(idx, idx_t, index_ty);
element_ty
// ref mut, for soundness (issue #23116). In particular, in
// the latter case, we need to be clear that the type of the
// referent for the reference that results is *equal to* the
- // type of the lvalue it is referencing, and not some
+ // type of the place it is referencing, and not some
// supertype thereof.
- let init_ty = self.check_expr_with_lvalue_pref(init, LvaluePreference::from_mutbl(m));
+ let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
self.demand_eqtype(init.span, local_ty, init_ty);
init_ty
} else {
/// statement and the return type has been left as default or has been specified as `()`. If so,
/// it suggests adding a semicolon.
fn suggest_missing_semicolon(&self,
- err: &mut DiagnosticBuilder<'tcx>,
- expression: &'gcx hir::Expr,
- expected: Ty<'tcx>,
- cause_span: Span) {
+ err: &mut DiagnosticBuilder<'tcx>,
+ expression: &'gcx hir::Expr,
+ expected: Ty<'tcx>,
+ cause_span: Span) {
if expected.is_nil() {
// `BlockTailExpression` only relevant if the tail expr would be
// useful on its own.
hir::ExprLoop(..) |
hir::ExprMatch(..) |
hir::ExprBlock(..) => {
- let sp = cause_span.next_point();
+ let sp = self.tcx.sess.codemap().next_point(cause_span);
err.span_suggestion(sp,
"try adding a semicolon",
";".to_string());
let lifetime_count = generics.lifetimes().count();
for leaf_ty in ty.walk() {
- if let ty::TyParam(ParamTy {idx, ..}) = leaf_ty.sty {
+ if let ty::TyParam(ty::ParamTy {idx, ..}) = leaf_ty.sty {
debug!("Found use of ty param num {}", idx);
tps_used[idx as usize - lifetime_count] = true;
} else if let ty::TyError = leaf_ty.sty {
//! Code related to processing overloaded binary and unary operators.
-use super::FnCtxt;
+use super::{FnCtxt, Needs};
use super::method::MethodCallee;
-use rustc::ty::{self, Ty, TypeFoldable, NoPreference, PreferMutLvalue, TypeVariants};
+use rustc::ty::{self, Ty, TypeFoldable, TypeVariants};
use rustc::ty::TypeVariants::{TyStr, TyRef};
use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow};
use rustc::infer::type_variable::TypeVariableOrigin;
return_ty
};
- let tcx = self.tcx;
- if !tcx.expr_is_lval(lhs_expr) {
+ if !self.is_place_expr(lhs_expr) {
struct_span_err!(
- tcx.sess, lhs_expr.span,
+ self.tcx.sess, lhs_expr.span,
E0067, "invalid left-hand side expression")
.span_label(
lhs_expr.span,
op,
is_assign);
- let lhs_pref = match is_assign {
- IsAssign::Yes => PreferMutLvalue,
- IsAssign::No => NoPreference
+ let lhs_needs = match is_assign {
+ IsAssign::Yes => Needs::MutPlace,
+ IsAssign::No => Needs::None
};
// Find a suitable supertype of the LHS expression's type, by coercing to
// a type variable, to pass as the `Self` to the trait, avoiding invariant
// trait matching creating lifetime constraints that are too strict.
// E.g. adding `&'a T` and `&'b T`, given `&'x T: Add<&'x T>`, will result
// in `&'a T <: &'x T` and `&'b T <: &'x T`, instead of `'a = 'b = 'x`.
- let lhs_ty = self.check_expr_coercable_to_type_with_lvalue_pref(lhs_expr,
+ let lhs_ty = self.check_expr_coercable_to_type_with_needs(lhs_expr,
self.next_ty_var(TypeVariableOrigin::MiscVariable(lhs_expr.span)),
- lhs_pref);
+ lhs_needs);
let lhs_ty = self.resolve_type_vars_with_obligations(lhs_ty);
// NB: As we have not yet type-checked the RHS, we don't have the
for (i, &impl1_def_id) in impls.iter().enumerate() {
for &impl2_def_id in &impls[(i + 1)..] {
- let used_to_be_allowed = self.tcx.infer_ctxt().enter(|infcx| {
- if let Some(overlap) =
- traits::overlapping_impls(&infcx, impl1_def_id, impl2_def_id,
- IntercrateMode::Issue43355)
- {
+ let used_to_be_allowed = traits::overlapping_impls(
+ self.tcx,
+ impl1_def_id,
+ impl2_def_id,
+ IntercrateMode::Issue43355,
+ |overlap| {
self.check_for_common_items_in_impls(
- impl1_def_id, impl2_def_id, overlap, false);
+ impl1_def_id,
+ impl2_def_id,
+ overlap,
+ false,
+ );
false
- } else {
- true
- }
- });
+ },
+ || true,
+ );
if used_to_be_allowed {
- self.tcx.infer_ctxt().enter(|infcx| {
- if let Some(overlap) =
- traits::overlapping_impls(&infcx, impl1_def_id, impl2_def_id,
- IntercrateMode::Fixed)
- {
- self.check_for_common_items_in_impls(
- impl1_def_id, impl2_def_id, overlap, true);
- }
- });
+ traits::overlapping_impls(
+ self.tcx,
+ impl1_def_id,
+ impl2_def_id,
+ IntercrateMode::Fixed,
+ |overlap| self.check_for_common_items_in_impls(
+ impl1_def_id,
+ impl2_def_id,
+ overlap,
+ true,
+ ),
+ || (),
+ );
}
}
}
"##,
E0067: r##"
-The left-hand side of a compound assignment expression must be an lvalue
-expression. An lvalue expression represents a memory location and includes
+The left-hand side of a compound assignment expression must be a place
+expression. A place expression represents a memory location and includes
item paths (ie, namespaced variables), dereferences, indexing expressions,
and field references.
```compile_fail,E0067
use std::collections::LinkedList;
-// Bad: assignment to non-lvalue expression
+// Bad: assignment to non-place expression
LinkedList::new() += 1;
// ...
"##,
E0070: r##"
-The left-hand side of an assignment operator must be an lvalue expression. An
-lvalue expression represents a memory location and can be a variable (with
+The left-hand side of an assignment operator must be a place expression. An
+place expression represents a memory location and can be a variable (with
optional namespacing), a dereference, an indexing expression or a field
reference.
More details can be found in the [Expressions] section of the Reference.
-[Expressions]: https://doc.rust-lang.org/reference/expressions.html#lvalues-rvalues-and-temporaries
+[Expressions]: https://doc.rust-lang.org/reference/expressions.html#places-rvalues-and-temporaries
Now, we can go further. Here are some erroneous code examples:
fn some_function() {
SOME_CONST = 14; // error : a constant value cannot be changed!
- 1 = 3; // error : 1 isn't a valid lvalue!
+ 1 = 3; // error : 1 isn't a valid place!
some_other_func() = 4; // error : we can't assign value to a function!
SomeStruct.x = 12; // error : SomeStruct a structure name but it is used
// like a variable!
// except according to those terms.
use rustc_lint;
-use rustc_driver::{driver, target_features, abort_on_err};
+use rustc_driver::{self, driver, target_features, abort_on_err};
use rustc::session::{self, config};
use rustc::hir::def_id::DefId;
use rustc::hir::def::Def;
use rustc::hir::map as hir_map;
use rustc::lint;
use rustc::util::nodemap::FxHashMap;
-use rustc_trans;
use rustc_resolve as resolve;
use rustc_metadata::creader::CrateLoader;
use rustc_metadata::cstore::CStore;
let mut sess = session::build_session_(
sessopts, cpath, diagnostic_handler, codemap,
);
- let trans = rustc_trans::LlvmTransCrate::new(&sess);
+ let trans = rustc_driver::get_trans(&sess);
let cstore = Rc::new(CStore::new(trans.metadata_loader()));
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
let link_out = format!("<a href=\"{link}\"{title}>{content}</a>",
link = link_buf,
title = title.map_or(String::new(),
- |t| format!(" title=\"{}\"", t)),
+ |t| format!(" title=\"{}\"", Escape(&t))),
content = content.unwrap_or(String::new()));
unsafe { hoedown_buffer_put(ob, link_out.as_ptr(), link_out.len()); }
use std::process;
use std::sync::mpsc::channel;
-use rustc_driver::rustc_trans;
-
use externalfiles::ExternalHtml;
use rustc::session::search_paths::SearchPaths;
use rustc::session::config::{ErrorOutputType, RustcOptGroup, nightly_options,
use rustc_driver::driver::phase_2_configure_and_expand;
use rustc_metadata::cstore::CStore;
use rustc_resolve::MakeGlobMap;
-use rustc_trans;
use syntax::ast;
use syntax::codemap::CodeMap;
use syntax::feature_gate::UnstableFeatures;
let mut sess = session::build_session_(
sessopts, Some(input_path.to_owned()), handler, codemap.clone(),
);
- let trans = rustc_trans::LlvmTransCrate::new(&sess);
+ let trans = rustc_driver::get_trans(&sess);
let cstore = Rc::new(CStore::new(trans.metadata_loader()));
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
sess.parse_sess.config =
));
let emitter = errors::emitter::EmitterWriter::new(box Sink(data.clone()),
Some(codemap.clone()),
+ false,
false);
let old = io::set_panic(Some(box Sink(data.clone())));
let _bomb = Bomb(data.clone(), old.unwrap_or(box io::stdout()));
let mut sess = session::build_session_(
sessopts, None, diagnostic_handler, codemap,
);
- let trans = rustc_trans::LlvmTransCrate::new(&sess);
+ let trans = rustc_driver::get_trans(&sess);
let cstore = Rc::new(CStore::new(trans.metadata_loader()));
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
force_alloc_system = []
panic-unwind = ["panic_unwind"]
profiler = ["profiler_builtins"]
+wasm_syscall = []
{
type Output = V;
+ /// Returns a reference to the value corresponding to the supplied key.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the key is not present in the `HashMap`.
#[inline]
- fn index(&self, index: &Q) -> &V {
- self.get(index).expect("no entry found for key")
+ fn index(&self, key: &Q) -> &V {
+ self.get(key).expect("no entry found for key")
}
}
/// # if cfg!(target_os = "linux") {
/// use std::io;
///
- /// let error = io::Error::from_raw_os_error(98);
- /// assert_eq!(error.kind(), io::ErrorKind::AddrInUse);
+ /// let error = io::Error::from_raw_os_error(22);
+ /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
/// # }
/// ```
///
/// # if cfg!(windows) {
/// use std::io;
///
- /// let error = io::Error::from_raw_os_error(10048);
- /// assert_eq!(error.kind(), io::ErrorKind::AddrInUse);
+ /// let error = io::Error::from_raw_os_error(10022);
+ /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
/// # }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
}
assert!(events > 0);
}
+
+ #[test]
+ fn test_command_implements_send() {
+ fn take_send_type<T: Send>(_: T) {}
+ take_send_type(Command::new(""))
+ }
}
// other keys.
program: CString,
args: Vec<CString>,
- argv: Vec<*const c_char>,
+ argv: Argv,
env: CommandEnv<DefaultEnvKey>,
cwd: Option<CString>,
stderr: Option<Stdio>,
}
+// Create a new type for argv, so that we can make it `Send`
+struct Argv(Vec<*const c_char>);
+
+// It is safe to make Argv Send, because it contains pointers to memory owned by `Command.args`
+unsafe impl Send for Argv {}
+
// passed back to std::process with the pipes connected to the child, if any
// were requested
pub struct StdioPipes {
let mut saw_nul = false;
let program = os2c(program, &mut saw_nul);
Command {
- argv: vec![program.as_ptr(), ptr::null()],
+ argv: Argv(vec![program.as_ptr(), ptr::null()]),
program,
args: Vec::new(),
env: Default::default(),
// Overwrite the trailing NULL pointer in `argv` and then add a new null
// pointer.
let arg = os2c(arg, &mut self.saw_nul);
- self.argv[self.args.len() + 1] = arg.as_ptr();
- self.argv.push(ptr::null());
+ self.argv.0[self.args.len() + 1] = arg.as_ptr();
+ self.argv.0.push(ptr::null());
// Also make sure we keep track of the owned value to schedule a
// destructor for this memory.
self.saw_nul
}
pub fn get_argv(&self) -> &Vec<*const c_char> {
- &self.argv
+ &self.argv.0
}
#[allow(dead_code)]
use ffi::OsString;
use marker::PhantomData;
-use mem;
use vec;
+use sys::ArgsSysCall;
pub unsafe fn init(_argc: isize, _argv: *const *const u8) {
// On wasm these should always be null, so there's nothing for us to do here
}
pub fn args() -> Args {
- // When the runtime debugging is enabled we'll link to some extra runtime
- // functions to actually implement this. These are for now just implemented
- // in a node.js script but they're off by default as they're sort of weird
- // in a web-wasm world.
- if !super::DEBUG {
- return Args {
- iter: Vec::new().into_iter(),
- _dont_send_or_sync_me: PhantomData,
- }
- }
-
- // You'll find the definitions of these in `src/etc/wasm32-shim.js`. These
- // are just meant for debugging and should not be relied on.
- extern {
- fn rust_wasm_args_count() -> usize;
- fn rust_wasm_args_arg_size(a: usize) -> usize;
- fn rust_wasm_args_arg_fill(a: usize, ptr: *mut u8);
- }
-
- unsafe {
- let cnt = rust_wasm_args_count();
- let mut v = Vec::with_capacity(cnt);
- for i in 0..cnt {
- let n = rust_wasm_args_arg_size(i);
- let mut data = vec![0; n];
- rust_wasm_args_arg_fill(i, data.as_mut_ptr());
- v.push(mem::transmute::<Vec<u8>, OsString>(data));
- }
- Args {
- iter: v.into_iter(),
- _dont_send_or_sync_me: PhantomData,
- }
+ let v = ArgsSysCall::perform();
+ Args {
+ iter: v.into_iter(),
+ _dont_send_or_sync_me: PhantomData,
}
}
use io;
use os::raw::c_char;
-
-// Right now the wasm backend doesn't even have the ability to print to the
-// console by default. Wasm can't import anything from JS! (you have to
-// explicitly provide it).
-//
-// Sometimes that's a real bummer, though, so this flag can be set to `true` to
-// enable calling various shims defined in `src/etc/wasm32-shim.js` which should
-// help receive debug output and see what's going on. In general this flag
-// currently controls "will we call out to our own defined shims in node.js",
-// and this flag should always be `false` for release builds.
-const DEBUG: bool = false;
+use ptr;
+use sys::os_str::Buf;
+use sys_common::{AsInner, FromInner};
+use ffi::{OsString, OsStr};
+use time::Duration;
pub mod args;
#[cfg(feature = "backtrace")]
}
pub unsafe fn abort_internal() -> ! {
- ::intrinsics::abort();
+ ExitSysCall::perform(1)
}
// We don't have randomness yet, but I totally used a random number generator to
pub fn hashmap_random_keys() -> (u64, u64) {
(1, 2)
}
+
+// Implement a minimal set of system calls to enable basic IO
+pub enum SysCallIndex {
+ Read = 0,
+ Write = 1,
+ Exit = 2,
+ Args = 3,
+ GetEnv = 4,
+ SetEnv = 5,
+ Time = 6,
+}
+
+#[repr(C)]
+pub struct ReadSysCall {
+ fd: usize,
+ ptr: *mut u8,
+ len: usize,
+ result: usize,
+}
+
+impl ReadSysCall {
+ pub fn perform(fd: usize, buffer: &mut [u8]) -> usize {
+ let mut call_record = ReadSysCall {
+ fd,
+ len: buffer.len(),
+ ptr: buffer.as_mut_ptr(),
+ result: 0
+ };
+ if unsafe { syscall(SysCallIndex::Read, &mut call_record) } {
+ call_record.result
+ } else {
+ 0
+ }
+ }
+}
+
+#[repr(C)]
+pub struct WriteSysCall {
+ fd: usize,
+ ptr: *const u8,
+ len: usize,
+}
+
+impl WriteSysCall {
+ pub fn perform(fd: usize, buffer: &[u8]) {
+ let mut call_record = WriteSysCall {
+ fd,
+ len: buffer.len(),
+ ptr: buffer.as_ptr()
+ };
+ unsafe { syscall(SysCallIndex::Write, &mut call_record); }
+ }
+}
+
+#[repr(C)]
+pub struct ExitSysCall {
+ code: usize,
+}
+
+impl ExitSysCall {
+ pub fn perform(code: usize) -> ! {
+ let mut call_record = ExitSysCall {
+ code
+ };
+ unsafe {
+ syscall(SysCallIndex::Exit, &mut call_record);
+ ::intrinsics::abort();
+ }
+ }
+}
+
+fn receive_buffer<E, F: FnMut(&mut [u8]) -> Result<usize, E>>(estimate: usize, mut f: F)
+ -> Result<Vec<u8>, E>
+{
+ let mut buffer = vec![0; estimate];
+ loop {
+ let result = f(&mut buffer)?;
+ if result <= buffer.len() {
+ buffer.truncate(result);
+ break;
+ }
+ buffer.resize(result, 0);
+ }
+ Ok(buffer)
+}
+
+#[repr(C)]
+pub struct ArgsSysCall {
+ ptr: *mut u8,
+ len: usize,
+ result: usize
+}
+
+impl ArgsSysCall {
+ pub fn perform() -> Vec<OsString> {
+ receive_buffer(1024, |buffer| -> Result<usize, !> {
+ let mut call_record = ArgsSysCall {
+ len: buffer.len(),
+ ptr: buffer.as_mut_ptr(),
+ result: 0
+ };
+ if unsafe { syscall(SysCallIndex::Args, &mut call_record) } {
+ Ok(call_record.result)
+ } else {
+ Ok(0)
+ }
+ })
+ .unwrap()
+ .split(|b| *b == 0)
+ .map(|s| FromInner::from_inner(Buf { inner: s.to_owned() }))
+ .collect()
+ }
+}
+
+#[repr(C)]
+pub struct GetEnvSysCall {
+ key_ptr: *const u8,
+ key_len: usize,
+ value_ptr: *mut u8,
+ value_len: usize,
+ result: usize
+}
+
+impl GetEnvSysCall {
+ pub fn perform(key: &OsStr) -> Option<OsString> {
+ let key_buf = &AsInner::as_inner(key).inner;
+ receive_buffer(64, |buffer| {
+ let mut call_record = GetEnvSysCall {
+ key_len: key_buf.len(),
+ key_ptr: key_buf.as_ptr(),
+ value_len: buffer.len(),
+ value_ptr: buffer.as_mut_ptr(),
+ result: !0usize
+ };
+ if unsafe { syscall(SysCallIndex::GetEnv, &mut call_record) } {
+ if call_record.result == !0usize {
+ Err(())
+ } else {
+ Ok(call_record.result)
+ }
+ } else {
+ Err(())
+ }
+ }).ok().map(|s| {
+ FromInner::from_inner(Buf { inner: s })
+ })
+ }
+}
+
+#[repr(C)]
+pub struct SetEnvSysCall {
+ key_ptr: *const u8,
+ key_len: usize,
+ value_ptr: *const u8,
+ value_len: usize
+}
+
+impl SetEnvSysCall {
+ pub fn perform(key: &OsStr, value: Option<&OsStr>) {
+ let key_buf = &AsInner::as_inner(key).inner;
+ let value_buf = value.map(|v| &AsInner::as_inner(v).inner);
+ let mut call_record = SetEnvSysCall {
+ key_len: key_buf.len(),
+ key_ptr: key_buf.as_ptr(),
+ value_len: value_buf.map(|v| v.len()).unwrap_or(!0usize),
+ value_ptr: value_buf.map(|v| v.as_ptr()).unwrap_or(ptr::null())
+ };
+ unsafe { syscall(SysCallIndex::SetEnv, &mut call_record); }
+ }
+}
+
+pub enum TimeClock {
+ Monotonic = 0,
+ System = 1,
+}
+
+#[repr(C)]
+pub struct TimeSysCall {
+ clock: usize,
+ secs_hi: usize,
+ secs_lo: usize,
+ nanos: usize
+}
+
+impl TimeSysCall {
+ pub fn perform(clock: TimeClock) -> Duration {
+ let mut call_record = TimeSysCall {
+ clock: clock as usize,
+ secs_hi: 0,
+ secs_lo: 0,
+ nanos: 0
+ };
+ if unsafe { syscall(SysCallIndex::Time, &mut call_record) } {
+ Duration::new(
+ ((call_record.secs_hi as u64) << 32) | (call_record.secs_lo as u64),
+ call_record.nanos as u32
+ )
+ } else {
+ panic!("Time system call is not implemented by WebAssembly host");
+ }
+ }
+}
+
+unsafe fn syscall<T>(index: SysCallIndex, data: &mut T) -> bool {
+ #[cfg(feature = "wasm_syscall")]
+ extern {
+ #[no_mangle]
+ fn rust_wasm_syscall(index: usize, data: *mut Void) -> usize;
+ }
+
+ #[cfg(not(feature = "wasm_syscall"))]
+ unsafe fn rust_wasm_syscall(_index: usize, _data: *mut Void) -> usize { 0 }
+
+ rust_wasm_syscall(index as usize, data as *mut T as *mut Void) != 0
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use core::intrinsics;
-
use error::Error as StdError;
use ffi::{OsString, OsStr};
use fmt;
use io;
-use mem;
use path::{self, PathBuf};
use str;
-use sys::{unsupported, Void};
+use sys::{unsupported, Void, ExitSysCall, GetEnvSysCall, SetEnvSysCall};
pub fn errno() -> i32 {
0
}
pub fn getenv(k: &OsStr) -> io::Result<Option<OsString>> {
- // If we're debugging the runtime then we actually probe node.js to ask for
- // the value of environment variables to help provide inputs to programs.
- // The `extern` shims here are defined in `src/etc/wasm32-shim.js` and are
- // intended for debugging only, you should not rely on them.
- if !super::DEBUG {
- return Ok(None)
- }
-
- extern {
- fn rust_wasm_getenv_len(k: *const u8, kl: usize) -> isize;
- fn rust_wasm_getenv_data(k: *const u8, kl: usize, v: *mut u8);
- }
- unsafe {
- let k: &[u8] = mem::transmute(k);
- let n = rust_wasm_getenv_len(k.as_ptr(), k.len());
- if n == -1 {
- return Ok(None)
- }
- let mut data = vec![0; n as usize];
- rust_wasm_getenv_data(k.as_ptr(), k.len(), data.as_mut_ptr());
- Ok(Some(mem::transmute(data)))
- }
+ Ok(GetEnvSysCall::perform(k))
}
-pub fn setenv(_k: &OsStr, _v: &OsStr) -> io::Result<()> {
- unsupported()
+pub fn setenv(k: &OsStr, v: &OsStr) -> io::Result<()> {
+ Ok(SetEnvSysCall::perform(k, Some(v)))
}
-pub fn unsetenv(_n: &OsStr) -> io::Result<()> {
- unsupported()
+pub fn unsetenv(k: &OsStr) -> io::Result<()> {
+ Ok(SetEnvSysCall::perform(k, None))
}
pub fn temp_dir() -> PathBuf {
}
pub fn exit(_code: i32) -> ! {
- unsafe { intrinsics::abort() }
+ ExitSysCall::perform(_code as isize as usize)
}
pub fn getpid() -> u32 {
// except according to those terms.
use io;
-use sys::{Void, unsupported};
+use sys::{ReadSysCall, WriteSysCall};
-pub struct Stdin(Void);
+pub struct Stdin;
pub struct Stdout;
pub struct Stderr;
impl Stdin {
pub fn new() -> io::Result<Stdin> {
- unsupported()
+ Ok(Stdin)
}
- pub fn read(&self, _data: &mut [u8]) -> io::Result<usize> {
- match self.0 {}
+ pub fn read(&self, data: &mut [u8]) -> io::Result<usize> {
+ Ok(ReadSysCall::perform(0, data))
}
}
}
pub fn write(&self, data: &[u8]) -> io::Result<usize> {
- // If runtime debugging is enabled at compile time we'll invoke some
- // runtime functions that are defined in our src/etc/wasm32-shim.js
- // debugging script. Note that this ffi function call is intended
- // *purely* for debugging only and should not be relied upon.
- if !super::DEBUG {
- return unsupported()
- }
- extern {
- fn rust_wasm_write_stdout(data: *const u8, len: usize);
- }
- unsafe {
- rust_wasm_write_stdout(data.as_ptr(), data.len())
- }
+ WriteSysCall::perform(1, data);
Ok(data.len())
}
}
pub fn write(&self, data: &[u8]) -> io::Result<usize> {
- // See comments in stdout for what's going on here.
- if !super::DEBUG {
- return unsupported()
- }
- extern {
- fn rust_wasm_write_stderr(data: *const u8, len: usize);
- }
- unsafe {
- rust_wasm_write_stderr(data.as_ptr(), data.len())
- }
+ WriteSysCall::perform(2, data);
Ok(data.len())
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use fmt;
use time::Duration;
+use sys::{TimeSysCall, TimeClock};
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-pub struct Instant;
+pub struct Instant(Duration);
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct SystemTime;
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+pub struct SystemTime(Duration);
-pub const UNIX_EPOCH: SystemTime = SystemTime;
+pub const UNIX_EPOCH: SystemTime = SystemTime(Duration::from_secs(0));
impl Instant {
pub fn now() -> Instant {
- panic!("not supported on web assembly");
+ Instant(TimeSysCall::perform(TimeClock::Monotonic))
}
- pub fn sub_instant(&self, _other: &Instant) -> Duration {
- panic!("can't sub yet");
+ pub fn sub_instant(&self, other: &Instant) -> Duration {
+ self.0 - other.0
}
- pub fn add_duration(&self, _other: &Duration) -> Instant {
- panic!("can't add yet");
+ pub fn add_duration(&self, other: &Duration) -> Instant {
+ Instant(self.0 + *other)
}
- pub fn sub_duration(&self, _other: &Duration) -> Instant {
- panic!("can't sub yet");
+ pub fn sub_duration(&self, other: &Duration) -> Instant {
+ Instant(self.0 - *other)
}
}
impl SystemTime {
pub fn now() -> SystemTime {
- panic!("not supported on web assembly");
+ SystemTime(TimeSysCall::perform(TimeClock::System))
}
- pub fn sub_time(&self, _other: &SystemTime)
+ pub fn sub_time(&self, other: &SystemTime)
-> Result<Duration, Duration> {
- panic!()
- }
-
- pub fn add_duration(&self, _other: &Duration) -> SystemTime {
- panic!()
+ self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
}
- pub fn sub_duration(&self, _other: &Duration) -> SystemTime {
- panic!()
+ pub fn add_duration(&self, other: &Duration) -> SystemTime {
+ SystemTime(self.0 + *other)
}
-}
-impl fmt::Debug for SystemTime {
- fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {
- panic!()
+ pub fn sub_duration(&self, other: &Duration) -> SystemTime {
+ SystemTime(self.0 - *other)
}
}
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Temporal quantification.
+//!
+//! Example:
+//!
+//! ```
+//! use std::time::Duration;
+//!
+//! let five_seconds = Duration::new(5, 0);
+//! // both declarations are equivalent
+//! assert_eq!(Duration::new(5, 0), Duration::from_secs(5));
+//! ```
+
+#![stable(feature = "time", since = "1.3.0")]
+
+use error::Error;
+use fmt;
+use ops::{Add, Sub, AddAssign, SubAssign};
+use sys::time;
+use sys_common::FromInner;
+
+#[stable(feature = "time", since = "1.3.0")]
+pub use core::time::Duration;
+
+/// A measurement of a monotonically nondecreasing clock.
+/// Opaque and useful only with `Duration`.
+///
+/// Instants are always guaranteed to be no less than any previously measured
+/// 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
+/// 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
+/// backwards.
+///
+/// Instants are opaque types that can only be compared to one another. There is
+/// no method to get "the number of seconds" from an instant. Instead, it only
+/// allows measuring the duration between two instants (or comparing two
+/// instants).
+///
+/// Example:
+///
+/// ```no_run
+/// use std::time::{Duration, Instant};
+/// use std::thread::sleep;
+///
+/// fn main() {
+/// let now = Instant::now();
+///
+/// // we sleep for 2 seconds
+/// sleep(Duration::new(2, 0));
+/// // it prints '2'
+/// println!("{}", now.elapsed().as_secs());
+/// }
+/// ```
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[stable(feature = "time2", since = "1.8.0")]
+pub struct Instant(time::Instant);
+
+/// A measurement of the system clock, useful for talking to
+/// external entities like the file system or other processes.
+///
+/// Distinct from the [`Instant`] type, this time measurement **is not
+/// monotonic**. This means that you can save a file to the file system, then
+/// save another file to the file system, **and the second file has a
+/// `SystemTime` measurement earlier than the first**. In other words, an
+/// operation that happens after another operation in real time may have an
+/// earlier `SystemTime`!
+///
+/// Consequently, comparing two `SystemTime` instances to learn about the
+/// duration between them returns a [`Result`] instead of an infallible [`Duration`]
+/// to indicate that this sort of time drift may happen and needs to be handled.
+///
+/// Although a `SystemTime` cannot be directly inspected, the [`UNIX_EPOCH`]
+/// constant is provided in this module as an anchor in time to learn
+/// information about a `SystemTime`. By calculating the duration from this
+/// fixed point in time, a `SystemTime` can be converted to a human-readable time,
+/// or perhaps some other string representation.
+///
+/// [`Instant`]: ../../std/time/struct.Instant.html
+/// [`Result`]: ../../std/result/enum.Result.html
+/// [`Duration`]: ../../std/time/struct.Duration.html
+/// [`UNIX_EPOCH`]: ../../std/time/constant.UNIX_EPOCH.html
+///
+/// Example:
+///
+/// ```no_run
+/// use std::time::{Duration, SystemTime};
+/// use std::thread::sleep;
+///
+/// fn main() {
+/// let now = SystemTime::now();
+///
+/// // we sleep for 2 seconds
+/// sleep(Duration::new(2, 0));
+/// match now.elapsed() {
+/// Ok(elapsed) => {
+/// // it prints '2'
+/// println!("{}", elapsed.as_secs());
+/// }
+/// Err(e) => {
+/// // an error occurred!
+/// println!("Error: {:?}", e);
+/// }
+/// }
+/// }
+/// ```
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[stable(feature = "time2", since = "1.8.0")]
+pub struct SystemTime(time::SystemTime);
+
+/// An error returned from the `duration_since` and `elapsed` methods on
+/// `SystemTime`, used to learn how far in the opposite direction a system time
+/// lies.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::thread::sleep;
+/// use std::time::{Duration, SystemTime};
+///
+/// let sys_time = SystemTime::now();
+/// sleep(Duration::from_secs(1));
+/// let new_sys_time = SystemTime::now();
+/// match sys_time.duration_since(new_sys_time) {
+/// Ok(_) => {}
+/// Err(e) => println!("SystemTimeError difference: {:?}", e.duration()),
+/// }
+/// ```
+#[derive(Clone, Debug)]
+#[stable(feature = "time2", since = "1.8.0")]
+pub struct SystemTimeError(Duration);
+
+impl Instant {
+ /// Returns an instant corresponding to "now".
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::time::Instant;
+ ///
+ /// let now = Instant::now();
+ /// ```
+ #[stable(feature = "time2", since = "1.8.0")]
+ pub fn now() -> Instant {
+ Instant(time::Instant::now())
+ }
+
+ /// Returns the amount of time elapsed from another instant to this one.
+ ///
+ /// # Panics
+ ///
+ /// This function will panic if `earlier` is later than `self`.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::time::{Duration, Instant};
+ /// use std::thread::sleep;
+ ///
+ /// let now = Instant::now();
+ /// sleep(Duration::new(1, 0));
+ /// let new_now = Instant::now();
+ /// println!("{:?}", new_now.duration_since(now));
+ /// ```
+ #[stable(feature = "time2", since = "1.8.0")]
+ pub fn duration_since(&self, earlier: Instant) -> Duration {
+ self.0.sub_instant(&earlier.0)
+ }
+
+ /// Returns the amount of time elapsed since this instant was created.
+ ///
+ /// # Panics
+ ///
+ /// This function may panic if the current time is earlier than this
+ /// instant, which is something that can happen if an `Instant` is
+ /// produced synthetically.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::thread::sleep;
+ /// use std::time::{Duration, Instant};
+ ///
+ /// let instant = Instant::now();
+ /// let three_secs = Duration::from_secs(3);
+ /// sleep(three_secs);
+ /// assert!(instant.elapsed() >= three_secs);
+ /// ```
+ #[stable(feature = "time2", since = "1.8.0")]
+ pub fn elapsed(&self) -> Duration {
+ Instant::now() - *self
+ }
+}
+
+#[stable(feature = "time2", since = "1.8.0")]
+impl Add<Duration> for Instant {
+ type Output = Instant;
+
+ fn add(self, other: Duration) -> Instant {
+ Instant(self.0.add_duration(&other))
+ }
+}
+
+#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
+impl AddAssign<Duration> for Instant {
+ fn add_assign(&mut self, other: Duration) {
+ *self = *self + other;
+ }
+}
+
+#[stable(feature = "time2", since = "1.8.0")]
+impl Sub<Duration> for Instant {
+ type Output = Instant;
+
+ fn sub(self, other: Duration) -> Instant {
+ Instant(self.0.sub_duration(&other))
+ }
+}
+
+#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
+impl SubAssign<Duration> for Instant {
+ fn sub_assign(&mut self, other: Duration) {
+ *self = *self - other;
+ }
+}
+
+#[stable(feature = "time2", since = "1.8.0")]
+impl Sub<Instant> for Instant {
+ type Output = Duration;
+
+ fn sub(self, other: Instant) -> Duration {
+ self.duration_since(other)
+ }
+}
+
+#[stable(feature = "time2", since = "1.8.0")]
+impl fmt::Debug for Instant {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.0.fmt(f)
+ }
+}
+
+impl SystemTime {
+ /// Returns the system time corresponding to "now".
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::time::SystemTime;
+ ///
+ /// let sys_time = SystemTime::now();
+ /// ```
+ #[stable(feature = "time2", since = "1.8.0")]
+ pub fn now() -> SystemTime {
+ SystemTime(time::SystemTime::now())
+ }
+
+ /// Returns the amount of time elapsed from an earlier point in time.
+ ///
+ /// This function may fail because measurements taken earlier are not
+ /// guaranteed to always be before later measurements (due to anomalies such
+ /// as the system clock being adjusted either forwards or backwards).
+ ///
+ /// If successful, [`Ok`]`(`[`Duration`]`)` is returned where the duration represents
+ /// the amount of time elapsed from the specified measurement to this one.
+ ///
+ /// Returns an [`Err`] if `earlier` is later than `self`, and the error
+ /// contains how far from `self` the time is.
+ ///
+ /// [`Ok`]: ../../std/result/enum.Result.html#variant.Ok
+ /// [`Duration`]: ../../std/time/struct.Duration.html
+ /// [`Err`]: ../../std/result/enum.Result.html#variant.Err
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::time::SystemTime;
+ ///
+ /// let sys_time = SystemTime::now();
+ /// let difference = sys_time.duration_since(sys_time)
+ /// .expect("SystemTime::duration_since failed");
+ /// println!("{:?}", difference);
+ /// ```
+ #[stable(feature = "time2", since = "1.8.0")]
+ pub fn duration_since(&self, earlier: SystemTime)
+ -> Result<Duration, SystemTimeError> {
+ self.0.sub_time(&earlier.0).map_err(SystemTimeError)
+ }
+
+ /// Returns the amount of time elapsed since this system time was created.
+ ///
+ /// This function may fail as the underlying system clock is susceptible to
+ /// drift and updates (e.g. the system clock could go backwards), so this
+ /// function may not always succeed. If successful, [`Ok`]`(`[`Duration`]`)` is
+ /// returned where the duration represents the amount of time elapsed from
+ /// this time measurement to the current time.
+ ///
+ /// Returns an [`Err`] if `self` is later than the current system time, and
+ /// the error contains how far from the current system time `self` is.
+ ///
+ /// [`Ok`]: ../../std/result/enum.Result.html#variant.Ok
+ /// [`Duration`]: ../../std/time/struct.Duration.html
+ /// [`Err`]: ../../std/result/enum.Result.html#variant.Err
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::thread::sleep;
+ /// use std::time::{Duration, SystemTime};
+ ///
+ /// let sys_time = SystemTime::now();
+ /// let one_sec = Duration::from_secs(1);
+ /// sleep(one_sec);
+ /// assert!(sys_time.elapsed().unwrap() >= one_sec);
+ /// ```
+ #[stable(feature = "time2", since = "1.8.0")]
+ pub fn elapsed(&self) -> Result<Duration, SystemTimeError> {
+ SystemTime::now().duration_since(*self)
+ }
+}
+
+#[stable(feature = "time2", since = "1.8.0")]
+impl Add<Duration> for SystemTime {
+ type Output = SystemTime;
+
+ fn add(self, dur: Duration) -> SystemTime {
+ SystemTime(self.0.add_duration(&dur))
+ }
+}
+
+#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
+impl AddAssign<Duration> for SystemTime {
+ fn add_assign(&mut self, other: Duration) {
+ *self = *self + other;
+ }
+}
+
+#[stable(feature = "time2", since = "1.8.0")]
+impl Sub<Duration> for SystemTime {
+ type Output = SystemTime;
+
+ fn sub(self, dur: Duration) -> SystemTime {
+ SystemTime(self.0.sub_duration(&dur))
+ }
+}
+
+#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
+impl SubAssign<Duration> for SystemTime {
+ fn sub_assign(&mut self, other: Duration) {
+ *self = *self - other;
+ }
+}
+
+#[stable(feature = "time2", since = "1.8.0")]
+impl fmt::Debug for SystemTime {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.0.fmt(f)
+ }
+}
+
+/// An anchor in time which can be used to create new `SystemTime` instances or
+/// learn about where in time a `SystemTime` lies.
+///
+/// This constant is defined to be "1970-01-01 00:00:00 UTC" on all systems with
+/// respect to the system clock. Using `duration_since` on an existing
+/// [`SystemTime`] instance can tell how far away from this point in time a
+/// measurement lies, and using `UNIX_EPOCH + duration` can be used to create a
+/// [`SystemTime`] instance to represent another fixed point in time.
+///
+/// [`SystemTime`]: ../../std/time/struct.SystemTime.html
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::time::{SystemTime, UNIX_EPOCH};
+///
+/// match SystemTime::now().duration_since(UNIX_EPOCH) {
+/// Ok(n) => println!("1970-01-01 00:00:00 UTC was {} seconds ago!", n.as_secs()),
+/// Err(_) => panic!("SystemTime before UNIX EPOCH!"),
+/// }
+/// ```
+#[stable(feature = "time2", since = "1.8.0")]
+pub const UNIX_EPOCH: SystemTime = SystemTime(time::UNIX_EPOCH);
+
+impl SystemTimeError {
+ /// Returns the positive duration which represents how far forward the
+ /// second system time was from the first.
+ ///
+ /// A `SystemTimeError` is returned from the [`duration_since`] and [`elapsed`]
+ /// methods of [`SystemTime`] whenever the second system time represents a point later
+ /// in time than the `self` of the method call.
+ ///
+ /// [`duration_since`]: ../../std/time/struct.SystemTime.html#method.duration_since
+ /// [`elapsed`]: ../../std/time/struct.SystemTime.html#method.elapsed
+ /// [`SystemTime`]: ../../std/time/struct.SystemTime.html
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::thread::sleep;
+ /// use std::time::{Duration, SystemTime};
+ ///
+ /// let sys_time = SystemTime::now();
+ /// sleep(Duration::from_secs(1));
+ /// let new_sys_time = SystemTime::now();
+ /// match sys_time.duration_since(new_sys_time) {
+ /// Ok(_) => {}
+ /// Err(e) => println!("SystemTimeError difference: {:?}", e.duration()),
+ /// }
+ /// ```
+ #[stable(feature = "time2", since = "1.8.0")]
+ pub fn duration(&self) -> Duration {
+ self.0
+ }
+}
+
+#[stable(feature = "time2", since = "1.8.0")]
+impl Error for SystemTimeError {
+ fn description(&self) -> &str { "other time was not earlier than self" }
+}
+
+#[stable(feature = "time2", since = "1.8.0")]
+impl fmt::Display for SystemTimeError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "second time provided was later than self")
+ }
+}
+
+impl FromInner<time::SystemTime> for SystemTime {
+ fn from_inner(time: time::SystemTime) -> SystemTime {
+ SystemTime(time)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::{Instant, SystemTime, Duration, UNIX_EPOCH};
+
+ macro_rules! assert_almost_eq {
+ ($a:expr, $b:expr) => ({
+ let (a, b) = ($a, $b);
+ if a != b {
+ let (a, b) = if a > b {(a, b)} else {(b, a)};
+ assert!(a - Duration::new(0, 100) <= b);
+ }
+ })
+ }
+
+ #[test]
+ fn instant_monotonic() {
+ let a = Instant::now();
+ let b = Instant::now();
+ assert!(b >= a);
+ }
+
+ #[test]
+ fn instant_elapsed() {
+ let a = Instant::now();
+ a.elapsed();
+ }
+
+ #[test]
+ fn instant_math() {
+ let a = Instant::now();
+ let b = Instant::now();
+ let dur = b.duration_since(a);
+ assert_almost_eq!(b - dur, a);
+ assert_almost_eq!(a + dur, b);
+
+ let second = Duration::new(1, 0);
+ assert_almost_eq!(a - second + second, a);
+ }
+
+ #[test]
+ #[should_panic]
+ fn instant_duration_panic() {
+ let a = Instant::now();
+ (a - Duration::new(1, 0)).duration_since(a);
+ }
+
+ #[test]
+ fn system_time_math() {
+ let a = SystemTime::now();
+ let b = SystemTime::now();
+ match b.duration_since(a) {
+ Ok(dur) if dur == Duration::new(0, 0) => {
+ assert_almost_eq!(a, b);
+ }
+ Ok(dur) => {
+ assert!(b > a);
+ assert_almost_eq!(b - dur, a);
+ assert_almost_eq!(a + dur, b);
+ }
+ Err(dur) => {
+ let dur = dur.duration();
+ assert!(a > b);
+ assert_almost_eq!(b + dur, a);
+ assert_almost_eq!(a - dur, b);
+ }
+ }
+
+ let second = Duration::new(1, 0);
+ assert_almost_eq!(a.duration_since(a - second).unwrap(), second);
+ assert_almost_eq!(a.duration_since(a + second).unwrap_err()
+ .duration(), second);
+
+ assert_almost_eq!(a - second + second, a);
+
+ // A difference of 80 and 800 years cannot fit inside a 32-bit time_t
+ if !(cfg!(unix) && ::mem::size_of::<::libc::time_t>() <= 4) {
+ let eighty_years = second * 60 * 60 * 24 * 365 * 80;
+ assert_almost_eq!(a - eighty_years + eighty_years, a);
+ assert_almost_eq!(a - (eighty_years * 10) + (eighty_years * 10), a);
+ }
+
+ let one_second_from_epoch = UNIX_EPOCH + Duration::new(1, 0);
+ let one_second_from_epoch2 = UNIX_EPOCH + Duration::new(0, 500_000_000)
+ + Duration::new(0, 500_000_000);
+ assert_eq!(one_second_from_epoch, one_second_from_epoch2);
+ }
+
+ #[test]
+ fn system_time_elapsed() {
+ let a = SystemTime::now();
+ drop(a.elapsed());
+ }
+
+ #[test]
+ fn since_epoch() {
+ let ts = SystemTime::now();
+ let a = ts.duration_since(UNIX_EPOCH).unwrap();
+ let b = ts.duration_since(UNIX_EPOCH - Duration::new(1, 0)).unwrap();
+ assert!(b > a);
+ assert_eq!(b - a, Duration::new(1, 0));
+
+ let thirty_years = Duration::new(1, 0) * 60 * 60 * 24 * 365 * 30;
+
+ // Right now for CI this test is run in an emulator, and apparently the
+ // aarch64 emulator's sense of time is that we're still living in the
+ // 70s.
+ //
+ // Otherwise let's assume that we're all running computers later than
+ // 2000.
+ if !cfg!(target_arch = "aarch64") {
+ assert!(a > thirty_years);
+ }
+
+ // let's assume that we're all running computers earlier than 2090.
+ // Should give us ~70 years to fix this!
+ let hundred_twenty_years = thirty_years * 4;
+ assert!(a < hundred_twenty_years);
+ }
+}
+++ /dev/null
-// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use iter::Sum;
-use ops::{Add, Sub, Mul, Div, AddAssign, SubAssign, MulAssign, DivAssign};
-
-const NANOS_PER_SEC: u32 = 1_000_000_000;
-const NANOS_PER_MILLI: u32 = 1_000_000;
-const NANOS_PER_MICRO: u32 = 1_000;
-const MILLIS_PER_SEC: u64 = 1_000;
-const MICROS_PER_SEC: u64 = 1_000_000;
-
-/// A `Duration` type to represent a span of time, typically used for system
-/// 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
-/// nanosecond-level precision, APIs binding a system timeout will typically round up
-/// the number of nanoseconds.
-///
-/// `Duration`s implement many common traits, including [`Add`], [`Sub`], and other
-/// [`ops`] traits.
-///
-/// [`Add`]: ../../std/ops/trait.Add.html
-/// [`Sub`]: ../../std/ops/trait.Sub.html
-/// [`ops`]: ../../std/ops/index.html
-///
-/// # Examples
-///
-/// ```
-/// use std::time::Duration;
-///
-/// let five_seconds = Duration::new(5, 0);
-/// let five_seconds_and_five_nanos = five_seconds + Duration::new(0, 5);
-///
-/// assert_eq!(five_seconds_and_five_nanos.as_secs(), 5);
-/// assert_eq!(five_seconds_and_five_nanos.subsec_nanos(), 5);
-///
-/// let ten_millis = Duration::from_millis(10);
-/// ```
-#[stable(feature = "duration", since = "1.3.0")]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash, Default)]
-pub struct Duration {
- secs: u64,
- nanos: u32, // Always 0 <= nanos < NANOS_PER_SEC
-}
-
-impl Duration {
- /// Creates a new `Duration` from the specified number of whole seconds and
- /// additional nanoseconds.
- ///
- /// If the number of nanoseconds is greater than 1 billion (the number of
- /// nanoseconds in a second), then it will carry over into the seconds provided.
- ///
- /// # Panics
- ///
- /// This constructor will panic if the carry from the nanoseconds overflows
- /// the seconds counter.
- ///
- /// # Examples
- ///
- /// ```
- /// use std::time::Duration;
- ///
- /// let five_seconds = Duration::new(5, 0);
- /// ```
- #[stable(feature = "duration", since = "1.3.0")]
- #[inline]
- pub fn new(secs: u64, nanos: u32) -> Duration {
- let secs = secs.checked_add((nanos / NANOS_PER_SEC) as u64)
- .expect("overflow in Duration::new");
- let nanos = nanos % NANOS_PER_SEC;
- Duration { secs: secs, nanos: nanos }
- }
-
- /// Creates a new `Duration` from the specified number of whole seconds.
- ///
- /// # Examples
- ///
- /// ```
- /// use std::time::Duration;
- ///
- /// let duration = Duration::from_secs(5);
- ///
- /// assert_eq!(5, duration.as_secs());
- /// assert_eq!(0, duration.subsec_nanos());
- /// ```
- #[stable(feature = "duration", since = "1.3.0")]
- #[inline]
- pub const fn from_secs(secs: u64) -> Duration {
- Duration { secs: secs, nanos: 0 }
- }
-
- /// Creates a new `Duration` from the specified number of milliseconds.
- ///
- /// # Examples
- ///
- /// ```
- /// use std::time::Duration;
- ///
- /// let duration = Duration::from_millis(2569);
- ///
- /// assert_eq!(2, duration.as_secs());
- /// assert_eq!(569_000_000, duration.subsec_nanos());
- /// ```
- #[stable(feature = "duration", since = "1.3.0")]
- #[inline]
- pub const fn from_millis(millis: u64) -> Duration {
- Duration {
- secs: millis / MILLIS_PER_SEC,
- nanos: ((millis % MILLIS_PER_SEC) as u32) * NANOS_PER_MILLI,
- }
- }
-
- /// Creates a new `Duration` from the specified number of microseconds.
- ///
- /// # Examples
- ///
- /// ```
- /// #![feature(duration_from_micros)]
- /// use std::time::Duration;
- ///
- /// let duration = Duration::from_micros(1_000_002);
- ///
- /// assert_eq!(1, duration.as_secs());
- /// assert_eq!(2000, duration.subsec_nanos());
- /// ```
- #[unstable(feature = "duration_from_micros", issue = "44400")]
- #[inline]
- pub const fn from_micros(micros: u64) -> Duration {
- Duration {
- secs: micros / MICROS_PER_SEC,
- nanos: ((micros % MICROS_PER_SEC) as u32) * NANOS_PER_MICRO,
- }
- }
-
- /// Creates a new `Duration` from the specified number of nanoseconds.
- ///
- /// # Examples
- ///
- /// ```
- /// #![feature(duration_extras)]
- /// use std::time::Duration;
- ///
- /// let duration = Duration::from_nanos(1_000_000_123);
- ///
- /// assert_eq!(1, duration.as_secs());
- /// assert_eq!(123, duration.subsec_nanos());
- /// ```
- #[unstable(feature = "duration_extras", issue = "46507")]
- #[inline]
- pub const fn from_nanos(nanos: u64) -> Duration {
- Duration {
- secs: nanos / (NANOS_PER_SEC as u64),
- nanos: (nanos % (NANOS_PER_SEC as u64)) as u32,
- }
- }
-
- /// Returns the number of _whole_ seconds contained by this `Duration`.
- ///
- /// The returned value does not include the fractional (nanosecond) part of the
- /// duration, which can be obtained using [`subsec_nanos`].
- ///
- /// # Examples
- ///
- /// ```
- /// use std::time::Duration;
- ///
- /// let duration = Duration::new(5, 730023852);
- /// assert_eq!(duration.as_secs(), 5);
- /// ```
- ///
- /// To determine the total number of seconds represented by the `Duration`,
- /// use `as_secs` in combination with [`subsec_nanos`]:
- ///
- /// ```
- /// use std::time::Duration;
- ///
- /// let duration = Duration::new(5, 730023852);
- ///
- /// assert_eq!(5.730023852,
- /// duration.as_secs() as f64
- /// + duration.subsec_nanos() as f64 * 1e-9);
- /// ```
- ///
- /// [`subsec_nanos`]: #method.subsec_nanos
- #[stable(feature = "duration", since = "1.3.0")]
- #[inline]
- pub fn as_secs(&self) -> u64 { self.secs }
-
- /// Returns the fractional part of this `Duration`, in milliseconds.
- ///
- /// This method does **not** return the length of the duration when
- /// represented by milliseconds. The returned number always represents a
- /// fractional portion of a second (i.e. it is less than one thousand).
- ///
- /// # Examples
- ///
- /// ```
- /// #![feature(duration_extras)]
- /// use std::time::Duration;
- ///
- /// let duration = Duration::from_millis(5432);
- /// assert_eq!(duration.as_secs(), 5);
- /// assert_eq!(duration.subsec_millis(), 432);
- /// ```
- #[unstable(feature = "duration_extras", issue = "46507")]
- #[inline]
- pub fn subsec_millis(&self) -> u32 { self.nanos / NANOS_PER_MILLI }
-
- /// Returns the fractional part of this `Duration`, in microseconds.
- ///
- /// This method does **not** return the length of the duration when
- /// represented by microseconds. The returned number always represents a
- /// fractional portion of a second (i.e. it is less than one million).
- ///
- /// # Examples
- ///
- /// ```
- /// #![feature(duration_extras, duration_from_micros)]
- /// use std::time::Duration;
- ///
- /// let duration = Duration::from_micros(1_234_567);
- /// assert_eq!(duration.as_secs(), 1);
- /// assert_eq!(duration.subsec_micros(), 234_567);
- /// ```
- #[unstable(feature = "duration_extras", issue = "46507")]
- #[inline]
- pub fn subsec_micros(&self) -> u32 { self.nanos / NANOS_PER_MICRO }
-
- /// Returns the fractional part of this `Duration`, in nanoseconds.
- ///
- /// This method does **not** return the length of the duration when
- /// represented by nanoseconds. The returned number always represents a
- /// fractional portion of a second (i.e. it is less than one billion).
- ///
- /// # Examples
- ///
- /// ```
- /// use std::time::Duration;
- ///
- /// let duration = Duration::from_millis(5010);
- /// assert_eq!(duration.as_secs(), 5);
- /// assert_eq!(duration.subsec_nanos(), 10_000_000);
- /// ```
- #[stable(feature = "duration", since = "1.3.0")]
- #[inline]
- pub fn subsec_nanos(&self) -> u32 { self.nanos }
-
- /// Checked `Duration` addition. Computes `self + other`, returning [`None`]
- /// if overflow occurred.
- ///
- /// [`None`]: ../../std/option/enum.Option.html#variant.None
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// use std::time::Duration;
- ///
- /// assert_eq!(Duration::new(0, 0).checked_add(Duration::new(0, 1)), Some(Duration::new(0, 1)));
- /// assert_eq!(Duration::new(1, 0).checked_add(Duration::new(std::u64::MAX, 0)), None);
- /// ```
- #[stable(feature = "duration_checked_ops", since = "1.16.0")]
- #[inline]
- pub fn checked_add(self, rhs: Duration) -> Option<Duration> {
- if let Some(mut secs) = self.secs.checked_add(rhs.secs) {
- let mut nanos = self.nanos + rhs.nanos;
- if nanos >= NANOS_PER_SEC {
- nanos -= NANOS_PER_SEC;
- if let Some(new_secs) = secs.checked_add(1) {
- secs = new_secs;
- } else {
- return None;
- }
- }
- debug_assert!(nanos < NANOS_PER_SEC);
- Some(Duration {
- secs,
- nanos,
- })
- } else {
- None
- }
- }
-
- /// Checked `Duration` subtraction. Computes `self - other`, returning [`None`]
- /// if the result would be negative or if overflow occurred.
- ///
- /// [`None`]: ../../std/option/enum.Option.html#variant.None
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// use std::time::Duration;
- ///
- /// assert_eq!(Duration::new(0, 1).checked_sub(Duration::new(0, 0)), Some(Duration::new(0, 1)));
- /// assert_eq!(Duration::new(0, 0).checked_sub(Duration::new(0, 1)), None);
- /// ```
- #[stable(feature = "duration_checked_ops", since = "1.16.0")]
- #[inline]
- pub fn checked_sub(self, rhs: Duration) -> Option<Duration> {
- if let Some(mut secs) = self.secs.checked_sub(rhs.secs) {
- let nanos = if self.nanos >= rhs.nanos {
- self.nanos - rhs.nanos
- } else {
- if let Some(sub_secs) = secs.checked_sub(1) {
- secs = sub_secs;
- self.nanos + NANOS_PER_SEC - rhs.nanos
- } else {
- return None;
- }
- };
- debug_assert!(nanos < NANOS_PER_SEC);
- Some(Duration { secs: secs, nanos: nanos })
- } else {
- None
- }
- }
-
- /// Checked `Duration` multiplication. Computes `self * other`, returning
- /// [`None`] if overflow occurred.
- ///
- /// [`None`]: ../../std/option/enum.Option.html#variant.None
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// use std::time::Duration;
- ///
- /// assert_eq!(Duration::new(0, 500_000_001).checked_mul(2), Some(Duration::new(1, 2)));
- /// assert_eq!(Duration::new(std::u64::MAX - 1, 0).checked_mul(2), None);
- /// ```
- #[stable(feature = "duration_checked_ops", since = "1.16.0")]
- #[inline]
- pub fn checked_mul(self, rhs: u32) -> Option<Duration> {
- // Multiply nanoseconds as u64, because it cannot overflow that way.
- let total_nanos = self.nanos as u64 * rhs as u64;
- let extra_secs = total_nanos / (NANOS_PER_SEC as u64);
- let nanos = (total_nanos % (NANOS_PER_SEC as u64)) as u32;
- if let Some(secs) = self.secs
- .checked_mul(rhs as u64)
- .and_then(|s| s.checked_add(extra_secs)) {
- debug_assert!(nanos < NANOS_PER_SEC);
- Some(Duration {
- secs,
- nanos,
- })
- } else {
- None
- }
- }
-
- /// Checked `Duration` division. Computes `self / other`, returning [`None`]
- /// if `other == 0`.
- ///
- /// [`None`]: ../../std/option/enum.Option.html#variant.None
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// use std::time::Duration;
- ///
- /// assert_eq!(Duration::new(2, 0).checked_div(2), Some(Duration::new(1, 0)));
- /// assert_eq!(Duration::new(1, 0).checked_div(2), Some(Duration::new(0, 500_000_000)));
- /// assert_eq!(Duration::new(2, 0).checked_div(0), None);
- /// ```
- #[stable(feature = "duration_checked_ops", since = "1.16.0")]
- #[inline]
- pub fn checked_div(self, rhs: u32) -> Option<Duration> {
- if rhs != 0 {
- let secs = self.secs / (rhs as u64);
- let carry = self.secs - secs * (rhs as u64);
- let extra_nanos = carry * (NANOS_PER_SEC as u64) / (rhs as u64);
- let nanos = self.nanos / rhs + (extra_nanos as u32);
- debug_assert!(nanos < NANOS_PER_SEC);
- Some(Duration { secs: secs, nanos: nanos })
- } else {
- None
- }
- }
-}
-
-#[stable(feature = "duration", since = "1.3.0")]
-impl Add for Duration {
- type Output = Duration;
-
- fn add(self, rhs: Duration) -> Duration {
- self.checked_add(rhs).expect("overflow when adding durations")
- }
-}
-
-#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
-impl AddAssign for Duration {
- fn add_assign(&mut self, rhs: Duration) {
- *self = *self + rhs;
- }
-}
-
-#[stable(feature = "duration", since = "1.3.0")]
-impl Sub for Duration {
- type Output = Duration;
-
- fn sub(self, rhs: Duration) -> Duration {
- self.checked_sub(rhs).expect("overflow when subtracting durations")
- }
-}
-
-#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
-impl SubAssign for Duration {
- fn sub_assign(&mut self, rhs: Duration) {
- *self = *self - rhs;
- }
-}
-
-#[stable(feature = "duration", since = "1.3.0")]
-impl Mul<u32> for Duration {
- type Output = Duration;
-
- fn mul(self, rhs: u32) -> Duration {
- self.checked_mul(rhs).expect("overflow when multiplying duration by scalar")
- }
-}
-
-#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
-impl MulAssign<u32> for Duration {
- fn mul_assign(&mut self, rhs: u32) {
- *self = *self * rhs;
- }
-}
-
-#[stable(feature = "duration", since = "1.3.0")]
-impl Div<u32> for Duration {
- type Output = Duration;
-
- fn div(self, rhs: u32) -> Duration {
- self.checked_div(rhs).expect("divide by zero error when dividing duration by scalar")
- }
-}
-
-#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
-impl DivAssign<u32> for Duration {
- fn div_assign(&mut self, rhs: u32) {
- *self = *self / rhs;
- }
-}
-
-#[stable(feature = "duration_sum", since = "1.16.0")]
-impl Sum for Duration {
- fn sum<I: Iterator<Item=Duration>>(iter: I) -> Duration {
- iter.fold(Duration::new(0, 0), |a, b| a + b)
- }
-}
-
-#[stable(feature = "duration_sum", since = "1.16.0")]
-impl<'a> Sum<&'a Duration> for Duration {
- fn sum<I: Iterator<Item=&'a Duration>>(iter: I) -> Duration {
- iter.fold(Duration::new(0, 0), |a, b| a + *b)
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::Duration;
-
- #[test]
- fn creation() {
- assert!(Duration::from_secs(1) != Duration::from_secs(0));
- assert_eq!(Duration::from_secs(1) + Duration::from_secs(2),
- Duration::from_secs(3));
- assert_eq!(Duration::from_millis(10) + Duration::from_secs(4),
- Duration::new(4, 10 * 1_000_000));
- assert_eq!(Duration::from_millis(4000), Duration::new(4, 0));
- }
-
- #[test]
- fn secs() {
- assert_eq!(Duration::new(0, 0).as_secs(), 0);
- assert_eq!(Duration::from_secs(1).as_secs(), 1);
- assert_eq!(Duration::from_millis(999).as_secs(), 0);
- assert_eq!(Duration::from_millis(1001).as_secs(), 1);
- }
-
- #[test]
- fn nanos() {
- assert_eq!(Duration::new(0, 0).subsec_nanos(), 0);
- assert_eq!(Duration::new(0, 5).subsec_nanos(), 5);
- assert_eq!(Duration::new(0, 1_000_000_001).subsec_nanos(), 1);
- assert_eq!(Duration::from_secs(1).subsec_nanos(), 0);
- assert_eq!(Duration::from_millis(999).subsec_nanos(), 999 * 1_000_000);
- assert_eq!(Duration::from_millis(1001).subsec_nanos(), 1 * 1_000_000);
- }
-
- #[test]
- fn add() {
- assert_eq!(Duration::new(0, 0) + Duration::new(0, 1),
- Duration::new(0, 1));
- assert_eq!(Duration::new(0, 500_000_000) + Duration::new(0, 500_000_001),
- Duration::new(1, 1));
- }
-
- #[test]
- fn checked_add() {
- assert_eq!(Duration::new(0, 0).checked_add(Duration::new(0, 1)),
- Some(Duration::new(0, 1)));
- assert_eq!(Duration::new(0, 500_000_000).checked_add(Duration::new(0, 500_000_001)),
- Some(Duration::new(1, 1)));
- assert_eq!(Duration::new(1, 0).checked_add(Duration::new(::u64::MAX, 0)), None);
- }
-
- #[test]
- fn sub() {
- assert_eq!(Duration::new(0, 1) - Duration::new(0, 0),
- Duration::new(0, 1));
- assert_eq!(Duration::new(0, 500_000_001) - Duration::new(0, 500_000_000),
- Duration::new(0, 1));
- assert_eq!(Duration::new(1, 0) - Duration::new(0, 1),
- Duration::new(0, 999_999_999));
- }
-
- #[test]
- fn checked_sub() {
- let zero = Duration::new(0, 0);
- let one_nano = Duration::new(0, 1);
- let one_sec = Duration::new(1, 0);
- assert_eq!(one_nano.checked_sub(zero), Some(Duration::new(0, 1)));
- assert_eq!(one_sec.checked_sub(one_nano),
- Some(Duration::new(0, 999_999_999)));
- assert_eq!(zero.checked_sub(one_nano), None);
- assert_eq!(zero.checked_sub(one_sec), None);
- }
-
- #[test] #[should_panic]
- fn sub_bad1() {
- Duration::new(0, 0) - Duration::new(0, 1);
- }
-
- #[test] #[should_panic]
- fn sub_bad2() {
- Duration::new(0, 0) - Duration::new(1, 0);
- }
-
- #[test]
- fn mul() {
- assert_eq!(Duration::new(0, 1) * 2, Duration::new(0, 2));
- assert_eq!(Duration::new(1, 1) * 3, Duration::new(3, 3));
- assert_eq!(Duration::new(0, 500_000_001) * 4, Duration::new(2, 4));
- assert_eq!(Duration::new(0, 500_000_001) * 4000,
- Duration::new(2000, 4000));
- }
-
- #[test]
- fn checked_mul() {
- assert_eq!(Duration::new(0, 1).checked_mul(2), Some(Duration::new(0, 2)));
- assert_eq!(Duration::new(1, 1).checked_mul(3), Some(Duration::new(3, 3)));
- assert_eq!(Duration::new(0, 500_000_001).checked_mul(4), Some(Duration::new(2, 4)));
- assert_eq!(Duration::new(0, 500_000_001).checked_mul(4000),
- Some(Duration::new(2000, 4000)));
- assert_eq!(Duration::new(::u64::MAX - 1, 0).checked_mul(2), None);
- }
-
- #[test]
- fn div() {
- assert_eq!(Duration::new(0, 1) / 2, Duration::new(0, 0));
- assert_eq!(Duration::new(1, 1) / 3, Duration::new(0, 333_333_333));
- assert_eq!(Duration::new(99, 999_999_000) / 100,
- Duration::new(0, 999_999_990));
- }
-
- #[test]
- fn checked_div() {
- assert_eq!(Duration::new(2, 0).checked_div(2), Some(Duration::new(1, 0)));
- assert_eq!(Duration::new(1, 0).checked_div(2), Some(Duration::new(0, 500_000_000)));
- assert_eq!(Duration::new(2, 0).checked_div(0), None);
- }
-}
+++ /dev/null
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Temporal quantification.
-//!
-//! Example:
-//!
-//! ```
-//! use std::time::Duration;
-//!
-//! let five_seconds = Duration::new(5, 0);
-//! // both declarations are equivalent
-//! assert_eq!(Duration::new(5, 0), Duration::from_secs(5));
-//! ```
-
-#![stable(feature = "time", since = "1.3.0")]
-
-use error::Error;
-use fmt;
-use ops::{Add, Sub, AddAssign, SubAssign};
-use sys::time;
-use sys_common::FromInner;
-
-#[stable(feature = "time", since = "1.3.0")]
-pub use self::duration::Duration;
-
-mod duration;
-
-/// A measurement of a monotonically nondecreasing clock.
-/// Opaque and useful only with `Duration`.
-///
-/// Instants are always guaranteed to be no less than any previously measured
-/// 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
-/// 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
-/// backwards.
-///
-/// Instants are opaque types that can only be compared to one another. There is
-/// no method to get "the number of seconds" from an instant. Instead, it only
-/// allows measuring the duration between two instants (or comparing two
-/// instants).
-///
-/// Example:
-///
-/// ```no_run
-/// use std::time::{Duration, Instant};
-/// use std::thread::sleep;
-///
-/// fn main() {
-/// let now = Instant::now();
-///
-/// // we sleep for 2 seconds
-/// sleep(Duration::new(2, 0));
-/// // it prints '2'
-/// println!("{}", now.elapsed().as_secs());
-/// }
-/// ```
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[stable(feature = "time2", since = "1.8.0")]
-pub struct Instant(time::Instant);
-
-/// A measurement of the system clock, useful for talking to
-/// external entities like the file system or other processes.
-///
-/// Distinct from the [`Instant`] type, this time measurement **is not
-/// monotonic**. This means that you can save a file to the file system, then
-/// save another file to the file system, **and the second file has a
-/// `SystemTime` measurement earlier than the first**. In other words, an
-/// operation that happens after another operation in real time may have an
-/// earlier `SystemTime`!
-///
-/// Consequently, comparing two `SystemTime` instances to learn about the
-/// duration between them returns a [`Result`] instead of an infallible [`Duration`]
-/// to indicate that this sort of time drift may happen and needs to be handled.
-///
-/// Although a `SystemTime` cannot be directly inspected, the [`UNIX_EPOCH`]
-/// constant is provided in this module as an anchor in time to learn
-/// information about a `SystemTime`. By calculating the duration from this
-/// fixed point in time, a `SystemTime` can be converted to a human-readable time,
-/// or perhaps some other string representation.
-///
-/// [`Instant`]: ../../std/time/struct.Instant.html
-/// [`Result`]: ../../std/result/enum.Result.html
-/// [`Duration`]: ../../std/time/struct.Duration.html
-/// [`UNIX_EPOCH`]: ../../std/time/constant.UNIX_EPOCH.html
-///
-/// Example:
-///
-/// ```no_run
-/// use std::time::{Duration, SystemTime};
-/// use std::thread::sleep;
-///
-/// fn main() {
-/// let now = SystemTime::now();
-///
-/// // we sleep for 2 seconds
-/// sleep(Duration::new(2, 0));
-/// match now.elapsed() {
-/// Ok(elapsed) => {
-/// // it prints '2'
-/// println!("{}", elapsed.as_secs());
-/// }
-/// Err(e) => {
-/// // an error occurred!
-/// println!("Error: {:?}", e);
-/// }
-/// }
-/// }
-/// ```
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[stable(feature = "time2", since = "1.8.0")]
-pub struct SystemTime(time::SystemTime);
-
-/// An error returned from the `duration_since` and `elapsed` methods on
-/// `SystemTime`, used to learn how far in the opposite direction a system time
-/// lies.
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::thread::sleep;
-/// use std::time::{Duration, SystemTime};
-///
-/// let sys_time = SystemTime::now();
-/// sleep(Duration::from_secs(1));
-/// let new_sys_time = SystemTime::now();
-/// match sys_time.duration_since(new_sys_time) {
-/// Ok(_) => {}
-/// Err(e) => println!("SystemTimeError difference: {:?}", e.duration()),
-/// }
-/// ```
-#[derive(Clone, Debug)]
-#[stable(feature = "time2", since = "1.8.0")]
-pub struct SystemTimeError(Duration);
-
-impl Instant {
- /// Returns an instant corresponding to "now".
- ///
- /// # Examples
- ///
- /// ```
- /// use std::time::Instant;
- ///
- /// let now = Instant::now();
- /// ```
- #[stable(feature = "time2", since = "1.8.0")]
- pub fn now() -> Instant {
- Instant(time::Instant::now())
- }
-
- /// Returns the amount of time elapsed from another instant to this one.
- ///
- /// # Panics
- ///
- /// This function will panic if `earlier` is later than `self`.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::time::{Duration, Instant};
- /// use std::thread::sleep;
- ///
- /// let now = Instant::now();
- /// sleep(Duration::new(1, 0));
- /// let new_now = Instant::now();
- /// println!("{:?}", new_now.duration_since(now));
- /// ```
- #[stable(feature = "time2", since = "1.8.0")]
- pub fn duration_since(&self, earlier: Instant) -> Duration {
- self.0.sub_instant(&earlier.0)
- }
-
- /// Returns the amount of time elapsed since this instant was created.
- ///
- /// # Panics
- ///
- /// This function may panic if the current time is earlier than this
- /// instant, which is something that can happen if an `Instant` is
- /// produced synthetically.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::thread::sleep;
- /// use std::time::{Duration, Instant};
- ///
- /// let instant = Instant::now();
- /// let three_secs = Duration::from_secs(3);
- /// sleep(three_secs);
- /// assert!(instant.elapsed() >= three_secs);
- /// ```
- #[stable(feature = "time2", since = "1.8.0")]
- pub fn elapsed(&self) -> Duration {
- Instant::now() - *self
- }
-}
-
-#[stable(feature = "time2", since = "1.8.0")]
-impl Add<Duration> for Instant {
- type Output = Instant;
-
- fn add(self, other: Duration) -> Instant {
- Instant(self.0.add_duration(&other))
- }
-}
-
-#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
-impl AddAssign<Duration> for Instant {
- fn add_assign(&mut self, other: Duration) {
- *self = *self + other;
- }
-}
-
-#[stable(feature = "time2", since = "1.8.0")]
-impl Sub<Duration> for Instant {
- type Output = Instant;
-
- fn sub(self, other: Duration) -> Instant {
- Instant(self.0.sub_duration(&other))
- }
-}
-
-#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
-impl SubAssign<Duration> for Instant {
- fn sub_assign(&mut self, other: Duration) {
- *self = *self - other;
- }
-}
-
-#[stable(feature = "time2", since = "1.8.0")]
-impl Sub<Instant> for Instant {
- type Output = Duration;
-
- fn sub(self, other: Instant) -> Duration {
- self.duration_since(other)
- }
-}
-
-#[stable(feature = "time2", since = "1.8.0")]
-impl fmt::Debug for Instant {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(f)
- }
-}
-
-impl SystemTime {
- /// Returns the system time corresponding to "now".
- ///
- /// # Examples
- ///
- /// ```
- /// use std::time::SystemTime;
- ///
- /// let sys_time = SystemTime::now();
- /// ```
- #[stable(feature = "time2", since = "1.8.0")]
- pub fn now() -> SystemTime {
- SystemTime(time::SystemTime::now())
- }
-
- /// Returns the amount of time elapsed from an earlier point in time.
- ///
- /// This function may fail because measurements taken earlier are not
- /// guaranteed to always be before later measurements (due to anomalies such
- /// as the system clock being adjusted either forwards or backwards).
- ///
- /// If successful, [`Ok`]`(`[`Duration`]`)` is returned where the duration represents
- /// the amount of time elapsed from the specified measurement to this one.
- ///
- /// Returns an [`Err`] if `earlier` is later than `self`, and the error
- /// contains how far from `self` the time is.
- ///
- /// [`Ok`]: ../../std/result/enum.Result.html#variant.Ok
- /// [`Duration`]: ../../std/time/struct.Duration.html
- /// [`Err`]: ../../std/result/enum.Result.html#variant.Err
- ///
- /// # Examples
- ///
- /// ```
- /// use std::time::SystemTime;
- ///
- /// let sys_time = SystemTime::now();
- /// let difference = sys_time.duration_since(sys_time)
- /// .expect("SystemTime::duration_since failed");
- /// println!("{:?}", difference);
- /// ```
- #[stable(feature = "time2", since = "1.8.0")]
- pub fn duration_since(&self, earlier: SystemTime)
- -> Result<Duration, SystemTimeError> {
- self.0.sub_time(&earlier.0).map_err(SystemTimeError)
- }
-
- /// Returns the amount of time elapsed since this system time was created.
- ///
- /// This function may fail as the underlying system clock is susceptible to
- /// drift and updates (e.g. the system clock could go backwards), so this
- /// function may not always succeed. If successful, [`Ok`]`(`[`Duration`]`)` is
- /// returned where the duration represents the amount of time elapsed from
- /// this time measurement to the current time.
- ///
- /// Returns an [`Err`] if `self` is later than the current system time, and
- /// the error contains how far from the current system time `self` is.
- ///
- /// [`Ok`]: ../../std/result/enum.Result.html#variant.Ok
- /// [`Duration`]: ../../std/time/struct.Duration.html
- /// [`Err`]: ../../std/result/enum.Result.html#variant.Err
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::thread::sleep;
- /// use std::time::{Duration, SystemTime};
- ///
- /// let sys_time = SystemTime::now();
- /// let one_sec = Duration::from_secs(1);
- /// sleep(one_sec);
- /// assert!(sys_time.elapsed().unwrap() >= one_sec);
- /// ```
- #[stable(feature = "time2", since = "1.8.0")]
- pub fn elapsed(&self) -> Result<Duration, SystemTimeError> {
- SystemTime::now().duration_since(*self)
- }
-}
-
-#[stable(feature = "time2", since = "1.8.0")]
-impl Add<Duration> for SystemTime {
- type Output = SystemTime;
-
- fn add(self, dur: Duration) -> SystemTime {
- SystemTime(self.0.add_duration(&dur))
- }
-}
-
-#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
-impl AddAssign<Duration> for SystemTime {
- fn add_assign(&mut self, other: Duration) {
- *self = *self + other;
- }
-}
-
-#[stable(feature = "time2", since = "1.8.0")]
-impl Sub<Duration> for SystemTime {
- type Output = SystemTime;
-
- fn sub(self, dur: Duration) -> SystemTime {
- SystemTime(self.0.sub_duration(&dur))
- }
-}
-
-#[stable(feature = "time_augmented_assignment", since = "1.9.0")]
-impl SubAssign<Duration> for SystemTime {
- fn sub_assign(&mut self, other: Duration) {
- *self = *self - other;
- }
-}
-
-#[stable(feature = "time2", since = "1.8.0")]
-impl fmt::Debug for SystemTime {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(f)
- }
-}
-
-/// An anchor in time which can be used to create new `SystemTime` instances or
-/// learn about where in time a `SystemTime` lies.
-///
-/// This constant is defined to be "1970-01-01 00:00:00 UTC" on all systems with
-/// respect to the system clock. Using `duration_since` on an existing
-/// [`SystemTime`] instance can tell how far away from this point in time a
-/// measurement lies, and using `UNIX_EPOCH + duration` can be used to create a
-/// [`SystemTime`] instance to represent another fixed point in time.
-///
-/// [`SystemTime`]: ../../std/time/struct.SystemTime.html
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::time::{SystemTime, UNIX_EPOCH};
-///
-/// match SystemTime::now().duration_since(UNIX_EPOCH) {
-/// Ok(n) => println!("1970-01-01 00:00:00 UTC was {} seconds ago!", n.as_secs()),
-/// Err(_) => panic!("SystemTime before UNIX EPOCH!"),
-/// }
-/// ```
-#[stable(feature = "time2", since = "1.8.0")]
-pub const UNIX_EPOCH: SystemTime = SystemTime(time::UNIX_EPOCH);
-
-impl SystemTimeError {
- /// Returns the positive duration which represents how far forward the
- /// second system time was from the first.
- ///
- /// A `SystemTimeError` is returned from the [`duration_since`] and [`elapsed`]
- /// methods of [`SystemTime`] whenever the second system time represents a point later
- /// in time than the `self` of the method call.
- ///
- /// [`duration_since`]: ../../std/time/struct.SystemTime.html#method.duration_since
- /// [`elapsed`]: ../../std/time/struct.SystemTime.html#method.elapsed
- /// [`SystemTime`]: ../../std/time/struct.SystemTime.html
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::thread::sleep;
- /// use std::time::{Duration, SystemTime};
- ///
- /// let sys_time = SystemTime::now();
- /// sleep(Duration::from_secs(1));
- /// let new_sys_time = SystemTime::now();
- /// match sys_time.duration_since(new_sys_time) {
- /// Ok(_) => {}
- /// Err(e) => println!("SystemTimeError difference: {:?}", e.duration()),
- /// }
- /// ```
- #[stable(feature = "time2", since = "1.8.0")]
- pub fn duration(&self) -> Duration {
- self.0
- }
-}
-
-#[stable(feature = "time2", since = "1.8.0")]
-impl Error for SystemTimeError {
- fn description(&self) -> &str { "other time was not earlier than self" }
-}
-
-#[stable(feature = "time2", since = "1.8.0")]
-impl fmt::Display for SystemTimeError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "second time provided was later than self")
- }
-}
-
-impl FromInner<time::SystemTime> for SystemTime {
- fn from_inner(time: time::SystemTime) -> SystemTime {
- SystemTime(time)
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::{Instant, SystemTime, Duration, UNIX_EPOCH};
-
- macro_rules! assert_almost_eq {
- ($a:expr, $b:expr) => ({
- let (a, b) = ($a, $b);
- if a != b {
- let (a, b) = if a > b {(a, b)} else {(b, a)};
- assert!(a - Duration::new(0, 100) <= b);
- }
- })
- }
-
- #[test]
- fn instant_monotonic() {
- let a = Instant::now();
- let b = Instant::now();
- assert!(b >= a);
- }
-
- #[test]
- fn instant_elapsed() {
- let a = Instant::now();
- a.elapsed();
- }
-
- #[test]
- fn instant_math() {
- let a = Instant::now();
- let b = Instant::now();
- let dur = b.duration_since(a);
- assert_almost_eq!(b - dur, a);
- assert_almost_eq!(a + dur, b);
-
- let second = Duration::new(1, 0);
- assert_almost_eq!(a - second + second, a);
- }
-
- #[test]
- #[should_panic]
- fn instant_duration_panic() {
- let a = Instant::now();
- (a - Duration::new(1, 0)).duration_since(a);
- }
-
- #[test]
- fn system_time_math() {
- let a = SystemTime::now();
- let b = SystemTime::now();
- match b.duration_since(a) {
- Ok(dur) if dur == Duration::new(0, 0) => {
- assert_almost_eq!(a, b);
- }
- Ok(dur) => {
- assert!(b > a);
- assert_almost_eq!(b - dur, a);
- assert_almost_eq!(a + dur, b);
- }
- Err(dur) => {
- let dur = dur.duration();
- assert!(a > b);
- assert_almost_eq!(b + dur, a);
- assert_almost_eq!(a - dur, b);
- }
- }
-
- let second = Duration::new(1, 0);
- assert_almost_eq!(a.duration_since(a - second).unwrap(), second);
- assert_almost_eq!(a.duration_since(a + second).unwrap_err()
- .duration(), second);
-
- assert_almost_eq!(a - second + second, a);
-
- // A difference of 80 and 800 years cannot fit inside a 32-bit time_t
- if !(cfg!(unix) && ::mem::size_of::<::libc::time_t>() <= 4) {
- let eighty_years = second * 60 * 60 * 24 * 365 * 80;
- assert_almost_eq!(a - eighty_years + eighty_years, a);
- assert_almost_eq!(a - (eighty_years * 10) + (eighty_years * 10), a);
- }
-
- let one_second_from_epoch = UNIX_EPOCH + Duration::new(1, 0);
- let one_second_from_epoch2 = UNIX_EPOCH + Duration::new(0, 500_000_000)
- + Duration::new(0, 500_000_000);
- assert_eq!(one_second_from_epoch, one_second_from_epoch2);
- }
-
- #[test]
- fn system_time_elapsed() {
- let a = SystemTime::now();
- drop(a.elapsed());
- }
-
- #[test]
- fn since_epoch() {
- let ts = SystemTime::now();
- let a = ts.duration_since(UNIX_EPOCH).unwrap();
- let b = ts.duration_since(UNIX_EPOCH - Duration::new(1, 0)).unwrap();
- assert!(b > a);
- assert_eq!(b - a, Duration::new(1, 0));
-
- let thirty_years = Duration::new(1, 0) * 60 * 60 * 24 * 365 * 30;
-
- // Right now for CI this test is run in an emulator, and apparently the
- // aarch64 emulator's sense of time is that we're still living in the
- // 70s.
- //
- // Otherwise let's assume that we're all running computers later than
- // 2000.
- if !cfg!(target_arch = "aarch64") {
- assert!(a > thirty_years);
- }
-
- // let's assume that we're all running computers earlier than 2090.
- // Should give us ~70 years to fix this!
- let hundred_twenty_years = thirty_years * 4;
- assert!(a < hundred_twenty_years);
- }
-}
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::stable_hasher::StableHasher;
use std::cell::{RefCell, Ref};
+use std::cmp;
use std::hash::Hash;
use std::path::{Path, PathBuf};
use std::rc::Rc;
}
}
- /// Given a `Span`, try to get a shorter span ending just after the first
- /// occurrence of `char` `c`.
+ /// Given a `Span`, get a new `Span` covering the first token and all its trailing whitespace or
+ /// the original `Span`.
+ ///
+ /// If `sp` points to `"let mut x"`, then a span pointing at `"let "` will be returned.
+ pub fn span_until_non_whitespace(&self, sp: Span) -> Span {
+ if let Ok(snippet) = self.span_to_snippet(sp) {
+ let mut offset = 0;
+ // get the bytes width of all the non-whitespace characters
+ for c in snippet.chars().take_while(|c| !c.is_whitespace()) {
+ offset += c.len_utf8();
+ }
+ // get the bytes width of all the whitespace characters after that
+ for c in snippet[offset..].chars().take_while(|c| c.is_whitespace()) {
+ offset += c.len_utf8();
+ }
+ if offset > 1 {
+ return sp.with_hi(BytePos(sp.lo().0 + offset as u32));
+ }
+ }
+ sp
+ }
+
+ /// Given a `Span`, try to get a shorter span ending just after the first occurrence of `char`
+ /// `c`.
pub fn span_through_char(&self, sp: Span, c: char) -> Span {
if let Ok(snippet) = self.span_to_snippet(sp) {
if let Some(offset) = snippet.find(c) {
self.span_until_char(sp, '{')
}
+ /// Returns a new span representing just the end-point of this span
+ pub fn end_point(&self, sp: Span) -> Span {
+ let pos = sp.hi().0;
+
+ let width = self.find_width_of_character_at_span(sp, false);
+ let corrected_end_position = pos.checked_sub(width).unwrap_or(pos);
+
+ let end_point = BytePos(cmp::max(corrected_end_position, sp.lo().0));
+ sp.with_lo(end_point)
+ }
+
+ /// Returns a new span representing the next character after the end-point of this span
+ pub fn next_point(&self, sp: Span) -> Span {
+ let start_of_next_point = sp.hi().0;
+
+ let width = self.find_width_of_character_at_span(sp, true);
+ // If the width is 1, then the next span should point to the same `lo` and `hi`. However,
+ // in the case of a multibyte character, where the width != 1, the next span should
+ // span multiple bytes to include the whole character.
+ let end_of_next_point = start_of_next_point.checked_add(
+ width - 1).unwrap_or(start_of_next_point);
+
+ let end_of_next_point = BytePos(cmp::max(sp.lo().0 + 1, end_of_next_point));
+ Span::new(BytePos(start_of_next_point), end_of_next_point, sp.ctxt())
+ }
+
+ /// Finds the width of a character, either before or after the provided span.
+ fn find_width_of_character_at_span(&self, sp: Span, forwards: bool) -> u32 {
+ // Disregard malformed spans and assume a one-byte wide character.
+ if sp.lo() >= sp.hi() {
+ debug!("find_width_of_character_at_span: early return malformed span");
+ return 1;
+ }
+
+ let local_begin = self.lookup_byte_offset(sp.lo());
+ let local_end = self.lookup_byte_offset(sp.hi());
+ debug!("find_width_of_character_at_span: local_begin=`{:?}`, local_end=`{:?}`",
+ local_begin, local_end);
+
+ let start_index = local_begin.pos.to_usize();
+ let end_index = local_end.pos.to_usize();
+ debug!("find_width_of_character_at_span: start_index=`{:?}`, end_index=`{:?}`",
+ start_index, end_index);
+
+ // Disregard indexes that are at the start or end of their spans, they can't fit bigger
+ // characters.
+ if (!forwards && end_index == usize::min_value()) ||
+ (forwards && start_index == usize::max_value()) {
+ debug!("find_width_of_character_at_span: start or end of span, cannot be multibyte");
+ return 1;
+ }
+
+ let source_len = (local_begin.fm.end_pos - local_begin.fm.start_pos).to_usize();
+ debug!("find_width_of_character_at_span: source_len=`{:?}`", source_len);
+ // Ensure indexes are also not malformed.
+ if start_index > end_index || end_index > source_len {
+ debug!("find_width_of_character_at_span: source indexes are malformed");
+ return 1;
+ }
+
+ // We need to extend the snippet to the end of the src rather than to end_index so when
+ // searching forwards for boundaries we've got somewhere to search.
+ let snippet = if let Some(ref src) = local_begin.fm.src {
+ let len = src.len();
+ (&src[start_index..len]).to_string()
+ } else if let Some(src) = local_begin.fm.external_src.borrow().get_source() {
+ let len = src.len();
+ (&src[start_index..len]).to_string()
+ } else {
+ return 1;
+ };
+ debug!("find_width_of_character_at_span: snippet=`{:?}`", snippet);
+
+ let file_start_pos = local_begin.fm.start_pos.to_usize();
+ let file_end_pos = local_begin.fm.end_pos.to_usize();
+ debug!("find_width_of_character_at_span: file_start_pos=`{:?}` file_end_pos=`{:?}`",
+ file_start_pos, file_end_pos);
+
+ let mut target = if forwards { end_index + 1 } else { end_index - 1 };
+ debug!("find_width_of_character_at_span: initial target=`{:?}`", target);
+
+ while !snippet.is_char_boundary(target - start_index)
+ && target >= file_start_pos && target <= file_end_pos {
+ target = if forwards { target + 1 } else { target - 1 };
+ debug!("find_width_of_character_at_span: target=`{:?}`", target);
+ }
+ debug!("find_width_of_character_at_span: final target=`{:?}`", target);
+
+ if forwards {
+ (target - end_index) as u32
+ } else {
+ (end_index - target) as u32
+ }
+ }
+
pub fn get_filemap(&self, filename: &FileName) -> Option<Rc<FileMap>> {
for fm in self.files.borrow().iter() {
if *filename == fm.name {
use errors::FatalError;
use ext::tt::quoted::{self, TokenTree};
use parse::{Directory, ParseSess};
-use parse::parser::{PathStyle, Parser};
-use parse::token::{self, DocComment, Token, Nonterminal};
+use parse::parser::{Parser, PathStyle};
+use parse::token::{self, DocComment, Nonterminal, Token};
use print::pprust;
use symbol::keywords;
use tokenstream::TokenStream;
use std::mem;
use std::rc::Rc;
use std::collections::HashMap;
-use std::collections::hash_map::Entry::{Vacant, Occupied};
+use std::collections::hash_map::Entry::{Occupied, Vacant};
-// To avoid costly uniqueness checks, we require that `MatchSeq` always has
-// a nonempty body.
+// To avoid costly uniqueness checks, we require that `MatchSeq` always has a nonempty body.
+/// Either a sequence of token trees or a single one. This is used as the representation of the
+/// sequence of tokens that make up a matcher.
#[derive(Clone)]
enum TokenTreeOrTokenTreeVec {
Tt(TokenTree),
}
impl TokenTreeOrTokenTreeVec {
+ /// Returns the number of constituent top-level token trees of `self` (top-level in that it
+ /// will not recursively descend into subtrees).
fn len(&self) -> usize {
match *self {
TtSeq(ref v) => v.len(),
}
}
+ /// The the `index`-th token tree of `self`.
fn get_tt(&self, index: usize) -> TokenTree {
match *self {
TtSeq(ref v) => v[index].clone(),
}
}
-/// an unzipping of `TokenTree`s
+/// An unzipping of `TokenTree`s... see the `stack` field of `MatcherPos`.
+///
+/// This is used by `inner_parse_loop` to keep track of delimited submatchers that we have
+/// descended into.
#[derive(Clone)]
struct MatcherTtFrame {
+ /// The "parent" matcher that we are descending into.
elts: TokenTreeOrTokenTreeVec,
+ /// The position of the "dot" in `elts` at the time we descended.
idx: usize,
}
+/// Represents a single "position" (aka "matcher position", aka "item"), as described in the module
+/// documentation.
#[derive(Clone)]
struct MatcherPos {
- stack: Vec<MatcherTtFrame>,
+ /// The token or sequence of tokens that make up the matcher
top_elts: TokenTreeOrTokenTreeVec,
- sep: Option<Token>,
+ /// The position of the "dot" in this matcher
idx: usize,
- up: Option<Box<MatcherPos>>,
+ /// The beginning position in the source that the beginning of this matcher corresponds to. In
+ /// other words, the token in the source at `sp_lo` is matched against the first token of the
+ /// matcher.
+ sp_lo: BytePos,
+
+ /// For each named metavar in the matcher, we keep track of token trees matched against the
+ /// metavar by the black box parser. In particular, there may be more than one match per
+ /// metavar if we are in a repetition (each repetition matches each of the variables).
+ /// Moreover, matchers and repetitions can be nested; the `matches` field is shared (hence the
+ /// `Rc`) among all "nested" matchers. `match_lo`, `match_cur`, and `match_hi` keep track of
+ /// the current position of the `self` matcher position in the shared `matches` list.
+ ///
+ /// Also, note that while we are descending into a sequence, matchers are given their own
+ /// `matches` vector. Only once we reach the end of a full repetition of the sequence do we add
+ /// all bound matches from the submatcher into the shared top-level `matches` vector. If `sep`
+ /// and `up` are `Some`, then `matches` is _not_ the shared top-level list. Instead, if one
+ /// wants the shared `matches`, one should use `up.matches`.
matches: Vec<Rc<Vec<NamedMatch>>>,
+ /// The position in `matches` corresponding to the first metavar in this matcher's sequence of
+ /// token trees. In other words, the first metavar in the first token of `top_elts` corresponds
+ /// to `matches[match_lo]`.
match_lo: usize,
+ /// The position in `matches` corresponding to the metavar we are currently trying to match
+ /// against the source token stream. `match_lo <= match_cur <= match_hi`.
match_cur: usize,
+ /// Similar to `match_lo` except `match_hi` is the position in `matches` of the _last_ metavar
+ /// in this matcher.
match_hi: usize,
- sp_lo: BytePos,
+
+ // Specifically used if we are matching a repetition. If we aren't both should be `None`.
+ /// The separator if we are in a repetition
+ sep: Option<Token>,
+ /// The "parent" matcher position if we are in a repetition. That is, the matcher position just
+ /// before we enter the sequence.
+ up: Option<Box<MatcherPos>>,
+
+ // Specifically used to "unzip" token trees. By "unzip", we mean to unwrap the delimiters from
+ // a delimited token tree (e.g. something wrapped in `(` `)`) or to get the contents of a doc
+ // comment...
+ /// When matching against matchers with nested delimited submatchers (e.g. `pat ( pat ( .. )
+ /// pat ) pat`), we need to keep track of the matchers we are descending into. This stack does
+ /// that where the bottom of the stack is the outermost matcher.
+ // Also, throughout the comments, this "descent" is often referred to as "unzipping"...
+ stack: Vec<MatcherTtFrame>,
}
impl MatcherPos {
+ /// Add `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);
}
}
+/// Represents the possible results of an attempted parse.
+pub enum ParseResult<T> {
+ /// Parsed successfully.
+ Success(T),
+ /// Arm failed to match. If the second parameter is `token::Eof`, it indicates an unexpected
+ /// end of macro invocation. Otherwise, it indicates that no rules expected the given token.
+ Failure(syntax_pos::Span, Token),
+ /// Fatal error (malformed macro?). Abort compilation.
+ Error(syntax_pos::Span, String),
+}
+
+/// A `ParseResult` where the `Success` variant contains a mapping of `Ident`s to `NamedMatch`es.
+/// This represents the mapping of metavars to the token trees they bind to.
pub type NamedParseResult = ParseResult<HashMap<Ident, Rc<NamedMatch>>>;
+/// Count how many metavars are named in the given matcher `ms`.
pub fn count_names(ms: &[TokenTree]) -> usize {
ms.iter().fold(0, |count, elt| {
count + match *elt {
})
}
+/// Initialize `len` empty shared `Vec`s to be used to store matches of metavars.
+fn create_matches(len: usize) -> Vec<Rc<Vec<NamedMatch>>> {
+ (0..len).into_iter().map(|_| Rc::new(Vec::new())).collect()
+}
+
+/// Generate 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 position `lo` in the source.
fn initial_matcher_pos(ms: Vec<TokenTree>, lo: BytePos) -> Box<MatcherPos> {
let match_idx_hi = count_names(&ms[..]);
let matches = create_matches(match_idx_hi);
Box::new(MatcherPos {
- stack: vec![],
- top_elts: TtSeq(ms),
- sep: None,
+ // Start with the top level matcher given to us
+ top_elts: TtSeq(ms), // "elts" is an abbr. for "elements"
+ // The "dot" is before the first token of the matcher
idx: 0,
- up: None,
+ // We start matching with byte `lo` in the source code
+ sp_lo: lo,
+
+ // Initialize `matches` to a bunch of empty `Vec`s -- one for each metavar in `top_elts`.
+ // `match_lo` for `top_elts` is 0 and `match_hi` is `matches.len()`. `match_cur` is 0 since
+ // we haven't actually matched anything yet.
matches,
match_lo: 0,
match_cur: 0,
match_hi: match_idx_hi,
- sp_lo: lo
+
+ // Haven't descended into any delimiters, so empty stack
+ stack: vec![],
+
+ // Haven't descended into any sequences, so both of these are `None`.
+ sep: None,
+ up: None,
})
}
/// token tree. The depth of the `NamedMatch` structure will therefore depend
/// only on the nesting depth of `ast::TTSeq`s in the originating
/// token tree it was derived from.
-
#[derive(Debug, Clone)]
pub enum NamedMatch {
MatchedSeq(Rc<Vec<NamedMatch>>, syntax_pos::Span),
- MatchedNonterminal(Rc<Nonterminal>)
+ MatchedNonterminal(Rc<Nonterminal>),
}
-fn nameize<I: Iterator<Item=NamedMatch>>(sess: &ParseSess, ms: &[TokenTree], mut res: I)
- -> NamedParseResult {
- fn n_rec<I: Iterator<Item=NamedMatch>>(sess: &ParseSess, m: &TokenTree, res: &mut I,
- ret_val: &mut HashMap<Ident, Rc<NamedMatch>>)
- -> Result<(), (syntax_pos::Span, String)> {
+/// Takes a sequence of token trees `ms` representing a matcher which successfully matched input
+/// and an iterator of items that matched input and produces a `NamedParseResult`.
+fn nameize<I: Iterator<Item = NamedMatch>>(
+ sess: &ParseSess,
+ ms: &[TokenTree],
+ mut res: I,
+) -> NamedParseResult {
+ // Recursively descend into each type of matcher (e.g. sequences, delimited, metavars) and make
+ // sure that each metavar has _exactly one_ binding. If a metavar does not have exactly one
+ // binding, then there is an error. If it does, then we insert the binding into the
+ // `NamedParseResult`.
+ fn n_rec<I: Iterator<Item = NamedMatch>>(
+ sess: &ParseSess,
+ m: &TokenTree,
+ res: &mut I,
+ ret_val: &mut HashMap<Ident, Rc<NamedMatch>>,
+ ) -> Result<(), (syntax_pos::Span, String)> {
match *m {
- TokenTree::Sequence(_, ref seq) => {
- for next_m in &seq.tts {
- n_rec(sess, next_m, res.by_ref(), ret_val)?
- }
- }
- TokenTree::Delimited(_, ref delim) => {
- for next_m in &delim.tts {
- n_rec(sess, next_m, res.by_ref(), ret_val)?;
- }
- }
+ TokenTree::Sequence(_, ref seq) => for next_m in &seq.tts {
+ n_rec(sess, next_m, res.by_ref(), ret_val)?
+ },
+ TokenTree::Delimited(_, ref delim) => for next_m in &delim.tts {
+ n_rec(sess, next_m, res.by_ref(), ret_val)?;
+ },
TokenTree::MetaVarDecl(span, _, id) if id.name == keywords::Invalid.name() => {
if sess.missing_fragment_specifiers.borrow_mut().remove(&span) {
return Err((span, "missing fragment specifier".to_string()));
let mut ret_val = HashMap::new();
for m in ms {
match n_rec(sess, m, res.by_ref(), &mut ret_val) {
- Ok(_) => {},
+ Ok(_) => {}
Err((sp, msg)) => return Error(sp, msg),
}
}
Success(ret_val)
}
-pub enum ParseResult<T> {
- Success(T),
- /// Arm failed to match. If the second parameter is `token::Eof`, it
- /// indicates an unexpected end of macro invocation. Otherwise, it
- /// indicates that no rules expected the given token.
- Failure(syntax_pos::Span, Token),
- /// Fatal error (malformed macro?). Abort compilation.
- Error(syntax_pos::Span, String)
-}
-
+/// Generate 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 {
token::Eof => "unexpected end of macro invocation".to_string(),
- _ => format!("no rules expected the token `{}`", pprust::token_to_string(&tok)),
+ _ => format!(
+ "no rules expected the token `{}`",
+ pprust::token_to_string(&tok)
+ ),
}
}
/// Perform a token equality check, ignoring syntax context (that is, an unhygienic comparison)
-fn token_name_eq(t1 : &Token, t2 : &Token) -> bool {
+fn token_name_eq(t1: &Token, t2: &Token) -> bool {
if let (Some(id1), Some(id2)) = (t1.ident(), t2.ident()) {
id1.name == id2.name
} else if let (&token::Lifetime(id1), &token::Lifetime(id2)) = (t1, t2) {
}
}
-fn create_matches(len: usize) -> Vec<Rc<Vec<NamedMatch>>> {
- (0..len).into_iter().map(|_| Rc::new(Vec::new())).collect()
-}
-
-fn inner_parse_loop(sess: &ParseSess,
- cur_items: &mut SmallVector<Box<MatcherPos>>,
- next_items: &mut Vec<Box<MatcherPos>>,
- eof_items: &mut SmallVector<Box<MatcherPos>>,
- bb_items: &mut SmallVector<Box<MatcherPos>>,
- token: &Token,
- span: syntax_pos::Span)
- -> ParseResult<()> {
+/// Process the matcher positions of `cur_items` until it is empty. In the process, this will
+/// produce more items in `next_items`, `eof_items`, and `bb_items`.
+///
+/// For more info about the how this happens, see the module-level doc comments and the inline
+/// comments of this function.
+///
+/// # Parameters
+///
+/// - `sess`: the parsing session into which errors are emitted.
+/// - `cur_items`: the set of current items to be processed. This should be empty by the end of a
+/// successful execution of this function.
+/// - `next_items`: the set of newly generated items. These are used to replenish `cur_items` in
+/// the function `parse`.
+/// - `eof_items`: the set of items that would be valid if this was the EOF.
+/// - `bb_items`: the set of items that are waiting for the black-box parser.
+/// - `token`: the current token of the parser.
+/// - `span`: the `Span` in the source code corresponding to the token trees we are trying to match
+/// against the matcher positions in `cur_items`.
+///
+/// # Returns
+///
+/// A `ParseResult`. Note that matches are kept track of through the items generated.
+fn inner_parse_loop(
+ sess: &ParseSess,
+ cur_items: &mut SmallVector<Box<MatcherPos>>,
+ next_items: &mut Vec<Box<MatcherPos>>,
+ eof_items: &mut SmallVector<Box<MatcherPos>>,
+ bb_items: &mut SmallVector<Box<MatcherPos>>,
+ token: &Token,
+ span: syntax_pos::Span,
+) -> ParseResult<()> {
+ // Pop items from `cur_items` until it is empty.
while let Some(mut item) = cur_items.pop() {
- // When unzipped trees end, remove them
+ // When unzipped trees end, remove them. This corresponds to backtracking out of a
+ // delimited submatcher into which we already descended. In backtracking out again, we need
+ // to advance the "dot" past the delimiters in the outer matcher.
while item.idx >= item.top_elts.len() {
match item.stack.pop() {
Some(MatcherTtFrame { elts, idx }) => {
item.top_elts = elts;
item.idx = idx + 1;
}
- None => break
+ None => break,
}
}
+ // Get the current position of the "dot" (`idx`) in `item` and the number of token trees in
+ // the matcher (`len`).
let idx = item.idx;
let len = item.top_elts.len();
- // at end of sequence
+ // If `idx >= len`, then we are at or past the end of the matcher of `item`.
if idx >= len {
- // We are repeating iff there is a parent
+ // We are repeating iff there is a parent. If the matcher is inside of a repetition,
+ // then we could be at the end of a sequence or at the beginning of the next
+ // repetition.
if item.up.is_some() {
- // Disregarding the separator, add the "up" case to the tokens that should be
- // examined.
- // (remove this condition to make trailing seps ok)
+ // At this point, regardless of whether there is a separator, we should add all
+ // matches from the complete repetition of the sequence to the shared, top-level
+ // `matches` list (actually, `up.matches`, which could itself not be the top-level,
+ // but anyway...). Moreover, we add another item to `cur_items` in which the "dot"
+ // is at the end of the `up` matcher. This ensures that the "dot" in the `up`
+ // matcher is also advanced sufficiently.
+ //
+ // NOTE: removing the condition `idx == len` allows trailing separators.
if idx == len {
+ // Get the `up` matcher
let mut new_pos = item.up.clone().unwrap();
- // update matches (the MBE "parse tree") by appending
- // each tree as a subtree.
-
- // Only touch the binders we have actually bound
+ // Add matches from this repetition to the `matches` of `up`
for idx in item.match_lo..item.match_hi {
let sub = item.matches[idx].clone();
let span = span.with_lo(item.sp_lo);
new_pos.push_match(idx, MatchedSeq(sub, span));
}
+ // Move the "dot" past the repetition in `up`
new_pos.match_cur = item.match_hi;
new_pos.idx += 1;
cur_items.push(new_pos);
}
- // Check if we need a separator
+ // Check if we need a separator.
if idx == len && item.sep.is_some() {
- // We have a separator, and it is the current token.
- if item.sep.as_ref().map(|sep| token_name_eq(token, sep)).unwrap_or(false) {
+ // We have a separator, and it is the current token. We can advance past the
+ // separator token.
+ if item.sep
+ .as_ref()
+ .map(|sep| token_name_eq(token, sep))
+ .unwrap_or(false)
+ {
item.idx += 1;
next_items.push(item);
}
- } else { // we don't need a separator
+ }
+ // We don't need a separator. Move the "dot" back to the beginning of the matcher
+ // and try to match again.
+ else {
item.match_cur = item.match_lo;
item.idx = 0;
cur_items.push(item);
}
- } else {
- // We aren't repeating, so we must be potentially at the end of the input.
+ }
+ // If we are not in a repetition, then being at the end of a matcher means that we have
+ // reached the potential end of the input.
+ else {
eof_items.push(item);
}
- } else {
+ }
+ // We are in the middle of a matcher.
+ else {
+ // Look at what token in the matcher we are trying to match the current token (`token`)
+ // against. Depending on that, we may generate new items.
match item.top_elts.get_tt(idx) {
- /* need to descend into sequence */
+ // Need to descend into a sequence
TokenTree::Sequence(sp, seq) => {
if seq.op == quoted::KleeneOp::ZeroOrMore {
// Examine the case where there are 0 matches of this sequence
top_elts: Tt(TokenTree::Sequence(sp, seq)),
}));
}
+
+ // We need to match a metavar (but the identifier is invalid)... this is an error
TokenTree::MetaVarDecl(span, _, id) if id.name == keywords::Invalid.name() => {
if sess.missing_fragment_specifiers.borrow_mut().remove(&span) {
return Error(span, "missing fragment specifier".to_string());
}
}
+
+ // We need to match a metavar with a valid ident... call out to the black-box
+ // parser by adding an item to `bb_items`.
TokenTree::MetaVarDecl(_, _, id) => {
// Built-in nonterminals never start with these tokens,
// so we can eliminate them from consideration.
bb_items.push(item);
}
}
+
+ // We need to descend into a delimited submatcher or a doc comment. To do this, we
+ // push the current matcher onto a stack and push a new item containing the
+ // submatcher onto `cur_items`.
+ //
+ // At the beginning of the loop, if we reach the end of the delimited submatcher,
+ // we pop the stack to backtrack out of the descent.
seq @ TokenTree::Delimited(..) | seq @ TokenTree::Token(_, DocComment(..)) => {
let lower_elts = mem::replace(&mut item.top_elts, Tt(seq));
let idx = item.idx;
item.idx = 0;
cur_items.push(item);
}
+
+ // We just matched a normal token. We can just advance the parser.
TokenTree::Token(_, ref t) if token_name_eq(t, token) => {
item.idx += 1;
next_items.push(item);
}
+
+ // There was another token that was not `token`... This means we can't add any
+ // rules. NOTE that this is not necessarily an error unless _all_ items in
+ // `cur_items` end up doing this. There may still be some other matchers that do
+ // end up working out.
TokenTree::Token(..) | TokenTree::MetaVar(..) => {}
}
}
}
+ // Yay a successful parse (so far)!
Success(())
}
-pub fn parse(sess: &ParseSess,
- tts: TokenStream,
- ms: &[TokenTree],
- directory: Option<Directory>,
- recurse_into_modules: bool)
- -> NamedParseResult {
+/// Use the given sequence of token trees (`ms`) as a matcher. Match the given token stream `tts`
+/// against it and return the match.
+///
+/// # Parameters
+///
+/// - `sess`: The session into which errors are emitted
+/// - `tts`: The tokenstream we are matching against the pattern `ms`
+/// - `ms`: A sequence of token trees representing a pattern against which we are matching
+/// - `directory`: Information about the file locations (needed for the black-box parser)
+/// - `recurse_into_modules`: Whether or not to recurse into modules (needed for the black-box
+/// parser)
+pub fn parse(
+ sess: &ParseSess,
+ tts: TokenStream,
+ ms: &[TokenTree],
+ directory: Option<Directory>,
+ recurse_into_modules: bool,
+) -> NamedParseResult {
+ // Create a parser that can be used for the "black box" parts.
let mut parser = Parser::new(sess, tts, directory, recurse_into_modules, true);
+
+ // A queue of possible matcher positions. We initialize it with the matcher position in which
+ // the "dot" is before the first token of the first token tree in `ms`. `inner_parse_loop` then
+ // processes all of these possible matcher positions and produces posible next positions into
+ // `next_items`. After some post-processing, the contents of `next_items` replenish `cur_items`
+ // and we start over again.
let mut cur_items = SmallVector::one(initial_matcher_pos(ms.to_owned(), parser.span.lo()));
- let mut next_items = Vec::new(); // or proceed normally
+ let mut next_items = Vec::new();
loop {
- let mut bb_items = SmallVector::new(); // black-box parsed by parser.rs
+ // Matcher positions black-box parsed by parser.rs (`parser`)
+ let mut bb_items = SmallVector::new();
+
+ // Matcher positions that would be valid if the macro invocation was over now
let mut eof_items = SmallVector::new();
assert!(next_items.is_empty());
- match inner_parse_loop(sess, &mut cur_items, &mut next_items, &mut eof_items, &mut bb_items,
- &parser.token, parser.span) {
- Success(_) => {},
+ // Process `cur_items` until either we have finished the input or we need to get some
+ // parsing from the black-box parser done. The result is that `next_items` will contain a
+ // bunch of possible next matcher positions in `next_items`.
+ match inner_parse_loop(
+ sess,
+ &mut cur_items,
+ &mut next_items,
+ &mut eof_items,
+ &mut bb_items,
+ &parser.token,
+ parser.span,
+ ) {
+ Success(_) => {}
Failure(sp, tok) => return Failure(sp, tok),
Error(sp, msg) => return Error(sp, msg),
}
// inner parse loop handled all cur_items, so it's empty
assert!(cur_items.is_empty());
- /* error messages here could be improved with links to orig. rules */
+ // We need to do some post processing after the `inner_parser_loop`.
+ //
+ // Error messages here could be improved with links to original rules.
+
+ // If we reached the EOF, check that there is EXACTLY ONE possible matcher. Otherwise,
+ // either the parse is ambiguous (which should never happen) or their is a syntax error.
if token_name_eq(&parser.token, &token::Eof) {
if eof_items.len() == 1 {
- let matches = eof_items[0].matches.iter_mut().map(|dv| {
- Rc::make_mut(dv).pop().unwrap()
- });
+ let matches = eof_items[0]
+ .matches
+ .iter_mut()
+ .map(|dv| Rc::make_mut(dv).pop().unwrap());
return nameize(sess, ms, matches);
} else if eof_items.len() > 1 {
- return Error(parser.span, "ambiguity: multiple successful parses".to_string());
+ return Error(
+ parser.span,
+ "ambiguity: multiple successful parses".to_string(),
+ );
} else {
return Failure(parser.span, token::Eof);
}
- } else if (!bb_items.is_empty() && !next_items.is_empty()) || bb_items.len() > 1 {
- let nts = bb_items.iter().map(|item| match item.top_elts.get_tt(item.idx) {
- TokenTree::MetaVarDecl(_, bind, name) => {
- format!("{} ('{}')", name, bind)
- }
- _ => panic!()
- }).collect::<Vec<String>>().join(" or ");
-
- return Error(parser.span, format!(
- "local ambiguity: multiple parsing options: {}",
- match next_items.len() {
- 0 => format!("built-in NTs {}.", nts),
- 1 => format!("built-in NTs {} or 1 other option.", nts),
- n => format!("built-in NTs {} or {} other options.", nts, n),
- }
- ));
- } else if bb_items.is_empty() && next_items.is_empty() {
+ }
+ // Another possibility is that we need to call out to parse some rust nonterminal
+ // (black-box) parser. However, if there is not EXACTLY ONE of these, something is wrong.
+ else if (!bb_items.is_empty() && !next_items.is_empty()) || bb_items.len() > 1 {
+ let nts = bb_items
+ .iter()
+ .map(|item| match item.top_elts.get_tt(item.idx) {
+ TokenTree::MetaVarDecl(_, bind, name) => format!("{} ('{}')", name, bind),
+ _ => panic!(),
+ })
+ .collect::<Vec<String>>()
+ .join(" or ");
+
+ return Error(
+ parser.span,
+ format!(
+ "local ambiguity: multiple parsing options: {}",
+ match next_items.len() {
+ 0 => format!("built-in NTs {}.", nts),
+ 1 => format!("built-in NTs {} or 1 other option.", nts),
+ n => format!("built-in NTs {} or {} other options.", nts, n),
+ }
+ ),
+ );
+ }
+ // If there are no posible next positions AND we aren't waiting for the black-box parser,
+ // then their is a syntax error.
+ else if bb_items.is_empty() && next_items.is_empty() {
return Failure(parser.span, parser.token);
- } else if !next_items.is_empty() {
- /* Now process the next token */
+ }
+ // Dump all possible `next_items` into `cur_items` for the next iteration.
+ else if !next_items.is_empty() {
+ // Now process the next token
cur_items.extend(next_items.drain(..));
parser.bump();
- } else /* bb_items.len() == 1 */ {
+ }
+ // Finally, we have the case where we need to call the black-box parser to get some
+ // nonterminal.
+ else {
+ assert_eq!(bb_items.len(), 1);
+
let mut item = bb_items.pop().unwrap();
if let TokenTree::MetaVarDecl(span, _, ident) = item.top_elts.get_tt(item.idx) {
let match_cur = item.match_cur;
- item.push_match(match_cur,
- MatchedNonterminal(Rc::new(parse_nt(&mut parser, span, &ident.name.as_str()))));
+ item.push_match(
+ match_cur,
+ MatchedNonterminal(Rc::new(parse_nt(&mut parser, span, &ident.name.as_str()))),
+ );
item.idx += 1;
item.match_cur += 1;
} else {
"expr" => token.can_begin_expr(),
"ty" => token.can_begin_type(),
"ident" => token.is_ident(),
- "vis" => match *token { // The follow-set of :vis + "priv" keyword + interpolated
+ "vis" => match *token {
+ // The follow-set of :vis + "priv" keyword + interpolated
Token::Comma | Token::Ident(_) | Token::Interpolated(_) => true,
_ => token.can_begin_type(),
},
"block" => match *token {
Token::OpenDelim(token::Brace) => true,
Token::Interpolated(ref nt) => match nt.0 {
- token::NtItem(_) |
- token::NtPat(_) |
- token::NtTy(_) |
- token::NtIdent(_) |
- token::NtMeta(_) |
- token::NtPath(_) |
- token::NtVis(_) => false, // none of these may start with '{'.
+ token::NtItem(_)
+ | token::NtPat(_)
+ | token::NtTy(_)
+ | token::NtIdent(_)
+ | token::NtMeta(_)
+ | token::NtPath(_)
+ | token::NtVis(_) => false, // none of these may start with '{'.
_ => true,
},
_ => false,
}
}
+/// A call to the "black-box" parser to parse some rust nonterminal.
+///
+/// # Parameters
+///
+/// - `p`: the "black-box" parser to use
+/// - `sp`: the `Span` we want to parse
+/// - `name`: the name of the metavar _matcher_ we want to match (e.g. `tt`, `ident`, `block`,
+/// etc...)
+///
+/// # Returns
+///
+/// The parsed nonterminal.
fn parse_nt<'a>(p: &mut Parser<'a>, sp: Span, name: &str) -> Nonterminal {
if name == "tt" {
return token::NtTT(p.parse_token_tree());
"ident" => match p.token {
token::Ident(sn) => {
p.bump();
- token::NtIdent(Spanned::<Ident>{node: sn, span: p.prev_span})
+ token::NtIdent(Spanned::<Ident> {
+ node: sn,
+ span: p.prev_span,
+ })
}
_ => {
let token_str = pprust::token_to_string(&p.token);
- p.fatal(&format!("expected ident, found {}",
- &token_str[..])).emit();
+ p.fatal(&format!("expected ident, found {}", &token_str[..]))
+ .emit();
FatalError.raise()
}
},
"lifetime" => token::NtLifetime(p.expect_lifetime()),
// this is not supposed to happen, since it has been checked
// when compiling the macro.
- _ => p.span_bug(sp, "invalid fragment specifier")
+ _ => p.span_bug(sp, "invalid fragment specifier"),
}
}
use ast;
use ext::tt::macro_parser;
-use parse::{ParseSess, token};
+use parse::{token, ParseSess};
use print::pprust;
use symbol::keywords;
-use syntax_pos::{DUMMY_SP, Span, BytePos};
+use syntax_pos::{BytePos, Span, DUMMY_SP};
use tokenstream;
use std::rc::Rc;
+/// Contains the sub-token-trees of a "delimited" token tree, such as the contents of `(`. Note
+/// that the delimiter itself might be `NoDelim`.
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct Delimited {
pub delim: token::DelimToken,
}
impl Delimited {
+ /// Return the opening delimiter (possibly `NoDelim`).
pub fn open_token(&self) -> token::Token {
token::OpenDelim(self.delim)
}
+ /// Return 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.
pub fn open_tt(&self, span: Span) -> TokenTree {
let open_span = if span == DUMMY_SP {
DUMMY_SP
TokenTree::Token(open_span, self.open_token())
}
+ /// Return a `self::TokenTree` with a `Span` corresponding to the closing delimiter.
pub fn close_tt(&self, span: Span) -> TokenTree {
let close_span = if span == DUMMY_SP {
DUMMY_SP
/// for token sequences.
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum KleeneOp {
+ /// Kleene star (`*`) for zero or more repetitions
ZeroOrMore,
+ /// Kleene plus (`+`) for one or more repetitions
OneOrMore,
}
/// Similar to `tokenstream::TokenTree`, except that `$i`, `$i:ident`, and `$(...)`
-/// are "first-class" token trees.
+/// are "first-class" token trees. Useful for parsing macros.
#[derive(Debug, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)]
pub enum TokenTree {
Token(Span, token::Token),
/// E.g. `$var`
MetaVar(Span, ast::Ident),
/// E.g. `$var:expr`. This is only used in the left hand side of MBE macros.
- MetaVarDecl(Span, ast::Ident /* name to bind */, ast::Ident /* kind of nonterminal */),
+ MetaVarDecl(
+ Span,
+ ast::Ident, /* name to bind */
+ ast::Ident, /* kind of nonterminal */
+ ),
}
impl TokenTree {
+ /// Return the number of tokens in the tree.
pub fn len(&self) -> usize {
match *self {
TokenTree::Delimited(_, ref delimed) => match delimed.delim {
}
}
+ /// 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 {
TokenTree::Delimited(_, ref delimed) => match delimed.delim {
}
}
+ /// Get 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.
pub fn span(&self) -> Span {
match *self {
- TokenTree::Token(sp, _) |
- TokenTree::MetaVar(sp, _) |
- TokenTree::MetaVarDecl(sp, _, _) |
- TokenTree::Delimited(sp, _) |
- TokenTree::Sequence(sp, _) => sp,
+ TokenTree::Token(sp, _)
+ | TokenTree::MetaVar(sp, _)
+ | TokenTree::MetaVarDecl(sp, _, _)
+ | TokenTree::Delimited(sp, _)
+ | TokenTree::Sequence(sp, _) => sp,
}
}
}
-pub fn parse(input: tokenstream::TokenStream, expect_matchers: bool, sess: &ParseSess)
- -> Vec<TokenTree> {
+/// Takes a `tokenstream::TokenStream` and returns a `Vec<self::TokenTree>`. Specifically, this
+/// takes a generic `TokenStream`, such as is used in the rest of the compiler, and returns a
+/// collection of `TokenTree` for use in parsing a macro.
+///
+/// # Parameters
+///
+/// - `input`: a token stream to read from, the contents of which we are parsing.
+/// - `expect_matchers`: `parse` can be used to parse either the "patterns" or the "body" of a
+/// macro. Both take roughly the same form _except_ that in a pattern, metavars are declared with
+/// their "matcher" type. For example `$var:expr` or `$id:ident`. In this example, `expr` and
+/// `ident` are "matchers". They are not present in the body of a macro rule -- just in the
+/// pattern, so we pass a parameter to indicate whether to expect them or not.
+/// - `sess`: the parsing session. Any errors will be emitted to this session.
+///
+/// # Returns
+///
+/// A collection of `self::TokenTree`. There may also be some errors emitted to `sess`.
+pub fn parse(
+ input: tokenstream::TokenStream,
+ expect_matchers: bool,
+ sess: &ParseSess,
+) -> Vec<TokenTree> {
+ // Will contain the final collection of `self::TokenTree`
let mut result = Vec::new();
+
+ // For each token tree in `input`, parse the token into a `self::TokenTree`, consuming
+ // additional trees if need be.
let mut trees = input.trees();
while let Some(tree) = trees.next() {
let tree = parse_tree(tree, &mut trees, expect_matchers, sess);
+
+ // Given the parsed tree, if there is a metavar and we are expecting matchers, actually
+ // parse out the matcher (i.e. in `$id:ident` this would parse the `:` and `ident`).
match tree {
TokenTree::MetaVar(start_sp, ident) if expect_matchers => {
let span = match trees.next() {
Some(kind) => {
let span = end_sp.with_lo(start_sp.lo());
result.push(TokenTree::MetaVarDecl(span, ident, kind));
- continue
+ continue;
}
_ => end_sp,
},
- tree => tree.as_ref().map(tokenstream::TokenTree::span).unwrap_or(span),
+ tree => tree.as_ref()
+ .map(tokenstream::TokenTree::span)
+ .unwrap_or(span),
},
- tree => tree.as_ref().map(tokenstream::TokenTree::span).unwrap_or(start_sp),
+ tree => tree.as_ref()
+ .map(tokenstream::TokenTree::span)
+ .unwrap_or(start_sp),
};
sess.missing_fragment_specifiers.borrow_mut().insert(span);
- result.push(TokenTree::MetaVarDecl(span, ident, keywords::Invalid.ident()));
+ result.push(TokenTree::MetaVarDecl(
+ span,
+ ident,
+ keywords::Invalid.ident(),
+ ));
}
+
+ // Not a metavar or no matchers allowed, so just return the tree
_ => result.push(tree),
}
}
result
}
-fn parse_tree<I>(tree: tokenstream::TokenTree,
- trees: &mut I,
- expect_matchers: bool,
- sess: &ParseSess)
- -> TokenTree
- where I: Iterator<Item = tokenstream::TokenTree>,
+/// Takes a `tokenstream::TokenTree` and returns a `self::TokenTree`. Specifically, this takes a
+/// generic `TokenTree`, such as is used in the rest of the compiler, and returns a `TokenTree`
+/// for use in parsing a macro.
+///
+/// Converting the given tree may involve reading more tokens.
+///
+/// # Parameters
+///
+/// - `tree`: the tree we wish to convert.
+/// - `trees`: an iterator over trees. We may need to read more tokens from it in order to finish
+/// converting `tree`
+/// - `expect_matchers`: same as for `parse` (see above).
+/// - `sess`: the parsing session. Any errors will be emitted to this session.
+fn parse_tree<I>(
+ tree: tokenstream::TokenTree,
+ trees: &mut I,
+ expect_matchers: bool,
+ sess: &ParseSess,
+) -> TokenTree
+where
+ I: Iterator<Item = tokenstream::TokenTree>,
{
+ // Depending on what `tree` is, we could be parsing different parts of a macro
match tree {
+ // `tree` is a `$` token. Look at the next token in `trees`
tokenstream::TokenTree::Token(span, token::Dollar) => match trees.next() {
+ // `tree` is followed by a delimited set of token trees. This indicates the beginning
+ // of a repetition sequence in the macro (e.g. `$(pat)*`).
Some(tokenstream::TokenTree::Delimited(span, delimited)) => {
+ // Must have `(` not `{` or `[`
if delimited.delim != token::Paren {
let tok = pprust::token_to_string(&token::OpenDelim(delimited.delim));
let msg = format!("expected `(`, found `{}`", tok);
sess.span_diagnostic.span_err(span, &msg);
}
+ // Parse the contents of the sequence itself
let sequence = parse(delimited.tts.into(), expect_matchers, sess);
+ // Get the Kleene operator and optional separator
let (separator, op) = parse_sep_and_kleene_op(trees, span, sess);
+ // Count the number of captured "names" (i.e. named metavars)
let name_captures = macro_parser::count_names(&sequence);
- TokenTree::Sequence(span, Rc::new(SequenceRepetition {
- tts: sequence,
- separator,
- op,
- num_captures: name_captures,
- }))
+ TokenTree::Sequence(
+ span,
+ Rc::new(SequenceRepetition {
+ tts: sequence,
+ separator,
+ op,
+ num_captures: name_captures,
+ }),
+ )
}
+
+ // `tree` is followed by an `ident`. This could be `$meta_var` or the `$crate` special
+ // metavariable that names the crate of the invokation.
Some(tokenstream::TokenTree::Token(ident_span, ref token)) if token.is_ident() => {
let ident = token.ident().unwrap();
let span = ident_span.with_lo(span.lo());
if ident.name == keywords::Crate.name() {
- let ident = ast::Ident { name: keywords::DollarCrate.name(), ..ident };
+ let ident = ast::Ident {
+ name: keywords::DollarCrate.name(),
+ ..ident
+ };
TokenTree::Token(span, token::Ident(ident))
} else {
TokenTree::MetaVar(span, ident)
}
}
+
+ // `tree` is followed by a random token. This is an error.
Some(tokenstream::TokenTree::Token(span, tok)) => {
- let msg = format!("expected identifier, found `{}`", pprust::token_to_string(&tok));
+ let msg = format!(
+ "expected identifier, found `{}`",
+ pprust::token_to_string(&tok)
+ );
sess.span_diagnostic.span_err(span, &msg);
TokenTree::MetaVar(span, keywords::Invalid.ident())
}
+
+ // There are no more tokens. Just return the `$` we already have.
None => TokenTree::Token(span, token::Dollar),
},
+
+ // `tree` is an arbitrary token. Keep it.
tokenstream::TokenTree::Token(span, tok) => TokenTree::Token(span, tok),
- tokenstream::TokenTree::Delimited(span, delimited) => {
- TokenTree::Delimited(span, Rc::new(Delimited {
+
+ // `tree` is the beginning of a delimited set of tokens (e.g. `(` or `{`). We need to
+ // descend into the delimited set and further parse it.
+ tokenstream::TokenTree::Delimited(span, delimited) => TokenTree::Delimited(
+ span,
+ Rc::new(Delimited {
delim: delimited.delim,
tts: parse(delimited.tts.into(), expect_matchers, sess),
- }))
- }
+ }),
+ ),
}
}
-fn parse_sep_and_kleene_op<I>(input: &mut I, span: Span, sess: &ParseSess)
- -> (Option<token::Token>, KleeneOp)
- where I: Iterator<Item = tokenstream::TokenTree>,
+/// Attempt to parse a single Kleene star, possibly with a separator.
+///
+/// For example, in a pattern such as `$(a),*`, `a` is the pattern to be repeated, `,` is the
+/// separator, and `*` is the Kleene operator. This function is specifically concerned with parsing
+/// the last two tokens of such a pattern: namely, the optional separator and the Kleene operator
+/// itself. Note that here we are parsing the _macro_ itself, rather than trying to match some
+/// stream of tokens in an invocation of a macro.
+///
+/// This function will take some input iterator `input` corresponding to `span` and a parsing
+/// session `sess`. If the next one (or possibly two) tokens in `input` correspond to a Kleene
+/// 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.
+fn parse_sep_and_kleene_op<I>(
+ input: &mut I,
+ span: Span,
+ sess: &ParseSess,
+) -> (Option<token::Token>, KleeneOp)
+where
+ I: Iterator<Item = tokenstream::TokenTree>,
{
fn kleene_op(token: &token::Token) -> Option<KleeneOp> {
match *token {
}
}
+ // We attempt to look at the next two token trees in `input`. I will call the first #1 and the
+ // second #2. If #1 and #2 don't match a valid KleeneOp with/without separator, that is an
+ // error, and we should emit an error on the most specific span possible.
let span = match input.next() {
+ // #1 is a token
Some(tokenstream::TokenTree::Token(span, tok)) => match kleene_op(&tok) {
+ // #1 is a KleeneOp with no separator
Some(op) => return (None, op),
+
+ // #1 is not a KleeneOp, but may be a separator... need to look at #2
None => match input.next() {
+ // #2 is a token
Some(tokenstream::TokenTree::Token(span, tok2)) => match kleene_op(&tok2) {
+ // #2 is a KleeneOp, so #1 must be a separator
Some(op) => return (Some(tok), op),
+
+ // #2 is not a KleeneOp... error
None => span,
},
- tree => tree.as_ref().map(tokenstream::TokenTree::span).unwrap_or(span),
- }
+
+ // #2 is not a token at all... error
+ tree => tree.as_ref()
+ .map(tokenstream::TokenTree::span)
+ .unwrap_or(span),
+ },
},
- tree => tree.as_ref().map(tokenstream::TokenTree::span).unwrap_or(span),
+
+ // #1 is not a token at all... error
+ tree => tree.as_ref()
+ .map(tokenstream::TokenTree::span)
+ .unwrap_or(span),
};
+ // Error...
sess.span_diagnostic.span_err(span, "expected `*` or `+`");
(None, KleeneOp::ZeroOrMore)
}
("thread_local", Whitelisted, Gated(Stability::Unstable,
"thread_local",
"`#[thread_local]` is an experimental feature, and does \
- not currently handle destructors. There is no \
- corresponding `#[task_local]` mapping to the task \
- model",
+ not currently handle destructors.",
cfg_fn!(thread_local))),
("rustc_on_unimplemented", Normal, Gated(Stability::Unstable,
is just used for rustc unit tests \
and will never be stable",
cfg_fn!(rustc_attrs))),
+ ("rustc_serialize_exclude_null", Normal, Gated(Stability::Unstable,
+ "rustc_attrs",
+ "the `#[rustc_serialize_exclude_null]` attribute \
+ is an internal-only feature",
+ cfg_fn!(rustc_attrs))),
("rustc_synthetic", Whitelisted, Gated(Stability::Unstable,
"rustc_attrs",
"this attribute \
registry: Option<Registry>,
cm: Rc<CodeMapper + 'static>,
pretty: bool,
+ /// Whether "approximate suggestions" are enabled in the config
+ approximate_suggestions: bool,
}
impl JsonEmitter {
pub fn stderr(registry: Option<Registry>,
code_map: Rc<CodeMap>,
- pretty: bool) -> JsonEmitter {
+ pretty: bool,
+ approximate_suggestions: bool) -> JsonEmitter {
JsonEmitter {
dst: Box::new(io::stderr()),
registry,
cm: code_map,
pretty,
+ approximate_suggestions,
}
}
pub fn basic(pretty: bool) -> JsonEmitter {
let file_path_mapping = FilePathMapping::empty();
- JsonEmitter::stderr(None, Rc::new(CodeMap::new(file_path_mapping)), pretty)
+ JsonEmitter::stderr(None, Rc::new(CodeMap::new(file_path_mapping)),
+ pretty, false)
}
pub fn new(dst: Box<Write + Send>,
registry: Option<Registry>,
code_map: Rc<CodeMap>,
- pretty: bool) -> JsonEmitter {
+ pretty: bool,
+ approximate_suggestions: bool) -> JsonEmitter {
JsonEmitter {
dst,
registry,
cm: code_map,
pretty,
+ approximate_suggestions,
}
}
}
}
#[derive(RustcEncodable)]
+#[allow(unused_attributes)]
struct DiagnosticSpan {
file_name: String,
byte_start: u32,
/// If we are suggesting a replacement, this will contain text
/// that should be sliced in atop this span.
suggested_replacement: Option<String>,
+ /// If the suggestion is approximate
+ #[rustc_serialize_exclude_null]
+ suggestion_approximate: Option<bool>,
/// Macro invocations that created the code at this span, if any.
expansion: Option<Box<DiagnosticSpanMacroExpansion>>,
}
}
let buf = BufWriter::default();
let output = buf.clone();
- EmitterWriter::new(Box::new(buf), Some(je.cm.clone()), false).emit(db);
+ EmitterWriter::new(Box::new(buf), Some(je.cm.clone()), false, false).emit(db);
let output = Arc::try_unwrap(output.0).unwrap().into_inner().unwrap();
let output = String::from_utf8(output).unwrap();
impl DiagnosticSpan {
fn from_span_label(span: SpanLabel,
- suggestion: Option<&String>,
+ suggestion: Option<(&String, bool)>,
je: &JsonEmitter)
-> DiagnosticSpan {
Self::from_span_etc(span.span,
fn from_span_etc(span: Span,
is_primary: bool,
label: Option<String>,
- suggestion: Option<&String>,
+ suggestion: Option<(&String, bool)>,
je: &JsonEmitter)
-> DiagnosticSpan {
// obtain the full backtrace from the `macro_backtrace`
fn from_span_full(span: Span,
is_primary: bool,
label: Option<String>,
- suggestion: Option<&String>,
+ suggestion: Option<(&String, bool)>,
mut backtrace: vec::IntoIter<MacroBacktrace>,
je: &JsonEmitter)
-> DiagnosticSpan {
def_site_span,
})
});
+
+ let suggestion_approximate = if je.approximate_suggestions {
+ suggestion.map(|x| x.1)
+ } else {
+ None
+ };
+
DiagnosticSpan {
file_name: start.file.name.to_string(),
byte_start: span.lo().0 - start.file.start_pos.0,
column_end: end.col.0 + 1,
is_primary,
text: DiagnosticSpanLine::from_span(span, je),
- suggested_replacement: suggestion.cloned(),
+ suggested_replacement: suggestion.map(|x| x.0.clone()),
+ suggestion_approximate,
expansion: backtrace_step,
label,
}
suggestion.substitutions
.iter()
.flat_map(|substitution| {
- substitution.parts.iter().map(move |suggestion| {
+ substitution.parts.iter().map(move |suggestion_inner| {
let span_label = SpanLabel {
- span: suggestion.span,
+ span: suggestion_inner.span,
is_primary: true,
label: None,
};
DiagnosticSpan::from_span_label(span_label,
- Some(&suggestion.snippet),
+ Some((&suggestion_inner.snippet,
+ suggestion.approximate)),
je)
})
})
#![feature(match_default_bindings)]
#![feature(i128_type)]
#![feature(const_atomic_usize_new)]
+#![feature(rustc_attrs)]
// See librustc_cratesio_shim/Cargo.toml for a comment explaining this.
#[allow(unused_extern_crates)]
fn mk_sess(cm: Rc<CodeMap>) -> ParseSess {
let emitter = errors::emitter::EmitterWriter::new(Box::new(io::sink()),
Some(cm.clone()),
+ false,
false);
ParseSess {
span_diagnostic: errors::Handler::with_emitter(true, false, Box::new(emitter)),
expect.clone()
};
(format!("expected one of {}, found `{}`", expect, actual),
- (self.prev_span.next_point(), format!("expected one of {} here", short_expect)))
+ (self.sess.codemap().next_point(self.prev_span),
+ format!("expected one of {} here", short_expect)))
} else if expected.is_empty() {
(format!("unexpected token: `{}`", actual),
(self.prev_span, "unexpected token after this".to_string()))
} else {
(format!("expected {}, found `{}`", expect, actual),
- (self.prev_span.next_point(), format!("expected {} here", expect)))
+ (self.sess.codemap().next_point(self.prev_span),
+ format!("expected {} here", expect)))
};
let mut err = self.fatal(&msg_exp);
let sp = if self.token == token::Token::Eof {
self.expect_keyword(keywords::Fn)?;
let (inputs, variadic) = self.parse_fn_args(false, true)?;
- let ret_ty = self.parse_ret_ty()?;
+ let ret_ty = self.parse_ret_ty(false)?;
let decl = P(FnDecl {
inputs,
output: ret_ty,
}
/// Parse optional return type [ -> TY ] in function decl
- pub fn parse_ret_ty(&mut self) -> PResult<'a, FunctionRetTy> {
+ fn parse_ret_ty(&mut self, allow_plus: bool) -> PResult<'a, FunctionRetTy> {
if self.eat(&token::RArrow) {
- Ok(FunctionRetTy::Ty(self.parse_ty_no_plus()?))
+ Ok(FunctionRetTy::Ty(self.parse_ty_common(allow_plus, true)?))
} else {
Ok(FunctionRetTy::Default(self.span.with_hi(self.span.lo())))
}
maybe_whole!(self, NtTy, |x| x);
let lo = self.span;
+ let mut impl_dyn_multi = false;
let node = if self.eat(&token::OpenDelim(token::Paren)) {
// `(TYPE)` is a parenthesized type.
// `(TYPE,)` is a tuple with a single field of type TYPE.
self.parse_remaining_bounds(lifetime_defs, path, lo, parse_plus)?
}
} else if self.eat_keyword(keywords::Impl) {
- // FIXME: figure out priority of `+` in `impl Trait1 + Trait2` (#34511).
- TyKind::ImplTrait(self.parse_ty_param_bounds()?)
+ // Always parse bounds greedily for better error recovery.
+ let bounds = self.parse_ty_param_bounds()?;
+ impl_dyn_multi = bounds.len() > 1 || self.prev_token_kind == PrevTokenKind::Plus;
+ TyKind::ImplTrait(bounds)
} else if self.check_keyword(keywords::Dyn) &&
self.look_ahead(1, |t| t.can_begin_bound() && !can_continue_type_after_ident(t)) {
- // FIXME: figure out priority of `+` in `dyn Trait1 + Trait2` (#34511).
self.bump(); // `dyn`
- TyKind::TraitObject(self.parse_ty_param_bounds()?, TraitObjectSyntax::Dyn)
+ // Always parse bounds greedily for better error recovery.
+ let bounds = self.parse_ty_param_bounds()?;
+ impl_dyn_multi = bounds.len() > 1 || self.prev_token_kind == PrevTokenKind::Plus;
+ TyKind::TraitObject(bounds, TraitObjectSyntax::Dyn)
} else if self.check(&token::Question) ||
self.check_lifetime() && self.look_ahead(1, |t| t == &token::BinOp(token::Plus)) {
// Bound list (trait object type)
let ty = Ty { node, span, id: ast::DUMMY_NODE_ID };
// Try to recover from use of `+` with incorrect priority.
+ self.maybe_report_ambiguous_plus(allow_plus, impl_dyn_multi, &ty);
self.maybe_recover_from_bad_type_plus(allow_plus, &ty)?;
let ty = self.maybe_recover_from_bad_qpath(ty, allow_qpath_recovery)?;
Ok(TyKind::TraitObject(bounds, TraitObjectSyntax::None))
}
+ fn maybe_report_ambiguous_plus(&mut self, allow_plus: bool, impl_dyn_multi: bool, ty: &Ty) {
+ if !allow_plus && impl_dyn_multi {
+ let sum_with_parens = format!("({})", pprust::ty_to_string(&ty));
+ self.struct_span_err(ty.span, "ambiguous `+` in a type")
+ .span_suggestion(ty.span, "use parentheses to disambiguate", sum_with_parens)
+ .emit();
+ }
+ }
+
fn maybe_recover_from_bad_type_plus(&mut self, allow_plus: bool, ty: &Ty) -> PResult<'a, ()> {
// Do not add `+` to expected tokens.
if !allow_plus || self.token != token::BinOp(token::Plus) {
// return. This won't catch blocks with an explicit `return`, but that would be caught by
// the dead code lint.
if self.eat_keyword(keywords::Else) || !cond.returns() {
- let sp = lo.next_point();
+ let sp = self.sess.codemap().next_point(lo);
let mut err = self.diagnostic()
.struct_span_err(sp, "missing condition for `if` statemement");
err.span_label(sp, "expected if condition here");
pub fn parse_fn_decl(&mut self, allow_variadic: bool) -> PResult<'a, P<FnDecl>> {
let (args, variadic) = self.parse_fn_args(true, allow_variadic)?;
- let ret_ty = self.parse_ret_ty()?;
+ let ret_ty = self.parse_ret_ty(true)?;
Ok(P(FnDecl {
inputs: args,
self.expect(&token::CloseDelim(token::Paren))?;
Ok(P(FnDecl {
inputs: fn_inputs,
- output: self.parse_ret_ty()?,
+ output: self.parse_ret_ty(true)?,
variadic: false
}))
}
args
}
};
- let output = self.parse_ret_ty()?;
+ let output = self.parse_ret_ty(true)?;
Ok(P(FnDecl {
inputs: inputs_captures,
self.expect(&token::Semi)?;
let prev_span = self.prev_span;
+
Ok(self.mk_item(lo.to(prev_span),
ident,
ItemKind::ExternCrate(maybe_path),
let emitter = EmitterWriter::new(Box::new(Shared { data: output.clone() }),
Some(code_map.clone()),
+ false,
false);
let handler = Handler::with_emitter(true, false, Box::new(emitter));
handler.span_err(msp, "foo");
Struct(_, ref fields) => {
let emit_struct_field = cx.ident_of("emit_struct_field");
let mut stmts = Vec::new();
- for (i, &FieldInfo { name, ref self_, span, .. }) in fields.iter().enumerate() {
+ for (i, &FieldInfo { name, ref self_, span, attrs, .. }) in fields.iter().enumerate() {
let name = match name {
Some(id) => id.name,
None => Symbol::intern(&format!("_field{}", i)),
} else {
cx.expr(span, ExprKind::Ret(Some(call)))
};
- stmts.push(cx.stmt_expr(call));
+
+ // This exists for https://github.com/rust-lang/rust/pull/47540
+ //
+ // If we decide to stabilize that flag this can be removed
+ let expr = if attrs.iter().any(|a| a.check_name("rustc_serialize_exclude_null")) {
+ let is_some = cx.ident_of("is_some");
+ let condition = cx.expr_method_call(span, self_.clone(), is_some, vec![]);
+ cx.expr_if(span, condition, call, None)
+ } else {
+ call
+ };
+ let stmt = cx.stmt_expr(expr);
+ stmts.push(stmt);
}
// unit structs have no fields and need to return Ok()
&catch_all_substructure);
// Final wrinkle: the self_args are expressions that deref
- // down to desired l-values, but we cannot actually deref
+ // down to desired places, but we cannot actually deref
// them when they are fed as r-values into a tuple
// expression; here add a layer of borrowing, turning
// `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`.
} else {
// Final wrinkle: the self_args are expressions that deref
- // down to desired l-values, but we cannot actually deref
+ // down to desired places, but we cannot actually deref
// them when they are fed as r-values into a tuple
// expression; here add a layer of borrowing, turning
// `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`.
self.data().with_ctxt(ctxt)
}
- /// Returns a new span representing just the end-point of this span
- pub fn end_point(self) -> Span {
- let span = self.data();
- let lo = cmp::max(span.hi.0 - 1, span.lo.0);
- span.with_lo(BytePos(lo))
- }
-
- /// Returns a new span representing the next character after the end-point of this span
- pub fn next_point(self) -> Span {
- let span = self.data();
- let lo = cmp::max(span.hi.0, span.lo.0 + 1);
- Span::new(BytePos(lo), BytePos(lo), span.ctxt)
- }
-
/// Returns `self` if `self` is not the dummy span, and `other` otherwise.
pub fn substitute_dummy(self, other: Span) -> Span {
if self.source_equal(&DUMMY_SP) { other } else { self }
--- /dev/null
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use super::*;
+
+pub(crate) struct JsonFormatter<T> {
+ out: OutputLocation<T>,
+}
+
+impl<T: Write> JsonFormatter<T> {
+ pub fn new(out: OutputLocation<T>) -> Self {
+ Self { out }
+ }
+
+ fn write_message(&mut self, s: &str) -> io::Result<()> {
+ assert!(!s.contains('\n'));
+
+ self.out.write_all(s.as_ref())?;
+ self.out.write_all(b"\n")
+ }
+
+ fn write_event(
+ &mut self,
+ ty: &str,
+ name: &str,
+ evt: &str,
+ extra: Option<String>,
+ ) -> io::Result<()> {
+ if let Some(extras) = extra {
+ self.write_message(&*format!(
+ r#"{{ "type": "{}", "name": "{}", "event": "{}", {} }}"#,
+ ty,
+ name,
+ evt,
+ extras
+ ))
+ } else {
+ self.write_message(&*format!(
+ r#"{{ "type": "{}", "name": "{}", "event": "{}" }}"#,
+ ty,
+ name,
+ evt
+ ))
+ }
+ }
+}
+
+impl<T: Write> OutputFormatter for JsonFormatter<T> {
+ fn write_run_start(&mut self, test_count: usize) -> io::Result<()> {
+ self.write_message(&*format!(
+ r#"{{ "type": "suite", "event": "started", "test_count": "{}" }}"#,
+ test_count
+ ))
+ }
+
+ fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
+ self.write_message(&*format!(
+ r#"{{ "type": "test", "event": "started", "name": "{}" }}"#,
+ desc.name
+ ))
+ }
+
+ fn write_result(
+ &mut self,
+ desc: &TestDesc,
+ result: &TestResult,
+ stdout: &[u8],
+ ) -> io::Result<()> {
+ match *result {
+ TrOk => self.write_event("test", desc.name.as_slice(), "ok", None),
+
+ TrFailed => {
+ let extra_data = if stdout.len() > 0 {
+ Some(format!(
+ r#""stdout": "{}""#,
+ EscapedString(String::from_utf8_lossy(stdout))
+ ))
+ } else {
+ None
+ };
+
+ self.write_event("test", desc.name.as_slice(), "failed", extra_data)
+ }
+
+ TrFailedMsg(ref m) => {
+ self.write_event(
+ "test",
+ desc.name.as_slice(),
+ "failed",
+ Some(format!(r#""message": "{}""#, EscapedString(m))),
+ )
+ }
+
+ TrIgnored => self.write_event("test", desc.name.as_slice(), "ignored", None),
+
+ TrAllowedFail => {
+ self.write_event("test", desc.name.as_slice(), "allowed_failure", None)
+ }
+
+ TrBench(ref bs) => {
+ let median = bs.ns_iter_summ.median as usize;
+ let deviation = (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as usize;
+
+ let mbps = if bs.mb_s == 0 {
+ "".into()
+ } else {
+ format!(r#", "mib_per_second": {}"#, bs.mb_s)
+ };
+
+ let line = format!(
+ "{{ \"type\": \"bench\", \
+ \"name\": \"{}\", \
+ \"median\": {}, \
+ \"deviation\": {}{} }}",
+ desc.name,
+ median,
+ deviation,
+ mbps
+ );
+
+ self.write_message(&*line)
+ }
+ }
+ }
+
+ fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
+ self.write_message(&*format!(
+ r#"{{ "type": "test", "event": "timeout", "name": "{}" }}"#,
+ desc.name
+ ))
+ }
+
+ fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
+
+ self.write_message(&*format!(
+ "{{ \"type\": \"suite\", \
+ \"event\": \"{}\", \
+ \"passed\": {}, \
+ \"failed\": {}, \
+ \"allowed_fail\": {}, \
+ \"ignored\": {}, \
+ \"measured\": {}, \
+ \"filtered_out\": \"{}\" }}",
+ if state.failed == 0 { "ok" } else { "failed" },
+ state.passed,
+ state.failed + state.allowed_fail,
+ state.allowed_fail,
+ state.ignored,
+ state.measured,
+ state.filtered_out
+ ))?;
+
+ Ok(state.failed == 0)
+ }
+}
+
+/// A formatting utility used to print strings with characters in need of escaping.
+/// Base code taken form `libserialize::json::escape_str`
+struct EscapedString<S: AsRef<str>>(S);
+
+impl<S: AsRef<str>> ::std::fmt::Display for EscapedString<S> {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+ let mut start = 0;
+
+ for (i, byte) in self.0.as_ref().bytes().enumerate() {
+ let escaped = match byte {
+ b'"' => "\\\"",
+ b'\\' => "\\\\",
+ b'\x00' => "\\u0000",
+ b'\x01' => "\\u0001",
+ b'\x02' => "\\u0002",
+ b'\x03' => "\\u0003",
+ b'\x04' => "\\u0004",
+ b'\x05' => "\\u0005",
+ b'\x06' => "\\u0006",
+ b'\x07' => "\\u0007",
+ b'\x08' => "\\b",
+ b'\t' => "\\t",
+ b'\n' => "\\n",
+ b'\x0b' => "\\u000b",
+ b'\x0c' => "\\f",
+ b'\r' => "\\r",
+ b'\x0e' => "\\u000e",
+ b'\x0f' => "\\u000f",
+ b'\x10' => "\\u0010",
+ b'\x11' => "\\u0011",
+ b'\x12' => "\\u0012",
+ b'\x13' => "\\u0013",
+ b'\x14' => "\\u0014",
+ b'\x15' => "\\u0015",
+ b'\x16' => "\\u0016",
+ b'\x17' => "\\u0017",
+ b'\x18' => "\\u0018",
+ b'\x19' => "\\u0019",
+ b'\x1a' => "\\u001a",
+ b'\x1b' => "\\u001b",
+ b'\x1c' => "\\u001c",
+ b'\x1d' => "\\u001d",
+ b'\x1e' => "\\u001e",
+ b'\x1f' => "\\u001f",
+ b'\x7f' => "\\u007f",
+ _ => {
+ continue;
+ }
+ };
+
+ if start < i {
+ f.write_str(&self.0.as_ref()[start..i])?;
+ }
+
+ f.write_str(escaped)?;
+
+ start = i + 1;
+ }
+
+ if start != self.0.as_ref().len() {
+ f.write_str(&self.0.as_ref()[start..])?;
+ }
+
+ Ok(())
+ }
+}
--- /dev/null
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use super::*;
+
+mod pretty;
+mod json;
+mod terse;
+
+pub(crate) use self::pretty::PrettyFormatter;
+pub(crate) use self::json::JsonFormatter;
+pub(crate) use self::terse::TerseFormatter;
+
+pub(crate) trait OutputFormatter {
+ fn write_run_start(&mut self, test_count: usize) -> io::Result<()>;
+ fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()>;
+ fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()>;
+ fn write_result(
+ &mut self,
+ desc: &TestDesc,
+ result: &TestResult,
+ stdout: &[u8],
+ ) -> io::Result<()>;
+ fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool>;
+}
--- /dev/null
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use super::*;
+
+pub(crate) struct PrettyFormatter<T> {
+ out: OutputLocation<T>,
+ use_color: bool,
+
+ /// Number of columns to fill when aligning names
+ max_name_len: usize,
+
+ is_multithreaded: bool,
+}
+
+impl<T: Write> PrettyFormatter<T> {
+ pub fn new(
+ out: OutputLocation<T>,
+ use_color: bool,
+ max_name_len: usize,
+ is_multithreaded: bool,
+ ) -> Self {
+ PrettyFormatter {
+ out,
+ use_color,
+ max_name_len,
+ is_multithreaded,
+ }
+ }
+
+ #[cfg(test)]
+ pub fn output_location(&self) -> &OutputLocation<T> {
+ &self.out
+ }
+
+ pub fn write_ok(&mut self) -> io::Result<()> {
+ self.write_short_result("ok", term::color::GREEN)
+ }
+
+ pub fn write_failed(&mut self) -> io::Result<()> {
+ self.write_short_result("FAILED", term::color::RED)
+ }
+
+ pub fn write_ignored(&mut self) -> io::Result<()> {
+ self.write_short_result("ignored", term::color::YELLOW)
+ }
+
+ pub fn write_allowed_fail(&mut self) -> io::Result<()> {
+ self.write_short_result("FAILED (allowed)", term::color::YELLOW)
+ }
+
+ pub fn write_bench(&mut self) -> io::Result<()> {
+ self.write_pretty("bench", term::color::CYAN)
+ }
+
+ pub fn write_short_result(
+ &mut self,
+ result: &str,
+ color: term::color::Color,
+ ) -> io::Result<()> {
+ self.write_pretty(result, color)?;
+ self.write_plain("\n")
+ }
+
+ pub fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
+ match self.out {
+ Pretty(ref mut term) => {
+ if self.use_color {
+ term.fg(color)?;
+ }
+ term.write_all(word.as_bytes())?;
+ if self.use_color {
+ term.reset()?;
+ }
+ term.flush()
+ }
+ Raw(ref mut stdout) => {
+ stdout.write_all(word.as_bytes())?;
+ stdout.flush()
+ }
+ }
+ }
+
+ pub fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {
+ let s = s.as_ref();
+ self.out.write_all(s.as_bytes())?;
+ self.out.flush()
+ }
+
+ pub fn write_successes(&mut self, state: &ConsoleTestState) -> io::Result<()> {
+ self.write_plain("\nsuccesses:\n")?;
+ let mut successes = Vec::new();
+ let mut stdouts = String::new();
+ for &(ref f, ref stdout) in &state.not_failures {
+ successes.push(f.name.to_string());
+ if !stdout.is_empty() {
+ stdouts.push_str(&format!("---- {} stdout ----\n\t", f.name));
+ let output = String::from_utf8_lossy(stdout);
+ stdouts.push_str(&output);
+ stdouts.push_str("\n");
+ }
+ }
+ if !stdouts.is_empty() {
+ self.write_plain("\n")?;
+ self.write_plain(&stdouts)?;
+ }
+
+ self.write_plain("\nsuccesses:\n")?;
+ successes.sort();
+ for name in &successes {
+ self.write_plain(&format!(" {}\n", name))?;
+ }
+ Ok(())
+ }
+
+ pub fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
+ self.write_plain("\nfailures:\n")?;
+ let mut failures = Vec::new();
+ let mut fail_out = String::new();
+ for &(ref f, ref stdout) in &state.failures {
+ failures.push(f.name.to_string());
+ if !stdout.is_empty() {
+ fail_out.push_str(&format!("---- {} stdout ----\n\t", f.name));
+ let output = String::from_utf8_lossy(stdout);
+ fail_out.push_str(&output);
+ fail_out.push_str("\n");
+ }
+ }
+ if !fail_out.is_empty() {
+ self.write_plain("\n")?;
+ self.write_plain(&fail_out)?;
+ }
+
+ self.write_plain("\nfailures:\n")?;
+ failures.sort();
+ for name in &failures {
+ self.write_plain(&format!(" {}\n", name))?;
+ }
+ Ok(())
+ }
+
+ fn write_test_name(&mut self, desc: &TestDesc) -> io::Result<()> {
+ let name = desc.padded_name(self.max_name_len, desc.name.padding());
+ self.write_plain(&format!("test {} ... ", name))?;
+
+ Ok(())
+ }
+}
+
+impl<T: Write> OutputFormatter for PrettyFormatter<T> {
+ fn write_run_start(&mut self, test_count: usize) -> io::Result<()> {
+ let noun = if test_count != 1 { "tests" } else { "test" };
+ self.write_plain(&format!("\nrunning {} {}\n", test_count, noun))
+ }
+
+ fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
+ // When running tests concurrently, we should not print
+ // the test's name as the result will be mis-aligned.
+ // When running the tests serially, we print the name here so
+ // that the user can see which test hangs.
+ if !self.is_multithreaded {
+ self.write_test_name(desc)?;
+ }
+
+ Ok(())
+ }
+
+ fn write_result(&mut self, desc: &TestDesc, result: &TestResult, _: &[u8]) -> io::Result<()> {
+ if self.is_multithreaded {
+ self.write_test_name(desc)?;
+ }
+
+ match *result {
+ TrOk => self.write_ok(),
+ TrFailed | TrFailedMsg(_) => self.write_failed(),
+ TrIgnored => self.write_ignored(),
+ TrAllowedFail => self.write_allowed_fail(),
+ TrBench(ref bs) => {
+ self.write_bench()?;
+ self.write_plain(&format!(": {}\n", fmt_bench_samples(bs)))
+ }
+ }
+ }
+
+ fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
+ if self.is_multithreaded {
+ self.write_test_name(desc)?;
+ }
+
+ self.write_plain(&format!(
+ "test {} has been running for over {} seconds\n",
+ desc.name,
+ TEST_WARN_TIMEOUT_S
+ ))
+ }
+
+ fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
+ if state.options.display_output {
+ self.write_successes(state)?;
+ }
+ let success = state.failed == 0;
+ if !success {
+ self.write_failures(state)?;
+ }
+
+ self.write_plain("\ntest result: ")?;
+
+ if success {
+ // There's no parallelism at this point so it's safe to use color
+ self.write_pretty("ok", term::color::GREEN)?;
+ } else {
+ self.write_pretty("FAILED", term::color::RED)?;
+ }
+
+ let s = if state.allowed_fail > 0 {
+ format!(
+ ". {} passed; {} failed ({} allowed); {} ignored; {} measured; {} filtered out\n\n",
+ state.passed,
+ state.failed + state.allowed_fail,
+ state.allowed_fail,
+ state.ignored,
+ state.measured,
+ state.filtered_out
+ )
+ } else {
+ format!(
+ ". {} passed; {} failed; {} ignored; {} measured; {} filtered out\n\n",
+ state.passed,
+ state.failed,
+ state.ignored,
+ state.measured,
+ state.filtered_out
+ )
+ };
+
+ self.write_plain(&s)?;
+
+ Ok(success)
+ }
+}
--- /dev/null
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use super::*;
+
+pub(crate) struct TerseFormatter<T> {
+ out: OutputLocation<T>,
+ use_color: bool,
+ is_multithreaded: bool,
+ /// Number of columns to fill when aligning names
+ max_name_len: usize,
+
+ test_count: usize,
+}
+
+impl<T: Write> TerseFormatter<T> {
+ pub fn new(
+ out: OutputLocation<T>,
+ use_color: bool,
+ max_name_len: usize,
+ is_multithreaded: bool,
+ ) -> Self {
+ TerseFormatter {
+ out,
+ use_color,
+ max_name_len,
+ is_multithreaded,
+ test_count: 0,
+ }
+ }
+
+ pub fn write_ok(&mut self) -> io::Result<()> {
+ self.write_short_result(".", term::color::GREEN)
+ }
+
+ pub fn write_failed(&mut self) -> io::Result<()> {
+ self.write_short_result("F", term::color::RED)
+ }
+
+ pub fn write_ignored(&mut self) -> io::Result<()> {
+ self.write_short_result("i", term::color::YELLOW)
+ }
+
+ pub fn write_allowed_fail(&mut self) -> io::Result<()> {
+ self.write_short_result("a", term::color::YELLOW)
+ }
+
+ pub fn write_bench(&mut self) -> io::Result<()> {
+ self.write_pretty("bench", term::color::CYAN)
+ }
+
+ pub fn write_short_result(
+ &mut self,
+ result: &str,
+ color: term::color::Color,
+ ) -> io::Result<()> {
+ self.write_pretty(result, color)?;
+ if self.test_count % QUIET_MODE_MAX_COLUMN == QUIET_MODE_MAX_COLUMN - 1 {
+ // we insert a new line every 100 dots in order to flush the
+ // screen when dealing with line-buffered output (e.g. piping to
+ // `stamp` in the rust CI).
+ self.write_plain("\n")?;
+ }
+
+ self.test_count += 1;
+ Ok(())
+ }
+
+ pub fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
+ match self.out {
+ Pretty(ref mut term) => {
+ if self.use_color {
+ term.fg(color)?;
+ }
+ term.write_all(word.as_bytes())?;
+ if self.use_color {
+ term.reset()?;
+ }
+ term.flush()
+ }
+ Raw(ref mut stdout) => {
+ stdout.write_all(word.as_bytes())?;
+ stdout.flush()
+ }
+ }
+ }
+
+ pub fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {
+ let s = s.as_ref();
+ self.out.write_all(s.as_bytes())?;
+ self.out.flush()
+ }
+
+ pub fn write_outputs(&mut self, state: &ConsoleTestState) -> io::Result<()> {
+ self.write_plain("\nsuccesses:\n")?;
+ let mut successes = Vec::new();
+ let mut stdouts = String::new();
+ for &(ref f, ref stdout) in &state.not_failures {
+ successes.push(f.name.to_string());
+ if !stdout.is_empty() {
+ stdouts.push_str(&format!("---- {} stdout ----\n\t", f.name));
+ let output = String::from_utf8_lossy(stdout);
+ stdouts.push_str(&output);
+ stdouts.push_str("\n");
+ }
+ }
+ if !stdouts.is_empty() {
+ self.write_plain("\n")?;
+ self.write_plain(&stdouts)?;
+ }
+
+ self.write_plain("\nsuccesses:\n")?;
+ successes.sort();
+ for name in &successes {
+ self.write_plain(&format!(" {}\n", name))?;
+ }
+ Ok(())
+ }
+
+ pub fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
+ self.write_plain("\nfailures:\n")?;
+ let mut failures = Vec::new();
+ let mut fail_out = String::new();
+ for &(ref f, ref stdout) in &state.failures {
+ failures.push(f.name.to_string());
+ if !stdout.is_empty() {
+ fail_out.push_str(&format!("---- {} stdout ----\n\t", f.name));
+ let output = String::from_utf8_lossy(stdout);
+ fail_out.push_str(&output);
+ fail_out.push_str("\n");
+ }
+ }
+ if !fail_out.is_empty() {
+ self.write_plain("\n")?;
+ self.write_plain(&fail_out)?;
+ }
+
+ self.write_plain("\nfailures:\n")?;
+ failures.sort();
+ for name in &failures {
+ self.write_plain(&format!(" {}\n", name))?;
+ }
+ Ok(())
+ }
+
+ fn write_test_name(&mut self, desc: &TestDesc) -> io::Result<()> {
+ let name = desc.padded_name(self.max_name_len, desc.name.padding());
+ self.write_plain(&format!("test {} ... ", name))?;
+
+ Ok(())
+ }
+}
+
+impl<T: Write> OutputFormatter for TerseFormatter<T> {
+ fn write_run_start(&mut self, test_count: usize) -> io::Result<()> {
+ let noun = if test_count != 1 { "tests" } else { "test" };
+ self.write_plain(&format!("\nrunning {} {}\n", test_count, noun))
+ }
+
+ fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
+ // Remnants from old libtest code that used the padding value
+ // in order to indicate benchmarks.
+ // When running benchmarks, terse-mode should still print their name as if
+ // it is the Pretty formatter.
+ if !self.is_multithreaded && desc.name.padding() == PadOnRight {
+ self.write_test_name(desc)?;
+ }
+
+ Ok(())
+ }
+
+ fn write_result(&mut self, desc: &TestDesc, result: &TestResult, _: &[u8]) -> io::Result<()> {
+ match *result {
+ TrOk => self.write_ok(),
+ TrFailed | TrFailedMsg(_) => self.write_failed(),
+ TrIgnored => self.write_ignored(),
+ TrAllowedFail => self.write_allowed_fail(),
+ TrBench(ref bs) => {
+ if self.is_multithreaded {
+ self.write_test_name(desc)?;
+ }
+ self.write_bench()?;
+ self.write_plain(&format!(": {}\n", fmt_bench_samples(bs)))
+ }
+ }
+ }
+
+ fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
+ self.write_plain(&format!(
+ "test {} has been running for over {} seconds\n",
+ desc.name,
+ TEST_WARN_TIMEOUT_S
+ ))
+ }
+
+ fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
+ if state.options.display_output {
+ self.write_outputs(state)?;
+ }
+ let success = state.failed == 0;
+ if !success {
+ self.write_failures(state)?;
+ }
+
+ self.write_plain("\ntest result: ")?;
+
+ if success {
+ // There's no parallelism at this point so it's safe to use color
+ self.write_pretty("ok", term::color::GREEN)?;
+ } else {
+ self.write_pretty("FAILED", term::color::RED)?;
+ }
+
+ let s = if state.allowed_fail > 0 {
+ format!(
+ ". {} passed; {} failed ({} allowed); {} ignored; {} measured; {} filtered out\n\n",
+ state.passed,
+ state.failed + state.allowed_fail,
+ state.allowed_fail,
+ state.ignored,
+ state.measured,
+ state.filtered_out
+ )
+ } else {
+ format!(
+ ". {} passed; {} failed; {} ignored; {} measured; {} filtered out\n\n",
+ state.passed,
+ state.failed,
+ state.ignored,
+ state.measured,
+ state.filtered_out
+ )
+ };
+
+ self.write_plain(&s)?;
+
+ Ok(success)
+ }
+}
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::{Instant, Duration};
+use std::borrow::Cow;
const TEST_WARN_TIMEOUT_S: u64 = 60;
const QUIET_MODE_MAX_COLUMN: usize = 100; // insert a '\n' after 100 tests in quiet mode
}
pub mod stats;
+mod formatters;
+
+use formatters::{OutputFormatter, PrettyFormatter, TerseFormatter, JsonFormatter};
// The name of a test. By convention this follows the rules for rust
// paths; i.e. it should be a series of identifiers separated by double
pub enum TestName {
StaticTestName(&'static str),
DynTestName(String),
+ AlignedTestName(Cow<'static, str>, NamePadding),
}
impl TestName {
fn as_slice(&self) -> &str {
match *self {
StaticTestName(s) => s,
DynTestName(ref s) => s,
+ AlignedTestName(ref s, _) => &*s,
}
}
+
+ fn padding(&self) -> NamePadding {
+ match self {
+ &AlignedTestName(_, p) => p,
+ _ => PadNone,
+ }
+ }
+
+ fn with_padding(&self, padding: NamePadding) -> TestName {
+ let name = match self {
+ &TestName::StaticTestName(name) => Cow::Borrowed(name),
+ &TestName::DynTestName(ref name) => Cow::Owned(name.clone()),
+ &TestName::AlignedTestName(ref name, _) => name.clone(),
+ };
+
+ TestName::AlignedTestName(name, padding)
+ }
}
impl fmt::Display for TestName {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
}
}
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum NamePadding {
PadNone,
PadOnRight,
impl Metric {
pub fn new(value: f64, noise: f64) -> Metric {
- Metric {
- value,
- noise,
- }
+ Metric { value, noise }
}
}
impl Options {
pub fn new() -> Options {
- Options {
- display_output: false,
- }
+ Options { display_output: false }
}
pub fn display_output(mut self, display_output: bool) -> Options {
// rather than a &[].
pub fn test_main_static(tests: &[TestDescAndFn]) {
let args = env::args().collect::<Vec<_>>();
- let owned_tests = tests.iter()
- .map(|t| {
- match t.testfn {
- StaticTestFn(f) => {
- TestDescAndFn {
- testfn: StaticTestFn(f),
- desc: t.desc.clone(),
- }
- }
- StaticBenchFn(f) => {
- TestDescAndFn {
- testfn: StaticBenchFn(f),
- desc: t.desc.clone(),
- }
- }
- _ => panic!("non-static tests passed to test::test_main_static"),
- }
- })
- .collect();
+ let owned_tests = tests
+ .iter()
+ .map(|t| match t.testfn {
+ StaticTestFn(f) => {
+ TestDescAndFn {
+ testfn: StaticTestFn(f),
+ desc: t.desc.clone(),
+ }
+ }
+ StaticBenchFn(f) => {
+ TestDescAndFn {
+ testfn: StaticBenchFn(f),
+ desc: t.desc.clone(),
+ }
+ }
+ _ => panic!("non-static tests passed to test::test_main_static"),
+ })
+ .collect();
test_main(&args, owned_tests, Options::new())
}
NeverColor,
}
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum OutputFormat {
+ Pretty,
+ Terse,
+ Json,
+}
+
#[derive(Debug)]
pub struct TestOpts {
pub list: bool,
pub logfile: Option<PathBuf>,
pub nocapture: bool,
pub color: ColorConfig,
- pub quiet: bool,
+ pub format: OutputFormat,
pub test_threads: Option<usize>,
pub skip: Vec<String>,
pub options: Options,
logfile: None,
nocapture: false,
color: AutoColor,
- quiet: false,
+ format: OutputFormat::Pretty,
test_threads: None,
skip: vec![],
options: Options::new(),
.optflag("", "bench", "Run benchmarks instead of tests")
.optflag("", "list", "List all tests and benchmarks")
.optflag("h", "help", "Display this message (longer with --help)")
- .optopt("", "logfile", "Write logs to the specified file instead \
- of stdout", "PATH")
- .optflag("", "nocapture", "don't capture stdout/stderr of each \
- task, allow printing directly")
- .optopt("", "test-threads", "Number of threads used for running tests \
- in parallel", "n_threads")
- .optmulti("", "skip", "Skip tests whose names contain FILTER (this flag can \
- be used multiple times)","FILTER")
- .optflag("q", "quiet", "Display one character per test instead of one line")
- .optflag("", "exact", "Exactly match filters rather than by substring")
- .optopt("", "color", "Configure coloring of output:
+ .optopt(
+ "",
+ "logfile",
+ "Write logs to the specified file instead \
+ of stdout",
+ "PATH",
+ )
+ .optflag(
+ "",
+ "nocapture",
+ "don't capture stdout/stderr of each \
+ task, allow printing directly",
+ )
+ .optopt(
+ "",
+ "test-threads",
+ "Number of threads used for running tests \
+ in parallel",
+ "n_threads",
+ )
+ .optmulti(
+ "",
+ "skip",
+ "Skip tests whose names contain FILTER (this flag can \
+ be used multiple times)",
+ "FILTER",
+ )
+ .optflag(
+ "q",
+ "quiet",
+ "Display one character per test instead of one line. \
+ Alias to --format=terse",
+ )
+ .optflag(
+ "",
+ "exact",
+ "Exactly match filters rather than by substring",
+ )
+ .optopt(
+ "",
+ "color",
+ "Configure coloring of output:
auto = colorize if stdout is a tty and tests are run on serially (default);
always = always colorize output;
- never = never colorize output;", "auto|always|never");
- return opts
+ never = never colorize output;",
+ "auto|always|never",
+ )
+ .optopt(
+ "",
+ "format",
+ "Configure formatting of output:
+ pretty = Print verbose output;
+ terse = Display one character per test;
+ json = Output a json document",
+ "pretty|terse|json",
+ )
+ .optopt(
+ "Z",
+ "",
+ "Enable nightly-only flags:
+ unstable-options = Allow use of experimental features",
+ "unstable-options",
+ );
+ return opts;
}
fn usage(binary: &str, options: &getopts::Options) {
let message = format!("Usage: {} [OPTIONS] [FILTER]", binary);
- println!(r#"{usage}
+ println!(
+ r#"{usage}
The FILTER string is tested against the name of all tests, and only those
tests whose names contain the filter are run.
test, then the test runner will ignore these tests during
normal test runs. Running with --ignored will run these
tests."#,
- usage = options.usage(&message));
+ usage = options.usage(&message)
+ );
+}
+
+// FIXME: Copied from libsyntax until linkage errors are resolved. Issue #47566
+fn is_nightly() -> bool {
+ // Whether this is a feature-staged build, i.e. on the beta or stable channel
+ let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some();
+ // Whether we should enable unstable features for bootstrapping
+ let bootstrap = env::var("RUSTC_BOOTSTRAP").is_ok();
+
+ bootstrap || !disable_unstable_features
}
// Parses command line arguments into test options
pub fn parse_opts(args: &[String]) -> Option<OptRes> {
+ let mut allow_unstable = false;
let opts = optgroups();
let args = args.get(1..).unwrap_or(args);
let matches = match opts.parse(args) {
Err(f) => return Some(Err(f.to_string())),
};
+ if let Some(opt) = matches.opt_str("Z") {
+ if !is_nightly() {
+ return Some(Err(
+ "the option `Z` is only accepted on the nightly compiler"
+ .into(),
+ ));
+ }
+
+ match &*opt {
+ "unstable-options" => {
+ allow_unstable = true;
+ }
+ _ => {
+ return Some(Err("Unrecognized option to `Z`".into()));
+ }
+ }
+ };
+
if matches.opt_present("h") {
usage(&args[0], &opts);
return None;
if !nocapture {
nocapture = match env::var("RUST_TEST_NOCAPTURE") {
Ok(val) => &val != "0",
- Err(_) => false
+ Err(_) => false,
};
}
let test_threads = match matches.opt_str("test-threads") {
- Some(n_str) =>
+ Some(n_str) => {
match n_str.parse::<usize>() {
- Ok(0) =>
- return Some(Err(format!("argument for --test-threads must not be 0"))),
+ Ok(0) => return Some(Err(format!("argument for --test-threads must not be 0"))),
Ok(n) => Some(n),
- Err(e) =>
- return Some(Err(format!("argument for --test-threads must be a number > 0 \
- (error: {})", e)))
- },
- None =>
- None,
+ Err(e) => {
+ return Some(Err(format!(
+ "argument for --test-threads must be a number > 0 \
+ (error: {})",
+ e
+ )))
+ }
+ }
+ }
+ None => None,
};
let color = match matches.opt_str("color").as_ref().map(|s| &**s) {
Some("never") => NeverColor,
Some(v) => {
- return Some(Err(format!("argument for --color must be auto, always, or never (was \
+ return Some(Err(format!(
+ "argument for --color must be auto, always, or never (was \
+ {})",
+ v
+ )))
+ }
+ };
+
+ let format = match matches.opt_str("format").as_ref().map(|s| &**s) {
+ None if quiet => OutputFormat::Terse,
+ Some("pretty") | None => OutputFormat::Pretty,
+ Some("terse") => OutputFormat::Terse,
+ Some("json") => {
+ if !allow_unstable {
+ return Some(Err(
+ "The \"json\" format is only accepted on the nightly compiler"
+ .into(),
+ ));
+ }
+ OutputFormat::Json
+ }
+
+ Some(v) => {
+ return Some(Err(format!(
+ "argument for --format must be pretty, terse, or json (was \
{})",
- v)))
+ v
+ )))
}
};
logfile,
nocapture,
color,
- quiet,
+ format,
test_threads,
skip: matches.opt_strs("skip"),
options: Options::new(),
Raw(T),
}
-struct ConsoleTestState<T> {
+impl<T: Write> Write for OutputLocation<T> {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ match *self {
+ Pretty(ref mut term) => term.write(buf),
+ Raw(ref mut stdout) => stdout.write(buf),
+ }
+ }
+
+ fn flush(&mut self) -> io::Result<()> {
+ match *self {
+ Pretty(ref mut term) => term.flush(),
+ Raw(ref mut stdout) => stdout.flush(),
+ }
+ }
+}
+
+struct ConsoleTestState {
log_out: Option<File>,
- out: OutputLocation<T>,
- use_color: bool,
- quiet: bool,
total: usize,
passed: usize,
failed: usize,
metrics: MetricMap,
failures: Vec<(TestDesc, Vec<u8>)>,
not_failures: Vec<(TestDesc, Vec<u8>)>,
- max_name_len: usize, // number of columns to fill when aligning names
options: Options,
}
-impl<T: Write> ConsoleTestState<T> {
- pub fn new(opts: &TestOpts, _: Option<T>) -> io::Result<ConsoleTestState<io::Stdout>> {
+impl ConsoleTestState {
+ pub fn new(opts: &TestOpts) -> io::Result<ConsoleTestState> {
let log_out = match opts.logfile {
Some(ref path) => Some(File::create(path)?),
None => None,
};
- let out = match term::stdout() {
- None => Raw(io::stdout()),
- Some(t) => Pretty(t),
- };
Ok(ConsoleTestState {
- out,
log_out,
- use_color: use_color(opts),
- quiet: opts.quiet,
total: 0,
passed: 0,
failed: 0,
metrics: MetricMap::new(),
failures: Vec::new(),
not_failures: Vec::new(),
- max_name_len: 0,
options: opts.options,
})
}
- pub fn write_ok(&mut self) -> io::Result<()> {
- self.write_short_result("ok", ".", term::color::GREEN)
- }
-
- pub fn write_failed(&mut self) -> io::Result<()> {
- self.write_short_result("FAILED", "F", term::color::RED)
- }
-
- pub fn write_ignored(&mut self) -> io::Result<()> {
- self.write_short_result("ignored", "i", term::color::YELLOW)
- }
-
- pub fn write_allowed_fail(&mut self) -> io::Result<()> {
- self.write_short_result("FAILED (allowed)", "a", term::color::YELLOW)
- }
-
- pub fn write_bench(&mut self) -> io::Result<()> {
- self.write_pretty("bench", term::color::CYAN)
- }
-
- pub fn write_short_result(&mut self, verbose: &str, quiet: &str, color: term::color::Color)
- -> io::Result<()> {
- if self.quiet {
- self.write_pretty(quiet, color)?;
- if self.current_test_count() % QUIET_MODE_MAX_COLUMN == QUIET_MODE_MAX_COLUMN - 1 {
- // we insert a new line every 100 dots in order to flush the
- // screen when dealing with line-buffered output (e.g. piping to
- // `stamp` in the rust CI).
- self.write_plain("\n")?;
- }
- Ok(())
- } else {
- self.write_pretty(verbose, color)?;
- self.write_plain("\n")
- }
- }
-
- pub fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
- match self.out {
- Pretty(ref mut term) => {
- if self.use_color {
- term.fg(color)?;
- }
- term.write_all(word.as_bytes())?;
- if self.use_color {
- term.reset()?;
- }
- term.flush()
- }
- Raw(ref mut stdout) => {
- stdout.write_all(word.as_bytes())?;
- stdout.flush()
- }
- }
- }
-
- pub fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {
- let s = s.as_ref();
- match self.out {
- Pretty(ref mut term) => {
- term.write_all(s.as_bytes())?;
- term.flush()
- }
- Raw(ref mut stdout) => {
- stdout.write_all(s.as_bytes())?;
- stdout.flush()
- }
- }
- }
-
- pub fn write_run_start(&mut self, len: usize) -> io::Result<()> {
- self.total = len;
- let noun = if len != 1 {
- "tests"
- } else {
- "test"
- };
- self.write_plain(&format!("\nrunning {} {}\n", len, noun))
- }
-
- pub fn write_test_start(&mut self, test: &TestDesc, align: NamePadding) -> io::Result<()> {
- if self.quiet && align != PadOnRight {
- Ok(())
- } else {
- let name = test.padded_name(self.max_name_len, align);
- self.write_plain(&format!("test {} ... ", name))
- }
- }
-
- pub fn write_result(&mut self, result: &TestResult) -> io::Result<()> {
- match *result {
- TrOk => self.write_ok(),
- TrFailed | TrFailedMsg(_) => self.write_failed(),
- TrIgnored => self.write_ignored(),
- TrAllowedFail => self.write_allowed_fail(),
- TrBench(ref bs) => {
- self.write_bench()?;
- self.write_plain(&format!(": {}\n", fmt_bench_samples(bs)))
- }
- }
- }
-
- pub fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
- self.write_plain(&format!("test {} has been running for over {} seconds\n",
- desc.name,
- TEST_WARN_TIMEOUT_S))
- }
-
pub fn write_log<S: AsRef<str>>(&mut self, msg: S) -> io::Result<()> {
let msg = msg.as_ref();
match self.log_out {
}
pub fn write_log_result(&mut self, test: &TestDesc, result: &TestResult) -> io::Result<()> {
- self.write_log(
- format!("{} {}\n",
- match *result {
- TrOk => "ok".to_owned(),
- TrFailed => "failed".to_owned(),
- TrFailedMsg(ref msg) => format!("failed: {}", msg),
- TrIgnored => "ignored".to_owned(),
- TrAllowedFail => "failed (allowed)".to_owned(),
- TrBench(ref bs) => fmt_bench_samples(bs),
- },
- test.name))
- }
-
- pub fn write_failures(&mut self) -> io::Result<()> {
- self.write_plain("\nfailures:\n")?;
- let mut failures = Vec::new();
- let mut fail_out = String::new();
- for &(ref f, ref stdout) in &self.failures {
- failures.push(f.name.to_string());
- if !stdout.is_empty() {
- fail_out.push_str(&format!("---- {} stdout ----\n\t", f.name));
- let output = String::from_utf8_lossy(stdout);
- fail_out.push_str(&output);
- fail_out.push_str("\n");
- }
- }
- if !fail_out.is_empty() {
- self.write_plain("\n")?;
- self.write_plain(&fail_out)?;
- }
-
- self.write_plain("\nfailures:\n")?;
- failures.sort();
- for name in &failures {
- self.write_plain(&format!(" {}\n", name))?;
- }
- Ok(())
- }
-
- pub fn write_outputs(&mut self) -> io::Result<()> {
- self.write_plain("\nsuccesses:\n")?;
- let mut successes = Vec::new();
- let mut stdouts = String::new();
- for &(ref f, ref stdout) in &self.not_failures {
- successes.push(f.name.to_string());
- if !stdout.is_empty() {
- stdouts.push_str(&format!("---- {} stdout ----\n\t", f.name));
- let output = String::from_utf8_lossy(stdout);
- stdouts.push_str(&output);
- stdouts.push_str("\n");
- }
- }
- if !stdouts.is_empty() {
- self.write_plain("\n")?;
- self.write_plain(&stdouts)?;
- }
-
- self.write_plain("\nsuccesses:\n")?;
- successes.sort();
- for name in &successes {
- self.write_plain(&format!(" {}\n", name))?;
- }
- Ok(())
+ self.write_log(format!(
+ "{} {}\n",
+ match *result {
+ TrOk => "ok".to_owned(),
+ TrFailed => "failed".to_owned(),
+ TrFailedMsg(ref msg) => format!("failed: {}", msg),
+ TrIgnored => "ignored".to_owned(),
+ TrAllowedFail => "failed (allowed)".to_owned(),
+ TrBench(ref bs) => fmt_bench_samples(bs),
+ },
+ test.name
+ ))
}
fn current_test_count(&self) -> usize {
self.passed + self.failed + self.ignored + self.measured + self.allowed_fail
}
-
- pub fn write_run_finish(&mut self) -> io::Result<bool> {
- assert!(self.current_test_count() == self.total);
-
- if self.options.display_output {
- self.write_outputs()?;
- }
- let success = self.failed == 0;
- if !success {
- self.write_failures()?;
- }
-
- self.write_plain("\ntest result: ")?;
- if success {
- // There's no parallelism at this point so it's safe to use color
- self.write_pretty("ok", term::color::GREEN)?;
- } else {
- self.write_pretty("FAILED", term::color::RED)?;
- }
- let s = if self.allowed_fail > 0 {
- format!(
- ". {} passed; {} failed ({} allowed); {} ignored; {} measured; {} filtered out\n\n",
- self.passed,
- self.failed + self.allowed_fail,
- self.allowed_fail,
- self.ignored,
- self.measured,
- self.filtered_out)
- } else {
- format!(
- ". {} passed; {} failed; {} ignored; {} measured; {} filtered out\n\n",
- self.passed,
- self.failed,
- self.ignored,
- self.measured,
- self.filtered_out)
- };
- self.write_plain(&s)?;
- return Ok(success);
- }
}
// Format a number with thousands separators
let median = bs.ns_iter_summ.median as usize;
let deviation = (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as usize;
- output.write_fmt(format_args!("{:>11} ns/iter (+/- {})",
- fmt_thousands_sep(median, ','),
- fmt_thousands_sep(deviation, ',')))
- .unwrap();
+ output
+ .write_fmt(format_args!(
+ "{:>11} ns/iter (+/- {})",
+ fmt_thousands_sep(median, ','),
+ fmt_thousands_sep(deviation, ',')
+ ))
+ .unwrap();
if bs.mb_s != 0 {
- output.write_fmt(format_args!(" = {} MB/s", bs.mb_s)).unwrap();
+ output
+ .write_fmt(format_args!(" = {} MB/s", bs.mb_s))
+ .unwrap();
}
output
}
// List the tests to console, and optionally to logfile. Filters are honored.
pub fn list_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Result<()> {
- let mut st = ConsoleTestState::new(opts, None::<io::Stdout>)?;
+ let mut output = match term::stdout() {
+ None => Raw(io::stdout()),
+ Some(t) => Pretty(t),
+ };
+
+ let quiet = opts.format == OutputFormat::Terse;
+ let mut st = ConsoleTestState::new(opts)?;
let mut ntest = 0;
let mut nbench = 0;
for test in filter_tests(&opts, tests) {
use TestFn::*;
- let TestDescAndFn { desc: TestDesc { name, .. }, testfn } = test;
+ let TestDescAndFn {
+ desc: TestDesc { name, .. },
+ testfn,
+ } = test;
let fntype = match testfn {
- StaticTestFn(..) | DynTestFn(..) => { ntest += 1; "test" },
- StaticBenchFn(..) | DynBenchFn(..) => { nbench += 1; "benchmark" },
+ StaticTestFn(..) | DynTestFn(..) => {
+ ntest += 1;
+ "test"
+ }
+ StaticBenchFn(..) |
+ DynBenchFn(..) => {
+ nbench += 1;
+ "benchmark"
+ }
};
- st.write_plain(format!("{}: {}\n", name, fntype))?;
+ writeln!(output, "{}: {}", name, fntype)?;
st.write_log(format!("{} {}\n", fntype, name))?;
}
}
}
- if !opts.quiet {
+ if !quiet {
if ntest != 0 || nbench != 0 {
- st.write_plain("\n")?;
+ writeln!(output, "")?;
}
- st.write_plain(format!("{}, {}\n",
+
+ writeln!(output,
+ "{}, {}",
plural(ntest, "test"),
- plural(nbench, "benchmark")))?;
+ plural(nbench, "benchmark")
+ )?;
}
Ok(())
// A simple console test runner
pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Result<bool> {
+ fn callback(
+ event: &TestEvent,
+ st: &mut ConsoleTestState,
+ out: &mut OutputFormatter,
+ ) -> io::Result<()> {
- fn callback<T: Write>(event: &TestEvent, st: &mut ConsoleTestState<T>) -> io::Result<()> {
match (*event).clone() {
- TeFiltered(ref filtered_tests) => st.write_run_start(filtered_tests.len()),
+ TeFiltered(ref filtered_tests) => {
+ st.total = filtered_tests.len();
+ out.write_run_start(filtered_tests.len())
+ }
TeFilteredOut(filtered_out) => Ok(st.filtered_out = filtered_out),
- TeWait(ref test, padding) => st.write_test_start(test, padding),
- TeTimeout(ref test) => st.write_timeout(test),
+ TeWait(ref test) => out.write_test_start(test),
+ TeTimeout(ref test) => out.write_timeout(test),
TeResult(test, result, stdout) => {
st.write_log_result(&test, &result)?;
- st.write_result(&result)?;
+ out.write_result(&test, &result, &*stdout)?;
match result {
TrOk => {
st.passed += 1;
TrIgnored => st.ignored += 1,
TrAllowedFail => st.allowed_fail += 1,
TrBench(bs) => {
- st.metrics.insert_metric(test.name.as_slice(),
- bs.ns_iter_summ.median,
- bs.ns_iter_summ.max - bs.ns_iter_summ.min);
+ st.metrics.insert_metric(
+ test.name.as_slice(),
+ bs.ns_iter_summ.median,
+ bs.ns_iter_summ.max - bs.ns_iter_summ.min,
+ );
st.measured += 1
}
TrFailed => {
TrFailedMsg(msg) => {
st.failed += 1;
let mut stdout = stdout;
- stdout.extend_from_slice(
- format!("note: {}", msg).as_bytes()
- );
+ stdout.extend_from_slice(format!("note: {}", msg).as_bytes());
st.failures.push((test, stdout));
}
}
}
}
- let mut st = ConsoleTestState::new(opts, None::<io::Stdout>)?;
+ let output = match term::stdout() {
+ None => Raw(io::stdout()),
+ Some(t) => Pretty(t),
+ };
+
+ let max_name_len = tests
+ .iter()
+ .max_by_key(|t| len_if_padded(*t))
+ .map(|t| t.desc.name.as_slice().len())
+ .unwrap_or(0);
+
+ let is_multithreaded = opts.test_threads.unwrap_or_else(get_concurrency) > 1;
+
+ let mut out: Box<OutputFormatter> = match opts.format {
+ OutputFormat::Pretty => Box::new(PrettyFormatter::new(
+ output,
+ use_color(opts),
+ max_name_len,
+ is_multithreaded,
+ )),
+ OutputFormat::Terse => Box::new(TerseFormatter::new(
+ output,
+ use_color(opts),
+ max_name_len,
+ is_multithreaded,
+ )),
+ OutputFormat::Json => Box::new(JsonFormatter::new(output)),
+ };
+ let mut st = ConsoleTestState::new(opts)?;
fn len_if_padded(t: &TestDescAndFn) -> usize {
match t.testfn.padding() {
PadNone => 0,
PadOnRight => t.desc.name.as_slice().len(),
}
}
- if let Some(t) = tests.iter().max_by_key(|t| len_if_padded(*t)) {
- let n = t.desc.name.as_slice();
- st.max_name_len = n.len();
- }
- run_tests(opts, tests, |x| callback(&x, &mut st))?;
- return st.write_run_finish();
+
+ run_tests(opts, tests, |x| callback(&x, &mut st, &mut *out))?;
+
+ assert!(st.current_test_count() == st.total);
+
+ return out.write_run_finish(&st);
}
#[test]
allow_fail: false,
};
- let mut st = ConsoleTestState {
+ let mut out = PrettyFormatter::new(Raw(Vec::new()), false, 10, false);
+
+ let st = ConsoleTestState {
log_out: None,
- out: Raw(Vec::new()),
- use_color: false,
- quiet: false,
total: 0,
passed: 0,
failed: 0,
allowed_fail: 0,
filtered_out: 0,
measured: 0,
- max_name_len: 10,
metrics: MetricMap::new(),
failures: vec![(test_b, Vec::new()), (test_a, Vec::new())],
options: Options::new(),
not_failures: Vec::new(),
};
- st.write_failures().unwrap();
- let s = match st.out {
- Raw(ref m) => String::from_utf8_lossy(&m[..]),
- Pretty(_) => unreachable!(),
+ out.write_failures(&st).unwrap();
+ let s = match out.output_location() {
+ &Raw(ref m) => String::from_utf8_lossy(&m[..]),
+ &Pretty(_) => unreachable!(),
};
let apos = s.find("a").unwrap();
#[derive(Clone)]
pub enum TestEvent {
TeFiltered(Vec<TestDesc>),
- TeWait(TestDesc, NamePadding),
+ TeWait(TestDesc),
TeResult(TestDesc, TestResult, Vec<u8>),
TeTimeout(TestDesc),
TeFilteredOut(usize),
pub type MonitorMsg = (TestDesc, TestResult, Vec<u8>);
+struct Sink(Arc<Mutex<Vec<u8>>>);
+impl Write for Sink {
+ fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+ Write::write(&mut *self.0.lock().unwrap(), data)
+ }
+ fn flush(&mut self) -> io::Result<()> {
+ Ok(())
+ }
+}
pub fn run_tests<F>(opts: &TestOpts, tests: Vec<TestDescAndFn>, mut callback: F) -> io::Result<()>
- where F: FnMut(TestEvent) -> io::Result<()>
+where
+ F: FnMut(TestEvent) -> io::Result<()>,
{
use std::collections::HashMap;
use std::sync::mpsc::RecvTimeoutError;
filtered_tests = convert_benchmarks_to_tests(filtered_tests);
}
+ let filtered_tests = {
+ let mut filtered_tests = filtered_tests;
+ for test in filtered_tests.iter_mut() {
+ test.desc.name = test.desc.name.with_padding(test.testfn.padding());
+ }
+
+ filtered_tests
+ };
+
let filtered_out = tests_len - filtered_tests.len();
callback(TeFilteredOut(filtered_out))?;
- let filtered_descs = filtered_tests.iter()
- .map(|t| t.desc.clone())
- .collect();
+ let filtered_descs = filtered_tests.iter().map(|t| t.desc.clone()).collect();
callback(TeFiltered(filtered_descs))?;
let (filtered_tests, filtered_benchs): (Vec<_>, _) =
- filtered_tests.into_iter().partition(|e| {
- match e.testfn {
- StaticTestFn(_) | DynTestFn(_) => true,
- _ => false,
- }
+ filtered_tests.into_iter().partition(|e| match e.testfn {
+ StaticTestFn(_) | DynTestFn(_) => true,
+ _ => false,
});
- let concurrency = match opts.test_threads {
- Some(n) => n,
- None => get_concurrency(),
- };
+ let concurrency = opts.test_threads.unwrap_or_else(get_concurrency);
let mut remaining = filtered_tests;
remaining.reverse();
fn get_timed_out_tests(running_tests: &mut HashMap<TestDesc, Instant>) -> Vec<TestDesc> {
let now = Instant::now();
- let timed_out = running_tests.iter()
- .filter_map(|(desc, timeout)| if &now >= timeout { Some(desc.clone())} else { None })
+ let timed_out = running_tests
+ .iter()
+ .filter_map(|(desc, timeout)| if &now >= timeout {
+ Some(desc.clone())
+ } else {
+ None
+ })
.collect();
for test in &timed_out {
running_tests.remove(test);
*next_timeout - now
} else {
Duration::new(0, 0)
- }})
+ }
+ })
};
if concurrency == 1 {
while !remaining.is_empty() {
let test = remaining.pop().unwrap();
- callback(TeWait(test.desc.clone(), test.testfn.padding()))?;
+ callback(TeWait(test.desc.clone()))?;
run_test(opts, !opts.run_tests, test, tx.clone());
let (test, result, stdout) = rx.recv().unwrap();
callback(TeResult(test, result, stdout))?;
let test = remaining.pop().unwrap();
let timeout = Instant::now() + Duration::from_secs(TEST_WARN_TIMEOUT_S);
running_tests.insert(test.desc.clone(), timeout);
+ callback(TeWait(test.desc.clone()))?; //here no pad
run_test(opts, !opts.run_tests, test, tx.clone());
pending += 1;
}
let (desc, result, stdout) = res.unwrap();
running_tests.remove(&desc);
- callback(TeWait(desc.clone(), PadNone))?;
callback(TeResult(desc, result, stdout))?;
pending -= 1;
}
if opts.bench_benchmarks {
// All benchmarks run at the end, in serial.
for b in filtered_benchs {
- callback(TeWait(b.desc.clone(), b.testfn.padding()))?;
+ callback(TeWait(b.desc.clone()))?;
run_test(opts, false, b, tx.clone());
let (test, result, stdout) = rx.recv().unwrap();
callback(TeResult(test, result, stdout))?;
match opt_n {
Some(n) if n > 0 => n,
_ => {
- panic!("RUST_TEST_THREADS is `{}`, should be a positive integer.",
- s)
+ panic!(
+ "RUST_TEST_THREADS is `{}`, should be a positive integer.",
+ s
+ )
}
}
}
unsafe { libc::sysconf(libc::_SC_NPROCESSORS_ONLN) as usize }
}
- #[cfg(any(target_os = "freebsd",
- target_os = "dragonfly",
- target_os = "bitrig",
- target_os = "netbsd"))]
+ #[cfg(any(target_os = "freebsd", target_os = "dragonfly", target_os = "bitrig",
+ target_os = "netbsd"))]
fn num_cpus() -> usize {
use std::ptr;
if cpus < 1 {
let mut mib = [libc::CTL_HW, libc::HW_NCPU, 0, 0];
unsafe {
- libc::sysctl(mib.as_mut_ptr(),
- 2,
- &mut cpus as *mut _ as *mut _,
- &mut cpus_size as *mut _ as *mut _,
- ptr::null_mut(),
- 0);
+ libc::sysctl(
+ mib.as_mut_ptr(),
+ 2,
+ &mut cpus as *mut _ as *mut _,
+ &mut cpus_size as *mut _ as *mut _,
+ ptr::null_mut(),
+ 0,
+ );
}
if cpus < 1 {
cpus = 1;
let mut mib = [libc::CTL_HW, libc::HW_NCPU, 0, 0];
unsafe {
- libc::sysctl(mib.as_mut_ptr(),
- 2,
- &mut cpus as *mut _ as *mut _,
- &mut cpus_size as *mut _ as *mut _,
- ptr::null_mut(),
- 0);
+ libc::sysctl(
+ mib.as_mut_ptr(),
+ 2,
+ &mut cpus as *mut _ as *mut _,
+ &mut cpus_size as *mut _ as *mut _,
+ ptr::null_mut(),
+ 0,
+ );
}
if cpus < 1 {
cpus = 1;
filtered = match opts.filter {
None => filtered,
Some(ref filter) => {
- filtered.into_iter()
- .filter(|test| {
- if opts.filter_exact {
- test.desc.name.as_slice() == &filter[..]
- } else {
- test.desc.name.as_slice().contains(&filter[..])
- }
- })
- .collect()
+ filtered
+ .into_iter()
+ .filter(|test| if opts.filter_exact {
+ test.desc.name.as_slice() == &filter[..]
+ } else {
+ test.desc.name.as_slice().contains(&filter[..])
+ })
+ .collect()
}
};
// Skip tests that match any of the skip filters
- filtered = filtered.into_iter()
- .filter(|t| !opts.skip.iter().any(|sf| {
- if opts.filter_exact {
- t.desc.name.as_slice() == &sf[..]
- } else {
- t.desc.name.as_slice().contains(&sf[..])
- }
- }))
+ filtered = filtered
+ .into_iter()
+ .filter(|t| {
+ !opts.skip.iter().any(|sf| if opts.filter_exact {
+ t.desc.name.as_slice() == &sf[..]
+ } else {
+ t.desc.name.as_slice().contains(&sf[..])
+ })
+ })
.collect();
// Maybe pull out the ignored test and unignore them
} else {
fn filter(test: TestDescAndFn) -> Option<TestDescAndFn> {
if test.desc.ignore {
- let TestDescAndFn {desc, testfn} = test;
+ let TestDescAndFn { desc, testfn } = test;
Some(TestDescAndFn {
- desc: TestDesc { ignore: false, ..desc },
+ desc: TestDesc {
+ ignore: false,
+ ..desc
+ },
testfn,
})
} else {
};
// Sort the tests alphabetically
- filtered.sort_by(|t1, t2| t1.desc.name.as_slice().cmp(t2.desc.name.as_slice()));
+ filtered.sort_by(|t1, t2| {
+ t1.desc.name.as_slice().cmp(t2.desc.name.as_slice())
+ });
filtered
}
})
}))
}
- f => f,
- };
- TestDescAndFn {
- desc: x.desc,
- testfn,
- }
- }).collect()
+ f => f,
+ };
+ TestDescAndFn {
+ desc: x.desc,
+ testfn,
+ }
+ })
+ .collect()
}
-pub fn run_test(opts: &TestOpts,
- force_ignore: bool,
- test: TestDescAndFn,
- monitor_ch: Sender<MonitorMsg>) {
+pub fn run_test(
+ opts: &TestOpts,
+ force_ignore: bool,
+ test: TestDescAndFn,
+ monitor_ch: Sender<MonitorMsg>,
+) {
- let TestDescAndFn {desc, testfn} = test;
+ let TestDescAndFn { desc, testfn } = test;
- let ignore_because_panic_abort =
- cfg!(target_arch = "wasm32") &&
+ let ignore_because_panic_abort = cfg!(target_arch = "wasm32") &&
!cfg!(target_os = "emscripten") &&
desc.should_panic != ShouldPanic::No;
monitor_ch: Sender<MonitorMsg>,
nocapture: bool,
testfn: Box<FnBox() + Send>) {
- struct Sink(Arc<Mutex<Vec<u8>>>);
- impl Write for Sink {
- fn write(&mut self, data: &[u8]) -> io::Result<usize> {
- Write::write(&mut *self.0.lock().unwrap(), data)
- }
- fn flush(&mut self) -> io::Result<()> {
- Ok(())
- }
- }
-
// Buffer for capturing standard I/O
let data = Arc::new(Mutex::new(Vec::new()));
let data2 = data.clone();
let oldio = if !nocapture {
Some((
io::set_print(Some(Box::new(Sink(data2.clone())))),
- io::set_panic(Some(Box::new(Sink(data2))))
+ io::set_panic(Some(Box::new(Sink(data2)))),
))
} else {
None
let test_result = calc_result(&desc, result);
let stdout = data.lock().unwrap().to_vec();
- monitor_ch.send((desc.clone(), test_result, stdout)).unwrap();
+ monitor_ch
+ .send((desc.clone(), test_result, stdout))
+ .unwrap();
};
// If the platform is single-threaded we're just going to run
// the test synchronously, regardless of the concurrency
// level.
- let supports_threads =
- !cfg!(target_os = "emscripten") &&
- !cfg!(target_arch = "wasm32");
+ let supports_threads = !cfg!(target_os = "emscripten") && !cfg!(target_arch = "wasm32");
if supports_threads {
- let cfg = thread::Builder::new().name(match name {
- DynTestName(ref name) => name.clone(),
- StaticTestName(name) => name.to_owned(),
- });
+ let cfg = thread::Builder::new().name(name.as_slice().to_owned());
cfg.spawn(runtest).unwrap();
} else {
runtest();
match testfn {
DynBenchFn(bencher) => {
- let bs = ::bench::benchmark(|harness| bencher.run(harness));
- monitor_ch.send((desc, TrBench(bs), Vec::new())).unwrap();
- return;
+ ::bench::benchmark(desc,
+ monitor_ch,
+ opts.nocapture,
+ |harness| bencher.run(harness));
}
StaticBenchFn(benchfn) => {
- let bs = ::bench::benchmark(|harness| (benchfn.clone())(harness));
- monitor_ch.send((desc, TrBench(bs), Vec::new())).unwrap();
- return;
+ ::bench::benchmark(desc,
+ monitor_ch,
+ opts.nocapture,
+ |harness| (benchfn.clone())(harness));
}
DynTestFn(f) => {
let cb = move || {
};
run_test_inner(desc, monitor_ch, opts.nocapture, Box::new(cb))
}
- StaticTestFn(f) =>
+ StaticTestFn(f) => {
run_test_inner(desc, monitor_ch, opts.nocapture,
- Box::new(move || __rust_begin_short_backtrace(f))),
+ Box::new(move || __rust_begin_short_backtrace(f)))
+ }
}
}
match (&desc.should_panic, task_result) {
(&ShouldPanic::No, Ok(())) |
(&ShouldPanic::Yes, Err(_)) => TrOk,
- (&ShouldPanic::YesWithMessage(msg), Err(ref err)) =>
+ (&ShouldPanic::YesWithMessage(msg), Err(ref err)) => {
if err.downcast_ref::<String>()
- .map(|e| &**e)
- .or_else(|| err.downcast_ref::<&'static str>().map(|e| *e))
- .map(|e| e.contains(msg))
- .unwrap_or(false) {
+ .map(|e| &**e)
+ .or_else(|| err.downcast_ref::<&'static str>().map(|e| *e))
+ .map(|e| e.contains(msg))
+ .unwrap_or(false)
+ {
TrOk
} else {
if desc.allow_fail {
} else {
TrFailedMsg(format!("Panic did not include expected string '{}'", msg))
}
- },
+ }
+ }
_ if desc.allow_fail => TrAllowedFail,
_ => TrFailed,
}
/// you want to see grow larger, so a change larger than `noise` in the
/// negative direction represents a regression.
pub fn insert_metric(&mut self, name: &str, value: f64, noise: f64) {
- let m = Metric {
- value,
- noise,
- };
+ let m = Metric { value, noise };
self.0.insert(name.to_owned(), m);
}
pub fn fmt_metrics(&self) -> String {
let v = self.0
- .iter()
- .map(|(k, v)| format!("{}: {} (+/- {})", *k, v.value, v.noise))
- .collect::<Vec<_>>();
+ .iter()
+ .map(|(k, v)| format!("{}: {} (+/- {})", *k, v.value, v.noise))
+ .collect::<Vec<_>>();
v.join(", ")
}
}
impl Bencher {
/// Callback for benchmark functions to run in their body.
pub fn iter<T, F>(&mut self, mut inner: F)
- where F: FnMut() -> T
+ where
+ F: FnMut() -> T,
{
if self.mode == BenchMode::Single {
ns_iter_inner(&mut inner, 1);
}
pub fn bench<F>(&mut self, mut f: F) -> Option<stats::Summary>
- where F: FnMut(&mut Bencher)
+ where
+ F: FnMut(&mut Bencher),
{
f(self);
return self.summary;
}
fn ns_iter_inner<T, F>(inner: &mut F, k: u64) -> u64
- where F: FnMut() -> T
+where
+ F: FnMut() -> T,
{
let start = Instant::now();
for _ in 0..k {
pub fn iter<T, F>(inner: &mut F) -> stats::Summary
- where F: FnMut() -> T
+where
+ F: FnMut() -> T,
{
// Initial bench run to get ballpark figure.
let ns_single = ns_iter_inner(inner, 1);
// If we've run for 100ms and seem to have converged to a
// stable median.
if loop_run > Duration::from_millis(100) && summ.median_abs_dev_pct < 1.0 &&
- summ.median - summ5.median < summ5.median_abs_dev {
+ summ.median - summ5.median < summ5.median_abs_dev
+ {
return summ5;
}
}
pub mod bench {
+ use std::panic::{catch_unwind, AssertUnwindSafe};
use std::cmp;
+ use std::io;
+ use std::sync::{Arc, Mutex};
use stats;
- use super::{Bencher, BenchSamples, BenchMode};
+ use super::{Bencher, BenchSamples, BenchMode, Sink, MonitorMsg, TestDesc, Sender, TestResult};
- pub fn benchmark<F>(f: F) -> BenchSamples
- where F: FnMut(&mut Bencher)
+ pub fn benchmark<F>(desc: TestDesc, monitor_ch: Sender<MonitorMsg>, nocapture: bool, f: F)
+ where
+ F: FnMut(&mut Bencher),
{
let mut bs = Bencher {
mode: BenchMode::Auto,
bytes: 0,
};
- return match bs.bench(f) {
- Some(ns_iter_summ) => {
+ let data = Arc::new(Mutex::new(Vec::new()));
+ let data2 = data.clone();
+
+ let oldio = if !nocapture {
+ Some((
+ io::set_print(Some(Box::new(Sink(data2.clone())))),
+ io::set_panic(Some(Box::new(Sink(data2)))),
+ ))
+ } else {
+ None
+ };
+
+ let result = catch_unwind(AssertUnwindSafe(|| bs.bench(f)));
+
+ if let Some((printio, panicio)) = oldio {
+ io::set_print(printio);
+ io::set_panic(panicio);
+ };
+
+ let test_result = match result { //bs.bench(f) {
+ Ok(Some(ns_iter_summ)) => {
let ns_iter = cmp::max(ns_iter_summ.median as u64, 1);
let mb_s = bs.bytes * 1000 / ns_iter;
- BenchSamples {
+ let bs = BenchSamples {
ns_iter_summ,
mb_s: mb_s as usize,
- }
+ };
+ TestResult::TrBench(bs)
}
- None => {
+ Ok(None) => {
// iter not called, so no data.
// FIXME: error in this case?
let samples: &mut [f64] = &mut [0.0_f64; 1];
- BenchSamples {
+ let bs = BenchSamples {
ns_iter_summ: stats::Summary::new(samples),
mb_s: 0,
- }
+ };
+ TestResult::TrBench(bs)
+ }
+ Err(_) => {
+ TestResult::TrFailed
}
};
+
+ let stdout = data.lock().unwrap().to_vec();
+ monitor_ch.send((desc, test_result, stdout)).unwrap();
}
pub fn run_once<F>(f: F)
- where F: FnMut(&mut Bencher)
+ where
+ F: FnMut(&mut Bencher),
{
let mut bs = Bencher {
mode: BenchMode::Single,
#[test]
fn parse_ignored_flag() {
- let args = vec!["progname".to_string(), "filter".to_string(), "--ignored".to_string()];
+ let args = vec![
+ "progname".to_string(),
+ "filter".to_string(),
+ "--ignored".to_string(),
+ ];
let opts = match parse_opts(&args) {
Some(Ok(o)) => o,
_ => panic!("Malformed arg in parse_ignored_flag"),
opts.run_tests = true;
opts.run_ignored = true;
- let tests = vec![TestDescAndFn {
+ let tests =
+ vec![TestDescAndFn {
desc: TestDesc {
name: StaticTestName("1"),
ignore: true,
#[test]
pub fn exact_filter_match() {
fn tests() -> Vec<TestDescAndFn> {
- vec!["base",
- "base::test",
- "base::test1",
- "base::test2",
- ].into_iter()
- .map(|name| TestDescAndFn {
- desc: TestDesc {
- name: StaticTestName(name),
- ignore: false,
- should_panic: ShouldPanic::No,
- allow_fail: false,
- },
- testfn: DynTestFn(Box::new(move || {}))
- })
- .collect()
+ vec!["base", "base::test", "base::test1", "base::test2"]
+ .into_iter()
+ .map(|name| {
+ TestDescAndFn {
+ desc: TestDesc {
+ name: StaticTestName(name),
+ ignore: false,
+ should_panic: ShouldPanic::No,
+ allow_fail: false,
+ },
+ testfn: DynTestFn(Box::new(move || {}))
+ }
+ }).collect()
}
- let substr = filter_tests(&TestOpts {
+ let substr = filter_tests(
+ &TestOpts {
filter: Some("base".into()),
..TestOpts::new()
- }, tests());
+ },
+ tests(),
+ );
assert_eq!(substr.len(), 4);
- let substr = filter_tests(&TestOpts {
+ let substr = filter_tests(
+ &TestOpts {
filter: Some("bas".into()),
..TestOpts::new()
- }, tests());
+ },
+ tests(),
+ );
assert_eq!(substr.len(), 4);
- let substr = filter_tests(&TestOpts {
+ let substr = filter_tests(
+ &TestOpts {
filter: Some("::test".into()),
..TestOpts::new()
- }, tests());
+ },
+ tests(),
+ );
assert_eq!(substr.len(), 3);
- let substr = filter_tests(&TestOpts {
+ let substr = filter_tests(
+ &TestOpts {
filter: Some("base::test".into()),
..TestOpts::new()
- }, tests());
+ },
+ tests(),
+ );
assert_eq!(substr.len(), 3);
- let exact = filter_tests(&TestOpts {
+ let exact = filter_tests(
+ &TestOpts {
filter: Some("base".into()),
- filter_exact: true, ..TestOpts::new()
- }, tests());
+ filter_exact: true,
+ ..TestOpts::new()
+ },
+ tests(),
+ );
assert_eq!(exact.len(), 1);
- let exact = filter_tests(&TestOpts {
+ let exact = filter_tests(
+ &TestOpts {
filter: Some("bas".into()),
filter_exact: true,
..TestOpts::new()
- }, tests());
+ },
+ tests(),
+ );
assert_eq!(exact.len(), 0);
- let exact = filter_tests(&TestOpts {
+ let exact = filter_tests(
+ &TestOpts {
filter: Some("::test".into()),
filter_exact: true,
..TestOpts::new()
- }, tests());
+ },
+ tests(),
+ );
assert_eq!(exact.len(), 0);
- let exact = filter_tests(&TestOpts {
+ let exact = filter_tests(
+ &TestOpts {
filter: Some("base::test".into()),
filter_exact: true,
..TestOpts::new()
- }, tests());
+ },
+ tests(),
+ );
assert_eq!(exact.len(), 1);
}
let mut opts = TestOpts::new();
opts.run_tests = true;
- let names = vec!["sha1::test".to_string(),
- "isize::test_to_str".to_string(),
- "isize::test_pow".to_string(),
- "test::do_not_run_ignored_tests".to_string(),
- "test::ignored_tests_result_in_ignored".to_string(),
- "test::first_free_arg_should_be_a_filter".to_string(),
- "test::parse_ignored_flag".to_string(),
- "test::filter_for_ignored_option".to_string(),
- "test::sort_tests".to_string()];
+ let names = vec![
+ "sha1::test".to_string(),
+ "isize::test_to_str".to_string(),
+ "isize::test_pow".to_string(),
+ "test::do_not_run_ignored_tests".to_string(),
+ "test::ignored_tests_result_in_ignored".to_string(),
+ "test::first_free_arg_should_be_a_filter".to_string(),
+ "test::parse_ignored_flag".to_string(),
+ "test::filter_for_ignored_option".to_string(),
+ "test::sort_tests".to_string(),
+ ];
let tests = {
fn testfn() {}
let mut tests = Vec::new();
};
let filtered = filter_tests(&opts, tests);
- let expected = vec!["isize::test_pow".to_string(),
- "isize::test_to_str".to_string(),
- "sha1::test".to_string(),
- "test::do_not_run_ignored_tests".to_string(),
- "test::filter_for_ignored_option".to_string(),
- "test::first_free_arg_should_be_a_filter".to_string(),
- "test::ignored_tests_result_in_ignored".to_string(),
- "test::parse_ignored_flag".to_string(),
- "test::sort_tests".to_string()];
+ let expected = vec![
+ "isize::test_pow".to_string(),
+ "isize::test_to_str".to_string(),
+ "sha1::test".to_string(),
+ "test::do_not_run_ignored_tests".to_string(),
+ "test::filter_for_ignored_option".to_string(),
+ "test::first_free_arg_should_be_a_filter".to_string(),
+ "test::ignored_tests_result_in_ignored".to_string(),
+ "test::parse_ignored_flag".to_string(),
+ "test::sort_tests".to_string(),
+ ];
for (a, b) in expected.iter().zip(filtered) {
assert!(*a == b.desc.name.to_string());
#[test]
pub fn test_bench_once_iter() {
fn f(b: &mut Bencher) {
- b.iter(|| {
- })
+ b.iter(|| {})
}
bench::run_once(f);
}
#[test]
pub fn test_bench_no_iter() {
fn f(_: &mut Bencher) {}
- bench::benchmark(f);
+
+ let (tx, rx) = channel();
+
+ let desc = TestDesc {
+ name: StaticTestName("f"),
+ ignore: false,
+ should_panic: ShouldPanic::No,
+ allow_fail: false,
+ };
+
+ ::bench::benchmark(desc,
+ tx,
+ true,
+ f);
+ rx.recv().unwrap();
}
#[test]
pub fn test_bench_iter() {
fn f(b: &mut Bencher) {
- b.iter(|| {
- })
+ b.iter(|| {})
}
- bench::benchmark(f);
+
+ let (tx, rx) = channel();
+
+ let desc = TestDesc {
+ name: StaticTestName("f"),
+ ignore: false,
+ should_panic: ShouldPanic::No,
+ allow_fail: false,
+ };
+
+ ::bench::benchmark(desc,
+ tx,
+ true,
+ f);
+ rx.recv().unwrap();
}
}
}
#[test]
fn test_norm10narrow() {
- let val = &[966.0000000000,
- 985.0000000000,
- 1110.0000000000,
- 848.0000000000,
- 821.0000000000,
- 975.0000000000,
- 962.0000000000,
- 1157.0000000000,
- 1217.0000000000,
- 955.0000000000];
+ let val = &[
+ 966.0000000000,
+ 985.0000000000,
+ 1110.0000000000,
+ 848.0000000000,
+ 821.0000000000,
+ 975.0000000000,
+ 962.0000000000,
+ 1157.0000000000,
+ 1217.0000000000,
+ 955.0000000000,
+ ];
let summ = &Summary {
sum: 9996.0000000000,
min: 821.0000000000,
}
#[test]
fn test_norm10medium() {
- let val = &[954.0000000000,
- 1064.0000000000,
- 855.0000000000,
- 1000.0000000000,
- 743.0000000000,
- 1084.0000000000,
- 704.0000000000,
- 1023.0000000000,
- 357.0000000000,
- 869.0000000000];
+ let val = &[
+ 954.0000000000,
+ 1064.0000000000,
+ 855.0000000000,
+ 1000.0000000000,
+ 743.0000000000,
+ 1084.0000000000,
+ 704.0000000000,
+ 1023.0000000000,
+ 357.0000000000,
+ 869.0000000000,
+ ];
let summ = &Summary {
sum: 8653.0000000000,
min: 357.0000000000,
}
#[test]
fn test_norm10wide() {
- let val = &[505.0000000000,
- 497.0000000000,
- 1591.0000000000,
- 887.0000000000,
- 1026.0000000000,
- 136.0000000000,
- 1580.0000000000,
- 940.0000000000,
- 754.0000000000,
- 1433.0000000000];
+ let val = &[
+ 505.0000000000,
+ 497.0000000000,
+ 1591.0000000000,
+ 887.0000000000,
+ 1026.0000000000,
+ 136.0000000000,
+ 1580.0000000000,
+ 940.0000000000,
+ 754.0000000000,
+ 1433.0000000000,
+ ];
let summ = &Summary {
sum: 9349.0000000000,
min: 136.0000000000,
}
#[test]
fn test_norm25verynarrow() {
- let val = &[991.0000000000,
- 1018.0000000000,
- 998.0000000000,
- 1013.0000000000,
- 974.0000000000,
- 1007.0000000000,
- 1014.0000000000,
- 999.0000000000,
- 1011.0000000000,
- 978.0000000000,
- 985.0000000000,
- 999.0000000000,
- 983.0000000000,
- 982.0000000000,
- 1015.0000000000,
- 1002.0000000000,
- 977.0000000000,
- 948.0000000000,
- 1040.0000000000,
- 974.0000000000,
- 996.0000000000,
- 989.0000000000,
- 1015.0000000000,
- 994.0000000000,
- 1024.0000000000];
+ let val = &[
+ 991.0000000000,
+ 1018.0000000000,
+ 998.0000000000,
+ 1013.0000000000,
+ 974.0000000000,
+ 1007.0000000000,
+ 1014.0000000000,
+ 999.0000000000,
+ 1011.0000000000,
+ 978.0000000000,
+ 985.0000000000,
+ 999.0000000000,
+ 983.0000000000,
+ 982.0000000000,
+ 1015.0000000000,
+ 1002.0000000000,
+ 977.0000000000,
+ 948.0000000000,
+ 1040.0000000000,
+ 974.0000000000,
+ 996.0000000000,
+ 989.0000000000,
+ 1015.0000000000,
+ 994.0000000000,
+ 1024.0000000000,
+ ];
let summ = &Summary {
sum: 24926.0000000000,
min: 948.0000000000,
}
#[test]
fn test_exp10a() {
- let val = &[23.0000000000,
- 11.0000000000,
- 2.0000000000,
- 57.0000000000,
- 4.0000000000,
- 12.0000000000,
- 5.0000000000,
- 29.0000000000,
- 3.0000000000,
- 21.0000000000];
+ let val = &[
+ 23.0000000000,
+ 11.0000000000,
+ 2.0000000000,
+ 57.0000000000,
+ 4.0000000000,
+ 12.0000000000,
+ 5.0000000000,
+ 29.0000000000,
+ 3.0000000000,
+ 21.0000000000,
+ ];
let summ = &Summary {
sum: 167.0000000000,
min: 2.0000000000,
}
#[test]
fn test_exp10b() {
- let val = &[24.0000000000,
- 17.0000000000,
- 6.0000000000,
- 38.0000000000,
- 25.0000000000,
- 7.0000000000,
- 51.0000000000,
- 2.0000000000,
- 61.0000000000,
- 32.0000000000];
+ let val = &[
+ 24.0000000000,
+ 17.0000000000,
+ 6.0000000000,
+ 38.0000000000,
+ 25.0000000000,
+ 7.0000000000,
+ 51.0000000000,
+ 2.0000000000,
+ 61.0000000000,
+ 32.0000000000,
+ ];
let summ = &Summary {
sum: 263.0000000000,
min: 2.0000000000,
}
#[test]
fn test_exp10c() {
- let val = &[71.0000000000,
- 2.0000000000,
- 32.0000000000,
- 1.0000000000,
- 6.0000000000,
- 28.0000000000,
- 13.0000000000,
- 37.0000000000,
- 16.0000000000,
- 36.0000000000];
+ let val = &[
+ 71.0000000000,
+ 2.0000000000,
+ 32.0000000000,
+ 1.0000000000,
+ 6.0000000000,
+ 28.0000000000,
+ 13.0000000000,
+ 37.0000000000,
+ 16.0000000000,
+ 36.0000000000,
+ ];
let summ = &Summary {
sum: 242.0000000000,
min: 1.0000000000,
}
#[test]
fn test_exp25() {
- let val = &[3.0000000000,
- 24.0000000000,
- 1.0000000000,
- 19.0000000000,
- 7.0000000000,
- 5.0000000000,
- 30.0000000000,
- 39.0000000000,
- 31.0000000000,
- 13.0000000000,
- 25.0000000000,
- 48.0000000000,
- 1.0000000000,
- 6.0000000000,
- 42.0000000000,
- 63.0000000000,
- 2.0000000000,
- 12.0000000000,
- 108.0000000000,
- 26.0000000000,
- 1.0000000000,
- 7.0000000000,
- 44.0000000000,
- 25.0000000000,
- 11.0000000000];
+ let val = &[
+ 3.0000000000,
+ 24.0000000000,
+ 1.0000000000,
+ 19.0000000000,
+ 7.0000000000,
+ 5.0000000000,
+ 30.0000000000,
+ 39.0000000000,
+ 31.0000000000,
+ 13.0000000000,
+ 25.0000000000,
+ 48.0000000000,
+ 1.0000000000,
+ 6.0000000000,
+ 42.0000000000,
+ 63.0000000000,
+ 2.0000000000,
+ 12.0000000000,
+ 108.0000000000,
+ 26.0000000000,
+ 1.0000000000,
+ 7.0000000000,
+ 44.0000000000,
+ 25.0000000000,
+ 11.0000000000,
+ ];
let summ = &Summary {
sum: 593.0000000000,
min: 1.0000000000,
}
#[test]
fn test_binom25() {
- let val = &[18.0000000000,
- 17.0000000000,
- 27.0000000000,
- 15.0000000000,
- 21.0000000000,
- 25.0000000000,
- 17.0000000000,
- 24.0000000000,
- 25.0000000000,
- 24.0000000000,
- 26.0000000000,
- 26.0000000000,
- 23.0000000000,
- 15.0000000000,
- 23.0000000000,
- 17.0000000000,
- 18.0000000000,
- 18.0000000000,
- 21.0000000000,
- 16.0000000000,
- 15.0000000000,
- 31.0000000000,
- 20.0000000000,
- 17.0000000000,
- 15.0000000000];
+ let val = &[
+ 18.0000000000,
+ 17.0000000000,
+ 27.0000000000,
+ 15.0000000000,
+ 21.0000000000,
+ 25.0000000000,
+ 17.0000000000,
+ 24.0000000000,
+ 25.0000000000,
+ 24.0000000000,
+ 26.0000000000,
+ 26.0000000000,
+ 23.0000000000,
+ 15.0000000000,
+ 23.0000000000,
+ 17.0000000000,
+ 18.0000000000,
+ 18.0000000000,
+ 21.0000000000,
+ 16.0000000000,
+ 15.0000000000,
+ 31.0000000000,
+ 20.0000000000,
+ 17.0000000000,
+ 15.0000000000,
+ ];
let summ = &Summary {
sum: 514.0000000000,
min: 15.0000000000,
}
#[test]
fn test_pois25lambda30() {
- let val = &[27.0000000000,
- 33.0000000000,
- 34.0000000000,
- 34.0000000000,
- 24.0000000000,
- 39.0000000000,
- 28.0000000000,
- 27.0000000000,
- 31.0000000000,
- 28.0000000000,
- 38.0000000000,
- 21.0000000000,
- 33.0000000000,
- 36.0000000000,
- 29.0000000000,
- 37.0000000000,
- 32.0000000000,
- 34.0000000000,
- 31.0000000000,
- 39.0000000000,
- 25.0000000000,
- 31.0000000000,
- 32.0000000000,
- 40.0000000000,
- 24.0000000000];
+ let val = &[
+ 27.0000000000,
+ 33.0000000000,
+ 34.0000000000,
+ 34.0000000000,
+ 24.0000000000,
+ 39.0000000000,
+ 28.0000000000,
+ 27.0000000000,
+ 31.0000000000,
+ 28.0000000000,
+ 38.0000000000,
+ 21.0000000000,
+ 33.0000000000,
+ 36.0000000000,
+ 29.0000000000,
+ 37.0000000000,
+ 32.0000000000,
+ 34.0000000000,
+ 31.0000000000,
+ 39.0000000000,
+ 25.0000000000,
+ 31.0000000000,
+ 32.0000000000,
+ 40.0000000000,
+ 24.0000000000,
+ ];
let summ = &Summary {
sum: 787.0000000000,
min: 21.0000000000,
}
#[test]
fn test_pois25lambda40() {
- let val = &[42.0000000000,
- 50.0000000000,
- 42.0000000000,
- 46.0000000000,
- 34.0000000000,
- 45.0000000000,
- 34.0000000000,
- 49.0000000000,
- 39.0000000000,
- 28.0000000000,
- 40.0000000000,
- 35.0000000000,
- 37.0000000000,
- 39.0000000000,
- 46.0000000000,
- 44.0000000000,
- 32.0000000000,
- 45.0000000000,
- 42.0000000000,
- 37.0000000000,
- 48.0000000000,
- 42.0000000000,
- 33.0000000000,
- 42.0000000000,
- 48.0000000000];
+ let val = &[
+ 42.0000000000,
+ 50.0000000000,
+ 42.0000000000,
+ 46.0000000000,
+ 34.0000000000,
+ 45.0000000000,
+ 34.0000000000,
+ 49.0000000000,
+ 39.0000000000,
+ 28.0000000000,
+ 40.0000000000,
+ 35.0000000000,
+ 37.0000000000,
+ 39.0000000000,
+ 46.0000000000,
+ 44.0000000000,
+ 32.0000000000,
+ 45.0000000000,
+ 42.0000000000,
+ 37.0000000000,
+ 48.0000000000,
+ 42.0000000000,
+ 33.0000000000,
+ 42.0000000000,
+ 48.0000000000,
+ ];
let summ = &Summary {
sum: 1019.0000000000,
min: 28.0000000000,
}
#[test]
fn test_pois25lambda50() {
- let val = &[45.0000000000,
- 43.0000000000,
- 44.0000000000,
- 61.0000000000,
- 51.0000000000,
- 53.0000000000,
- 59.0000000000,
- 52.0000000000,
- 49.0000000000,
- 51.0000000000,
- 51.0000000000,
- 50.0000000000,
- 49.0000000000,
- 56.0000000000,
- 42.0000000000,
- 52.0000000000,
- 51.0000000000,
- 43.0000000000,
- 48.0000000000,
- 48.0000000000,
- 50.0000000000,
- 42.0000000000,
- 43.0000000000,
- 42.0000000000,
- 60.0000000000];
+ let val = &[
+ 45.0000000000,
+ 43.0000000000,
+ 44.0000000000,
+ 61.0000000000,
+ 51.0000000000,
+ 53.0000000000,
+ 59.0000000000,
+ 52.0000000000,
+ 49.0000000000,
+ 51.0000000000,
+ 51.0000000000,
+ 50.0000000000,
+ 49.0000000000,
+ 56.0000000000,
+ 42.0000000000,
+ 52.0000000000,
+ 51.0000000000,
+ 43.0000000000,
+ 48.0000000000,
+ 48.0000000000,
+ 50.0000000000,
+ 42.0000000000,
+ 43.0000000000,
+ 42.0000000000,
+ 60.0000000000,
+ ];
let summ = &Summary {
sum: 1235.0000000000,
min: 42.0000000000,
}
#[test]
fn test_unif25() {
- let val = &[99.0000000000,
- 55.0000000000,
- 92.0000000000,
- 79.0000000000,
- 14.0000000000,
- 2.0000000000,
- 33.0000000000,
- 49.0000000000,
- 3.0000000000,
- 32.0000000000,
- 84.0000000000,
- 59.0000000000,
- 22.0000000000,
- 86.0000000000,
- 76.0000000000,
- 31.0000000000,
- 29.0000000000,
- 11.0000000000,
- 41.0000000000,
- 53.0000000000,
- 45.0000000000,
- 44.0000000000,
- 98.0000000000,
- 98.0000000000,
- 7.0000000000];
+ let val = &[
+ 99.0000000000,
+ 55.0000000000,
+ 92.0000000000,
+ 79.0000000000,
+ 14.0000000000,
+ 2.0000000000,
+ 33.0000000000,
+ 49.0000000000,
+ 3.0000000000,
+ 32.0000000000,
+ 84.0000000000,
+ 59.0000000000,
+ 22.0000000000,
+ 86.0000000000,
+ 76.0000000000,
+ 31.0000000000,
+ 29.0000000000,
+ 11.0000000000,
+ 41.0000000000,
+ 53.0000000000,
+ 45.0000000000,
+ 44.0000000000,
+ 98.0000000000,
+ 98.0000000000,
+ 7.0000000000,
+ ];
let summ = &Summary {
sum: 1242.0000000000,
min: 2.0000000000,
#[bench]
pub fn sum_three_items(b: &mut Bencher) {
- b.iter(|| {
- [1e20f64, 1.5f64, -1e20f64].sum();
- })
+ b.iter(|| { [1e20f64, 1.5f64, -1e20f64].sum(); })
}
#[bench]
pub fn sum_many_f64(b: &mut Bencher) {
let nums = [-1e30f64, 1e60, 1e30, 1.0, -1e60];
let v = (0..500).map(|i| nums[i % 5]).collect::<Vec<_>>();
- b.iter(|| {
- v.sum();
- })
+ b.iter(|| { v.sum(); })
}
#[bench]
let target = env::var("TARGET").expect("TARGET was not set");
if target.contains("linux") {
- if target.contains("musl") && !target.contains("mips") {
+ if target.contains("musl") {
// musl is handled in lib.rs
} else if !target.contains("android") {
println!("cargo:rustc-link-lib=gcc_s");
}
}
-#[cfg(all(target_env = "musl", not(target_arch = "mips")))]
+#[cfg(target_env = "musl")]
#[link(name = "unwind", kind = "static", cfg(target_feature = "crt-static"))]
#[link(name = "gcc_s", cfg(not(target_feature = "crt-static")))]
extern {}
}
cfg_if! {
-if #[cfg(not(any(all(target_os = "android", target_arch = "arm"),
- all(target_os = "linux", target_arch = "arm"))))] {
+if #[cfg(all(any(target_os = "ios", not(target_arch = "arm"))))] {
// Not ARM EHABI
#[repr(C)]
#[derive(Copy, Clone, PartialEq)]
--- /dev/null
+Subproject commit 2717444753318e461e0c3b30dacd03ffbac96903
name = "rustc"
path = "rustc.rs"
-# All optional dependencies so the features passed to this Cargo.toml select
-# what should actually be built.
[dependencies]
rustc_back = { path = "../librustc_back" }
rustc_driver = { path = "../librustc_driver" }
[features]
jemalloc = ["rustc_back/jemalloc"]
-llvm = ["rustc_driver/llvm"]
StringMap<FunctionImporter::ImportMapTy> ImportLists;
StringMap<FunctionImporter::ExportSetTy> ExportLists;
StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries;
+
+#if LLVM_VERSION_GE(7, 0)
+ LLVMRustThinLTOData() : Index(/* isPerformingAnalysis = */ false) {}
+#endif
};
// Just an argument to the `LLVMRustCreateThinLTOData` function below.
//
// This is copied from `lib/LTO/ThinLTOCodeGenerator.cpp`
#if LLVM_VERSION_GE(5, 0)
+#if LLVM_VERSION_GE(7, 0)
+ auto deadIsPrevailing = [&](GlobalValue::GUID G) {
+ return PrevailingType::Unknown;
+ };
+ computeDeadSymbols(Ret->Index, Ret->GUIDPreservedSymbols, deadIsPrevailing);
+#else
computeDeadSymbols(Ret->Index, Ret->GUIDPreservedSymbols);
+#endif
ComputeCrossModuleImport(
Ret->Index,
Ret->ModuleToDefinedGVSummaries,
pub fn str(_: &[u8]) {
}
-// CHECK: @trait_borrow(%"core::ops::drop::Drop"* nonnull %arg0.0, {}* noalias nonnull readonly %arg0.1)
+// CHECK: @trait_borrow({}* nonnull %arg0.0, {}* noalias nonnull readonly %arg0.1)
// FIXME #25759 This should also have `nocapture`
#[no_mangle]
pub fn trait_borrow(_: &Drop) {
}
-// CHECK: @trait_box(%"core::ops::drop::Drop"* noalias nonnull, {}* noalias nonnull readonly)
+// CHECK: @trait_box({}* noalias nonnull, {}* noalias nonnull readonly)
#[no_mangle]
pub fn trait_box(_: Box<Drop>) {
}
}
struct Abc;
+
impl Foo for Abc {
const X: EFoo = EFoo::B;
}
pub fn test<A: Foo, B: Foo>(arg: EFoo) {
match arg {
- A::X => println!("A::X"), //~ error: statics cannot be referenced in patterns [E0158]
- B::X => println!("B::X"), //~ error: statics cannot be referenced in patterns [E0158]
+ A::X => println!("A::X"),
+ //~^ error: associated consts cannot be referenced in patterns [E0158]
+ B::X => println!("B::X"),
+ //~^ error: associated consts cannot be referenced in patterns [E0158]
_ => (),
}
}
fn changer<'a>(mut things: Box<Iterator<Item=&'a mut u8>>) {
for item in *things { *item = 0 }
-//~^ ERROR `std::iter::Iterator<Item=&mut u8>: std::marker::Sized` is not satisfied
+//~^ ERROR the trait bound `std::iter::Iterator<Item=&mut u8>: std::marker::Sized` is not satisfied
}
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// check that we link regions in mutable lvalue ops correctly - issue #41774
+// check that we link regions in mutable place ops correctly - issue #41774
struct Data(i32);
-// Change l-value in assignment ------------------------------------------------
+// Change place in assignment --------------------------------------------------
#[cfg(cfail1)]
-pub fn lvalue() -> i32 {
+pub fn place() -> i32 {
let mut x = 10;
let mut y = 11;
x = 9;
#[cfg(not(cfail1))]
#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")]
-pub fn lvalue() -> i32 {
+pub fn place() -> i32 {
let mut x = 10;
let mut y = 11;
y = 9;
fn main() {
let x = || -> i32 22;
- //~^ ERROR expected one of `!`, `(`, `::`, `<`, or `{`, found `22`
+ //~^ ERROR expected one of `!`, `(`, `+`, `::`, `<`, or `{`, found `22`
}
// compile-flags: -Z parse-only
fn foo() -> Vec<usize>> {
- //~^ ERROR expected one of `!`, `::`, `where`, or `{`, found `>`
+ //~^ ERROR expected one of `!`, `+`, `::`, `where`, or `{`, found `>`
Vec::new()
}
/// This is the entrypoint for a hot plugged rustc_trans
#[no_mangle]
-pub fn __rustc_codegen_backend(sess: &Session) -> Box<TransCrate> {
- Box::new(TheBackend(MetadataOnlyTransCrate::new(sess)))
+pub fn __rustc_codegen_backend() -> Box<TransCrate> {
+ Box::new(TheBackend(MetadataOnlyTransCrate::new()))
}
extern crate rustc_lint;
extern crate rustc_metadata;
extern crate rustc_errors;
-extern crate rustc_trans;
extern crate rustc_trans_utils;
extern crate syntax;
let descriptions = Registry::new(&rustc::DIAGNOSTICS);
let sess = build_session(opts, None, descriptions);
- let trans = rustc_trans::LlvmTransCrate::new(&sess);
+ let trans = rustc_driver::get_trans(&sess);
let cstore = Rc::new(CStore::new(trans.metadata_loader()));
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
(sess, cstore, trans)
--- /dev/null
+-include ../tools.mk
+
+# Test expected libtest's JSON output
+
+OUTPUT_FILE := $(TMPDIR)/libtest-json-output.json
+
+all:
+ $(RUSTC) --test f.rs
+ $(call RUN,f) -Z unstable-options --test-threads=1 --format=json > $(OUTPUT_FILE) || true
+
+ cat $(OUTPUT_FILE) | "$(PYTHON)" validate_json.py
+
+ # Compare to output file
+ diff output.json $(OUTPUT_FILE)
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[test]
+fn a() {
+ // Should pass
+}
+
+#[test]
+fn b() {
+ assert!(false)
+}
+
+#[test]
+#[should_panic]
+fn c() {
+ assert!(false);
+}
+
+#[test]
+#[ignore]
+fn d() {
+ assert!(false);
+}
+
--- /dev/null
+{ "type": "suite", "event": "started", "test_count": "4" }
+{ "type": "test", "event": "started", "name": "a" }
+{ "type": "test", "name": "a", "event": "ok" }
+{ "type": "test", "event": "started", "name": "b" }
+{ "type": "test", "name": "b", "event": "failed", "stdout": "thread 'b' panicked at 'assertion failed: false', f.rs:18:5\nnote: Run with `RUST_BACKTRACE=1` for a backtrace.\n" }
+{ "type": "test", "event": "started", "name": "c" }
+{ "type": "test", "name": "c", "event": "ok" }
+{ "type": "test", "event": "started", "name": "d" }
+{ "type": "test", "name": "d", "event": "ignored" }
+{ "type": "suite", "event": "failed", "passed": 2, "failed": 1, "allowed_fail": 0, "ignored": 1, "measured": 0, "filtered_out": "0" }
--- /dev/null
+#!/usr/bin/env python
+
+# Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+import sys
+import json
+
+# Try to decode line in order to ensure it is a valid JSON document
+for line in sys.stdin:
+ json.loads(line)
-include ../tools.mk
+ifeq ($(UNAME),Darwin)
+PLUGIN_FLAGS := -C link-args=-Wl,-undefined,dynamic_lookup
+endif
+
ifeq ($(findstring stage1,$(RUST_BUILD_STAGE)),stage1)
# ignore stage1
all:
all:
else
all: $(call NATIVE_STATICLIB,llvm-function-pass) $(call NATIVE_STATICLIB,llvm-module-pass)
- $(RUSTC) plugin.rs -C prefer-dynamic
+ $(RUSTC) plugin.rs -C prefer-dynamic $(PLUGIN_FLAGS)
$(RUSTC) main.rs
$(TMPDIR)/libllvm-function-pass.o:
extern crate rustc;
extern crate rustc_plugin;
-extern crate rustc_trans;
#[link(name = "llvm-function-pass", kind = "static")]
#[link(name = "llvm-module-pass", kind = "static")]
--- /dev/null
+-include ../tools.mk
+
+all:
+ cp non-utf8 $(TMPDIR)/non-utf.rs
+ cat $(TMPDIR)/non-utf.rs | $(RUSTC) - 2>&1 \
+ | $(CGREP) "error: couldn't read from stdin, as it did not contain valid UTF-8"
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// ignore-cross-compile
-
-#![feature(rustc_private)]
-
-extern crate tempdir;
-
use std::env;
use std::fs;
-use tempdir::TempDir;
+use std::path::PathBuf;
fn main() {
- let td = TempDir::new("create-dir-all-bare").unwrap();
- env::set_current_dir(td.path()).unwrap();
+ let path = PathBuf::from(env::var_os("RUST_TEST_TMPDIR").unwrap());
+ env::set_current_dir(&path).unwrap();
fs::create_dir_all("create-dir-all-bare").unwrap();
}
// no-prefer-dynamic
// ignore-cross-compile
-#![feature(rustc_private)]
-
-extern crate tempdir;
-
use std::env;
use std::fs;
use std::process;
use std::str;
-use tempdir::TempDir;
+use std::path::PathBuf;
fn main() {
// If we're the child, make sure we were invoked correctly
let my_path = env::current_exe().unwrap();
let my_dir = my_path.parent().unwrap();
- let child_dir = TempDir::new_in(&my_dir, "issue-15140-child").unwrap();
- let child_dir = child_dir.path();
+ let child_dir = PathBuf::from(env::var_os("RUST_TEST_TMPDIR").unwrap());
+ let child_dir = child_dir.join("issue-15140-child");
+ fs::create_dir_all(&child_dir).unwrap();
let child_path = child_dir.join(&format!("mytest{}",
env::consts::EXE_SUFFIX));
format!("child assertion failed\n child stdout:\n {}\n child stderr:\n {}",
str::from_utf8(&child_output.stdout).unwrap(),
str::from_utf8(&child_output.stderr).unwrap()));
-
- let res = fs::remove_dir_all(&child_dir);
- if res.is_err() {
- // On Windows deleting just executed mytest.exe can fail because it's still locked
- std::thread::sleep_ms(1000);
- fs::remove_dir_all(&child_dir).unwrap();
- }
}
// ignore-cross-compile
-#![feature(rustc_private)]
-
-extern crate tempdir;
-
+use std::env;
use std::ffi::CString;
use std::fs::{self, File};
-use tempdir::TempDir;
+use std::path::PathBuf;
fn rename_directory() {
- let tmpdir = TempDir::new("rename_directory").ok().expect("rename_directory failed");
- let tmpdir = tmpdir.path();
+ let tmpdir = PathBuf::from(env::var_os("RUST_TEST_TMPDIR").unwrap());
let old_path = tmpdir.join("foo/bar/baz");
fs::create_dir_all(&old_path).unwrap();
let test_file = &old_path.join("temp.txt");
// ignore-cross-compile
-#![feature(rustc_private)]
-
-extern crate tempdir;
-
use std::env;
use std::fs::File;
use std::io;
use std::io::{Read, Write};
use std::process::{Command, Stdio};
-
-use tempdir::TempDir;
+use std::path::PathBuf;
fn main() {
if env::args().len() > 1 {
}
fn parent() -> io::Result<()> {
- let td = TempDir::new("foo").unwrap();
- let input = td.path().join("input");
- let output = td.path().join("output");
+ let td = PathBuf::from(env::var_os("RUST_TEST_TMPDIR").unwrap());
+ let input = td.join("stdio-from-input");
+ let output = td.join("stdio-from-output");
File::create(&input)?.write_all(b"foo\n")?;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(rustc_private)]
-
-extern crate tempdir;
-
+use std::env;
use std::fs::File;
use std::io::{Read, Write};
-
-use tempdir::TempDir;
+use std::path::PathBuf;
#[cfg(unix)]
fn switch_stdout_to(file: File) {
}
fn main() {
- let td = TempDir::new("foo").unwrap();
- let path = td.path().join("bar");
+ let path = PathBuf::from(env::var_os("RUST_TEST_TMPDIR").unwrap());
+ let path = path.join("switch-stdout-output");
let f = File::create(&path).unwrap();
println!("foo");
if cfg!(target_os = "android") {
assert!(home_dir().is_none());
} else {
- assert!(home_dir().is_some());
+ // When HOME is not set, some platforms return `None`,
+ // but others return `Some` with a default.
+ // Just check that it is not "/home/MountainView".
+ assert_ne!(home_dir(), Some(PathBuf::from("/home/MountainView")));
}
}
// Test that we don't ICE when translating a generic impl method from
// an extern crate that contains a match expression on a local
-// variable lvalue where one of the match case bodies contains an
+// variable place where one of the match case bodies contains an
// expression that autoderefs through an overloaded generic deref
// impl.
// This used to generate invalid IR in that even if we took the
// `false` branch we'd still try to free the Box from the other
// arm. This was due to treating `*Box::new(9)` as an rvalue datum
-// instead of as an lvalue.
+// instead of as a place.
fn test(foo: bool) -> u8 {
match foo {
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Regression test for issue #47139:
+//
+// Coherence was encountering an (unnecessary) overflow trying to
+// decide if the two impls of dummy overlap.
+//
+// The overflow went something like:
+//
+// - `&'a ?T: Insertable` ?
+// - let ?T = Option<?U> ?
+// - `Option<?U>: Insertable` ?
+// - `Option<&'a ?U>: Insertable` ?
+// - `&'a ?U: Insertable` ?
+//
+// While somewhere in the middle, a projection would occur, which
+// broke cycle detection.
+//
+// It turned out that this cycle was being kicked off due to some
+// extended diagnostic attempts in coherence, so removing those
+// sidestepped the issue for now.
+
+#![allow(dead_code)]
+
+pub trait Insertable {
+ type Values;
+
+ fn values(self) -> Self::Values;
+}
+
+impl<T> Insertable for Option<T>
+ where
+ T: Insertable,
+ T::Values: Default,
+{
+ type Values = T::Values;
+
+ fn values(self) -> Self::Values {
+ self.map(Insertable::values).unwrap_or_default()
+ }
+}
+
+impl<'a, T> Insertable for &'a Option<T>
+ where
+ Option<&'a T>: Insertable,
+{
+ type Values = <Option<&'a T> as Insertable>::Values;
+
+ fn values(self) -> Self::Values {
+ self.as_ref().values()
+ }
+}
+
+impl<'a, T> Insertable for &'a [T]
+{
+ type Values = Self;
+
+ fn values(self) -> Self::Values {
+ self
+ }
+}
+
+trait Unimplemented { }
+
+trait Dummy { }
+
+struct Foo<T> { t: T }
+
+impl<'a, U> Dummy for Foo<&'a U>
+ where &'a U: Insertable
+{
+}
+
+impl<T> Dummy for T
+ where T: Unimplemented
+{ }
+
+fn main() {
+}
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Regression test for issue #47139:
+//
+// Same as issue-47139-1.rs, but the impls of dummy are in the
+// opposite order. This influenced the way that coherence ran and in
+// some cases caused the overflow to occur when it wouldn't otherwise.
+// In an effort to make the regr test more robust, I am including both
+// orderings.
+
+#![allow(dead_code)]
+
+pub trait Insertable {
+ type Values;
+
+ fn values(self) -> Self::Values;
+}
+
+impl<T> Insertable for Option<T>
+ where
+ T: Insertable,
+ T::Values: Default,
+{
+ type Values = T::Values;
+
+ fn values(self) -> Self::Values {
+ self.map(Insertable::values).unwrap_or_default()
+ }
+}
+
+impl<'a, T> Insertable for &'a Option<T>
+ where
+ Option<&'a T>: Insertable,
+{
+ type Values = <Option<&'a T> as Insertable>::Values;
+
+ fn values(self) -> Self::Values {
+ self.as_ref().values()
+ }
+}
+
+impl<'a, T> Insertable for &'a [T]
+{
+ type Values = Self;
+
+ fn values(self) -> Self::Values {
+ self
+ }
+}
+
+trait Unimplemented { }
+
+trait Dummy { }
+
+struct Foo<T> { t: T }
+
+impl<T> Dummy for T
+ where T: Unimplemented
+{ }
+
+impl<'a, U> Dummy for Foo<&'a U>
+ where &'a U: Insertable
+{
+}
+
+fn main() {
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn id<'c, 'b>(f: &'c &'b Fn(&i32)) -> &'c &'b Fn(&'static i32) {
+ f
+}
+
+fn main() {
+ let f: &Fn(&i32) = &|x| {};
+ id(&f);
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Test that an `&mut self` method, when invoked on an lvalue whose
-// type is `&mut [u8]`, passes in a pointer to the lvalue and not a
+// Test that an `&mut self` method, when invoked on a place whose
+// type is `&mut [u8]`, passes in a pointer to the place and not a
// temporary. Issue #19147.
use std::slice;
// all borrows are extended - nothing has been dropped yet
assert_eq!(get(), vec![]);
}
- // in a let-statement, extended lvalues are dropped
+ // in a let-statement, extended places are dropped
// *after* the let result (tho they have the same scope
// as far as scope-based borrowck goes).
assert_eq!(get(), vec![0, 2, 3, 1]);
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(never_type)]
+#![allow(dead_code)]
+#![allow(path_statements)]
+#![allow(unreachable_patterns)]
+
+fn never_direct(x: !) {
+ x;
+}
+
+fn never_ref_pat(ref x: !) {
+ *x;
+}
+
+fn never_ref(x: &!) {
+ let &y = x;
+ y;
+}
+
+fn never_pointer(x: *const !) {
+ unsafe {
+ *x;
+ }
+}
+
+fn never_slice(x: &[!]) {
+ x[0];
+}
+
+fn never_match(x: Result<(), !>) {
+ match x {
+ Ok(_) => {},
+ Err(_) => {},
+ }
+}
+
+pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// min-llvm-version 4.0
+// no-system-llvm -- needs MCSubtargetInfo::getFeatureTable()
// ignore-cloudabi no std::env
#![feature(cfg_target_feature)]
assert_eq!(b, 1: u16);
let mut v = Vec::new();
- v: Vec<u8> = vec![1, 2, 3]; // Lvalue type ascription
+ v: Vec<u8> = vec![1, 2, 3]; // Place expression type ascription
assert_eq!(v, [1u8, 2, 3]);
}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(const_fn)]
+
+type Field1 = i32;
+type Field2 = f32;
+type Field3 = i64;
+
+union DummyUnion {
+ field1: Field1,
+ field2: Field2,
+ field3: Field3,
+}
+
+const FLOAT1_AS_I32: i32 = 1065353216;
+const UNION: DummyUnion = DummyUnion { field1: FLOAT1_AS_I32 };
+
+const fn read_field1() -> Field1 {
+ const FIELD1: Field1 = unsafe { UNION.field1 };
+ FIELD1
+}
+
+const fn read_field2() -> Field2 {
+ const FIELD2: Field2 = unsafe { UNION.field2 };
+ FIELD2
+}
+
+const fn read_field3() -> Field3 {
+ const FIELD3: Field3 = unsafe { UNION.field3 };
+ FIELD3
+}
+
+fn main() {
+ assert_eq!(read_field1(), FLOAT1_AS_I32);
+ assert_eq!(read_field2(), 1.0);
+ assert_eq!(read_field3(), unsafe { UNION.field3 });
+}
}
}
+// Test every possible part of the syntax
use a::{B, d::{self, *, g::H}};
+// Test a more common use case
+use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
+
fn main() {
let _: B;
let _: E;
let _: F;
let _: H;
let _: d::g::I;
+
+ let _: Arc<AtomicBool>;
+ let _: Ordering;
}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags: -Z unstable-options --disable-commonmark
+
+#![crate_name = "foo"]
+
+//! hello [foo]
+//!
+//! [foo]: url 'title & <stuff> & "things"'
+
+// @has 'foo/index.html' 'title & <stuff> & "things"'
= note: `foo` must be defined only once in the type namespace of this module
help: You can use `as` to change the binding name of the import
|
-13 | use foo::foo as Otherfoo;
- | ^^^^^^^^^^^^^^^^^^^^
+13 | use foo::foo as other_foo;
+ | ^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error
| ^
error[E0015]: calls in constant functions are limited to constant functions, struct and enum constructors
- --> $DIR/const-fn-error.rs:17:5
+ --> $DIR/const-fn-error.rs:17:14
|
-17 | / for i in 0..x { //~ ERROR calls in constant functions
-18 | | //~| ERROR constant function contains unimplemented
-19 | | sum += i;
-20 | | }
- | |_____^
+17 | for i in 0..x { //~ ERROR calls in constant functions
+ | ^^^^
error[E0019]: constant function contains unimplemented expression type
- --> $DIR/const-fn-error.rs:17:5
+ --> $DIR/const-fn-error.rs:17:14
|
-17 | / for i in 0..x { //~ ERROR calls in constant functions
-18 | | //~| ERROR constant function contains unimplemented
-19 | | sum += i;
-20 | | }
- | |_____^
+17 | for i in 0..x { //~ ERROR calls in constant functions
+ | ^^^^
error[E0080]: constant evaluation error
--> $DIR/const-fn-error.rs:21:5
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+mod underscore;
+
+fn main() {
+ underscore!();
+}
--- /dev/null
+error: expected expression, found `_`
+ --> $DIR/underscore.rs:18:9
+ |
+18 | _
+ | ^
+ |
+ ::: $DIR/main.rs:15:5
+ |
+15 | underscore!();
+ | -------------- in this macro invocation
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// We want this file only so we can test cross-file error
+// messages, but we don't want it in an external crate.
+// ignore-test
+#![crate_type = "lib"]
+
+macro_rules! underscore {
+ () => (
+ _
+ )
+}
= note: `foo` must be defined only once in the value namespace of this module
help: You can use `as` to change the binding name of the import
|
-23 | use sub2::foo as Otherfoo; //~ ERROR the name `foo` is defined multiple times
- | ^^^^^^^^^^^^^^^^^^^^^
+23 | use sub2::foo as other_foo; //~ ERROR the name `foo` is defined multiple times
+ | ^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error
-error[E0658]: `#[thread_local]` is an experimental feature, and does not currently handle destructors. There is no corresponding `#[task_local]` mapping to the task model (see issue #29594)
+error[E0658]: `#[thread_local]` is an experimental feature, and does not currently handle destructors. (see issue #29594)
--> $DIR/feature-gate-thread_local.rs:18:1
|
18 | #[thread_local] //~ ERROR `#[thread_local]` is an experimental feature
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags: -Z parse-only -Z continue-parse-after-error
+
+fn f() -> impl A + {} // OK
+fn f() -> impl A + B {} // OK
+fn f() -> dyn A + B {} // OK
+fn f() -> A + B {} // OK
+
+impl S {
+ fn f(self) -> impl A + { // OK
+ let _ = |a, b| -> impl A + {}; // OK
+ }
+ fn f(self) -> impl A + B { // OK
+ let _ = |a, b| -> impl A + B {}; // OK
+ }
+ fn f(self) -> dyn A + B { // OK
+ let _ = |a, b| -> dyn A + B {}; // OK
+ }
+ fn f(self) -> A + B { // OK
+ let _ = |a, b| -> A + B {}; // OK
+ }
+}
+
+type A = fn() -> impl A +;
+//~^ ERROR ambiguous `+` in a type
+type A = fn() -> impl A + B;
+//~^ ERROR ambiguous `+` in a type
+type A = fn() -> dyn A + B;
+//~^ ERROR ambiguous `+` in a type
+type A = fn() -> A + B;
+//~^ ERROR expected a path on the left-hand side of `+`, not `fn() -> A`
+
+type A = Fn() -> impl A +;
+//~^ ERROR ambiguous `+` in a type
+type A = Fn() -> impl A + B;
+//~^ ERROR ambiguous `+` in a type
+type A = Fn() -> dyn A + B;
+//~^ ERROR ambiguous `+` in a type
+type A = Fn() -> A + B; // OK, interpreted as `(Fn() -> A) + B` for compatibility
+
+type A = &impl A +;
+//~^ ERROR ambiguous `+` in a type
+type A = &impl A + B;
+//~^ ERROR ambiguous `+` in a type
+type A = &dyn A + B;
+//~^ ERROR ambiguous `+` in a type
+type A = &A + B;
+//~^ ERROR expected a path on the left-hand side of `+`, not `&A`
+
+fn main() {}
--- /dev/null
+error: ambiguous `+` in a type
+ --> $DIR/impl-trait-plus-priority.rs:33:18
+ |
+33 | type A = fn() -> impl A +;
+ | ^^^^^^^^ help: use parentheses to disambiguate: `(impl A)`
+
+error: ambiguous `+` in a type
+ --> $DIR/impl-trait-plus-priority.rs:35:18
+ |
+35 | type A = fn() -> impl A + B;
+ | ^^^^^^^^^^ help: use parentheses to disambiguate: `(impl A + B)`
+
+error: ambiguous `+` in a type
+ --> $DIR/impl-trait-plus-priority.rs:37:18
+ |
+37 | type A = fn() -> dyn A + B;
+ | ^^^^^^^^^ help: use parentheses to disambiguate: `(dyn A + B)`
+
+error[E0178]: expected a path on the left-hand side of `+`, not `fn() -> A`
+ --> $DIR/impl-trait-plus-priority.rs:39:10
+ |
+39 | type A = fn() -> A + B;
+ | ^^^^^^^^^^^^^ perhaps you forgot parentheses?
+
+error: ambiguous `+` in a type
+ --> $DIR/impl-trait-plus-priority.rs:42:18
+ |
+42 | type A = Fn() -> impl A +;
+ | ^^^^^^^^ help: use parentheses to disambiguate: `(impl A)`
+
+error: ambiguous `+` in a type
+ --> $DIR/impl-trait-plus-priority.rs:44:18
+ |
+44 | type A = Fn() -> impl A + B;
+ | ^^^^^^^^^^ help: use parentheses to disambiguate: `(impl A + B)`
+
+error: ambiguous `+` in a type
+ --> $DIR/impl-trait-plus-priority.rs:46:18
+ |
+46 | type A = Fn() -> dyn A + B;
+ | ^^^^^^^^^ help: use parentheses to disambiguate: `(dyn A + B)`
+
+error: ambiguous `+` in a type
+ --> $DIR/impl-trait-plus-priority.rs:50:11
+ |
+50 | type A = &impl A +;
+ | ^^^^^^^^ help: use parentheses to disambiguate: `(impl A)`
+
+error: ambiguous `+` in a type
+ --> $DIR/impl-trait-plus-priority.rs:52:11
+ |
+52 | type A = &impl A + B;
+ | ^^^^^^^^^^ help: use parentheses to disambiguate: `(impl A + B)`
+
+error: ambiguous `+` in a type
+ --> $DIR/impl-trait-plus-priority.rs:54:11
+ |
+54 | type A = &dyn A + B;
+ | ^^^^^^^^^ help: use parentheses to disambiguate: `(dyn A + B)`
+
+error[E0178]: expected a path on the left-hand side of `+`, not `&A`
+ --> $DIR/impl-trait-plus-priority.rs:56:10
+ |
+56 | type A = &A + B;
+ | ^^^^^^ help: try adding parentheses: `&(A + B)`
+
+error: aborting due to 11 previous errors
+
= note: `foo` must be defined only once in the value namespace of this module
help: You can use `as` to change the binding name of the import
|
-25 | use a::foo as Otherfoo; //~ ERROR the name `foo` is defined multiple times
- | ^^^^^^^^^^^^^^^^^^
+25 | use a::foo as other_foo; //~ ERROR the name `foo` is defined multiple times
+ | ^^^^^^^^^^^^^^^^^^^
error[E0659]: `foo` is ambiguous
--> $DIR/duplicate.rs:56:9
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-macro_rules! not_an_lvalue {
+macro_rules! not_a_place {
($thing:expr) => {
$thing = 42;
//~^ ERROR invalid left-hand side expression
}
fn main() {
- not_an_lvalue!(99);
+ not_a_place!(99);
}
13 | $thing = 42;
| ^^^^^^^^^^^ left-hand of expression not valid
...
-19 | not_an_lvalue!(99);
- | ------------------- in this macro invocation
+19 | not_a_place!(99);
+ | ----------------- in this macro invocation
error: aborting due to previous error
= note: `sync` must be defined only once in the type namespace of this module
help: You can use `as` to change the binding name of the import
|
-14 | use std::sync as Othersync; //~ ERROR the name `sync` is defined multiple times
- | ^^^^^^^^^^^^^^^^^^^^^^
+14 | use std::sync as other_sync; //~ ERROR the name `sync` is defined multiple times
+ | ^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 2 previous errors
found type `&_`
error[E0271]: type mismatch resolving `<std::collections::hash_map::Iter<'_, _, _> as std::iter::Iterator>::Item == &_`
- --> $DIR/issue-33941.rs:14:5
+ --> $DIR/issue-33941.rs:14:14
|
14 | for _ in HashMap::new().iter().cloned() {} //~ ERROR type mismatch
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected tuple, found reference
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected tuple, found reference
|
= note: expected type `(&_, &_)`
found type `&_`
16 | &mut z
| ^^^^^^ borrowed value does not live long enough
17 | };
- | - `z` dropped here while still borrowed
+ | - `z` dropped here while still borrowed
...
21 | }
| - borrowed value needs to live until here
| ^^ borrowed value does not live long enough
...
18 | }
- | - borrowed value only lives until here
+ | - borrowed value only lives until here
|
= note: borrowed value must be valid for the static lifetime...
| ^ temporary value does not live long enough
...
17 | }
- | - temporary value only lives until here
+ | - temporary value only lives until here
|
note: borrowed value must be valid for the lifetime 'a as defined on the function body at 13:1...
--> $DIR/issue-46472.rs:13:1
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+trait T {
+ fn f(&self, _: ()) {
+ None::<()>.map(Self::f);
+ }
+ //~^^ ERROR function is expected to take a single 0-tuple as argument
+}
--- /dev/null
+error[E0601]: main function not found
+
+error[E0593]: function is expected to take a single 0-tuple as argument, but it takes 2 distinct arguments
+ --> $DIR/issue-47706-trait.rs:13:20
+ |
+12 | fn f(&self, _: ()) {
+ | ------------------ takes 2 distinct arguments
+13 | None::<()>.map(Self::f);
+ | ^^^ expected function that takes a single 0-tuple as argument
+
+error: aborting due to 2 previous errors
+
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// ignore-tidy-tab
+
#![warn(unused_mut, unused_parens)] // UI tests pass `-A unused`—see Issue #43896
#![feature(no_debug)]
let mut a = (1); // should suggest no `mut`, no parens
//~^ WARN does not need to be mutable
//~| WARN unnecessary parentheses
+ // the line after `mut` has a `\t` at the beginning, this is on purpose
+ let mut
+ b = 1;
+ //~^^ WARN does not need to be mutable
let d = Equinox { warp_factor: 9.975 };
match d {
Equinox { warp_factor: warp_factor } => {} // should suggest shorthand
//~^ WARN this pattern is redundant
}
- println!("{}", a);
+ println!("{} {}", a, b);
}
}
warning: unnecessary parentheses around assigned value
- --> $DIR/suggestions.rs:46:21
+ --> $DIR/suggestions.rs:48:21
|
-46 | let mut a = (1); // should suggest no `mut`, no parens
+48 | let mut a = (1); // should suggest no `mut`, no parens
| ^^^ help: remove these parentheses
|
note: lint level defined here
- --> $DIR/suggestions.rs:11:21
+ --> $DIR/suggestions.rs:13:21
|
-11 | #![warn(unused_mut, unused_parens)] // UI tests pass `-A unused`—see Issue #43896
+13 | #![warn(unused_mut, unused_parens)] // UI tests pass `-A unused`—see Issue #43896
| ^^^^^^^^^^^^^
warning: use of deprecated attribute `no_debug`: the `#[no_debug]` attribute was an experimental feature that has been deprecated due to lack of demand. See https://github.com/rust-lang/rust/issues/29721
- --> $DIR/suggestions.rs:41:1
+ --> $DIR/suggestions.rs:43:1
|
-41 | #[no_debug] // should suggest removal of deprecated attribute
+43 | #[no_debug] // should suggest removal of deprecated attribute
| ^^^^^^^^^^^ help: remove this attribute
|
= note: #[warn(deprecated)] on by default
warning: variable does not need to be mutable
- --> $DIR/suggestions.rs:46:13
+ --> $DIR/suggestions.rs:48:13
|
-46 | let mut a = (1); // should suggest no `mut`, no parens
- | ---^^
+48 | let mut a = (1); // should suggest no `mut`, no parens
+ | ----^
| |
| help: remove this `mut`
|
note: lint level defined here
- --> $DIR/suggestions.rs:11:9
+ --> $DIR/suggestions.rs:13:9
|
-11 | #![warn(unused_mut, unused_parens)] // UI tests pass `-A unused`—see Issue #43896
+13 | #![warn(unused_mut, unused_parens)] // UI tests pass `-A unused`—see Issue #43896
| ^^^^^^^^^^
+warning: variable does not need to be mutable
+ --> $DIR/suggestions.rs:52:13
+ |
+52 | let mut
+ | _____________^
+ | |_____________|
+ | ||
+53 | || b = 1;
+ | ||____________-^
+ | |____________|
+ | help: remove this `mut`
+
warning: static is marked #[no_mangle], but not exported
- --> $DIR/suggestions.rs:14:14
+ --> $DIR/suggestions.rs:16:14
|
-14 | #[no_mangle] static SHENZHOU: usize = 1; // should suggest `pub`
+16 | #[no_mangle] static SHENZHOU: usize = 1; // should suggest `pub`
| -^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| help: try making it public: `pub`
= note: #[warn(private_no_mangle_statics)] on by default
error: const items should never be #[no_mangle]
- --> $DIR/suggestions.rs:16:14
+ --> $DIR/suggestions.rs:18:14
|
-16 | #[no_mangle] const DISCOVERY: usize = 1; // should suggest `pub static` rather than `const`
+18 | #[no_mangle] const DISCOVERY: usize = 1; // should suggest `pub static` rather than `const`
| -----^^^^^^^^^^^^^^^^^^^^^^
| |
| help: try a static value: `pub static`
= note: #[deny(no_mangle_const_items)] on by default
warning: functions generic over types must be mangled
- --> $DIR/suggestions.rs:20:1
+ --> $DIR/suggestions.rs:22:1
|
-19 | #[no_mangle] // should suggest removal (generics can't be no-mangle)
+21 | #[no_mangle] // should suggest removal (generics can't be no-mangle)
| ------------ help: remove this attribute
-20 | pub fn defiant<T>(_t: T) {}
+22 | pub fn defiant<T>(_t: T) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: #[warn(no_mangle_generic_items)] on by default
warning: function is marked #[no_mangle], but not exported
- --> $DIR/suggestions.rs:24:1
+ --> $DIR/suggestions.rs:26:1
|
-24 | fn rio_grande() {} // should suggest `pub`
+26 | fn rio_grande() {} // should suggest `pub`
| -^^^^^^^^^^^^^^^^^
| |
| help: try making it public: `pub`
= note: #[warn(private_no_mangle_fns)] on by default
warning: static is marked #[no_mangle], but not exported
- --> $DIR/suggestions.rs:31:18
+ --> $DIR/suggestions.rs:33:18
|
-31 | #[no_mangle] pub static DAUNTLESS: bool = true;
+33 | #[no_mangle] pub static DAUNTLESS: bool = true;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: function is marked #[no_mangle], but not exported
- --> $DIR/suggestions.rs:33:18
+ --> $DIR/suggestions.rs:35:18
|
-33 | #[no_mangle] pub fn val_jean() {}
+35 | #[no_mangle] pub fn val_jean() {}
| ^^^^^^^^^^^^^^^^^^^^
warning: denote infinite loops with `loop { ... }`
- --> $DIR/suggestions.rs:44:5
+ --> $DIR/suggestions.rs:46:5
|
-44 | while true { // should suggest `loop`
+46 | while true { // should suggest `loop`
| ^^^^^^^^^^ help: use `loop`
|
= note: #[warn(while_true)] on by default
warning: the `warp_factor:` in this pattern is redundant
- --> $DIR/suggestions.rs:51:23
+ --> $DIR/suggestions.rs:57:23
|
-51 | Equinox { warp_factor: warp_factor } => {} // should suggest shorthand
+57 | Equinox { warp_factor: warp_factor } => {} // should suggest shorthand
| ------------^^^^^^^^^^^^
| |
| help: remove this
27 | ping!();
| -------- in this macro invocation
|
- ::: <ping macros>
+ ::: <ping macros>:1:1
|
1 | ( ) => { pong ! ( ) ; }
| -------------------------
28 | deep!();
| -------- in this macro invocation (#1)
|
- ::: <deep macros>
+ ::: <deep macros>:1:1
|
1 | ( ) => { foo ! ( ) ; }
| ------------------------
| | in this macro invocation (#2)
| in this expansion of `deep!` (#1)
|
- ::: <foo macros>
+ ::: <foo macros>:1:1
|
1 | ( ) => { bar ! ( ) ; }
| ------------------------
| | in this macro invocation (#3)
| in this expansion of `foo!` (#2)
|
- ::: <bar macros>
+ ::: <bar macros>:1:1
|
1 | ( ) => { ping ! ( ) ; }
| -------------------------
| | in this macro invocation (#4)
| in this expansion of `bar!` (#3)
|
- ::: <ping macros>
+ ::: <ping macros>:1:1
|
1 | ( ) => { pong ! ( ) ; }
| -------------------------
| ^^ borrowed value does not live long enough
...
38 | }
- | - borrowed value only lives until here
+ | - borrowed value only lives until here
39 |
40 | deref(p);
| - borrow later used here
| ^^ borrowed value does not live long enough
38 | //~^ ERROR `y` does not live long enough [E0597]
39 | }
- | - borrowed value only lives until here
+ | - borrowed value only lives until here
40 |
41 | deref(p);
| - borrow later used here
| |_________^ borrowed value does not live long enough
...
36 | }
- | - borrowed value only lives until here
+ | - borrowed value only lives until here
37 |
38 | deref(p);
| - borrow later used here
| ^^^^^^^^^ borrowed value does not live long enough
...
36 | }
- | - borrowed value only lives until here
+ | - borrowed value only lives until here
37 |
38 | deref(p);
| - borrow later used here
| ^^^^^^^^^ assignment to borrowed `v[..]` occurs here
...
35 | }
- | - borrow later used here, when `p` is dropped
+ | - borrow later used here, when `p` is dropped
error[E0506]: cannot assign to `v[..]` because it is borrowed
--> $DIR/drop-no-may-dangle.rs:34:5
34 | v[0] += 1; //~ ERROR cannot assign to `v[..]` because it is borrowed
| ^^^^^^^^^ assignment to borrowed `v[..]` occurs here
35 | }
- | - borrow later used here, when `p` is dropped
+ | - borrow later used here, when `p` is dropped
error: aborting due to 2 previous errors
| ^^^^^ assignment to borrowed `x` occurs here
33 | // FIXME ^ Should not error in the future with implicit dtors, only manually implemented ones
34 | }
- | - borrow later used here, when `foo` is dropped
+ | - borrow later used here, when `foo` is dropped
error: aborting due to previous error
31 | x = 1; //~ ERROR cannot assign to `x` because it is borrowed [E0506]
| ^^^^^ assignment to borrowed `x` occurs here
32 | }
- | - borrow later used here, when `foo` is dropped
+ | - borrow later used here, when `foo` is dropped
error: aborting due to previous error
| ^^^^^ assignment to borrowed `x` occurs here
33 | // FIXME ^ This currently errors and it should not.
34 | }
- | - borrow later used here, when `foo` is dropped
+ | - borrow later used here, when `foo` is dropped
error: aborting due to previous error
26 | x = 1; //~ ERROR cannot assign to `x` because it is borrowed [E0506]
| ^^^^^ assignment to borrowed `x` occurs here
27 | }
- | - borrow later used here, when `wrap` is dropped
+ | - borrow later used here, when `wrap` is dropped
error: aborting due to previous error
| ^^^^^^^ temporary value does not live long enough
18 | x
19 | }
- | - temporary value only lives until here
+ | - temporary value only lives until here
|
= note: borrowed value must be valid for lifetime '_#2r...
= note: `transmute` must be defined only once in the value namespace of this module
help: You can use `as` to change the binding name of the import
|
-11 | use std::mem::transmute as Othertransmute;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+11 | use std::mem::transmute as other_transmute;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// E0277 should point exclusively at line 14, not the entire for loop span
+
+fn main() {
+ for c in "asdf" {
+ //~^ ERROR the trait bound `&str: std::iter::Iterator` is not satisfied
+ //~| NOTE `&str` is not an iterator
+ //~| HELP the trait `std::iter::Iterator` is not implemented for `&str`
+ //~| NOTE required by `std::iter::IntoIterator::into_iter`
+ println!("");
+ }
+}
--- /dev/null
+error[E0277]: the trait bound `&str: std::iter::Iterator` is not satisfied
+ --> $DIR/for-c-in-str.rs:14:14
+ |
+14 | for c in "asdf" {
+ | ^^^^^^ `&str` is not an iterator; maybe try calling `.iter()` or a similar method
+ |
+ = help: the trait `std::iter::Iterator` is not implemented for `&str`
+ = note: required by `std::iter::IntoIterator::into_iter`
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern crate std;
+fn main() {}
+//~^^ ERROR the name `std` is defined multiple times [E0259]
--- /dev/null
+error[E0259]: the name `std` is defined multiple times
+ --> $DIR/issue-45799-bad-extern-crate-rename-suggestion-formatting.rs:11:1
+ |
+11 | extern crate std;
+ | ^^^^^^^^^^^^^^^^^ `std` reimported here
+ |
+ = note: `std` must be defined only once in the type namespace of this module
+help: You can use `as` to change the binding name of the import
+ |
+11 | extern crate std as other_std;
+ |
+
+error: aborting due to previous error
+
--> $DIR/try-on-option.rs:23:5
|
23 | x?; //~ the `?` operator
- | --
- | |
- | cannot use the `?` operator in a function that returns `u32`
- | in this macro invocation
+ | ^^ cannot use the `?` operator in a function that returns `u32`
|
= help: the trait `std::ops::Try` is not implemented for `u32`
= note: required by `std::ops::Try::from_error`
--> $DIR/try-operator-on-main.rs:19:5
|
19 | std::fs::File::open("foo")?; //~ ERROR the `?` operator can only
- | ---------------------------
- | |
- | cannot use the `?` operator in a function that returns `()`
- | in this macro invocation
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot use the `?` operator in a function that returns `()`
|
= help: the trait `std::ops::Try` is not implemented for `()`
= note: required by `std::ops::Try::from_error`
--> $DIR/try-operator-on-main.rs:22:5
|
22 | ()?; //~ ERROR the `?` operator can only
- | ---
- | |
- | the `?` operator cannot be applied to type `()`
- | in this macro invocation
+ | ^^^ the `?` operator cannot be applied to type `()`
|
= help: the trait `std::ops::Try` is not implemented for `()`
= note: required by `std::ops::Try::into_result`
--> $DIR/try-operator-on-main.rs:32:5
|
32 | ()?; //~ ERROR the `?` operator can only
- | ---
- | |
- | the `?` operator cannot be applied to type `()`
- | in this macro invocation
+ | ^^^ the `?` operator cannot be applied to type `()`
|
= help: the trait `std::ops::Try` is not implemented for `()`
= note: required by `std::ops::Try::into_result`
= note: `bar` must be defined only once in the type namespace of this module
help: You can use `as` to change the binding name of the import
|
-15 | self as Otherbar
+15 | self as other_bar
|
error: aborting due to 3 previous errors
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(use_nested_groups)]
+
+mod a {
+ pub mod b1 {
+ pub enum C2 {}
+ }
+
+ pub enum B2 {}
+}
+
+use a::{b1::{C1, C2}, B2};
+//~^ ERROR unresolved import `a::b1::C1`
+
+fn main() {
+ let _: C2;
+ let _: B2;
+}
--- /dev/null
+error[E0432]: unresolved import `a::b1::C1`
+ --> $DIR/use-nested-groups-error.rs:21:14
+ |
+21 | use a::{b1::{C1, C2}, B2};
+ | ^^ no `C1` in `a::b1`. Did you mean to use `C2`?
+
+error: aborting due to previous error
+
-Subproject commit 91e36aa86c7037de50642f2fec1cf47c3d18af02
+Subproject commit 1d6dfea44f97199d5d5c177c7dadcde393eaff9a
filter: config.filter.clone(),
filter_exact: config.filter_exact,
run_ignored: config.run_ignored,
- quiet: config.quiet,
+ format: if config.quiet { test::OutputFormat::Terse } else { test::OutputFormat::Pretty },
logfile: config.logfile.clone(),
run_tests: true,
bench_benchmarks: true,
for pretty_printer_file in &pretty_printer_files {
inputs.push(mtime(&rust_src_dir.join(pretty_printer_file)));
}
- for lib in config.run_lib_path.read_dir().unwrap() {
- let lib = lib.unwrap();
- inputs.push(mtime(&lib.path()));
+ let mut entries = config.run_lib_path.read_dir().unwrap()
+ .collect::<Vec<_>>();
+ while let Some(entry) = entries.pop() {
+ let entry = entry.unwrap();
+ let path = entry.path();
+ if entry.metadata().unwrap().is_file() {
+ inputs.push(mtime(&path));
+ } else {
+ entries.extend(path.read_dir().unwrap());
+ }
}
if let Some(ref rustdoc_path) = config.rustdoc_path {
inputs.push(mtime(&rustdoc_path));
}
/// For each `aux-build: foo/bar` annotation, we check to find the
- /// file in a `aux` directory relative to the test itself.
+ /// file in a `auxiliary` directory relative to the test itself.
fn compute_aux_test_paths(&self, rel_ab: &str) -> TestPaths {
let test_ab = self.testpaths
.file
"src/dlmalloc",
"src/jemalloc",
"src/llvm",
+ "src/llvm-emscripten",
"src/libbacktrace",
"src/libcompiler_builtins",
"src/librustc_data_structures/owning_ref",
projects / rust.git / commitdiff