NO_LLVM_ASSERTIONS=1
NO_DEBUG_ASSERTIONS=1
os: osx
- osx_image: xcode8.3
+ osx_image: xcode9.2
if: branch = auto
- env: >
NO_LLVM_ASSERTIONS=1
NO_DEBUG_ASSERTIONS=1
os: osx
- osx_image: xcode8.3
+ osx_image: xcode9.2
if: branch = auto
# OSX builders producing releases. These do not run the full test suite and
- [`column!()` macro is one-based instead of zero-based][46977]
- [`fmt::Arguments` can no longer be shared across threads][45198]
- [Access to `#[repr(packed)]` struct fields is now unsafe][44884]
+- [Cargo sets a different working directory for the compiler][cargo/4788]
[44884]: https://github.com/rust-lang/rust/pull/44884
[45198]: https://github.com/rust-lang/rust/pull/45198
[47080]: https://github.com/rust-lang/rust/pull/47080
[47084]: https://github.com/rust-lang/rust/pull/47084
[cargo/4743]: https://github.com/rust-lang/cargo/pull/4743
+[cargo/4788]: https://github.com/rust-lang/cargo/pull/4788
[cargo/4817]: https://github.com/rust-lang/cargo/pull/4817
[`RefCell::replace`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html#method.replace
[`RefCell::swap`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html#method.swap
"url 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
+[[package]]
+name = "clippy_lints"
+version = "0.0.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "if_chain 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "itertools 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "matches 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pulldown-cmark 0.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quine-mc_cluskey 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex-syntax 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "semver 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "toml 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-normalization 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
[[package]]
name = "cmake"
version = "0.1.29"
[[package]]
name = "languageserver-types"
-version = "0.27.0"
+version = "0.30.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"enum_primitive 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.125.0"
dependencies = [
"cargo 0.26.0",
+ "clippy_lints 0.0.186 (registry+https://github.com/rust-lang/crates.io-index)",
"env_logger 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
"failure 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"json 0.11.12 (registry+https://github.com/rust-lang/crates.io-index)",
"jsonrpc-core 8.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "languageserver-types 0.27.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "languageserver-types 0.30.0 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.0.0 (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)",
"racer 2.0.12 (registry+https://github.com/rust-lang/crates.io-index)",
"rayon 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rls-analysis 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rls-data 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rls-analysis 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rls-blacklist 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rls-data 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-rustc 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-vfs 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "rls-analysis"
-version = "0.10.0"
+version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"derive-new 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"radix_trie 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "rls-data 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rls-data 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
-name = "rls-data"
-version = "0.14.0"
+name = "rls-blacklist"
+version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
-]
[[package]]
name = "rls-data"
dependencies = [
"rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
"checksum cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d4c819a1287eb618df47cc647173c5c4c66ba19d888a6e50d605672aed3140de"
"checksum chrono 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7c20ebe0b2b08b0aeddba49c609fe7957ba2e33449882cb186a180bc60682fa9"
"checksum clap 2.29.0 (registry+https://github.com/rust-lang/crates.io-index)" = "110d43e343eb29f4f51c1db31beb879d546db27998577e5715270a54bcf41d3f"
+"checksum clippy_lints 0.0.186 (registry+https://github.com/rust-lang/crates.io-index)" = "a3864104a4e6092e644b985dd7543e5f24e99aa7262f5ee400bcb17cfeec1bf5"
"checksum cmake 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)" = "56d741ea7a69e577f6d06b36b7dff4738f680593dc27a701ffa8506b73ce28bb"
"checksum coco 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c06169f5beb7e31c7c67ebf5540b8b472d23e3eade3b2ec7d1f5b504a85f91bd"
"checksum commoncrypto 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d056a8586ba25a1e4d61cb090900e495952c7886786fc55f909ab2f819b69007"
"checksum jsonrpc-core 8.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ddf83704f4e79979a424d1082dd2c1e52683058056c9280efa19ac5f6bc9033c"
"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
"checksum kuchiki 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e03098e8e719c92b7794515dfd5c1724e2b12f5ce1788e61cfa4663f82eba8d8"
-"checksum languageserver-types 0.27.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8a2036fc8576a22689b7e3171c07eb8e8f700678d7a8a53f6f65abbeb35261e1"
+"checksum languageserver-types 0.30.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1541f9b22687f060511d213036e1f058797c48e3501e177f01cb6e88de802f5b"
"checksum lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73"
"checksum lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c8f31047daa365f19be14b47c29df4f7c3b581832407daabe6ae77397619237d"
"checksum lazycell 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3b585b7a6811fb03aa10e74b278a0f00f8dd9b45dc681f148bb29fa5cb61859b"
"checksum regex 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "744554e01ccbd98fff8c457c3b092cd67af62a555a43bfe97ae8a0451f7799fa"
"checksum regex-syntax 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "f9ec002c35e86791825ed294b50008eea9ddfc8def4420124fbc6b08db834957"
"checksum regex-syntax 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "8e931c58b93d86f080c734bfd2bce7dd0079ae2331235818133c8be7f422e20e"
-"checksum rls-analysis 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "38841e3c5271715a574ac220d9b408b59ed9e2626909c3bc54b5853b4eaadb7b"
-"checksum rls-data 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8024f1feaca72d0aa4ae1e2a8d454a31b9a33ed02f8d0e9c8559bf53c267ec3c"
+"checksum rls-analysis 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "30b08808959205a5cf23c68ace2d9d6defdd6867f3cd5d62981cf50fb52f8882"
+"checksum rls-blacklist 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "56fb7b8e4850b988fbcf277fbdb1eff36879070d02fc1ca243b559273866973d"
"checksum rls-data 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bea04462e94b5512a78499837eecb7db182ff082144cd1b4bc32ef5d43de6510"
"checksum rls-rustc 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "85cfb9dde19e313da3e47738008f8a472e470cc42d910b71595a9238494701f2"
"checksum rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5d7c7046dc6a92f2ae02ed302746db4382e75131b9ce20ce967259f6b5867a6a"
pub builder: &'a Builder<'a>,
pub host: Interned<String>,
pub target: Interned<String>,
- pub path: Option<&'a Path>,
+ pub path: PathBuf,
}
struct StepDescription {
only_build: bool,
should_run: fn(ShouldRun) -> ShouldRun,
make_run: fn(RunConfig),
+ name: &'static str,
+}
+
+#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
+struct PathSet {
+ set: BTreeSet<PathBuf>,
+}
+
+impl PathSet {
+ fn empty() -> PathSet {
+ PathSet { set: BTreeSet::new() }
+ }
+
+ fn one<P: Into<PathBuf>>(path: P) -> PathSet {
+ let mut set = BTreeSet::new();
+ set.insert(path.into());
+ PathSet { set }
+ }
+
+ fn has(&self, needle: &Path) -> bool {
+ self.set.iter().any(|p| p.ends_with(needle))
+ }
+
+ fn path(&self, builder: &Builder) -> PathBuf {
+ self.set.iter().next().unwrap_or(&builder.build.src).to_path_buf()
+ }
}
impl StepDescription {
only_build: S::ONLY_BUILD,
should_run: S::should_run,
make_run: S::make_run,
+ name: unsafe { ::std::intrinsics::type_name::<S>() },
}
}
- fn maybe_run(&self, builder: &Builder, path: Option<&Path>) {
+ fn maybe_run(&self, builder: &Builder, pathset: &PathSet) {
+ if builder.config.exclude.iter().any(|e| pathset.has(e)) {
+ eprintln!("Skipping {:?} because it is excluded", pathset);
+ return;
+ } else if !builder.config.exclude.is_empty() {
+ eprintln!("{:?} not skipped for {:?} -- not in {:?}", pathset,
+ self.name, builder.config.exclude);
+ }
let build = builder.build;
let hosts = if self.only_build_targets || self.only_build {
build.build_triple()
for target in targets {
let run = RunConfig {
builder,
- path,
+ path: pathset.path(builder),
host: *host,
target: *target,
};
let should_runs = v.iter().map(|desc| {
(desc.should_run)(ShouldRun::new(builder))
}).collect::<Vec<_>>();
+
+ // sanity checks on rules
+ for (desc, should_run) in v.iter().zip(&should_runs) {
+ assert!(!should_run.paths.is_empty(),
+ "{:?} should have at least one pathset", desc.name);
+ }
+
if paths.is_empty() {
for (desc, should_run) in v.iter().zip(should_runs) {
if desc.default && should_run.is_really_default {
- desc.maybe_run(builder, None);
+ for pathset in &should_run.paths {
+ desc.maybe_run(builder, pathset);
+ }
}
}
} else {
for path in paths {
let mut attempted_run = false;
for (desc, should_run) in v.iter().zip(&should_runs) {
- if should_run.run(path) {
+ if let Some(pathset) = should_run.pathset_for_path(path) {
attempted_run = true;
- desc.maybe_run(builder, Some(path));
+ desc.maybe_run(builder, pathset);
}
}
if !attempted_run {
- eprintln!("Warning: no rules matched {}.", path.display());
+ panic!("Error: no rules matched {}.", path.display());
}
}
}
pub struct ShouldRun<'a> {
pub builder: &'a Builder<'a>,
// use a BTreeSet to maintain sort order
- paths: BTreeSet<PathBuf>,
+ paths: BTreeSet<PathSet>,
// If this is a default rule, this is an additional constraint placed on
// it's run. Generally something like compiler docs being enabled.
self
}
+ // Unlike `krate` this will create just one pathset. As such, it probably shouldn't actually
+ // ever be used, but as we transition to having all rules properly handle passing krate(...) by
+ // actually doing something different for every crate passed.
+ pub fn all_krates(mut self, name: &str) -> Self {
+ let mut set = BTreeSet::new();
+ for krate in self.builder.in_tree_crates(name) {
+ set.insert(PathBuf::from(&krate.path));
+ }
+ self.paths.insert(PathSet { set });
+ self
+ }
+
pub fn krate(mut self, name: &str) -> Self {
- for (_, krate_path) in self.builder.crates(name) {
- self.paths.insert(PathBuf::from(krate_path));
+ for krate in self.builder.in_tree_crates(name) {
+ self.paths.insert(PathSet::one(&krate.path));
}
self
}
- pub fn path(mut self, path: &str) -> Self {
- self.paths.insert(PathBuf::from(path));
+ // single, non-aliased path
+ pub fn path(self, path: &str) -> Self {
+ self.paths(&[path])
+ }
+
+ // multiple aliases for the same job
+ pub fn paths(mut self, paths: &[&str]) -> Self {
+ self.paths.insert(PathSet {
+ set: paths.iter().map(PathBuf::from).collect(),
+ });
self
}
// allows being more explicit about why should_run in Step returns the value passed to it
- pub fn never(self) -> ShouldRun<'a> {
+ pub fn never(mut self) -> ShouldRun<'a> {
+ self.paths.insert(PathSet::empty());
self
}
- fn run(&self, path: &Path) -> bool {
- self.paths.iter().any(|p| path.ends_with(p))
+ fn pathset_for_path(&self, path: &Path) -> Option<&PathSet> {
+ self.paths.iter().find(|pathset| pathset.has(path))
}
}
tool::RustInstaller, tool::Cargo, tool::Rls, tool::Rustdoc, tool::Clippy,
native::Llvm, tool::Rustfmt, tool::Miri),
Kind::Check => describe!(check::Std, check::Test, check::Rustc),
- Kind::Test => describe!(test::Tidy, test::Bootstrap, test::DefaultCompiletest,
- test::HostCompiletest, test::Crate, test::CrateLibrustc, test::Rustdoc,
- test::Linkcheck, test::Cargotest, test::Cargo, test::Rls, test::Docs,
- test::ErrorIndex, test::Distcheck, test::Rustfmt, test::Miri, test::Clippy,
- test::RustdocJS, test::RustdocTheme),
+ Kind::Test => describe!(test::Tidy, test::Bootstrap, test::Ui, test::RunPass,
+ test::CompileFail, test::ParseFail, test::RunFail, test::RunPassValgrind,
+ test::MirOpt, test::Codegen, test::CodegenUnits, test::Incremental, test::Debuginfo,
+ test::UiFullDeps, test::RunPassFullDeps, test::RunFailFullDeps,
+ test::CompileFailFullDeps, test::IncrementalFullDeps, test::Rustdoc, test::Pretty,
+ test::RunPassPretty, test::RunFailPretty, test::RunPassValgrindPretty,
+ test::RunPassFullDepsPretty, test::RunFailFullDepsPretty, test::RunMake,
+ test::Crate, test::CrateLibrustc, test::Rustdoc, test::Linkcheck, test::Cargotest,
+ test::Cargo, test::Rls, test::Docs, test::ErrorIndex, test::Distcheck,
+ test::Rustfmt, test::Miri, test::Clippy, test::RustdocJS, test::RustdocTheme),
Kind::Bench => describe!(test::Crate, test::CrateLibrustc),
Kind::Doc => describe!(doc::UnstableBook, doc::UnstableBookGen, doc::TheBook,
doc::Standalone, doc::Std, doc::Test, doc::Rustc, doc::ErrorIndex, doc::Nomicon,
doc::Reference, doc::Rustdoc, doc::RustByExample, doc::CargoBook),
Kind::Dist => describe!(dist::Docs, dist::Mingw, dist::Rustc, dist::DebuggerScripts,
dist::Std, dist::Analysis, dist::Src, dist::PlainSourceTarball, dist::Cargo,
- dist::Rls, dist::Rustfmt, dist::Extended, dist::HashSign,
- dist::DontDistWithMiriEnabled),
+ dist::Rls, dist::Rustfmt, dist::Extended, dist::HashSign),
Kind::Install => describe!(install::Docs, install::Std, install::Cargo, install::Rls,
install::Rustfmt, install::Analysis, install::Src, install::Rustc),
}
should_run = (desc.should_run)(should_run);
}
let mut help = String::from("Available paths:\n");
- for path in should_run.paths {
- help.push_str(format!(" ./x.py {} {}\n", subcommand, path.display()).as_str());
+ for pathset in should_run.paths {
+ for path in pathset.set {
+ help.push_str(format!(" ./x.py {} {}\n", subcommand, path.display()).as_str());
+ }
}
Some(help)
}
Subcommand::Clean { .. } => panic!(),
};
+ if let Some(path) = paths.get(0) {
+ if path == Path::new("nonexistent/path/to/trigger/cargo/metadata") {
+ return;
+ }
+ }
+
let builder = Builder {
build,
top_stage: build.config.stage.unwrap_or(2),
stack: RefCell::new(Vec::new()),
};
+ if kind == Kind::Dist {
+ assert!(!build.config.test_miri, "Do not distribute with miri enabled.\n\
+ The distributed libraries would include all MIR (increasing binary size).
+ The distributed MIR would include validation statements.");
+ }
+
StepDescription::run(&Builder::get_step_descriptions(builder.kind), &builder, paths);
}
//
// FIXME: the guard against msvc shouldn't need to be here
if !target.contains("msvc") {
- let ccache = self.config.ccache.as_ref();
- let ccacheify = |s: &Path| {
- let ccache = match ccache {
- Some(ref s) => s,
- None => return s.display().to_string(),
- };
- // FIXME: the cc-rs crate only recognizes the literal strings
- // `ccache` and `sccache` when doing caching compilations, so we
- // mirror that here. It should probably be fixed upstream to
- // accept a new env var or otherwise work with custom ccache
- // vars.
- match &ccache[..] {
- "ccache" | "sccache" => format!("{} {}", ccache, s.display()),
- _ => s.display().to_string(),
- }
- };
- let cc = ccacheify(&self.cc(target));
- cargo.env(format!("CC_{}", target), &cc)
- .env("CC", &cc);
+ let cc = self.cc(target);
+ cargo.env(format!("CC_{}", target), cc)
+ .env("CC", cc);
let cflags = self.cflags(target).join(" ");
cargo.env(format!("CFLAGS_{}", target), cflags.clone())
}
if let Ok(cxx) = self.cxx(target) {
- let cxx = ccacheify(&cxx);
- cargo.env(format!("CXX_{}", target), &cxx)
- .env("CXX", &cxx)
+ cargo.env(format!("CXX_{}", target), cxx)
+ .env("CXX", cxx)
.env(format!("CXXFLAGS_{}", target), cflags.clone())
.env("CXXFLAGS", cflags);
}
const DEFAULT: bool = true;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/libstd").krate("std")
+ run.all_krates("std")
}
fn make_run(run: RunConfig) {
const DEFAULT: bool = true;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/librustc").krate("rustc-main")
+ run.all_krates("rustc-main")
}
fn make_run(run: RunConfig) {
const DEFAULT: bool = true;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/libtest").krate("test")
+ run.all_krates("test")
}
fn make_run(run: RunConfig) {
const DEFAULT: bool = true;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/libstd").krate("std")
+ run.all_krates("std")
}
fn make_run(run: RunConfig) {
const DEFAULT: bool = true;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/libtest").krate("test")
+ run.all_krates("test")
}
fn make_run(run: RunConfig) {
const DEFAULT: bool = true;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/librustc").krate("rustc-main")
+ run.all_krates("rustc-main")
}
fn make_run(run: RunConfig) {
const DEFAULT: bool = true;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/librustc_trans")
+ run.all_krates("rustc_trans")
}
fn make_run(run: RunConfig) {
type Output = Compiler;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/rustc")
+ run.all_krates("rustc-main")
}
/// Prepare a new compiler from the artifacts in `stage`
pub sanitizers: bool,
pub profiler: bool,
pub ignore_git: bool,
+ pub exclude: Vec<PathBuf>,
pub run_host_only: bool,
let flags = Flags::parse(&args);
let file = flags.config.clone();
let mut config = Config::default();
+ config.exclude = flags.exclude;
config.llvm_enabled = true;
config.llvm_optimize = true;
config.llvm_version_check = true;
}
}
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct DontDistWithMiriEnabled;
-
-impl Step for DontDistWithMiriEnabled {
- type Output = PathBuf;
- const DEFAULT: bool = true;
-
- fn should_run(run: ShouldRun) -> ShouldRun {
- let build_miri = run.builder.build.config.test_miri;
- run.default_condition(build_miri)
- }
-
- fn make_run(run: RunConfig) {
- run.builder.ensure(DontDistWithMiriEnabled);
- }
-
- fn run(self, _: &Builder) -> PathBuf {
- panic!("Do not distribute with miri enabled.\n\
- The distributed libraries would include all MIR (increasing binary size).
- The distributed MIR would include validation statements.");
- }
-}
-
-
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Extended {
stage: u32,
fn should_run(run: ShouldRun) -> ShouldRun {
let builder = run.builder;
- run.krate("std").default_condition(builder.build.config.docs)
+ run.all_krates("std").default_condition(builder.build.config.docs)
}
fn make_run(run: RunConfig) {
pub jobs: Option<u32>,
pub cmd: Subcommand,
pub incremental: bool,
+ pub exclude: Vec<PathBuf>,
}
pub enum Subcommand {
opts.optopt("", "build", "build target of the stage0 compiler", "BUILD");
opts.optmulti("", "host", "host targets to build", "HOST");
opts.optmulti("", "target", "target targets to build", "TARGET");
+ opts.optmulti("", "exclude", "build paths to exclude", "PATH");
opts.optopt("", "on-fail", "command to run on failure", "CMD");
opts.optopt("", "stage", "stage to build", "N");
opts.optopt("", "keep-stage", "stage to keep without recompiling", "N");
};
// Get any optional paths which occur after the subcommand
let cwd = t!(env::current_dir());
- let paths = matches.free[1..].iter().map(|p| cwd.join(p)).collect::<Vec<_>>();
+ let src = matches.opt_str("src").map(PathBuf::from)
+ .or_else(|| env::var_os("SRC").map(PathBuf::from))
+ .unwrap_or(cwd.clone());
+ let paths = matches.free[1..].iter().map(|p| p.into()).collect::<Vec<PathBuf>>();
let cfg_file = matches.opt_str("config").map(PathBuf::from).or_else(|| {
if fs::metadata("config.toml").is_ok() {
stage = Some(1);
}
- let cwd = t!(env::current_dir());
- let src = matches.opt_str("src").map(PathBuf::from)
- .or_else(|| env::var_os("SRC").map(PathBuf::from))
- .unwrap_or(cwd);
-
Flags {
verbose: matches.opt_count("verbose"),
stage,
target: split(matches.opt_strs("target"))
.into_iter().map(|x| INTERNER.intern_string(x)).collect::<Vec<_>>(),
config: cfg_file,
- src,
jobs: matches.opt_str("jobs").map(|j| j.parse().unwrap()),
cmd,
incremental: matches.opt_present("incremental"),
+ exclude: split(matches.opt_strs("exclude"))
+ .into_iter().map(|p| p.into()).collect::<Vec<_>>(),
+ src,
}
}
}
//! More documentation can be found in each respective module below, and you can
//! also check out the `src/bootstrap/README.md` file for more information.
-#![deny(warnings)]
-#![allow(stable_features)]
-#![feature(associated_consts)]
+//#![deny(warnings)]
+#![feature(core_intrinsics)]
#[macro_use]
extern crate build_helper;
bench_step: String,
}
+impl Crate {
+ fn is_local(&self, build: &Build) -> bool {
+ self.path.starts_with(&build.config.src) &&
+ !self.path.to_string_lossy().ends_with("_shim")
+ }
+
+ fn local_path(&self, build: &Build) -> PathBuf {
+ assert!(self.is_local(build));
+ self.path.strip_prefix(&build.config.src).unwrap().into()
+ }
+}
+
/// The various "modes" of invoking Cargo.
///
/// These entries currently correspond to the various output directories of the
}
}
- /// Get a list of crates from a root crate.
- ///
- /// Returns Vec<(crate, path to crate, is_root_crate)>
- fn crates(&self, root: &str) -> Vec<(Interned<String>, &Path)> {
- let interned = INTERNER.intern_string(root.to_owned());
+ fn in_tree_crates(&self, root: &str) -> Vec<&Crate> {
let mut ret = Vec::new();
- let mut list = vec![interned];
+ let mut list = vec![INTERNER.intern_str(root)];
let mut visited = HashSet::new();
while let Some(krate) = list.pop() {
let krate = &self.crates[&krate];
- // If we can't strip prefix, then out-of-tree path
- let path = krate.path.strip_prefix(&self.src).unwrap_or(&krate.path);
- ret.push((krate.name, path));
- for dep in &krate.deps {
- if visited.insert(dep) && dep != "build_helper" {
- list.push(*dep);
+ if krate.is_local(self) {
+ ret.push(krate);
+ for dep in &krate.deps {
+ if visited.insert(dep) && dep != "build_helper" {
+ list.push(*dep);
+ }
}
}
}
}
fn make_run(run: RunConfig) {
- let emscripten = run.path.map(|p| {
- p.ends_with("llvm-emscripten")
- }).unwrap_or(false);
+ let emscripten = run.path.ends_with("llvm-emscripten");
run.builder.ensure(Llvm {
target: run.target,
emscripten,
.define("LLVM_TARGET_ARCH", target.split('-').next().unwrap())
.define("LLVM_DEFAULT_TARGET_TRIPLE", target);
+ // By default, LLVM will automatically find OCaml and, if it finds it,
+ // install the LLVM bindings in LLVM_OCAML_INSTALL_PATH, which defaults
+ // to /usr/bin/ocaml.
+ // This causes problem for non-root builds of Rust. Side-step the issue
+ // by setting LLVM_OCAML_INSTALL_PATH to a relative path, so it installs
+ // in the prefix.
+ cfg.define("LLVM_OCAML_INSTALL_PATH",
+ env::var_os("LLVM_OCAML_INSTALL_PATH").unwrap_or_else(|| "usr/lib/ocaml".into()));
// This setting makes the LLVM tools link to the dynamic LLVM library,
// which saves both memory during parallel links and overall disk space
//! This file implements the various regression test suites that we execute on
//! our CI.
-use std::collections::HashSet;
use std::env;
use std::ffi::OsString;
use std::iter;
use build_helper::{self, output};
use builder::{Kind, RunConfig, ShouldRun, Builder, Compiler, Step};
+use Crate as CargoCrate;
use cache::{INTERNER, Interned};
use compile;
use dist;
build.out.join(host).join("test")
}
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-struct Test {
- path: &'static str,
- mode: &'static str,
- suite: &'static str,
+macro_rules! default_test {
+ ($name:ident { path: $path:expr, mode: $mode:expr, suite: $suite:expr }) => {
+ test!($name { path: $path, mode: $mode, suite: $suite, default: true, host: false });
+ }
}
-static DEFAULT_COMPILETESTS: &[Test] = &[
- Test { path: "src/test/ui", mode: "ui", suite: "ui" },
- Test { path: "src/test/run-pass", mode: "run-pass", suite: "run-pass" },
- Test { path: "src/test/compile-fail", mode: "compile-fail", suite: "compile-fail" },
- Test { path: "src/test/parse-fail", mode: "parse-fail", suite: "parse-fail" },
- Test { path: "src/test/run-fail", mode: "run-fail", suite: "run-fail" },
- Test {
- path: "src/test/run-pass-valgrind",
- mode: "run-pass-valgrind",
- suite: "run-pass-valgrind"
- },
- Test { path: "src/test/mir-opt", mode: "mir-opt", suite: "mir-opt" },
- Test { path: "src/test/codegen", mode: "codegen", suite: "codegen" },
- Test { path: "src/test/codegen-units", mode: "codegen-units", suite: "codegen-units" },
- Test { path: "src/test/incremental", mode: "incremental", suite: "incremental" },
-
- // What this runs varies depending on the native platform being apple
- Test { path: "src/test/debuginfo", mode: "debuginfo-XXX", suite: "debuginfo" },
-];
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct DefaultCompiletest {
- compiler: Compiler,
- target: Interned<String>,
- mode: &'static str,
- suite: &'static str,
+macro_rules! host_test {
+ ($name:ident { path: $path:expr, mode: $mode:expr, suite: $suite:expr }) => {
+ test!($name { path: $path, mode: $mode, suite: $suite, default: true, host: true });
+ }
}
-impl Step for DefaultCompiletest {
- type Output = ();
- const DEFAULT: bool = true;
-
- fn should_run(mut run: ShouldRun) -> ShouldRun {
- for test in DEFAULT_COMPILETESTS {
- run = run.path(test.path);
+macro_rules! test {
+ ($name:ident {
+ path: $path:expr,
+ mode: $mode:expr,
+ suite: $suite:expr,
+ default: $default:expr,
+ host: $host:expr
+ }) => {
+ #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+ pub struct $name {
+ pub compiler: Compiler,
+ pub target: Interned<String>,
}
- run
- }
- fn make_run(run: RunConfig) {
- let compiler = run.builder.compiler(run.builder.top_stage, run.host);
+ impl Step for $name {
+ type Output = ();
+ const DEFAULT: bool = $default;
+ const ONLY_HOSTS: bool = $host;
- let test = run.path.map(|path| {
- DEFAULT_COMPILETESTS.iter().find(|&&test| {
- path.ends_with(test.path)
- }).unwrap_or_else(|| {
- panic!("make_run in compile test to receive test path, received {:?}", path);
- })
- });
-
- if let Some(test) = test {
- run.builder.ensure(DefaultCompiletest {
- compiler,
- target: run.target,
- mode: test.mode,
- suite: test.suite,
- });
- } else {
- for test in DEFAULT_COMPILETESTS {
- run.builder.ensure(DefaultCompiletest {
- compiler,
- target: run.target,
- mode: test.mode,
- suite: test.suite
- });
+ fn should_run(run: ShouldRun) -> ShouldRun {
+ run.path($path)
}
- }
- }
-
- fn run(self, builder: &Builder) {
- builder.ensure(Compiletest {
- compiler: self.compiler,
- target: self.target,
- mode: self.mode,
- suite: self.suite,
- })
- }
-}
-
-// Also default, but host-only.
-static HOST_COMPILETESTS: &[Test] = &[
- Test { path: "src/test/ui-fulldeps", mode: "ui", suite: "ui-fulldeps" },
- Test { path: "src/test/run-pass-fulldeps", mode: "run-pass", suite: "run-pass-fulldeps" },
- Test { path: "src/test/run-fail-fulldeps", mode: "run-fail", suite: "run-fail-fulldeps" },
- Test {
- path: "src/test/compile-fail-fulldeps",
- mode: "compile-fail",
- suite: "compile-fail-fulldeps",
- },
- Test {
- path: "src/test/incremental-fulldeps",
- mode: "incremental",
- suite: "incremental-fulldeps",
- },
- Test { path: "src/test/rustdoc", mode: "rustdoc", suite: "rustdoc" },
-
- Test { path: "src/test/pretty", mode: "pretty", suite: "pretty" },
- Test { path: "src/test/run-pass/pretty", mode: "pretty", suite: "run-pass" },
- Test { path: "src/test/run-fail/pretty", mode: "pretty", suite: "run-fail" },
- Test { path: "src/test/run-pass-valgrind/pretty", mode: "pretty", suite: "run-pass-valgrind" },
- Test { path: "src/test/run-pass-fulldeps/pretty", mode: "pretty", suite: "run-pass-fulldeps" },
- Test { path: "src/test/run-fail-fulldeps/pretty", mode: "pretty", suite: "run-fail-fulldeps" },
- Test { path: "src/test/run-make", mode: "run-make", suite: "run-make" },
-];
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct HostCompiletest {
- compiler: Compiler,
- target: Interned<String>,
- mode: &'static str,
- suite: &'static str,
-}
+ fn make_run(run: RunConfig) {
+ let compiler = run.builder.compiler(run.builder.top_stage, run.host);
-impl Step for HostCompiletest {
- type Output = ();
- const DEFAULT: bool = true;
- const ONLY_HOSTS: bool = true;
-
- fn should_run(mut run: ShouldRun) -> ShouldRun {
- for test in HOST_COMPILETESTS {
- run = run.path(test.path);
- }
- run
- }
-
- fn make_run(run: RunConfig) {
- let compiler = run.builder.compiler(run.builder.top_stage, run.host);
-
- let test = run.path.map(|path| {
- HOST_COMPILETESTS.iter().find(|&&test| {
- path.ends_with(test.path)
- }).unwrap_or_else(|| {
- panic!("make_run in compile test to receive test path, received {:?}", path);
- })
- });
-
- if let Some(test) = test {
- run.builder.ensure(HostCompiletest {
- compiler,
- target: run.target,
- mode: test.mode,
- suite: test.suite,
- });
- } else {
- for test in HOST_COMPILETESTS {
- if test.mode == "pretty" {
- continue;
- }
- run.builder.ensure(HostCompiletest {
+ run.builder.ensure($name {
compiler,
target: run.target,
- mode: test.mode,
- suite: test.suite
});
}
- }
- }
- fn run(self, builder: &Builder) {
- builder.ensure(Compiletest {
- compiler: self.compiler,
- target: self.target,
- mode: self.mode,
- suite: self.suite,
- })
+ fn run(self, builder: &Builder) {
+ builder.ensure(Compiletest {
+ compiler: self.compiler,
+ target: self.target,
+ mode: $mode,
+ suite: $suite,
+ })
+ }
+ }
}
}
+default_test!(Ui {
+ path: "src/test/ui",
+ mode: "ui",
+ suite: "ui"
+});
+
+default_test!(RunPass {
+ path: "src/test/run-pass",
+ mode: "run-pass",
+ suite: "run-pass"
+});
+
+default_test!(CompileFail {
+ path: "src/test/compile-fail",
+ mode: "compile-fail",
+ suite: "compile-fail"
+});
+
+default_test!(ParseFail {
+ path: "src/test/parse-fail",
+ mode: "parse-fail",
+ suite: "parse-fail"
+});
+
+default_test!(RunFail {
+ path: "src/test/run-fail",
+ mode: "run-fail",
+ suite: "run-fail"
+});
+
+default_test!(RunPassValgrind {
+ path: "src/test/run-pass-valgrind",
+ mode: "run-pass-valgrind",
+ suite: "run-pass-valgrind"
+});
+
+default_test!(MirOpt {
+ path: "src/test/mir-opt",
+ mode: "mir-opt",
+ suite: "mir-opt"
+});
+
+default_test!(Codegen {
+ path: "src/test/codegen",
+ mode: "codegen",
+ suite: "codegen"
+});
+
+default_test!(CodegenUnits {
+ path: "src/test/codegen-units",
+ mode: "codegen-units",
+ suite: "codegen-units"
+});
+
+default_test!(Incremental {
+ path: "src/test/incremental",
+ mode: "incremental",
+ suite: "incremental"
+});
+
+default_test!(Debuginfo {
+ path: "src/test/debuginfo",
+ // What this runs varies depending on the native platform being apple
+ mode: "debuginfo-XXX",
+ suite: "debuginfo"
+});
+
+host_test!(UiFullDeps {
+ path: "src/test/ui-fulldeps",
+ mode: "ui",
+ suite: "ui-fulldeps"
+});
+
+host_test!(RunPassFullDeps {
+ path: "src/test/run-pass-fulldeps",
+ mode: "run-pass",
+ suite: "run-pass-fulldeps"
+});
+
+host_test!(RunFailFullDeps {
+ path: "src/test/run-fail-fulldeps",
+ mode: "run-fail",
+ suite: "run-fail-fulldeps"
+});
+
+host_test!(CompileFailFullDeps {
+ path: "src/test/compile-fail-fulldeps",
+ mode: "compile-fail",
+ suite: "compile-fail-fulldeps"
+});
+
+host_test!(IncrementalFullDeps {
+ path: "src/test/incremental-fulldeps",
+ mode: "incremental",
+ suite: "incremental-fulldeps"
+});
+
+host_test!(Rustdoc {
+ path: "src/test/rustdoc",
+ mode: "rustdoc",
+ suite: "rustdoc"
+});
+
+test!(Pretty {
+ path: "src/test/pretty",
+ mode: "pretty",
+ suite: "pretty",
+ default: false,
+ host: true
+});
+test!(RunPassPretty {
+ path: "src/test/run-pass/pretty",
+ mode: "pretty",
+ suite: "run-pass",
+ default: false,
+ host: true
+});
+test!(RunFailPretty {
+ path: "src/test/run-fail/pretty",
+ mode: "pretty",
+ suite: "run-fail",
+ default: false,
+ host: true
+});
+test!(RunPassValgrindPretty {
+ path: "src/test/run-pass-valgrind/pretty",
+ mode: "pretty",
+ suite: "run-pass-valgrind",
+ default: false,
+ host: true
+});
+test!(RunPassFullDepsPretty {
+ path: "src/test/run-pass-fulldeps/pretty",
+ mode: "pretty",
+ suite: "run-pass-fulldeps",
+ default: false,
+ host: true
+});
+test!(RunFailFullDepsPretty {
+ path: "src/test/run-fail-fulldeps/pretty",
+ mode: "pretty",
+ suite: "run-fail-fulldeps",
+ default: false,
+ host: true
+});
+
+host_test!(RunMake {
+ path: "src/test/run-make",
+ mode: "run-make",
+ suite: "run-make"
+});
+
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
struct Compiletest {
compiler: Compiler,
}
}
if suite == "run-make" && !build.config.llvm_enabled {
- println!("Ignoring run-make test suite as they generally don't work without LLVM");
+ println!("Ignoring run-make test suite as they generally dont work without LLVM");
return;
}
compiler: Compiler,
target: Interned<String>,
test_kind: TestKind,
- krate: Option<Interned<String>>,
+ krate: Interned<String>,
}
impl Step for CrateLibrustc {
let builder = run.builder;
let compiler = builder.compiler(builder.top_stage, run.host);
- let make = |name: Option<Interned<String>>| {
- let test_kind = if builder.kind == Kind::Test {
- TestKind::Test
- } else if builder.kind == Kind::Bench {
- TestKind::Bench
- } else {
- panic!("unexpected builder.kind in crate: {:?}", builder.kind);
- };
-
- builder.ensure(CrateLibrustc {
- compiler,
- target: run.target,
- test_kind,
- krate: name,
- });
- };
+ for krate in builder.in_tree_crates("rustc-main") {
+ if run.path.ends_with(&krate.path) {
+ let test_kind = if builder.kind == Kind::Test {
+ TestKind::Test
+ } else if builder.kind == Kind::Bench {
+ TestKind::Bench
+ } else {
+ panic!("unexpected builder.kind in crate: {:?}", builder.kind);
+ };
- if let Some(path) = run.path {
- for (name, krate_path) in builder.crates("rustc-main") {
- if path.ends_with(krate_path) {
- make(Some(name));
- }
+ builder.ensure(CrateLibrustc {
+ compiler,
+ target: run.target,
+ test_kind,
+ krate: krate.name,
+ });
}
- } else {
- make(None);
}
}
-
fn run(self, builder: &Builder) {
builder.ensure(Crate {
compiler: self.compiler,
}
}
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct CrateNotDefault {
+ compiler: Compiler,
+ target: Interned<String>,
+ test_kind: TestKind,
+ krate: &'static str,
+}
+
+impl Step for CrateNotDefault {
+ type Output = ();
+
+ fn should_run(run: ShouldRun) -> ShouldRun {
+ run.path("src/liballoc_jemalloc")
+ .path("src/librustc_asan")
+ .path("src/librustc_lsan")
+ .path("src/librustc_msan")
+ .path("src/librustc_tsan")
+ }
+
+ fn make_run(run: RunConfig) {
+ let builder = run.builder;
+ let compiler = builder.compiler(builder.top_stage, run.host);
+
+ let test_kind = if builder.kind == Kind::Test {
+ TestKind::Test
+ } else if builder.kind == Kind::Bench {
+ TestKind::Bench
+ } else {
+ panic!("unexpected builder.kind in crate: {:?}", builder.kind);
+ };
+
+ builder.ensure(CrateNotDefault {
+ compiler,
+ target: run.target,
+ test_kind,
+ krate: match run.path {
+ _ if run.path.ends_with("src/liballoc_jemalloc") => "alloc_jemalloc",
+ _ if run.path.ends_with("src/librustc_asan") => "rustc_asan",
+ _ if run.path.ends_with("src/librustc_lsan") => "rustc_lsan",
+ _ if run.path.ends_with("src/librustc_msan") => "rustc_msan",
+ _ if run.path.ends_with("src/librustc_tsan") => "rustc_tsan",
+ _ => panic!("unexpected path {:?}", run.path),
+ },
+ });
+ }
+
+ fn run(self, builder: &Builder) {
+ builder.ensure(Crate {
+ compiler: self.compiler,
+ target: self.target,
+ mode: Mode::Libstd,
+ test_kind: self.test_kind,
+ krate: INTERNER.intern_str(self.krate),
+ });
+ }
+}
+
+
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Crate {
compiler: Compiler,
target: Interned<String>,
mode: Mode,
test_kind: TestKind,
- krate: Option<Interned<String>>,
+ krate: Interned<String>,
}
impl Step for Crate {
type Output = ();
const DEFAULT: bool = true;
- fn should_run(run: ShouldRun) -> ShouldRun {
- run.krate("std").krate("test")
+ fn should_run(mut run: ShouldRun) -> ShouldRun {
+ let builder = run.builder;
+ run = run.krate("test");
+ for krate in run.builder.in_tree_crates("std") {
+ if krate.is_local(&run.builder) &&
+ !krate.name.contains("jemalloc") &&
+ !(krate.name.starts_with("rustc_") && krate.name.ends_with("san")) &&
+ krate.name != "dlmalloc" {
+ run = run.path(krate.local_path(&builder).to_str().unwrap());
+ }
+ }
+ run
}
fn make_run(run: RunConfig) {
let builder = run.builder;
let compiler = builder.compiler(builder.top_stage, run.host);
- let make = |mode: Mode, name: Option<Interned<String>>| {
+ let make = |mode: Mode, krate: &CargoCrate| {
let test_kind = if builder.kind == Kind::Test {
TestKind::Test
} else if builder.kind == Kind::Bench {
target: run.target,
mode,
test_kind,
- krate: name,
+ krate: krate.name,
});
};
- if let Some(path) = run.path {
- for (name, krate_path) in builder.crates("std") {
- if path.ends_with(krate_path) {
- make(Mode::Libstd, Some(name));
- }
+ for krate in builder.in_tree_crates("std") {
+ if run.path.ends_with(&krate.local_path(&builder)) {
+ make(Mode::Libstd, krate);
}
- for (name, krate_path) in builder.crates("test") {
- if path.ends_with(krate_path) {
- make(Mode::Libtest, Some(name));
- }
+ }
+ for krate in builder.in_tree_crates("test") {
+ if run.path.ends_with(&krate.local_path(&builder)) {
+ make(Mode::Libtest, krate);
}
- } else {
- make(Mode::Libstd, None);
- make(Mode::Libtest, None);
}
}
- /// Run all unit tests plus documentation tests for an entire crate DAG defined
- /// by a `Cargo.toml`
+ /// Run all unit tests plus documentation tests for a given crate defined
+ /// by a `Cargo.toml` (single manifest)
///
/// This is what runs tests for crates like the standard library, compiler, etc.
/// It essentially is the driver for running `cargo test`.
};
let mut cargo = builder.cargo(compiler, mode, target, test_kind.subcommand());
- let (name, root) = match mode {
+ match mode {
Mode::Libstd => {
compile::std_cargo(build, &compiler, target, &mut cargo);
- ("libstd", "std")
}
Mode::Libtest => {
compile::test_cargo(build, &compiler, target, &mut cargo);
- ("libtest", "test")
}
Mode::Librustc => {
builder.ensure(compile::Rustc { compiler, target });
compile::rustc_cargo(build, &mut cargo);
- ("librustc", "rustc-main")
}
_ => panic!("can only test libraries"),
};
- let root = INTERNER.intern_string(String::from(root));
let _folder = build.fold_output(|| {
- format!("{}_stage{}-{}", test_kind.subcommand(), compiler.stage, name)
+ format!("{}_stage{}-{}", test_kind.subcommand(), compiler.stage, krate)
});
- println!("{} {} stage{} ({} -> {})", test_kind, name, compiler.stage,
+ println!("{} {} stage{} ({} -> {})", test_kind, krate, compiler.stage,
&compiler.host, target);
// Build up the base `cargo test` command.
cargo.arg("--no-fail-fast");
}
- match krate {
- Some(krate) => {
- cargo.arg("-p").arg(krate);
- }
- None => {
- let mut visited = HashSet::new();
- let mut next = vec![root];
- while let Some(name) = next.pop() {
- // Right now jemalloc and the sanitizer crates are
- // target-specific crate in the sense that it's not present
- // on all platforms. Custom skip it here for now, but if we
- // add more this probably wants to get more generalized.
- //
- // Also skip `build_helper` as it's not compiled normally
- // for target during the bootstrap and it's just meant to be
- // a helper crate, not tested. If it leaks through then it
- // ends up messing with various mtime calculations and such.
- if !name.contains("jemalloc") &&
- *name != *"build_helper" &&
- !(name.starts_with("rustc_") && name.ends_with("san")) &&
- name != "dlmalloc" {
- cargo.arg("-p").arg(&format!("{}:0.0.0", name));
- }
- for dep in build.crates[&name].deps.iter() {
- if visited.insert(dep) {
- next.push(*dep);
- }
- }
- }
- }
- }
+ cargo.arg("-p").arg(krate);
// The tests are going to run with the *target* libraries, so we need to
// ensure that those libraries show up in the LD_LIBRARY_PATH equivalent.
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct Rustdoc {
+pub struct CrateRustdoc {
host: Interned<String>,
test_kind: TestKind,
}
-impl Step for Rustdoc {
+impl Step for CrateRustdoc {
type Output = ();
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/librustdoc").path("src/tools/rustdoc")
+ run.paths(&["src/librustdoc", "src/tools/rustdoc"])
}
fn make_run(run: RunConfig) {
panic!("unexpected builder.kind in crate: {:?}", builder.kind);
};
- builder.ensure(Rustdoc {
+ builder.ensure(CrateRustdoc {
host: run.host,
test_kind,
});
--- /dev/null
+# `macro_at_most_once_rep`
+
+The tracking issue for this feature is: TODO(mark-i-m)
+
+With this feature gate enabled, one can use `?` as a Kleene operator meaning "0
+or 1 repetitions" in a macro definition. Previously only `+` and `*` were allowed.
+
+For example:
+```rust
+macro_rules! foo {
+ (something $(,)?) // `?` indicates `,` is "optional"...
+ => {}
+}
+```
+
+------------------------
+
///
/// If a `Vec` *has* allocated memory, then the memory it points to is on the heap
/// (as defined by the allocator Rust is configured to use by default), and its
-/// pointer points to [`len`] initialized elements in order (what you would see
-/// if you coerced it to a slice), followed by [`capacity`]` - `[`len`]
-/// logically uninitialized elements.
+/// pointer points to [`len`] initialized, contiguous elements in order (what
+/// you would see if you coerced it to a slice), followed by [`capacity`]` -
+/// `[`len`] logically uninitialized, contiguous elements.
///
/// `Vec` will never perform a "small optimization" where elements are actually
/// stored on the stack for two reasons:
/// not break, however: using `unsafe` code to write to the excess capacity,
/// and then increasing the length to match, is always valid.
///
-/// `Vec` does not currently guarantee the order in which elements are dropped
-/// (the order has changed in the past, and may change again).
+/// `Vec` does not currently guarantee the order in which elements are dropped.
+/// The order has changed in the past and may change again.
///
/// [`vec!`]: ../../std/macro.vec.html
/// [`Index`]: ../../std/ops/trait.Index.html
pub fn retain<F>(&mut self, mut f: F)
where F: FnMut(&T) -> bool
{
- let len = self.len();
- let mut del = 0;
- {
- let v = &mut **self;
-
- for i in 0..len {
- if !f(&v[i]) {
- del += 1;
- } else if del > 0 {
- v.swap(i - del, i);
- }
- }
- }
- if del > 0 {
- self.truncate(len - del);
- }
+ self.drain_filter(|x| !f(x));
}
/// Removes all but the first of consecutive elements in the vector that resolve to the same
-Subproject commit 345447948f7a51eca970fa036cefd613d54a4f79
+Subproject commit 266ea0740a5bdd262a38bbd88fb55fc3d2a7a96e
#[stable(feature = "rust1", since = "1.0.0")]
pub use self::sources::{Repeat, repeat};
+#[unstable(feature = "iterator_repeat_with", issue = "48169")]
+pub use self::sources::{RepeatWith, repeat_with};
#[stable(feature = "iter_empty", since = "1.2.0")]
pub use self::sources::{Empty, empty};
#[stable(feature = "iter_once", since = "1.2.0")]
{}
#[doc(hidden)]
-default unsafe impl<'a, I, T: 'a> TrustedRandomAccess for Cloned<I>
+unsafe impl<'a, I, T: 'a> TrustedRandomAccess for Cloned<I>
where I: TrustedRandomAccess<Item=&'a T>, T: Clone
{
- unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item {
+ default unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item {
self.it.get_unchecked(i).clone()
}
#[inline]
- fn may_have_side_effect() -> bool { true }
+ default fn may_have_side_effect() -> bool { true }
}
#[doc(hidden)]
///
/// [`take`]: trait.Iterator.html#method.take
///
+/// If the element type of the iterator you need does not implement `Clone`,
+/// or if you do not want to keep the repeated element in memory, you can
+/// instead use the [`repeat_with`] function.
+///
+/// [`repeat_with`]: fn.repeat_with.html
+///
/// # Examples
///
/// Basic usage:
Repeat{element: elt}
}
+/// An iterator that repeats elements of type `A` endlessly by
+/// applying the provided closure `F: FnMut() -> A`.
+///
+/// This `struct` is created by the [`repeat_with`] function.
+/// See its documentation for more.
+///
+/// [`repeat_with`]: fn.repeat_with.html
+#[derive(Copy, Clone, Debug)]
+#[unstable(feature = "iterator_repeat_with", issue = "48169")]
+pub struct RepeatWith<F> {
+ repeater: F
+}
+
+#[unstable(feature = "iterator_repeat_with", issue = "48169")]
+impl<A, F: FnMut() -> A> Iterator for RepeatWith<F> {
+ type Item = A;
+
+ #[inline]
+ fn next(&mut self) -> Option<A> { Some((self.repeater)()) }
+
+ #[inline]
+ fn size_hint(&self) -> (usize, Option<usize>) { (usize::MAX, None) }
+}
+
+#[unstable(feature = "iterator_repeat_with", issue = "48169")]
+impl<A, F: FnMut() -> A> DoubleEndedIterator for RepeatWith<F> {
+ #[inline]
+ fn next_back(&mut self) -> Option<A> { self.next() }
+}
+
+#[unstable(feature = "fused", issue = "35602")]
+impl<A, F: FnMut() -> A> FusedIterator for RepeatWith<F> {}
+
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<A, F: FnMut() -> A> TrustedLen for RepeatWith<F> {}
+
+/// Creates a new iterator that repeats elements of type `A` endlessly by
+/// applying the provided closure, the repeater, `F: FnMut() -> A`.
+///
+/// The `repeat_with()` function calls the repeater over and over and over and
+/// over and over and 🔁.
+///
+/// Infinite iterators like `repeat_with()` are often used with adapters like
+/// [`take`], in order to make them finite.
+///
+/// [`take`]: trait.Iterator.html#method.take
+///
+/// If the element type of the iterator you need implements `Clone`, and
+/// it is OK to keep the source element in memory, you should instead use
+/// the [`repeat`] function.
+///
+/// [`repeat`]: fn.repeat.html
+///
+/// An iterator produced by `repeat_with()` is a `DoubleEndedIterator`.
+/// It is important to not that reversing `repeat_with(f)` will produce
+/// the exact same sequence as the non-reversed iterator. In other words,
+/// `repeat_with(f).rev().collect::<Vec<_>>()` is equivalent to
+/// `repeat_with(f).collect::<Vec<_>>()`.
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// #![feature(iterator_repeat_with)]
+///
+/// use std::iter;
+///
+/// // let's assume we have some value of a type that is not `Clone`
+/// // or which don't want to have in memory just yet because it is expensive:
+/// #[derive(PartialEq, Debug)]
+/// struct Expensive;
+///
+/// // a particular value forever:
+/// let mut things = iter::repeat_with(|| Expensive);
+///
+/// assert_eq!(Some(Expensive), things.next());
+/// assert_eq!(Some(Expensive), things.next());
+/// assert_eq!(Some(Expensive), things.next());
+/// assert_eq!(Some(Expensive), things.next());
+/// assert_eq!(Some(Expensive), things.next());
+/// ```
+///
+/// Using mutation and going finite:
+///
+/// ```rust
+/// #![feature(iterator_repeat_with)]
+///
+/// use std::iter;
+///
+/// // From the zeroth to the third power of two:
+/// let mut curr = 1;
+/// let mut pow2 = iter::repeat_with(|| { let tmp = curr; curr *= 2; tmp })
+/// .take(4);
+///
+/// assert_eq!(Some(1), pow2.next());
+/// assert_eq!(Some(2), pow2.next());
+/// assert_eq!(Some(4), pow2.next());
+/// assert_eq!(Some(8), pow2.next());
+///
+/// // ... and now we're done
+/// assert_eq!(None, pow2.next());
+/// ```
+#[inline]
+#[unstable(feature = "iterator_repeat_with", issue = "48169")]
+pub fn repeat_with<A, F: FnMut() -> A>(repeater: F) -> RepeatWith<F> {
+ RepeatWith { repeater }
+}
+
/// An iterator that yields nothing.
///
/// This `struct` is created by the [`empty`] function. See its documentation for more.
/// ```
/// #![feature(exact_size_is_empty)]
///
- /// let mut one_element = 0..1;
+ /// let mut one_element = std::iter::once(0);
/// assert!(!one_element.is_empty());
///
/// assert_eq!(one_element.next(), Some(0));
#![feature(unwind_attributes)]
#![feature(doc_spotlight)]
#![feature(rustc_const_unstable)]
+#![feature(iterator_repeat_with)]
#[prelude_import]
#[allow(unused)]
/// struct BarUse(Bar<[i32]>); // OK
/// ```
///
-/// The one exception is the implicit `Self` type of a trait, which does not
-/// get an implicit `Sized` bound. This is because a `Sized` bound prevents
-/// the trait from being used to form a [trait object]:
+/// The one exception is the implicit `Self` type of a trait. A trait does not
+/// have an implicit `Sized` bound as this is incompatible with [trait object]s
+/// where, by definition, the trait needs to work with all possible implementors,
+/// and thus could be any size.
+///
+/// Although Rust will let you bind `Sized` to a trait, you won't
+/// be able to use it to form a trait object later:
///
/// ```
/// # #![allow(unused_variables)]
pub mod bignum;
pub mod diy_float;
+macro_rules! doc_comment {
+ ($x:expr, $($tt:tt)*) => {
+ #[doc = $x]
+ $($tt)*
+ };
+}
+
// `Int` + `SignedInt` implemented for signed integers
macro_rules! int_impl {
- ($SelfT:ty, $ActualT:ident, $UnsignedT:ty, $BITS:expr) => {
- /// Returns the smallest value that can be represented by this integer type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(i8::min_value(), -128);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub const fn min_value() -> Self {
- !0 ^ ((!0 as $UnsignedT) >> 1) as Self
+ ($SelfT:ty, $ActualT:ident, $UnsignedT:ty, $BITS:expr, $Min:expr, $Max:expr, $Feature:expr,
+ $EndFeature:expr) => {
+ doc_comment! {
+ concat!("Returns the smallest value that can be represented by this integer type.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(", stringify!($SelfT), "::min_value(), ", stringify!($Min), ");",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub const fn min_value() -> Self {
+ !0 ^ ((!0 as $UnsignedT) >> 1) as Self
+ }
}
- /// Returns the largest value that can be represented by this integer type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(i8::max_value(), 127);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub const fn max_value() -> Self {
- !Self::min_value()
+ doc_comment! {
+ concat!("Returns the largest value that can be represented by this integer type.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(", stringify!($SelfT), "::max_value(), ", stringify!($Max), ");",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub const fn max_value() -> Self {
+ !Self::min_value()
+ }
}
- /// Converts a string slice in a given base to an integer.
- ///
- /// The string is expected to be an optional `+` or `-` sign
- /// followed by digits.
- /// Leading and trailing whitespace represent an error.
- /// Digits are a subset of these characters, depending on `radix`:
- ///
- /// * `0-9`
- /// * `a-z`
- /// * `A-Z`
- ///
- /// # Panics
- ///
- /// This function panics if `radix` is not in the range from 2 to 36.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(i32::from_str_radix("A", 16), Ok(10));
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
- from_str_radix(src, radix)
+ doc_comment! {
+ concat!("Converts a string slice in a given base to an integer.
+
+The string is expected to be an optional `+` or `-` sign followed by digits.
+Leading and trailing whitespace represent an error. Digits are a subset of these characters,
+depending on `radix`:
+
+ * `0-9`
+ * `a-z`
+ * `a-z`
+
+# Panics
+
+This function panics if `radix` is not in the range from 2 to 36.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(", stringify!($SelfT), "::from_str_radix(\"A\", 16), Ok(10));",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
+ from_str_radix(src, radix)
+ }
}
- /// Returns the number of ones in the binary representation of `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = -0b1000_0000i8;
- ///
- /// assert_eq!(n.count_ones(), 1);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() }
+ doc_comment! {
+ concat!("Returns the number of ones in the binary representation of `self`.
- /// Returns the number of zeros in the binary representation of `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = -0b1000_0000i8;
- ///
- /// assert_eq!(n.count_zeros(), 7);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn count_zeros(self) -> u32 {
- (!self).count_ones()
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0b100_0000", stringify!($SelfT), ";
+
+assert_eq!(n.count_ones(), 1);",
+$EndFeature, "
+```
+"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() }
}
- /// Returns the number of leading zeros in the binary representation
- /// of `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = -1i16;
- ///
- /// assert_eq!(n.leading_zeros(), 0);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn leading_zeros(self) -> u32 {
- (self as $UnsignedT).leading_zeros()
+ doc_comment! {
+ concat!("Returns the number of zeros in the binary representation of `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(", stringify!($SelfT), "::max_value().count_zeros(), 1);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn count_zeros(self) -> u32 {
+ (!self).count_ones()
+ }
}
- /// Returns the number of trailing zeros in the binary representation
- /// of `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = -4i8;
- ///
- /// assert_eq!(n.trailing_zeros(), 2);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn trailing_zeros(self) -> u32 {
- (self as $UnsignedT).trailing_zeros()
+ doc_comment! {
+ concat!("Returns the number of leading zeros in the binary representation of `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = -1", stringify!($SelfT), ";
+
+assert_eq!(n.leading_zeros(), 0);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn leading_zeros(self) -> u32 {
+ (self as $UnsignedT).leading_zeros()
+ }
+ }
+
+ doc_comment! {
+ concat!("Returns the number of trailing zeros in the binary representation of `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = -4", stringify!($SelfT), ";
+
+assert_eq!(n.trailing_zeros(), 2);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn trailing_zeros(self) -> u32 {
+ (self as $UnsignedT).trailing_zeros()
+ }
}
/// Shifts the bits to the left by a specified amount, `n`,
///
/// # Examples
///
+ /// Please note that this example is shared between integer types.
+ /// Which explains why `i64` is used here.
+ ///
/// Basic usage:
///
/// ```
///
/// # Examples
///
+ /// Please note that this example is shared between integer types.
+ /// Which explains why `i64` is used here.
+ ///
/// Basic usage:
///
/// ```
///
/// # Examples
///
+ /// Please note that this example is shared between integer types.
+ /// Which explains why `i16` is used here.
+ ///
/// Basic usage:
///
/// ```
(self as $UnsignedT).swap_bytes() as Self
}
- /// Converts an integer from big endian to the target's endianness.
- ///
- /// On big endian this is a no-op. On little endian the bytes are
- /// swapped.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0x0123456789ABCDEFi64;
- ///
- /// if cfg!(target_endian = "big") {
- /// assert_eq!(i64::from_be(n), n)
- /// } else {
- /// assert_eq!(i64::from_be(n), n.swap_bytes())
- /// }
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn from_be(x: Self) -> Self {
- if cfg!(target_endian = "big") { x } else { x.swap_bytes() }
- }
+ doc_comment! {
+ concat!("Converts an integer from big endian to the target's endianness.
- /// Converts an integer from little endian to the target's endianness.
- ///
- /// On little endian this is a no-op. On big endian the bytes are
- /// swapped.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0x0123456789ABCDEFi64;
- ///
- /// if cfg!(target_endian = "little") {
- /// assert_eq!(i64::from_le(n), n)
- /// } else {
- /// assert_eq!(i64::from_le(n), n.swap_bytes())
- /// }
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn from_le(x: Self) -> Self {
- if cfg!(target_endian = "little") { x } else { x.swap_bytes() }
- }
+On big endian this is a no-op. On little endian the bytes are swapped.
- /// Converts `self` to big endian from the target's endianness.
- ///
- /// On big endian this is a no-op. On little endian the bytes are
- /// swapped.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0x0123456789ABCDEFi64;
- ///
- /// if cfg!(target_endian = "big") {
- /// assert_eq!(n.to_be(), n)
- /// } else {
- /// assert_eq!(n.to_be(), n.swap_bytes())
- /// }
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn to_be(self) -> Self { // or not to be?
- if cfg!(target_endian = "big") { self } else { self.swap_bytes() }
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0x1A", stringify!($SelfT), ";
+
+if cfg!(target_endian = \"big\") {
+ assert_eq!(", stringify!($SelfT), "::from_be(n), n)
+} else {
+ assert_eq!(", stringify!($SelfT), "::from_be(n), n.swap_bytes())
+}",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn from_be(x: Self) -> Self {
+ if cfg!(target_endian = "big") { x } else { x.swap_bytes() }
+ }
}
- /// Converts `self` to little endian from the target's endianness.
- ///
- /// On little endian this is a no-op. On big endian the bytes are
- /// swapped.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0x0123456789ABCDEFi64;
- ///
- /// if cfg!(target_endian = "little") {
- /// assert_eq!(n.to_le(), n)
- /// } else {
- /// assert_eq!(n.to_le(), n.swap_bytes())
- /// }
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn to_le(self) -> Self {
- if cfg!(target_endian = "little") { self } else { self.swap_bytes() }
+ doc_comment! {
+ concat!("Converts an integer from little endian to the target's endianness.
+
+On little endian this is a no-op. On big endian the bytes are swapped.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0x1A", stringify!($SelfT), ";
+
+if cfg!(target_endian = \"little\") {
+ assert_eq!(", stringify!($SelfT), "::from_le(n), n)
+} else {
+ assert_eq!(", stringify!($SelfT), "::from_le(n), n.swap_bytes())
+}",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn from_le(x: Self) -> Self {
+ if cfg!(target_endian = "little") { x } else { x.swap_bytes() }
+ }
}
- /// Checked integer addition. Computes `self + rhs`, returning `None`
- /// if overflow occurred.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(7i16.checked_add(32760), Some(32767));
- /// assert_eq!(8i16.checked_add(32760), None);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn checked_add(self, rhs: Self) -> Option<Self> {
- let (a, b) = self.overflowing_add(rhs);
- if b {None} else {Some(a)}
+ doc_comment! {
+ concat!("Converts `self` to big endian from the target's endianness.
+
+On big endian this is a no-op. On little endian the bytes are swapped.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0x1A", stringify!($SelfT), ";
+
+if cfg!(target_endian = \"big\") {
+ assert_eq!(n.to_be(), n)
+} else {
+ assert_eq!(n.to_be(), n.swap_bytes())
+}",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn to_be(self) -> Self { // or not to be?
+ if cfg!(target_endian = "big") { self } else { self.swap_bytes() }
+ }
}
- /// Checked integer subtraction. Computes `self - rhs`, returning
- /// `None` if overflow occurred.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!((-127i8).checked_sub(1), Some(-128));
- /// assert_eq!((-128i8).checked_sub(1), None);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn checked_sub(self, rhs: Self) -> Option<Self> {
- let (a, b) = self.overflowing_sub(rhs);
- if b {None} else {Some(a)}
+ doc_comment! {
+ concat!("Converts `self` to little endian from the target's endianness.
+
+On little endian this is a no-op. On big endian the bytes are swapped.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0x1A", stringify!($SelfT), ";
+
+if cfg!(target_endian = \"little\") {
+ assert_eq!(n.to_le(), n)
+} else {
+ assert_eq!(n.to_le(), n.swap_bytes())
+}",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn to_le(self) -> Self {
+ if cfg!(target_endian = "little") { self } else { self.swap_bytes() }
+ }
}
- /// Checked integer multiplication. Computes `self * rhs`, returning
- /// `None` if overflow occurred.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(6i8.checked_mul(21), Some(126));
- /// assert_eq!(6i8.checked_mul(22), None);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn checked_mul(self, rhs: Self) -> Option<Self> {
- let (a, b) = self.overflowing_mul(rhs);
- if b {None} else {Some(a)}
+ doc_comment! {
+ concat!("Checked integer addition. Computes `self + rhs`, returning `None`
+if overflow occurred.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!((", stringify!($SelfT),
+"::max_value() - 2).checked_add(1), Some(", stringify!($SelfT), "::max_value() - 1));
+assert_eq!((", stringify!($SelfT), "::max_value() - 2).checked_add(3), None);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn checked_add(self, rhs: Self) -> Option<Self> {
+ let (a, b) = self.overflowing_add(rhs);
+ if b {None} else {Some(a)}
+ }
}
- /// Checked integer division. Computes `self / rhs`, returning `None`
- /// if `rhs == 0` or the division results in overflow.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!((-127i8).checked_div(-1), Some(127));
- /// assert_eq!((-128i8).checked_div(-1), None);
- /// assert_eq!((1i8).checked_div(0), None);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn checked_div(self, rhs: Self) -> Option<Self> {
- if rhs == 0 || (self == Self::min_value() && rhs == -1) {
- None
- } else {
- Some(unsafe { intrinsics::unchecked_div(self, rhs) })
+ doc_comment! {
+ concat!("Checked integer subtraction. Computes `self - rhs`, returning `None` if
+overflow occurred.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!((", stringify!($SelfT),
+"::min_value() + 2).checked_sub(1), Some(", stringify!($SelfT), "::min_value() + 1));
+assert_eq!((", stringify!($SelfT), "::min_value() + 2).checked_sub(3), None);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn checked_sub(self, rhs: Self) -> Option<Self> {
+ let (a, b) = self.overflowing_sub(rhs);
+ if b {None} else {Some(a)}
}
}
- /// Checked integer remainder. Computes `self % rhs`, returning `None`
- /// if `rhs == 0` or the division results in overflow.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// use std::i32;
- ///
- /// assert_eq!(5i32.checked_rem(2), Some(1));
- /// assert_eq!(5i32.checked_rem(0), None);
- /// assert_eq!(i32::MIN.checked_rem(-1), None);
- /// ```
- #[stable(feature = "wrapping", since = "1.7.0")]
- #[inline]
- pub fn checked_rem(self, rhs: Self) -> Option<Self> {
- if rhs == 0 || (self == Self::min_value() && rhs == -1) {
- None
- } else {
- Some(unsafe { intrinsics::unchecked_rem(self, rhs) })
+ doc_comment! {
+ concat!("Checked integer multiplication. Computes `self * rhs`, returning `None` if
+overflow occurred.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(", stringify!($SelfT),
+"::max_value().checked_mul(1), Some(", stringify!($SelfT), "::max_value()));
+assert_eq!(", stringify!($SelfT), "::max_value().checked_mul(2), None);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn checked_mul(self, rhs: Self) -> Option<Self> {
+ let (a, b) = self.overflowing_mul(rhs);
+ if b {None} else {Some(a)}
}
}
- /// Checked negation. Computes `-self`, returning `None` if `self ==
- /// MIN`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// use std::i32;
- ///
- /// assert_eq!(5i32.checked_neg(), Some(-5));
- /// assert_eq!(i32::MIN.checked_neg(), None);
- /// ```
- #[stable(feature = "wrapping", since = "1.7.0")]
- #[inline]
- pub fn checked_neg(self) -> Option<Self> {
- let (a, b) = self.overflowing_neg();
- if b {None} else {Some(a)}
- }
+ doc_comment! {
+ concat!("Checked integer division. Computes `self / rhs`, returning `None` if `rhs == 0`
+or the division results in overflow.
- /// Checked shift left. Computes `self << rhs`, returning `None`
- /// if `rhs` is larger than or equal to the number of bits in `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(0x10i32.checked_shl(4), Some(0x100));
- /// assert_eq!(0x10i32.checked_shl(33), None);
- /// ```
- #[stable(feature = "wrapping", since = "1.7.0")]
- #[inline]
- pub fn checked_shl(self, rhs: u32) -> Option<Self> {
- let (a, b) = self.overflowing_shl(rhs);
- if b {None} else {Some(a)}
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!((", stringify!($SelfT),
+"::min_value() + 1).checked_div(-1), Some(", stringify!($Max), "));
+assert_eq!(", stringify!($SelfT), "::min_value().checked_div(-1), None);
+assert_eq!((1", stringify!($SelfT), ").checked_div(0), None);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn checked_div(self, rhs: Self) -> Option<Self> {
+ if rhs == 0 || (self == Self::min_value() && rhs == -1) {
+ None
+ } else {
+ Some(unsafe { intrinsics::unchecked_div(self, rhs) })
+ }
+ }
}
- /// Checked shift right. Computes `self >> rhs`, returning `None`
- /// if `rhs` is larger than or equal to the number of bits in `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(0x10i32.checked_shr(4), Some(0x1));
- /// assert_eq!(0x10i32.checked_shr(33), None);
- /// ```
- #[stable(feature = "wrapping", since = "1.7.0")]
- #[inline]
- pub fn checked_shr(self, rhs: u32) -> Option<Self> {
- let (a, b) = self.overflowing_shr(rhs);
- if b {None} else {Some(a)}
+ doc_comment! {
+ concat!("Checked integer remainder. Computes `self % rhs`, returning `None` if
+`rhs == 0` or the division results in overflow.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(5", stringify!($SelfT), ".checked_rem(2), Some(1));
+assert_eq!(5", stringify!($SelfT), ".checked_rem(0), None);
+assert_eq!(", stringify!($SelfT), "::MIN.checked_rem(-1), None);",
+$EndFeature, "
+```"),
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ #[inline]
+ pub fn checked_rem(self, rhs: Self) -> Option<Self> {
+ if rhs == 0 || (self == Self::min_value() && rhs == -1) {
+ None
+ } else {
+ Some(unsafe { intrinsics::unchecked_rem(self, rhs) })
+ }
+ }
}
- /// Checked absolute value. Computes `self.abs()`, returning `None` if
- /// `self == MIN`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// use std::i32;
- ///
- /// assert_eq!((-5i32).checked_abs(), Some(5));
- /// assert_eq!(i32::MIN.checked_abs(), None);
- /// ```
- #[stable(feature = "no_panic_abs", since = "1.13.0")]
- #[inline]
- pub fn checked_abs(self) -> Option<Self> {
- if self.is_negative() {
- self.checked_neg()
- } else {
- Some(self)
+ doc_comment! {
+ concat!("Checked negation. Computes `-self`, returning `None` if `self == MIN`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(5", stringify!($SelfT), ".checked_neg(), Some(-5));
+assert_eq!(", stringify!($SelfT), "::MIN.checked_neg(), None);",
+$EndFeature, "
+```"),
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ #[inline]
+ pub fn checked_neg(self) -> Option<Self> {
+ let (a, b) = self.overflowing_neg();
+ if b {None} else {Some(a)}
}
}
- /// Saturating integer addition. Computes `self + rhs`, saturating at
- /// the numeric bounds instead of overflowing.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100i8.saturating_add(1), 101);
- /// assert_eq!(100i8.saturating_add(127), 127);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn saturating_add(self, rhs: Self) -> Self {
- match self.checked_add(rhs) {
- Some(x) => x,
- None if rhs >= 0 => Self::max_value(),
- None => Self::min_value(),
+ doc_comment! {
+ concat!("Checked shift left. Computes `self << rhs`, returning `None` if `rhs` is larger
+than or equal to the number of bits in `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(0x1", stringify!($SelfT), ".checked_shl(4), Some(0x10));
+assert_eq!(0x1", stringify!($SelfT), ".checked_shl(129), None);",
+$EndFeature, "
+```"),
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ #[inline]
+ pub fn checked_shl(self, rhs: u32) -> Option<Self> {
+ let (a, b) = self.overflowing_shl(rhs);
+ if b {None} else {Some(a)}
}
}
- /// Saturating integer subtraction. Computes `self - rhs`, saturating
- /// at the numeric bounds instead of overflowing.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100i8.saturating_sub(127), -27);
- /// assert_eq!((-100i8).saturating_sub(127), -128);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn saturating_sub(self, rhs: Self) -> Self {
- match self.checked_sub(rhs) {
- Some(x) => x,
- None if rhs >= 0 => Self::min_value(),
- None => Self::max_value(),
+ doc_comment! {
+ concat!("Checked shift right. Computes `self >> rhs`, returning `None` if `rhs` is
+larger than or equal to the number of bits in `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(0x10", stringify!($SelfT), ".checked_shr(4), Some(0x1));
+assert_eq!(0x10", stringify!($SelfT), ".checked_shr(128), None);",
+$EndFeature, "
+```"),
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ #[inline]
+ pub fn checked_shr(self, rhs: u32) -> Option<Self> {
+ let (a, b) = self.overflowing_shr(rhs);
+ if b {None} else {Some(a)}
}
}
- /// Saturating integer multiplication. Computes `self * rhs`,
- /// saturating at the numeric bounds instead of overflowing.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// use std::i32;
- ///
- /// assert_eq!(100i32.saturating_mul(127), 12700);
- /// assert_eq!((1i32 << 23).saturating_mul(1 << 23), i32::MAX);
- /// assert_eq!((-1i32 << 23).saturating_mul(1 << 23), i32::MIN);
- /// ```
- #[stable(feature = "wrapping", since = "1.7.0")]
- #[inline]
- pub fn saturating_mul(self, rhs: Self) -> Self {
- self.checked_mul(rhs).unwrap_or_else(|| {
- if (self < 0 && rhs < 0) || (self > 0 && rhs > 0) {
- Self::max_value()
+ doc_comment! {
+ concat!("Checked absolute value. Computes `self.abs()`, returning `None` if
+`self == MIN`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!((-5", stringify!($SelfT), ").checked_abs(), Some(5));
+assert_eq!(", stringify!($SelfT), "::MIN.checked_abs(), None);",
+$EndFeature, "
+```"),
+ #[stable(feature = "no_panic_abs", since = "1.13.0")]
+ #[inline]
+ pub fn checked_abs(self) -> Option<Self> {
+ if self.is_negative() {
+ self.checked_neg()
} else {
- Self::min_value()
+ Some(self)
}
- })
+ }
}
- /// Wrapping (modular) addition. Computes `self + rhs`,
- /// wrapping around at the boundary of the type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100i8.wrapping_add(27), 127);
- /// assert_eq!(100i8.wrapping_add(127), -29);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn wrapping_add(self, rhs: Self) -> Self {
- unsafe {
- intrinsics::overflowing_add(self, rhs)
+ doc_comment! {
+ concat!("Saturating integer addition. Computes `self + rhs`, saturating at the numeric
+bounds instead of overflowing.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
+assert_eq!(", stringify!($SelfT), "::max_value().saturating_add(100), ", stringify!($SelfT),
+"::max_value());",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn saturating_add(self, rhs: Self) -> Self {
+ match self.checked_add(rhs) {
+ Some(x) => x,
+ None if rhs >= 0 => Self::max_value(),
+ None => Self::min_value(),
+ }
}
}
- /// Wrapping (modular) subtraction. Computes `self - rhs`,
- /// wrapping around at the boundary of the type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(0i8.wrapping_sub(127), -127);
- /// assert_eq!((-2i8).wrapping_sub(127), 127);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn wrapping_sub(self, rhs: Self) -> Self {
- unsafe {
- intrinsics::overflowing_sub(self, rhs)
+ doc_comment! {
+ concat!("Saturating integer subtraction. Computes `self - rhs`, saturating at the
+numeric bounds instead of overflowing.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_sub(127), -27);
+assert_eq!(", stringify!($SelfT), "::min_value().saturating_sub(100), ", stringify!($SelfT),
+"::min_value());",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn saturating_sub(self, rhs: Self) -> Self {
+ match self.checked_sub(rhs) {
+ Some(x) => x,
+ None if rhs >= 0 => Self::min_value(),
+ None => Self::max_value(),
+ }
}
}
- /// Wrapping (modular) multiplication. Computes `self *
- /// rhs`, wrapping around at the boundary of the type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(10i8.wrapping_mul(12), 120);
- /// assert_eq!(11i8.wrapping_mul(12), -124);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn wrapping_mul(self, rhs: Self) -> Self {
- unsafe {
- intrinsics::overflowing_mul(self, rhs)
+ doc_comment! {
+ concat!("Saturating integer multiplication. Computes `self * rhs`, saturating at the
+numeric bounds instead of overflowing.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(10", stringify!($SelfT), ".saturating_mul(12), 120);
+assert_eq!(", stringify!($SelfT), "::MAX.saturating_mul(10), ", stringify!($SelfT), "::MAX);
+assert_eq!(", stringify!($SelfT), "::MIN.saturating_mul(10), ", stringify!($SelfT), "::MIN);",
+$EndFeature, "
+```"),
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ #[inline]
+ pub fn saturating_mul(self, rhs: Self) -> Self {
+ self.checked_mul(rhs).unwrap_or_else(|| {
+ if (self < 0 && rhs < 0) || (self > 0 && rhs > 0) {
+ Self::max_value()
+ } else {
+ Self::min_value()
+ }
+ })
}
}
- /// Wrapping (modular) division. Computes `self / rhs`,
- /// wrapping around at the boundary of the type.
- ///
- /// The only case where such wrapping can occur is when one
- /// divides `MIN / -1` on a signed type (where `MIN` is the
- /// negative minimal value for the type); this is equivalent
- /// to `-MIN`, a positive value that is too large to represent
- /// in the type. In such a case, this function returns `MIN`
- /// itself.
- ///
- /// # Panics
- ///
- /// This function will panic if `rhs` is 0.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100u8.wrapping_div(10), 10);
- /// assert_eq!((-128i8).wrapping_div(-1), -128);
- /// ```
- #[stable(feature = "num_wrapping", since = "1.2.0")]
- #[inline]
- pub fn wrapping_div(self, rhs: Self) -> Self {
- self.overflowing_div(rhs).0
+ doc_comment! {
+ concat!("Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the
+boundary of the type.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_add(27), 127);
+assert_eq!(", stringify!($SelfT), "::max_value().wrapping_add(2), ", stringify!($SelfT),
+"::min_value() + 1);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_add(self, rhs: Self) -> Self {
+ unsafe {
+ intrinsics::overflowing_add(self, rhs)
+ }
+ }
}
- /// Wrapping (modular) remainder. Computes `self % rhs`,
- /// wrapping around at the boundary of the type.
- ///
- /// Such wrap-around never actually occurs mathematically;
- /// implementation artifacts make `x % y` invalid for `MIN /
- /// -1` on a signed type (where `MIN` is the negative
- /// minimal value). In such a case, this function returns `0`.
- ///
- /// # Panics
- ///
- /// This function will panic if `rhs` is 0.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100i8.wrapping_rem(10), 0);
- /// assert_eq!((-128i8).wrapping_rem(-1), 0);
- /// ```
- #[stable(feature = "num_wrapping", since = "1.2.0")]
- #[inline]
- pub fn wrapping_rem(self, rhs: Self) -> Self {
- self.overflowing_rem(rhs).0
+ doc_comment! {
+ concat!("Wrapping (modular) subtraction. Computes `self - rhs`, wrapping around at the
+boundary of the type.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(0", stringify!($SelfT), ".wrapping_sub(127), -127);
+assert_eq!((-2", stringify!($SelfT), ").wrapping_sub(", stringify!($SelfT), "::max_value()), ",
+stringify!($SelfT), "::max_value());",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_sub(self, rhs: Self) -> Self {
+ unsafe {
+ intrinsics::overflowing_sub(self, rhs)
+ }
+ }
}
- /// Wrapping (modular) negation. Computes `-self`,
- /// wrapping around at the boundary of the type.
- ///
- /// The only case where such wrapping can occur is when one
- /// negates `MIN` on a signed type (where `MIN` is the
- /// negative minimal value for the type); this is a positive
- /// value that is too large to represent in the type. In such
- /// a case, this function returns `MIN` itself.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100i8.wrapping_neg(), -100);
- /// assert_eq!((-128i8).wrapping_neg(), -128);
- /// ```
- #[stable(feature = "num_wrapping", since = "1.2.0")]
- #[inline]
- pub fn wrapping_neg(self) -> Self {
- self.overflowing_neg().0
+ doc_comment! {
+ concat!("Wrapping (modular) multiplication. Computes `self * rhs`, wrapping around at
+the boundary of the type.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(10", stringify!($SelfT), ".wrapping_mul(12), 120);
+assert_eq!(11i8.wrapping_mul(12), -124);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_mul(self, rhs: Self) -> Self {
+ unsafe {
+ intrinsics::overflowing_mul(self, rhs)
+ }
+ }
}
- /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
- /// where `mask` removes any high-order bits of `rhs` that
- /// would cause the shift to exceed the bitwidth of the type.
- ///
- /// Note that this is *not* the same as a rotate-left; the
- /// RHS of a wrapping shift-left is restricted to the range
- /// of the type, rather than the bits shifted out of the LHS
- /// being returned to the other end. The primitive integer
- /// types all implement a `rotate_left` function, which may
- /// be what you want instead.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!((-1i8).wrapping_shl(7), -128);
- /// assert_eq!((-1i8).wrapping_shl(8), -1);
- /// ```
- #[stable(feature = "num_wrapping", since = "1.2.0")]
- #[inline]
- pub fn wrapping_shl(self, rhs: u32) -> Self {
- unsafe {
- intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
+ doc_comment! {
+ concat!("Wrapping (modular) division. Computes `self / rhs`, wrapping around at the
+boundary of the type.
+
+The only case where such wrapping can occur is when one divides `MIN / -1` on a signed type (where
+`MIN` is the negative minimal value for the type); this is equivalent to `-MIN`, a positive value
+that is too large to represent in the type. In such a case, this function returns `MIN` itself.
+
+# Panics
+
+This function will panic if `rhs` is 0.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_div(10), 10);
+assert_eq!((-128i8).wrapping_div(-1), -128);",
+$EndFeature, "
+```"),
+ #[stable(feature = "num_wrapping", since = "1.2.0")]
+ #[inline]
+ pub fn wrapping_div(self, rhs: Self) -> Self {
+ self.overflowing_div(rhs).0
}
}
- /// Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
- /// where `mask` removes any high-order bits of `rhs` that
- /// would cause the shift to exceed the bitwidth of the type.
- ///
- /// Note that this is *not* the same as a rotate-right; the
- /// RHS of a wrapping shift-right is restricted to the range
- /// of the type, rather than the bits shifted out of the LHS
- /// being returned to the other end. The primitive integer
- /// types all implement a `rotate_right` function, which may
- /// be what you want instead.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!((-128i8).wrapping_shr(7), -1);
- /// assert_eq!((-128i8).wrapping_shr(8), -128);
- /// ```
- #[stable(feature = "num_wrapping", since = "1.2.0")]
- #[inline]
- pub fn wrapping_shr(self, rhs: u32) -> Self {
- unsafe {
- intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
+ doc_comment! {
+ concat!("Wrapping (modular) remainder. Computes `self % rhs`, wrapping around at the
+boundary of the type.
+
+Such wrap-around never actually occurs mathematically; implementation artifacts make `x % y`
+invalid for `MIN / -1` on a signed type (where `MIN` is the negative minimal value). In such a case,
+this function returns `0`.
+
+# Panics
+
+This function will panic if `rhs` is 0.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_rem(10), 0);
+assert_eq!((-128i8).wrapping_rem(-1), 0);",
+$EndFeature, "
+```"),
+ #[stable(feature = "num_wrapping", since = "1.2.0")]
+ #[inline]
+ pub fn wrapping_rem(self, rhs: Self) -> Self {
+ self.overflowing_rem(rhs).0
}
}
- /// Wrapping (modular) absolute value. Computes `self.abs()`,
- /// wrapping around at the boundary of the type.
- ///
- /// The only case where such wrapping can occur is when one takes
- /// the absolute value of the negative minimal value for the type
- /// this is a positive value that is too large to represent in the
- /// type. In such a case, this function returns `MIN` itself.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100i8.wrapping_abs(), 100);
- /// assert_eq!((-100i8).wrapping_abs(), 100);
- /// assert_eq!((-128i8).wrapping_abs(), -128);
- /// assert_eq!((-128i8).wrapping_abs() as u8, 128);
- /// ```
- #[stable(feature = "no_panic_abs", since = "1.13.0")]
- #[inline]
- pub fn wrapping_abs(self) -> Self {
- if self.is_negative() {
- self.wrapping_neg()
- } else {
- self
+ doc_comment! {
+ concat!("Wrapping (modular) negation. Computes `-self`, wrapping around at the boundary
+of the type.
+
+The only case where such wrapping can occur is when one negates `MIN` on a signed type (where `MIN`
+is the negative minimal value for the type); this is a positive value that is too large to represent
+in the type. In such a case, this function returns `MIN` itself.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_neg(), -100);
+assert_eq!(", stringify!($SelfT), "::min_value().wrapping_neg(), ", stringify!($SelfT),
+"::min_value());",
+$EndFeature, "
+```"),
+ #[stable(feature = "num_wrapping", since = "1.2.0")]
+ #[inline]
+ pub fn wrapping_neg(self) -> Self {
+ self.overflowing_neg().0
}
}
- /// Calculates `self` + `rhs`
- ///
- /// Returns a tuple of the addition along with a boolean indicating
- /// whether an arithmetic overflow would occur. If an overflow would
- /// have occurred then the wrapped value is returned.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// use std::i32;
- ///
- /// assert_eq!(5i32.overflowing_add(2), (7, false));
- /// assert_eq!(i32::MAX.overflowing_add(1), (i32::MIN, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_add(self, rhs: Self) -> (Self, bool) {
- let (a, b) = unsafe {
- intrinsics::add_with_overflow(self as $ActualT,
- rhs as $ActualT)
- };
- (a as Self, b)
+ doc_comment! {
+ concat!("Panic-free bitwise shift-left; yields `self << mask(rhs)`, where `mask` removes
+any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.
+
+Note that this is *not* the same as a rotate-left; the RHS of a wrapping shift-left is restricted to
+the range of the type, rather than the bits shifted out of the LHS being returned to the other end.
+The primitive integer types all implement a `rotate_left` function, which may be what you want
+instead.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!((-1", stringify!($SelfT), ").wrapping_shl(7), -128);
+assert_eq!((-1", stringify!($SelfT), ").wrapping_shl(128), -1);",
+$EndFeature, "
+```"),
+ #[stable(feature = "num_wrapping", since = "1.2.0")]
+ #[inline]
+ pub fn wrapping_shl(self, rhs: u32) -> Self {
+ unsafe {
+ intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
+ }
+ }
}
- /// Calculates `self` - `rhs`
- ///
- /// Returns a tuple of the subtraction along with a boolean indicating
- /// whether an arithmetic overflow would occur. If an overflow would
- /// have occurred then the wrapped value is returned.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// use std::i32;
- ///
- /// assert_eq!(5i32.overflowing_sub(2), (3, false));
- /// assert_eq!(i32::MIN.overflowing_sub(1), (i32::MAX, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
- let (a, b) = unsafe {
- intrinsics::sub_with_overflow(self as $ActualT,
- rhs as $ActualT)
- };
- (a as Self, b)
+ doc_comment! {
+ concat!("Panic-free bitwise shift-right; yields `self >> mask(rhs)`, where `mask`
+removes any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.
+
+Note that this is *not* the same as a rotate-right; the RHS of a wrapping shift-right is restricted
+to the range of the type, rather than the bits shifted out of the LHS being returned to the other
+end. The primitive integer types all implement a `rotate_right` function, which may be what you want
+instead.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!((-128", stringify!($SelfT), ").wrapping_shr(7), -1);
+assert_eq!((-128i16).wrapping_shr(64), -128);",
+$EndFeature, "
+```"),
+ #[stable(feature = "num_wrapping", since = "1.2.0")]
+ #[inline]
+ pub fn wrapping_shr(self, rhs: u32) -> Self {
+ unsafe {
+ intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
+ }
+ }
}
- /// Calculates the multiplication of `self` and `rhs`.
- ///
- /// Returns a tuple of the multiplication along with a boolean
- /// indicating whether an arithmetic overflow would occur. If an
- /// overflow would have occurred then the wrapped value is returned.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// assert_eq!(5i32.overflowing_mul(2), (10, false));
- /// assert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
- let (a, b) = unsafe {
- intrinsics::mul_with_overflow(self as $ActualT,
- rhs as $ActualT)
- };
- (a as Self, b)
+ doc_comment! {
+ concat!("Wrapping (modular) absolute value. Computes `self.abs()`, wrapping around at
+the boundary of the type.
+
+The only case where such wrapping can occur is when one takes the absolute value of the negative
+minimal value for the type this is a positive value that is too large to represent in the type. In
+such a case, this function returns `MIN` itself.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_abs(), 100);
+assert_eq!((-100", stringify!($SelfT), ").wrapping_abs(), 100);
+assert_eq!(", stringify!($SelfT), "::min_value().wrapping_abs(), ", stringify!($SelfT),
+"::min_value());
+assert_eq!((-128i8).wrapping_abs() as u8, 128);",
+$EndFeature, "
+```"),
+ #[stable(feature = "no_panic_abs", since = "1.13.0")]
+ #[inline]
+ pub fn wrapping_abs(self) -> Self {
+ if self.is_negative() {
+ self.wrapping_neg()
+ } else {
+ self
+ }
+ }
}
- /// Calculates the divisor when `self` is divided by `rhs`.
- ///
- /// Returns a tuple of the divisor along with a boolean indicating
- /// whether an arithmetic overflow would occur. If an overflow would
- /// occur then self is returned.
- ///
- /// # Panics
- ///
- /// This function will panic if `rhs` is 0.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// use std::i32;
- ///
- /// assert_eq!(5i32.overflowing_div(2), (2, false));
- /// assert_eq!(i32::MIN.overflowing_div(-1), (i32::MIN, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_div(self, rhs: Self) -> (Self, bool) {
- if self == Self::min_value() && rhs == -1 {
- (self, true)
- } else {
- (self / rhs, false)
+ doc_comment! {
+ concat!("Calculates `self` + `rhs`
+
+Returns a tuple of the addition along with a boolean indicating whether an arithmetic overflow would
+occur. If an overflow would have occurred then the wrapped value is returned.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(5", stringify!($SelfT), ".overflowing_add(2), (7, false));
+assert_eq!(", stringify!($SelfT), "::MAX.overflowing_add(1), (", stringify!($SelfT),
+"::MIN, true));", $EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_add(self, rhs: Self) -> (Self, bool) {
+ let (a, b) = unsafe {
+ intrinsics::add_with_overflow(self as $ActualT,
+ rhs as $ActualT)
+ };
+ (a as Self, b)
}
}
- /// Calculates the remainder when `self` is divided by `rhs`.
- ///
- /// Returns a tuple of the remainder after dividing along with a boolean
- /// indicating whether an arithmetic overflow would occur. If an
- /// overflow would occur then 0 is returned.
- ///
- /// # Panics
- ///
- /// This function will panic if `rhs` is 0.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// use std::i32;
- ///
- /// assert_eq!(5i32.overflowing_rem(2), (1, false));
- /// assert_eq!(i32::MIN.overflowing_rem(-1), (0, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
- if self == Self::min_value() && rhs == -1 {
- (0, true)
- } else {
- (self % rhs, false)
+ doc_comment! {
+ concat!("Calculates `self` - `rhs`
+
+Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow
+would occur. If an overflow would have occurred then the wrapped value is returned.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(5", stringify!($SelfT), ".overflowing_sub(2), (3, false));
+assert_eq!(", stringify!($SelfT), "::MIN.overflowing_sub(1), (", stringify!($SelfT),
+"::MAX, true));", $EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
+ let (a, b) = unsafe {
+ intrinsics::sub_with_overflow(self as $ActualT,
+ rhs as $ActualT)
+ };
+ (a as Self, b)
}
}
- /// Negates self, overflowing if this is equal to the minimum value.
- ///
- /// Returns a tuple of the negated version of self along with a boolean
- /// indicating whether an overflow happened. If `self` is the minimum
- /// value (e.g. `i32::MIN` for values of type `i32`), then the minimum
- /// value will be returned again and `true` will be returned for an
- /// overflow happening.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// use std::i32;
- ///
- /// assert_eq!(2i32.overflowing_neg(), (-2, false));
- /// assert_eq!(i32::MIN.overflowing_neg(), (i32::MIN, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_neg(self) -> (Self, bool) {
- if self == Self::min_value() {
- (Self::min_value(), true)
- } else {
- (-self, false)
+ doc_comment! {
+ concat!("Calculates the multiplication of `self` and `rhs`.
+
+Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow
+would occur. If an overflow would have occurred then the wrapped value is returned.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(5", stringify!($SelfT), ".overflowing_mul(2), (10, false));
+assert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408, true));",
+$EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
+ let (a, b) = unsafe {
+ intrinsics::mul_with_overflow(self as $ActualT,
+ rhs as $ActualT)
+ };
+ (a as Self, b)
}
}
- /// Shifts self left by `rhs` bits.
- ///
- /// Returns a tuple of the shifted version of self along with a boolean
- /// indicating whether the shift value was larger than or equal to the
- /// number of bits. If the shift value is too large, then value is
- /// masked (N-1) where N is the number of bits, and this value is then
- /// used to perform the shift.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// assert_eq!(0x10i32.overflowing_shl(4), (0x100, false));
- /// assert_eq!(0x10i32.overflowing_shl(36), (0x100, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
- (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
+ doc_comment! {
+ concat!("Calculates the divisor when `self` is divided by `rhs`.
+
+Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would
+occur. If an overflow would occur then self is returned.
+
+# Panics
+
+This function will panic if `rhs` is 0.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(5", stringify!($SelfT), ".overflowing_div(2), (2, false));
+assert_eq!(", stringify!($SelfT), "::MIN.overflowing_div(-1), (", stringify!($SelfT),
+"::MIN, true));",
+$EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_div(self, rhs: Self) -> (Self, bool) {
+ if self == Self::min_value() && rhs == -1 {
+ (self, true)
+ } else {
+ (self / rhs, false)
+ }
+ }
}
- /// Shifts self right by `rhs` bits.
- ///
- /// Returns a tuple of the shifted version of self along with a boolean
- /// indicating whether the shift value was larger than or equal to the
- /// number of bits. If the shift value is too large, then value is
- /// masked (N-1) where N is the number of bits, and this value is then
- /// used to perform the shift.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// assert_eq!(0x10i32.overflowing_shr(4), (0x1, false));
- /// assert_eq!(0x10i32.overflowing_shr(36), (0x1, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
- (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
+ doc_comment! {
+ concat!("Calculates the remainder when `self` is divided by `rhs`.
+
+Returns a tuple of the remainder after dividing along with a boolean indicating whether an
+arithmetic overflow would occur. If an overflow would occur then 0 is returned.
+
+# Panics
+
+This function will panic if `rhs` is 0.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(5", stringify!($SelfT), ".overflowing_rem(2), (1, false));
+assert_eq!(", stringify!($SelfT), "::MIN.overflowing_rem(-1), (0, true));",
+$EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
+ if self == Self::min_value() && rhs == -1 {
+ (0, true)
+ } else {
+ (self % rhs, false)
+ }
+ }
}
- /// Computes the absolute value of `self`.
- ///
- /// Returns a tuple of the absolute version of self along with a
- /// boolean indicating whether an overflow happened. If self is the
- /// minimum value (e.g. i32::MIN for values of type i32), then the
- /// minimum value will be returned again and true will be returned for
- /// an overflow happening.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(10i8.overflowing_abs(), (10,false));
- /// assert_eq!((-10i8).overflowing_abs(), (10,false));
- /// assert_eq!((-128i8).overflowing_abs(), (-128,true));
- /// ```
- #[stable(feature = "no_panic_abs", since = "1.13.0")]
- #[inline]
- pub fn overflowing_abs(self) -> (Self, bool) {
- if self.is_negative() {
- self.overflowing_neg()
- } else {
- (self, false)
+ doc_comment! {
+ concat!("Negates self, overflowing if this is equal to the minimum value.
+
+Returns a tuple of the negated version of self along with a boolean indicating whether an overflow
+happened. If `self` is the minimum value (e.g. `i32::MIN` for values of type `i32`), then the
+minimum value will be returned again and `true` will be returned for an overflow happening.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(2", stringify!($SelfT), ".overflowing_neg(), (-2, false));
+assert_eq!(", stringify!($SelfT), "::MIN.overflowing_neg(), (", stringify!($SelfT),
+"::MIN, true));", $EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_neg(self) -> (Self, bool) {
+ if self == Self::min_value() {
+ (Self::min_value(), true)
+ } else {
+ (-self, false)
+ }
}
}
- /// Raises self to the power of `exp`, using exponentiation by squaring.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let x: i32 = 2; // or any other integer type
- ///
- /// assert_eq!(x.pow(4), 16);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- #[rustc_inherit_overflow_checks]
- pub fn pow(self, mut exp: u32) -> Self {
- let mut base = self;
- let mut acc = 1;
+ doc_comment! {
+ concat!("Shifts self left by `rhs` bits.
+
+Returns a tuple of the shifted version of self along with a boolean indicating whether the shift
+value was larger than or equal to the number of bits. If the shift value is too large, then value is
+masked (N-1) where N is the number of bits, and this value is then used to perform the shift.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(0x1", stringify!($SelfT),".overflowing_shl(4), (0x10, false));
+assert_eq!(0x1i32.overflowing_shl(36), (0x10, true));",
+$EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
+ (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
+ }
+ }
+
+ doc_comment! {
+ concat!("Shifts self right by `rhs` bits.
+
+Returns a tuple of the shifted version of self along with a boolean indicating whether the shift
+value was larger than or equal to the number of bits. If the shift value is too large, then value is
+masked (N-1) where N is the number of bits, and this value is then used to perform the shift.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(0x10", stringify!($SelfT), ".overflowing_shr(4), (0x1, false));
+assert_eq!(0x10i32.overflowing_shr(36), (0x1, true));",
+$EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
+ (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
+ }
+ }
+
+ doc_comment! {
+ concat!("Computes the absolute value of `self`.
+
+Returns a tuple of the absolute version of self along with a boolean indicating whether an overflow
+happened. If self is the minimum value (e.g. ", stringify!($SelfT), "::MIN for values of type
+ ", stringify!($SelfT), "), then the minimum value will be returned again and true will be returned
+for an overflow happening.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(10", stringify!($SelfT), ".overflowing_abs(), (10, false));
+assert_eq!((-10", stringify!($SelfT), ").overflowing_abs(), (10, false));
+assert_eq!((", stringify!($SelfT), "::min_value()).overflowing_abs(), (", stringify!($SelfT),
+"::min_value(), true));",
+$EndFeature, "
+```"),
+ #[stable(feature = "no_panic_abs", since = "1.13.0")]
+ #[inline]
+ pub fn overflowing_abs(self) -> (Self, bool) {
+ if self.is_negative() {
+ self.overflowing_neg()
+ } else {
+ (self, false)
+ }
+ }
+ }
+
+ doc_comment! {
+ concat!("Raises self to the power of `exp`, using exponentiation by squaring.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let x: ", stringify!($SelfT), " = 2; // or any other integer type
+
+assert_eq!(x.pow(4), 16);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ #[rustc_inherit_overflow_checks]
+ pub fn pow(self, mut exp: u32) -> Self {
+ let mut base = self;
+ let mut acc = 1;
+
+ while exp > 1 {
+ if (exp & 1) == 1 {
+ acc = acc * base;
+ }
+ exp /= 2;
+ base = base * base;
+ }
+
+ // Deal with the final bit of the exponent separately, since
+ // squaring the base afterwards is not necessary and may cause a
+ // needless overflow.
+ if exp == 1 {
+ acc = acc * base;
+ }
+
+ acc
+ }
+ }
+
+ doc_comment! {
+ concat!("Computes the absolute value of `self`.
- while exp > 1 {
- if (exp & 1) == 1 {
- acc = acc * base;
+# Overflow behavior
+
+The absolute value of `", stringify!($SelfT), "::min_value()` cannot be represented as an
+`", stringify!($SelfT), "`, and attempting to calculate it will cause an overflow. This means that
+code in debug mode will trigger a panic on this case and optimized code will return `",
+stringify!($SelfT), "::min_value()` without a panic.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(10", stringify!($SelfT), ".abs(), 10);
+assert_eq!((-10", stringify!($SelfT), ").abs(), 10);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ #[rustc_inherit_overflow_checks]
+ pub fn abs(self) -> Self {
+ if self.is_negative() {
+ // Note that the #[inline] above means that the overflow
+ // semantics of this negation depend on the crate we're being
+ // inlined into.
+ -self
+ } else {
+ self
}
- exp /= 2;
- base = base * base;
}
+ }
- // Deal with the final bit of the exponent separately, since
- // squaring the base afterwards is not necessary and may cause a
- // needless overflow.
- if exp == 1 {
- acc = acc * base;
- }
+ doc_comment! {
+ concat!("Returns a number representing sign of `self`.
- acc
- }
+ - `0` if the number is zero
+ - `1` if the number is positive
+ - `-1` if the number is negative
- /// Computes the absolute value of `self`.
- ///
- /// # Overflow behavior
- ///
- /// The absolute value of `i32::min_value()` cannot be represented as an
- /// `i32`, and attempting to calculate it will cause an overflow. This
- /// means that code in debug mode will trigger a panic on this case and
- /// optimized code will return `i32::min_value()` without a panic.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(10i8.abs(), 10);
- /// assert_eq!((-10i8).abs(), 10);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- #[rustc_inherit_overflow_checks]
- pub fn abs(self) -> Self {
- if self.is_negative() {
- // Note that the #[inline] above means that the overflow
- // semantics of this negation depend on the crate we're being
- // inlined into.
- -self
- } else {
- self
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(10", stringify!($SelfT), ".signum(), 1);
+assert_eq!(0", stringify!($SelfT), ".signum(), 0);
+assert_eq!((-10", stringify!($SelfT), ").signum(), -1);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn signum(self) -> Self {
+ match self {
+ n if n > 0 => 1,
+ 0 => 0,
+ _ => -1,
+ }
}
}
- /// Returns a number representing sign of `self`.
- ///
- /// - `0` if the number is zero
- /// - `1` if the number is positive
- /// - `-1` if the number is negative
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(10i8.signum(), 1);
- /// assert_eq!(0i8.signum(), 0);
- /// assert_eq!((-10i8).signum(), -1);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn signum(self) -> Self {
- match self {
- n if n > 0 => 1,
- 0 => 0,
- _ => -1,
- }
+ doc_comment! {
+ concat!("Returns `true` if `self` is positive and `false` if the number is zero or
+negative.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert!(10", stringify!($SelfT), ".is_positive());
+assert!(!(-10", stringify!($SelfT), ").is_positive());",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn is_positive(self) -> bool { self > 0 }
}
- /// Returns `true` if `self` is positive and `false` if the number
- /// is zero or negative.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert!(10i8.is_positive());
- /// assert!(!(-10i8).is_positive());
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn is_positive(self) -> bool { self > 0 }
+ doc_comment! {
+ concat!("Returns `true` if `self` is negative and `false` if the number is zero or
+positive.
- /// Returns `true` if `self` is negative and `false` if the number
- /// is zero or positive.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert!((-10i8).is_negative());
- /// assert!(!10i8.is_negative());
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn is_negative(self) -> bool { self < 0 }
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert!((-10", stringify!($SelfT), ").is_negative());
+assert!(!10", stringify!($SelfT), ".is_negative());",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn is_negative(self) -> bool { self < 0 }
+ }
}
}
#[lang = "i8"]
impl i8 {
- int_impl! { i8, i8, u8, 8 }
+ int_impl! { i8, i8, u8, 8, -128, 127, "", "" }
}
#[lang = "i16"]
impl i16 {
- int_impl! { i16, i16, u16, 16 }
+ int_impl! { i16, i16, u16, 16, -32768, 32767, "", "" }
}
#[lang = "i32"]
impl i32 {
- int_impl! { i32, i32, u32, 32 }
+ int_impl! { i32, i32, u32, 32, -2147483648, 2147483647, "", "" }
}
#[lang = "i64"]
impl i64 {
- int_impl! { i64, i64, u64, 64 }
+ int_impl! { i64, i64, u64, 64, -9223372036854775808, 9223372036854775807, "", "" }
}
#[lang = "i128"]
impl i128 {
- int_impl! { i128, i128, u128, 128 }
+ int_impl! { i128, i128, u128, 128, -170141183460469231731687303715884105728,
+ 170141183460469231731687303715884105727, "#![feature(i128_type)]
+#![feature(i128)]
+# fn main() {
+", "
+# }" }
}
#[cfg(target_pointer_width = "16")]
#[lang = "isize"]
impl isize {
- int_impl! { isize, i16, u16, 16 }
+ int_impl! { isize, i16, u16, 16, -32768, 32767, "", "" }
}
#[cfg(target_pointer_width = "32")]
#[lang = "isize"]
impl isize {
- int_impl! { isize, i32, u32, 32 }
+ int_impl! { isize, i32, u32, 32, -2147483648, 2147483647, "", "" }
}
#[cfg(target_pointer_width = "64")]
#[lang = "isize"]
impl isize {
- int_impl! { isize, i64, u64, 64 }
+ int_impl! { isize, i64, u64, 64, -9223372036854775808, 9223372036854775807, "", "" }
}
// `Int` + `UnsignedInt` implemented for unsigned integers
macro_rules! uint_impl {
- ($SelfT:ty, $ActualT:ty, $BITS:expr) => {
- /// Returns the smallest value that can be represented by this integer type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(u8::min_value(), 0);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub const fn min_value() -> Self { 0 }
+ ($SelfT:ty, $ActualT:ty, $BITS:expr, $MaxV:expr, $Feature:expr, $EndFeature:expr) => {
+ doc_comment! {
+ concat!("Returns the smallest value that can be represented by this integer type.
- /// Returns the largest value that can be represented by this integer type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(u8::max_value(), 255);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub const fn max_value() -> Self { !0 }
+# Examples
- /// Converts a string slice in a given base to an integer.
- ///
- /// The string is expected to be an optional `+` sign
- /// followed by digits.
- /// Leading and trailing whitespace represent an error.
- /// Digits are a subset of these characters, depending on `radix`:
- ///
- /// * `0-9`
- /// * `a-z`
- /// * `A-Z`
- ///
- /// # Panics
- ///
- /// This function panics if `radix` is not in the range from 2 to 36.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(u32::from_str_radix("A", 16), Ok(10));
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
- from_str_radix(src, radix)
- }
+Basic usage:
- /// Returns the number of ones in the binary representation of `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0b01001100u8;
- ///
- /// assert_eq!(n.count_ones(), 3);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn count_ones(self) -> u32 {
- unsafe { intrinsics::ctpop(self as $ActualT) as u32 }
+```
+", $Feature, "assert_eq!(", stringify!($SelfT), "::min_value(), 0);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub const fn min_value() -> Self { 0 }
}
- /// Returns the number of zeros in the binary representation of `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0b01001100u8;
- ///
- /// assert_eq!(n.count_zeros(), 5);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn count_zeros(self) -> u32 {
- (!self).count_ones()
- }
+ doc_comment! {
+ concat!("Returns the largest value that can be represented by this integer type.
- /// Returns the number of leading zeros in the binary representation
- /// of `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0b0101000u16;
- ///
- /// assert_eq!(n.leading_zeros(), 10);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn leading_zeros(self) -> u32 {
- unsafe { intrinsics::ctlz(self as $ActualT) as u32 }
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(", stringify!($SelfT), "::max_value(), ",
+stringify!($MaxV), ");", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub const fn max_value() -> Self { !0 }
}
- /// Returns the number of trailing zeros in the binary representation
- /// of `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0b0101000u16;
- ///
- /// assert_eq!(n.trailing_zeros(), 3);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn trailing_zeros(self) -> u32 {
- // As of LLVM 3.6 the codegen for the zero-safe cttz8 intrinsic
- // emits two conditional moves on x86_64. By promoting the value to
- // u16 and setting bit 8, we get better code without any conditional
- // operations.
- // FIXME: There's a LLVM patch (http://reviews.llvm.org/D9284)
- // pending, remove this workaround once LLVM generates better code
- // for cttz8.
- unsafe {
- if $BITS == 8 {
- intrinsics::cttz(self as u16 | 0x100) as u32
- } else {
- intrinsics::cttz(self) as u32
- }
+ doc_comment! {
+ concat!("Converts a string slice in a given base to an integer.
+
+The string is expected to be an optional `+` sign
+followed by digits.
+Leading and trailing whitespace represent an error.
+Digits are a subset of these characters, depending on `radix`:
+
+* `0-9`
+* `a-z`
+* `A-Z`
+
+# Panics
+
+This function panics if `radix` is not in the range from 2 to 36.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(", stringify!($SelfT), "::from_str_radix(\"A\", 16), Ok(10));",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
+ from_str_radix(src, radix)
}
}
- /// Shifts the bits to the left by a specified amount, `n`,
- /// wrapping the truncated bits to the end of the resulting integer.
- ///
- /// Please note this isn't the same operation as `<<`!
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0x0123456789ABCDEFu64;
- /// let m = 0x3456789ABCDEF012u64;
- ///
- /// assert_eq!(n.rotate_left(12), m);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn rotate_left(self, n: u32) -> Self {
- // Protect against undefined behaviour for over-long bit shifts
- let n = n % $BITS;
- (self << n) | (self >> (($BITS - n) % $BITS))
+ doc_comment! {
+ concat!("Returns the number of ones in the binary representation of `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0b01001100", stringify!($SelfT), ";
+
+assert_eq!(n.count_ones(), 3);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn count_ones(self) -> u32 {
+ unsafe { intrinsics::ctpop(self as $ActualT) as u32 }
+ }
}
- /// Shifts the bits to the right by a specified amount, `n`,
- /// wrapping the truncated bits to the beginning of the resulting
- /// integer.
- ///
- /// Please note this isn't the same operation as `>>`!
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0x0123456789ABCDEFu64;
- /// let m = 0xDEF0123456789ABCu64;
- ///
- /// assert_eq!(n.rotate_right(12), m);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn rotate_right(self, n: u32) -> Self {
- // Protect against undefined behaviour for over-long bit shifts
- let n = n % $BITS;
- (self >> n) | (self << (($BITS - n) % $BITS))
+ doc_comment! {
+ concat!("Returns the number of zeros in the binary representation of `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(", stringify!($SelfT), "::max_value().count_zeros(), 0);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn count_zeros(self) -> u32 {
+ (!self).count_ones()
+ }
}
- /// Reverses the byte order of the integer.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n: u16 = 0b0000000_01010101;
- /// assert_eq!(n, 85);
- ///
- /// let m = n.swap_bytes();
- ///
- /// assert_eq!(m, 0b01010101_00000000);
- /// assert_eq!(m, 21760);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn swap_bytes(self) -> Self {
- unsafe { intrinsics::bswap(self as $ActualT) as Self }
+ doc_comment! {
+ concat!("Returns the number of leading zeros in the binary representation of `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = ", stringify!($SelfT), "::max_value() >> 2;
+
+assert_eq!(n.leading_zeros(), 2);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn leading_zeros(self) -> u32 {
+ unsafe { intrinsics::ctlz(self as $ActualT) as u32 }
+ }
}
- /// Converts an integer from big endian to the target's endianness.
- ///
- /// On big endian this is a no-op. On little endian the bytes are
- /// swapped.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// let n = 0x0123456789ABCDEFu64;
- ///
- /// if cfg!(target_endian = "big") {
- /// assert_eq!(u64::from_be(n), n)
- /// } else {
- /// assert_eq!(u64::from_be(n), n.swap_bytes())
- /// }
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn from_be(x: Self) -> Self {
- if cfg!(target_endian = "big") { x } else { x.swap_bytes() }
+ doc_comment! {
+ concat!("Returns the number of trailing zeros in the binary representation
+of `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0b0101000", stringify!($SelfT), ";
+
+assert_eq!(n.trailing_zeros(), 3);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn trailing_zeros(self) -> u32 {
+ // As of LLVM 3.6 the codegen for the zero-safe cttz8 intrinsic
+ // emits two conditional moves on x86_64. By promoting the value to
+ // u16 and setting bit 8, we get better code without any conditional
+ // operations.
+ // FIXME: There's a LLVM patch (http://reviews.llvm.org/D9284)
+ // pending, remove this workaround once LLVM generates better code
+ // for cttz8.
+ unsafe {
+ if $BITS == 8 {
+ intrinsics::cttz(self as u16 | 0x100) as u32
+ } else {
+ intrinsics::cttz(self) as u32
+ }
+ }
+ }
}
- /// Converts an integer from little endian to the target's endianness.
+ /// Shifts the bits to the left by a specified amount, `n`,
+ /// wrapping the truncated bits to the end of the resulting integer.
///
- /// On little endian this is a no-op. On big endian the bytes are
- /// swapped.
+ /// Please note this isn't the same operation as `<<`!
///
/// # Examples
///
/// Basic usage:
///
+ /// Please note that this example is shared between integer types.
+ /// Which explains why `u64` is used here.
+ ///
/// ```
/// let n = 0x0123456789ABCDEFu64;
+ /// let m = 0x3456789ABCDEF012u64;
///
- /// if cfg!(target_endian = "little") {
- /// assert_eq!(u64::from_le(n), n)
- /// } else {
- /// assert_eq!(u64::from_le(n), n.swap_bytes())
- /// }
+ /// assert_eq!(n.rotate_left(12), m);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn from_le(x: Self) -> Self {
- if cfg!(target_endian = "little") { x } else { x.swap_bytes() }
+ pub fn rotate_left(self, n: u32) -> Self {
+ // Protect against undefined behaviour for over-long bit shifts
+ let n = n % $BITS;
+ (self << n) | (self >> (($BITS - n) % $BITS))
}
- /// Converts `self` to big endian from the target's endianness.
+ /// Shifts the bits to the right by a specified amount, `n`,
+ /// wrapping the truncated bits to the beginning of the resulting
+ /// integer.
///
- /// On big endian this is a no-op. On little endian the bytes are
- /// swapped.
+ /// Please note this isn't the same operation as `>>`!
///
/// # Examples
///
/// Basic usage:
///
+ /// Please note that this example is shared between integer types.
+ /// Which explains why `u64` is used here.
+ ///
/// ```
/// let n = 0x0123456789ABCDEFu64;
+ /// let m = 0xDEF0123456789ABCu64;
///
- /// if cfg!(target_endian = "big") {
- /// assert_eq!(n.to_be(), n)
- /// } else {
- /// assert_eq!(n.to_be(), n.swap_bytes())
- /// }
+ /// assert_eq!(n.rotate_right(12), m);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn to_be(self) -> Self { // or not to be?
- if cfg!(target_endian = "big") { self } else { self.swap_bytes() }
+ pub fn rotate_right(self, n: u32) -> Self {
+ // Protect against undefined behaviour for over-long bit shifts
+ let n = n % $BITS;
+ (self >> n) | (self << (($BITS - n) % $BITS))
}
- /// Converts `self` to little endian from the target's endianness.
- ///
- /// On little endian this is a no-op. On big endian the bytes are
- /// swapped.
+ /// Reverses the byte order of the integer.
///
/// # Examples
///
/// Basic usage:
///
- /// ```
- /// let n = 0x0123456789ABCDEFu64;
+ /// Please note that this example is shared between integer types.
+ /// Which explains why `u16` is used here.
///
- /// if cfg!(target_endian = "little") {
- /// assert_eq!(n.to_le(), n)
- /// } else {
- /// assert_eq!(n.to_le(), n.swap_bytes())
- /// }
/// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn to_le(self) -> Self {
- if cfg!(target_endian = "little") { self } else { self.swap_bytes() }
- }
-
- /// Checked integer addition. Computes `self + rhs`, returning `None`
- /// if overflow occurred.
- ///
- /// # Examples
+ /// let n: u16 = 0b0000000_01010101;
+ /// assert_eq!(n, 85);
///
- /// Basic usage:
+ /// let m = n.swap_bytes();
///
- /// ```
- /// assert_eq!(5u16.checked_add(65530), Some(65535));
- /// assert_eq!(6u16.checked_add(65530), None);
+ /// assert_eq!(m, 0b01010101_00000000);
+ /// assert_eq!(m, 21760);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn checked_add(self, rhs: Self) -> Option<Self> {
- let (a, b) = self.overflowing_add(rhs);
- if b {None} else {Some(a)}
+ pub fn swap_bytes(self) -> Self {
+ unsafe { intrinsics::bswap(self as $ActualT) as Self }
}
- /// Checked integer subtraction. Computes `self - rhs`, returning
- /// `None` if overflow occurred.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(1u8.checked_sub(1), Some(0));
- /// assert_eq!(0u8.checked_sub(1), None);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn checked_sub(self, rhs: Self) -> Option<Self> {
- let (a, b) = self.overflowing_sub(rhs);
- if b {None} else {Some(a)}
+ doc_comment! {
+ concat!("Converts an integer from big endian to the target's endianness.
+
+On big endian this is a no-op. On little endian the bytes are
+swapped.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0x1A", stringify!($SelfT), ";
+
+if cfg!(target_endian = \"big\") {
+ assert_eq!(", stringify!($SelfT), "::from_be(n), n)
+} else {
+ assert_eq!(", stringify!($SelfT), "::from_be(n), n.swap_bytes())
+}", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn from_be(x: Self) -> Self {
+ if cfg!(target_endian = "big") { x } else { x.swap_bytes() }
+ }
}
- /// Checked integer multiplication. Computes `self * rhs`, returning
- /// `None` if overflow occurred.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(5u8.checked_mul(51), Some(255));
- /// assert_eq!(5u8.checked_mul(52), None);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn checked_mul(self, rhs: Self) -> Option<Self> {
- let (a, b) = self.overflowing_mul(rhs);
- if b {None} else {Some(a)}
+ doc_comment! {
+ concat!("Converts an integer from little endian to the target's endianness.
+
+On little endian this is a no-op. On big endian the bytes are
+swapped.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0x1A", stringify!($SelfT), ";
+
+if cfg!(target_endian = \"little\") {
+ assert_eq!(", stringify!($SelfT), "::from_le(n), n)
+} else {
+ assert_eq!(", stringify!($SelfT), "::from_le(n), n.swap_bytes())
+}", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn from_le(x: Self) -> Self {
+ if cfg!(target_endian = "little") { x } else { x.swap_bytes() }
+ }
}
- /// Checked integer division. Computes `self / rhs`, returning `None`
- /// if `rhs == 0`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(128u8.checked_div(2), Some(64));
- /// assert_eq!(1u8.checked_div(0), None);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn checked_div(self, rhs: Self) -> Option<Self> {
- match rhs {
- 0 => None,
- rhs => Some(unsafe { intrinsics::unchecked_div(self, rhs) }),
+ doc_comment! {
+ concat!("Converts `self` to big endian from the target's endianness.
+
+On big endian this is a no-op. On little endian the bytes are
+swapped.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0x1A", stringify!($SelfT), ";
+
+if cfg!(target_endian = \"big\") {
+ assert_eq!(n.to_be(), n)
+} else {
+ assert_eq!(n.to_be(), n.swap_bytes())
+}", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn to_be(self) -> Self { // or not to be?
+ if cfg!(target_endian = "big") { self } else { self.swap_bytes() }
}
}
- /// Checked integer remainder. Computes `self % rhs`, returning `None`
- /// if `rhs == 0`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(5u32.checked_rem(2), Some(1));
- /// assert_eq!(5u32.checked_rem(0), None);
- /// ```
- #[stable(feature = "wrapping", since = "1.7.0")]
- #[inline]
- pub fn checked_rem(self, rhs: Self) -> Option<Self> {
- if rhs == 0 {
- None
- } else {
- Some(unsafe { intrinsics::unchecked_rem(self, rhs) })
+ doc_comment! {
+ concat!("Converts `self` to little endian from the target's endianness.
+
+On little endian this is a no-op. On big endian the bytes are
+swapped.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "let n = 0x1A", stringify!($SelfT), ";
+
+if cfg!(target_endian = \"little\") {
+ assert_eq!(n.to_le(), n)
+} else {
+ assert_eq!(n.to_le(), n.swap_bytes())
+}", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn to_le(self) -> Self {
+ if cfg!(target_endian = "little") { self } else { self.swap_bytes() }
}
}
- /// Checked negation. Computes `-self`, returning `None` unless `self ==
- /// 0`.
- ///
- /// Note that negating any positive integer will overflow.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(0u32.checked_neg(), Some(0));
- /// assert_eq!(1u32.checked_neg(), None);
- /// ```
- #[stable(feature = "wrapping", since = "1.7.0")]
- #[inline]
- pub fn checked_neg(self) -> Option<Self> {
- let (a, b) = self.overflowing_neg();
- if b {None} else {Some(a)}
+ doc_comment! {
+ concat!("Checked integer addition. Computes `self + rhs`, returning `None`
+if overflow occurred.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!((", stringify!($SelfT), "::max_value() - 2).checked_add(1), ",
+"Some(", stringify!($SelfT), "::max_value() - 1));
+assert_eq!((", stringify!($SelfT), "::max_value() - 2).checked_add(3),None);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn checked_add(self, rhs: Self) -> Option<Self> {
+ let (a, b) = self.overflowing_add(rhs);
+ if b {None} else {Some(a)}
+ }
}
- /// Checked shift left. Computes `self << rhs`, returning `None`
- /// if `rhs` is larger than or equal to the number of bits in `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(0x10u32.checked_shl(4), Some(0x100));
- /// assert_eq!(0x10u32.checked_shl(33), None);
- /// ```
- #[stable(feature = "wrapping", since = "1.7.0")]
- #[inline]
- pub fn checked_shl(self, rhs: u32) -> Option<Self> {
- let (a, b) = self.overflowing_shl(rhs);
- if b {None} else {Some(a)}
+ doc_comment! {
+ concat!("Checked integer subtraction. Computes `self - rhs`, returning
+`None` if overflow occurred.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(1", stringify!($SelfT), ".checked_sub(1), Some(0));
+assert_eq!(0", stringify!($SelfT), ".checked_sub(1), None);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn checked_sub(self, rhs: Self) -> Option<Self> {
+ let (a, b) = self.overflowing_sub(rhs);
+ if b {None} else {Some(a)}
+ }
}
- /// Checked shift right. Computes `self >> rhs`, returning `None`
- /// if `rhs` is larger than or equal to the number of bits in `self`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(0x10u32.checked_shr(4), Some(0x1));
- /// assert_eq!(0x10u32.checked_shr(33), None);
- /// ```
- #[stable(feature = "wrapping", since = "1.7.0")]
- #[inline]
- pub fn checked_shr(self, rhs: u32) -> Option<Self> {
- let (a, b) = self.overflowing_shr(rhs);
- if b {None} else {Some(a)}
+ doc_comment! {
+ concat!("Checked integer multiplication. Computes `self * rhs`, returning
+`None` if overflow occurred.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(5", stringify!($SelfT), ".checked_mul(1), Some(5));
+assert_eq!(", stringify!($SelfT), "::max_value().checked_mul(2), None);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn checked_mul(self, rhs: Self) -> Option<Self> {
+ let (a, b) = self.overflowing_mul(rhs);
+ if b {None} else {Some(a)}
+ }
}
- /// Saturating integer addition. Computes `self + rhs`, saturating at
- /// the numeric bounds instead of overflowing.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100u8.saturating_add(1), 101);
- /// assert_eq!(200u8.saturating_add(127), 255);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn saturating_add(self, rhs: Self) -> Self {
- match self.checked_add(rhs) {
- Some(x) => x,
- None => Self::max_value(),
+ doc_comment! {
+ concat!("Checked integer division. Computes `self / rhs`, returning `None`
+if `rhs == 0`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(128", stringify!($SelfT), ".checked_div(2), Some(64));
+assert_eq!(1", stringify!($SelfT), ".checked_div(0), None);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn checked_div(self, rhs: Self) -> Option<Self> {
+ match rhs {
+ 0 => None,
+ rhs => Some(unsafe { intrinsics::unchecked_div(self, rhs) }),
+ }
}
}
- /// Saturating integer subtraction. Computes `self - rhs`, saturating
- /// at the numeric bounds instead of overflowing.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100u8.saturating_sub(27), 73);
- /// assert_eq!(13u8.saturating_sub(127), 0);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn saturating_sub(self, rhs: Self) -> Self {
- match self.checked_sub(rhs) {
- Some(x) => x,
- None => Self::min_value(),
+ doc_comment! {
+ concat!("Checked integer remainder. Computes `self % rhs`, returning `None`
+if `rhs == 0`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(5", stringify!($SelfT), ".checked_rem(2), Some(1));
+assert_eq!(5", stringify!($SelfT), ".checked_rem(0), None);", $EndFeature, "
+```"),
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ #[inline]
+ pub fn checked_rem(self, rhs: Self) -> Option<Self> {
+ if rhs == 0 {
+ None
+ } else {
+ Some(unsafe { intrinsics::unchecked_rem(self, rhs) })
+ }
}
}
- /// Saturating integer multiplication. Computes `self * rhs`,
- /// saturating at the numeric bounds instead of overflowing.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// use std::u32;
- ///
- /// assert_eq!(100u32.saturating_mul(127), 12700);
- /// assert_eq!((1u32 << 23).saturating_mul(1 << 23), u32::MAX);
- /// ```
- #[stable(feature = "wrapping", since = "1.7.0")]
- #[inline]
- pub fn saturating_mul(self, rhs: Self) -> Self {
- self.checked_mul(rhs).unwrap_or(Self::max_value())
+ doc_comment! {
+ concat!("Checked negation. Computes `-self`, returning `None` unless `self ==
+0`.
+
+Note that negating any positive integer will overflow.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(0", stringify!($SelfT), ".checked_neg(), Some(0));
+assert_eq!(1", stringify!($SelfT), ".checked_neg(), None);", $EndFeature, "
+```"),
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ #[inline]
+ pub fn checked_neg(self) -> Option<Self> {
+ let (a, b) = self.overflowing_neg();
+ if b {None} else {Some(a)}
+ }
}
- /// Wrapping (modular) addition. Computes `self + rhs`,
- /// wrapping around at the boundary of the type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(200u8.wrapping_add(55), 255);
- /// assert_eq!(200u8.wrapping_add(155), 99);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn wrapping_add(self, rhs: Self) -> Self {
- unsafe {
- intrinsics::overflowing_add(self, rhs)
+ doc_comment! {
+ concat!("Checked shift left. Computes `self << rhs`, returning `None`
+if `rhs` is larger than or equal to the number of bits in `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(0x1", stringify!($SelfT), ".checked_shl(4), Some(0x10));
+assert_eq!(0x10", stringify!($SelfT), ".checked_shl(129), None);", $EndFeature, "
+```"),
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ #[inline]
+ pub fn checked_shl(self, rhs: u32) -> Option<Self> {
+ let (a, b) = self.overflowing_shl(rhs);
+ if b {None} else {Some(a)}
}
}
- /// Wrapping (modular) subtraction. Computes `self - rhs`,
- /// wrapping around at the boundary of the type.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100u8.wrapping_sub(100), 0);
- /// assert_eq!(100u8.wrapping_sub(155), 201);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn wrapping_sub(self, rhs: Self) -> Self {
- unsafe {
- intrinsics::overflowing_sub(self, rhs)
+ doc_comment! {
+ concat!("Checked shift right. Computes `self >> rhs`, returning `None`
+if `rhs` is larger than or equal to the number of bits in `self`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(0x10", stringify!($SelfT), ".checked_shr(4), Some(0x1));
+assert_eq!(0x10", stringify!($SelfT), ".checked_shr(129), None);", $EndFeature, "
+```"),
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ #[inline]
+ pub fn checked_shr(self, rhs: u32) -> Option<Self> {
+ let (a, b) = self.overflowing_shr(rhs);
+ if b {None} else {Some(a)}
+ }
+ }
+
+ doc_comment! {
+ concat!("Saturating integer addition. Computes `self + rhs`, saturating at
+the numeric bounds instead of overflowing.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
+assert_eq!(200u8.saturating_add(127), 255);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn saturating_add(self, rhs: Self) -> Self {
+ match self.checked_add(rhs) {
+ Some(x) => x,
+ None => Self::max_value(),
+ }
+ }
+ }
+
+ doc_comment! {
+ concat!("Saturating integer subtraction. Computes `self - rhs`, saturating
+at the numeric bounds instead of overflowing.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_sub(27), 73);
+assert_eq!(13", stringify!($SelfT), ".saturating_sub(127), 0);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn saturating_sub(self, rhs: Self) -> Self {
+ match self.checked_sub(rhs) {
+ Some(x) => x,
+ None => Self::min_value(),
+ }
+ }
+ }
+
+ doc_comment! {
+ concat!("Saturating integer multiplication. Computes `self * rhs`,
+saturating at the numeric bounds instead of overflowing.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(2", stringify!($SelfT), ".saturating_mul(10), 20);
+assert_eq!((", stringify!($SelfT), "::MAX).saturating_mul(10), ", stringify!($SelfT),
+"::MAX);", $EndFeature, "
+```"),
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ #[inline]
+ pub fn saturating_mul(self, rhs: Self) -> Self {
+ self.checked_mul(rhs).unwrap_or(Self::max_value())
+ }
+ }
+
+ doc_comment! {
+ concat!("Wrapping (modular) addition. Computes `self + rhs`,
+wrapping around at the boundary of the type.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(200", stringify!($SelfT), ".wrapping_add(55), 255);
+assert_eq!(200", stringify!($SelfT), ".wrapping_add(", stringify!($SelfT), "::max_value()), 199);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_add(self, rhs: Self) -> Self {
+ unsafe {
+ intrinsics::overflowing_add(self, rhs)
+ }
+ }
+ }
+
+ doc_comment! {
+ concat!("Wrapping (modular) subtraction. Computes `self - rhs`,
+wrapping around at the boundary of the type.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_sub(100), 0);
+assert_eq!(100", stringify!($SelfT), ".wrapping_sub(", stringify!($SelfT), "::max_value()), 101);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_sub(self, rhs: Self) -> Self {
+ unsafe {
+ intrinsics::overflowing_sub(self, rhs)
+ }
}
}
///
/// Basic usage:
///
+ /// Please note that this example is shared between integer types.
+ /// Which explains why `u8` is used here.
+ ///
/// ```
/// assert_eq!(10u8.wrapping_mul(12), 120);
/// assert_eq!(25u8.wrapping_mul(12), 44);
}
}
- /// Wrapping (modular) division. Computes `self / rhs`.
- /// Wrapped division on unsigned types is just normal division.
- /// There's no way wrapping could ever happen.
- /// This function exists, so that all operations
- /// are accounted for in the wrapping operations.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100u8.wrapping_div(10), 10);
- /// ```
- #[stable(feature = "num_wrapping", since = "1.2.0")]
- #[inline]
- pub fn wrapping_div(self, rhs: Self) -> Self {
- self / rhs
+ doc_comment! {
+ concat!("Wrapping (modular) division. Computes `self / rhs`.
+Wrapped division on unsigned types is just normal division.
+There's no way wrapping could ever happen.
+This function exists, so that all operations
+are accounted for in the wrapping operations.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_div(10), 10);", $EndFeature, "
+```"),
+ #[stable(feature = "num_wrapping", since = "1.2.0")]
+ #[inline]
+ pub fn wrapping_div(self, rhs: Self) -> Self {
+ self / rhs
+ }
}
- /// Wrapping (modular) remainder. Computes `self % rhs`.
- /// Wrapped remainder calculation on unsigned types is
- /// just the regular remainder calculation.
- /// There's no way wrapping could ever happen.
- /// This function exists, so that all operations
- /// are accounted for in the wrapping operations.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(100u8.wrapping_rem(10), 0);
- /// ```
- #[stable(feature = "num_wrapping", since = "1.2.0")]
- #[inline]
- pub fn wrapping_rem(self, rhs: Self) -> Self {
- self % rhs
+ doc_comment! {
+ concat!("Wrapping (modular) remainder. Computes `self % rhs`.
+Wrapped remainder calculation on unsigned types is
+just the regular remainder calculation.
+There's no way wrapping could ever happen.
+This function exists, so that all operations
+are accounted for in the wrapping operations.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_rem(10), 0);", $EndFeature, "
+```"),
+ #[stable(feature = "num_wrapping", since = "1.2.0")]
+ #[inline]
+ pub fn wrapping_rem(self, rhs: Self) -> Self {
+ self % rhs
+ }
}
/// Wrapping (modular) negation. Computes `-self`,
///
/// Basic usage:
///
+ /// Please note that this example is shared between integer types.
+ /// Which explains why `i8` is used here.
+ ///
/// ```
- /// assert_eq!(100u8.wrapping_neg(), 156);
- /// assert_eq!(0u8.wrapping_neg(), 0);
- /// assert_eq!(180u8.wrapping_neg(), 76);
- /// assert_eq!(180u8.wrapping_neg(), (127 + 1) - (180u8 - (127 + 1)));
+ /// assert_eq!(100i8.wrapping_neg(), -100);
+ /// assert_eq!((-128i8).wrapping_neg(), -128);
/// ```
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[inline]
self.overflowing_neg().0
}
- /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
- /// where `mask` removes any high-order bits of `rhs` that
- /// would cause the shift to exceed the bitwidth of the type.
- ///
- /// Note that this is *not* the same as a rotate-left; the
- /// RHS of a wrapping shift-left is restricted to the range
- /// of the type, rather than the bits shifted out of the LHS
- /// being returned to the other end. The primitive integer
- /// types all implement a `rotate_left` function, which may
- /// be what you want instead.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(1u8.wrapping_shl(7), 128);
- /// assert_eq!(1u8.wrapping_shl(8), 1);
- /// ```
- #[stable(feature = "num_wrapping", since = "1.2.0")]
- #[inline]
- pub fn wrapping_shl(self, rhs: u32) -> Self {
- unsafe {
- intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
+ doc_comment! {
+ concat!("Panic-free bitwise shift-left; yields `self << mask(rhs)`,
+where `mask` removes any high-order bits of `rhs` that
+would cause the shift to exceed the bitwidth of the type.
+
+Note that this is *not* the same as a rotate-left; the
+RHS of a wrapping shift-left is restricted to the range
+of the type, rather than the bits shifted out of the LHS
+being returned to the other end. The primitive integer
+types all implement a `rotate_left` function, which may
+be what you want instead.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(1", stringify!($SelfT), ".wrapping_shl(7), 128);
+assert_eq!(1", stringify!($SelfT), ".wrapping_shl(128), 1);", $EndFeature, "
+```"),
+ #[stable(feature = "num_wrapping", since = "1.2.0")]
+ #[inline]
+ pub fn wrapping_shl(self, rhs: u32) -> Self {
+ unsafe {
+ intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
+ }
}
}
- /// Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
- /// where `mask` removes any high-order bits of `rhs` that
- /// would cause the shift to exceed the bitwidth of the type.
- ///
- /// Note that this is *not* the same as a rotate-right; the
- /// RHS of a wrapping shift-right is restricted to the range
- /// of the type, rather than the bits shifted out of the LHS
- /// being returned to the other end. The primitive integer
- /// types all implement a `rotate_right` function, which may
- /// be what you want instead.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(128u8.wrapping_shr(7), 1);
- /// assert_eq!(128u8.wrapping_shr(8), 128);
- /// ```
- #[stable(feature = "num_wrapping", since = "1.2.0")]
- #[inline]
- pub fn wrapping_shr(self, rhs: u32) -> Self {
- unsafe {
- intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
+ doc_comment! {
+ concat!("Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
+where `mask` removes any high-order bits of `rhs` that
+would cause the shift to exceed the bitwidth of the type.
+
+Note that this is *not* the same as a rotate-right; the
+RHS of a wrapping shift-right is restricted to the range
+of the type, rather than the bits shifted out of the LHS
+being returned to the other end. The primitive integer
+types all implement a `rotate_right` function, which may
+be what you want instead.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(128", stringify!($SelfT), ".wrapping_shr(7), 1);
+assert_eq!(128", stringify!($SelfT), ".wrapping_shr(128), 128);", $EndFeature, "
+```"),
+ #[stable(feature = "num_wrapping", since = "1.2.0")]
+ #[inline]
+ pub fn wrapping_shr(self, rhs: u32) -> Self {
+ unsafe {
+ intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
+ }
}
}
- /// Calculates `self` + `rhs`
- ///
- /// Returns a tuple of the addition along with a boolean indicating
- /// whether an arithmetic overflow would occur. If an overflow would
- /// have occurred then the wrapped value is returned.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// use std::u32;
- ///
- /// assert_eq!(5u32.overflowing_add(2), (7, false));
- /// assert_eq!(u32::MAX.overflowing_add(1), (0, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_add(self, rhs: Self) -> (Self, bool) {
- let (a, b) = unsafe {
- intrinsics::add_with_overflow(self as $ActualT,
- rhs as $ActualT)
- };
- (a as Self, b)
+ doc_comment! {
+ concat!("Calculates `self` + `rhs`
+
+Returns a tuple of the addition along with a boolean indicating
+whether an arithmetic overflow would occur. If an overflow would
+have occurred then the wrapped value is returned.
+
+# Examples
+
+Basic usage
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(5", stringify!($SelfT), ".overflowing_add(2), (7, false));
+assert_eq!(", stringify!($SelfT), "::MAX.overflowing_add(1), (0, true));", $EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_add(self, rhs: Self) -> (Self, bool) {
+ let (a, b) = unsafe {
+ intrinsics::add_with_overflow(self as $ActualT,
+ rhs as $ActualT)
+ };
+ (a as Self, b)
+ }
}
- /// Calculates `self` - `rhs`
- ///
- /// Returns a tuple of the subtraction along with a boolean indicating
- /// whether an arithmetic overflow would occur. If an overflow would
- /// have occurred then the wrapped value is returned.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// use std::u32;
- ///
- /// assert_eq!(5u32.overflowing_sub(2), (3, false));
- /// assert_eq!(0u32.overflowing_sub(1), (u32::MAX, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
- let (a, b) = unsafe {
- intrinsics::sub_with_overflow(self as $ActualT,
- rhs as $ActualT)
- };
- (a as Self, b)
+ doc_comment! {
+ concat!("Calculates `self` - `rhs`
+
+Returns a tuple of the subtraction along with a boolean indicating
+whether an arithmetic overflow would occur. If an overflow would
+have occurred then the wrapped value is returned.
+
+# Examples
+
+Basic usage
+
+```
+", $Feature, "use std::", stringify!($SelfT), ";
+
+assert_eq!(5", stringify!($SelfT), ".overflowing_sub(2), (3, false));
+assert_eq!(0", stringify!($SelfT), ".overflowing_sub(1), (", stringify!($SelfT), "::MAX, true));",
+$EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
+ let (a, b) = unsafe {
+ intrinsics::sub_with_overflow(self as $ActualT,
+ rhs as $ActualT)
+ };
+ (a as Self, b)
+ }
}
/// Calculates the multiplication of `self` and `rhs`.
///
/// # Examples
///
- /// Basic usage
+ /// Basic usage:
+ ///
+ /// Please note that this example is shared between integer types.
+ /// Which explains why `u32` is used here.
///
/// ```
/// assert_eq!(5u32.overflowing_mul(2), (10, false));
(a as Self, b)
}
- /// Calculates the divisor when `self` is divided by `rhs`.
- ///
- /// Returns a tuple of the divisor along with a boolean indicating
- /// whether an arithmetic overflow would occur. Note that for unsigned
- /// integers overflow never occurs, so the second value is always
- /// `false`.
- ///
- /// # Panics
- ///
- /// This function will panic if `rhs` is 0.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// assert_eq!(5u32.overflowing_div(2), (2, false));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_div(self, rhs: Self) -> (Self, bool) {
- (self / rhs, false)
+ doc_comment! {
+ concat!("Calculates the divisor when `self` is divided by `rhs`.
+
+Returns a tuple of the divisor along with a boolean indicating
+whether an arithmetic overflow would occur. Note that for unsigned
+integers overflow never occurs, so the second value is always
+`false`.
+
+# Panics
+
+This function will panic if `rhs` is 0.
+
+# Examples
+
+Basic usage
+
+```
+", $Feature, "assert_eq!(5", stringify!($SelfT), ".overflowing_div(2), (2, false));", $EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_div(self, rhs: Self) -> (Self, bool) {
+ (self / rhs, false)
+ }
}
- /// Calculates the remainder when `self` is divided by `rhs`.
- ///
- /// Returns a tuple of the remainder after dividing along with a boolean
- /// indicating whether an arithmetic overflow would occur. Note that for
- /// unsigned integers overflow never occurs, so the second value is
- /// always `false`.
- ///
- /// # Panics
- ///
- /// This function will panic if `rhs` is 0.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// assert_eq!(5u32.overflowing_rem(2), (1, false));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
- (self % rhs, false)
+ doc_comment! {
+ concat!("Calculates the remainder when `self` is divided by `rhs`.
+
+Returns a tuple of the remainder after dividing along with a boolean
+indicating whether an arithmetic overflow would occur. Note that for
+unsigned integers overflow never occurs, so the second value is
+always `false`.
+
+# Panics
+
+This function will panic if `rhs` is 0.
+
+# Examples
+
+Basic usage
+
+```
+", $Feature, "assert_eq!(5", stringify!($SelfT), ".overflowing_rem(2), (1, false));", $EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
+ (self % rhs, false)
+ }
}
- /// Negates self in an overflowing fashion.
- ///
- /// Returns `!self + 1` using wrapping operations to return the value
- /// that represents the negation of this unsigned value. Note that for
- /// positive unsigned values overflow always occurs, but negating 0 does
- /// not overflow.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// assert_eq!(0u32.overflowing_neg(), (0, false));
- /// assert_eq!(2u32.overflowing_neg(), (-2i32 as u32, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_neg(self) -> (Self, bool) {
- ((!self).wrapping_add(1), self != 0)
+ doc_comment! {
+ concat!("Negates self in an overflowing fashion.
+
+Returns `!self + 1` using wrapping operations to return the value
+that represents the negation of this unsigned value. Note that for
+positive unsigned values overflow always occurs, but negating 0 does
+not overflow.
+
+# Examples
+
+Basic usage
+
+```
+", $Feature, "assert_eq!(0", stringify!($SelfT), ".overflowing_neg(), (0, false));
+assert_eq!(2", stringify!($SelfT), ".overflowing_neg(), (-2i32 as ", stringify!($SelfT),
+", true));", $EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_neg(self) -> (Self, bool) {
+ ((!self).wrapping_add(1), self != 0)
+ }
}
- /// Shifts self left by `rhs` bits.
- ///
- /// Returns a tuple of the shifted version of self along with a boolean
- /// indicating whether the shift value was larger than or equal to the
- /// number of bits. If the shift value is too large, then value is
- /// masked (N-1) where N is the number of bits, and this value is then
- /// used to perform the shift.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// assert_eq!(0x10u32.overflowing_shl(4), (0x100, false));
- /// assert_eq!(0x10u32.overflowing_shl(36), (0x100, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
- (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
+ doc_comment! {
+ concat!("Shifts self left by `rhs` bits.
+
+Returns a tuple of the shifted version of self along with a boolean
+indicating whether the shift value was larger than or equal to the
+number of bits. If the shift value is too large, then value is
+masked (N-1) where N is the number of bits, and this value is then
+used to perform the shift.
+
+# Examples
+
+Basic usage
+
+```
+", $Feature, "assert_eq!(0x1", stringify!($SelfT), ".overflowing_shl(4), (0x10, false));
+assert_eq!(0x1", stringify!($SelfT), ".overflowing_shl(132), (0x10, true));", $EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
+ (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
+ }
}
- /// Shifts self right by `rhs` bits.
- ///
- /// Returns a tuple of the shifted version of self along with a boolean
- /// indicating whether the shift value was larger than or equal to the
- /// number of bits. If the shift value is too large, then value is
- /// masked (N-1) where N is the number of bits, and this value is then
- /// used to perform the shift.
- ///
- /// # Examples
- ///
- /// Basic usage
- ///
- /// ```
- /// assert_eq!(0x10u32.overflowing_shr(4), (0x1, false));
- /// assert_eq!(0x10u32.overflowing_shr(36), (0x1, true));
- /// ```
- #[inline]
- #[stable(feature = "wrapping", since = "1.7.0")]
- pub fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
- (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
+ doc_comment! {
+ concat!("Shifts self right by `rhs` bits.
+
+Returns a tuple of the shifted version of self along with a boolean
+indicating whether the shift value was larger than or equal to the
+number of bits. If the shift value is too large, then value is
+masked (N-1) where N is the number of bits, and this value is then
+used to perform the shift.
+
+# Examples
+
+Basic usage
+
+```
+", $Feature, "assert_eq!(0x10", stringify!($SelfT), ".overflowing_shr(4), (0x1, false));
+assert_eq!(0x10", stringify!($SelfT), ".overflowing_shr(132), (0x1, true));", $EndFeature, "
+```"),
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
+ (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
+ }
}
- /// Raises self to the power of `exp`, using exponentiation by squaring.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(2u32.pow(4), 16);
- /// ```
+ doc_comment! {
+ concat!("Raises self to the power of `exp`, using exponentiation by squaring.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(2", stringify!($SelfT), ".pow(4), 16);", $EndFeature, "
+```"),
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
#[rustc_inherit_overflow_checks]
acc
}
+ }
- /// Returns `true` if and only if `self == 2^k` for some `k`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert!(16u8.is_power_of_two());
- /// assert!(!10u8.is_power_of_two());
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn is_power_of_two(self) -> bool {
- (self.wrapping_sub(1)) & self == 0 && !(self == 0)
+ doc_comment! {
+ concat!("Returns `true` if and only if `self == 2^k` for some `k`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert!(16", stringify!($SelfT), ".is_power_of_two());
+assert!(!10", stringify!($SelfT), ".is_power_of_two());", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn is_power_of_two(self) -> bool {
+ (self.wrapping_sub(1)) & self == 0 && !(self == 0)
+ }
}
// Returns one less than next power of two.
<$SelfT>::max_value() >> z
}
- /// Returns the smallest power of two greater than or equal to `self`.
- ///
- /// When return value overflows (i.e. `self > (1 << (N-1))` for type
- /// `uN`), it panics in debug mode and return value is wrapped to 0 in
- /// release mode (the only situation in which method can return 0).
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(2u8.next_power_of_two(), 2);
- /// assert_eq!(3u8.next_power_of_two(), 4);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[inline]
- pub fn next_power_of_two(self) -> Self {
- // Call the trait to get overflow checks
- ops::Add::add(self.one_less_than_next_power_of_two(), 1)
+ doc_comment! {
+ concat!("Returns the smallest power of two greater than or equal to `self`.
+
+When return value overflows (i.e. `self > (1 << (N-1))` for type
+`uN`), it panics in debug mode and return value is wrapped to 0 in
+release mode (the only situation in which method can return 0).
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(2", stringify!($SelfT), ".next_power_of_two(), 2);
+assert_eq!(3", stringify!($SelfT), ".next_power_of_two(), 4);", $EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn next_power_of_two(self) -> Self {
+ // Call the trait to get overflow checks
+ ops::Add::add(self.one_less_than_next_power_of_two(), 1)
+ }
}
- /// Returns the smallest power of two greater than or equal to `n`. If
- /// the next power of two is greater than the type's maximum value,
- /// `None` is returned, otherwise the power of two is wrapped in `Some`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert_eq!(2u8.checked_next_power_of_two(), Some(2));
- /// assert_eq!(3u8.checked_next_power_of_two(), Some(4));
- /// assert_eq!(200u8.checked_next_power_of_two(), None);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn checked_next_power_of_two(self) -> Option<Self> {
- self.one_less_than_next_power_of_two().checked_add(1)
+ doc_comment! {
+ concat!("Returns the smallest power of two greater than or equal to `n`. If
+the next power of two is greater than the type's maximum value,
+`None` is returned, otherwise the power of two is wrapped in `Some`.
+
+# Examples
+
+Basic usage:
+
+```
+", $Feature, "assert_eq!(2", stringify!($SelfT),
+".checked_next_power_of_two(), Some(2));
+assert_eq!(3", stringify!($SelfT), ".checked_next_power_of_two(), Some(4));
+assert_eq!(", stringify!($SelfT), "::max_value().checked_next_power_of_two(), None);",
+$EndFeature, "
+```"),
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn checked_next_power_of_two(self) -> Option<Self> {
+ self.one_less_than_next_power_of_two().checked_add(1)
+ }
}
}
}
#[lang = "u8"]
impl u8 {
- uint_impl! { u8, u8, 8 }
+ uint_impl! { u8, u8, 8, 255, "", "" }
/// Checks if the value is within the ASCII range.
#[lang = "u16"]
impl u16 {
- uint_impl! { u16, u16, 16 }
+ uint_impl! { u16, u16, 16, 65535, "", "" }
}
#[lang = "u32"]
impl u32 {
- uint_impl! { u32, u32, 32 }
+ uint_impl! { u32, u32, 32, 4294967295, "", "" }
}
#[lang = "u64"]
impl u64 {
- uint_impl! { u64, u64, 64 }
+ uint_impl! { u64, u64, 64, 18446744073709551615, "", "" }
}
#[lang = "u128"]
impl u128 {
- uint_impl! { u128, u128, 128 }
+ uint_impl! { u128, u128, 128, 340282366920938463463374607431768211455, "#![feature(i128_type)]
+#![feature(i128)]
+
+# fn main() {
+", "
+# }" }
}
#[cfg(target_pointer_width = "16")]
#[lang = "usize"]
impl usize {
- uint_impl! { usize, u16, 16 }
+ uint_impl! { usize, u16, 16, 65536, "", "" }
}
#[cfg(target_pointer_width = "32")]
#[lang = "usize"]
impl usize {
- uint_impl! { usize, u32, 32 }
+ uint_impl! { usize, u32, 32, 4294967295, "", "" }
}
#[cfg(target_pointer_width = "64")]
#[lang = "usize"]
impl usize {
- uint_impl! { usize, u64, 64 }
+ uint_impl! { usize, u64, 64, 18446744073709551615, "", "" }
}
/// A classification of floating point numbers.
issue = "32110")]
pub trait Float: Sized {
/// Type used by `to_bits` and `from_bits`.
- #[stable(feature = "core_float_bits", since = "1.24.0")]
+ #[stable(feature = "core_float_bits", since = "1.25.0")]
type Bits;
/// Returns `true` if this value is NaN and false otherwise.
fn min(self, other: Self) -> Self;
/// Raw transmutation to integer.
- #[stable(feature = "core_float_bits", since="1.24.0")]
+ #[stable(feature = "core_float_bits", since="1.25.0")]
fn to_bits(self) -> Self::Bits;
/// Raw transmutation from integer.
- #[stable(feature = "core_float_bits", since="1.24.0")]
+ #[stable(feature = "core_float_bits", since="1.25.0")]
fn from_bits(v: Self::Bits) -> Self;
}
/// (`start..end`).
///
/// The `Range` `start..end` contains all values with `x >= start` and
-/// `x < end`.
+/// `x < end`. It is empty unless `start < end`.
///
/// # Examples
///
/// assert_eq!((3..5), std::ops::Range { start: 3, end: 5 });
/// assert_eq!(3 + 4 + 5, (3..6).sum());
///
-/// let arr = [0, 1, 2, 3];
-/// assert_eq!(arr[ .. ], [0,1,2,3]);
-/// assert_eq!(arr[ ..3], [0,1,2 ]);
-/// assert_eq!(arr[1.. ], [ 1,2,3]);
-/// assert_eq!(arr[1..3], [ 1,2 ]); // Range
+/// let arr = ['a', 'b', 'c', 'd'];
+/// assert_eq!(arr[ .. ], ['a', 'b', 'c', 'd']);
+/// assert_eq!(arr[ ..3], ['a', 'b', 'c', ]);
+/// assert_eq!(arr[1.. ], [ 'b', 'c', 'd']);
+/// assert_eq!(arr[1..3], [ 'b', 'c' ]); // Range
/// ```
#[derive(Clone, PartialEq, Eq, Hash)] // not Copy -- see #27186
#[stable(feature = "rust1", since = "1.0.0")]
}
}
-#[unstable(feature = "range_contains", reason = "recently added as per RFC", issue = "32311")]
impl<Idx: PartialOrd<Idx>> Range<Idx> {
/// Returns `true` if `item` is contained in the range.
///
/// assert!(!(3..3).contains(3));
/// assert!(!(3..2).contains(3));
/// ```
+ #[unstable(feature = "range_contains", reason = "recently added as per RFC", issue = "32311")]
pub fn contains(&self, item: Idx) -> bool {
(self.start <= item) && (item < self.end)
}
+
+ /// Returns `true` if the range contains no items.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(range_is_empty)]
+ ///
+ /// assert!(!(3..5).is_empty());
+ /// assert!( (3..3).is_empty());
+ /// assert!( (3..2).is_empty());
+ /// ```
+ ///
+ /// The range is empty if either side is incomparable:
+ ///
+ /// ```
+ /// #![feature(range_is_empty,inclusive_range_syntax)]
+ ///
+ /// use std::f32::NAN;
+ /// assert!(!(3.0..5.0).is_empty());
+ /// assert!( (3.0..NAN).is_empty());
+ /// assert!( (NAN..5.0).is_empty());
+ /// ```
+ #[unstable(feature = "range_is_empty", reason = "recently added", issue = "48111")]
+ pub fn is_empty(&self) -> bool {
+ !(self.start < self.end)
+ }
}
/// A range only bounded inclusively below (`start..`).
/// An range bounded inclusively below and above (`start..=end`).
///
/// The `RangeInclusive` `start..=end` contains all values with `x >= start`
-/// and `x <= end`.
+/// and `x <= end`. It is empty unless `start <= end`.
+///
+/// This iterator is [fused], but the specific values of `start` and `end` after
+/// iteration has finished are **unspecified** other than that [`.is_empty()`]
+/// will return `true` once no more values will be produced.
+///
+/// [fused]: ../iter/trait.FusedIterator.html
+/// [`.is_empty()`]: #method.is_empty
///
/// # Examples
///
}
}
-#[unstable(feature = "range_contains", reason = "recently added as per RFC", issue = "32311")]
impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
/// Returns `true` if `item` is contained in the range.
///
/// assert!( (3..=3).contains(3));
/// assert!(!(3..=2).contains(3));
/// ```
+ #[unstable(feature = "range_contains", reason = "recently added as per RFC", issue = "32311")]
pub fn contains(&self, item: Idx) -> bool {
self.start <= item && item <= self.end
}
+
+ /// Returns `true` if the range contains no items.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(range_is_empty,inclusive_range_syntax)]
+ ///
+ /// assert!(!(3..=5).is_empty());
+ /// assert!(!(3..=3).is_empty());
+ /// assert!( (3..=2).is_empty());
+ /// ```
+ ///
+ /// The range is empty if either side is incomparable:
+ ///
+ /// ```
+ /// #![feature(range_is_empty,inclusive_range_syntax)]
+ ///
+ /// use std::f32::NAN;
+ /// assert!(!(3.0..=5.0).is_empty());
+ /// assert!( (3.0..=NAN).is_empty());
+ /// assert!( (NAN..=5.0).is_empty());
+ /// ```
+ ///
+ /// This method returns `true` after iteration has finished:
+ ///
+ /// ```
+ /// #![feature(range_is_empty,inclusive_range_syntax)]
+ ///
+ /// let mut r = 3..=5;
+ /// for _ in r.by_ref() {}
+ /// // Precise field values are unspecified here
+ /// assert!(r.is_empty());
+ /// ```
+ #[unstable(feature = "range_is_empty", reason = "recently added", issue = "48111")]
+ pub fn is_empty(&self) -> bool {
+ !(self.start <= self.end)
+ }
}
/// A range only bounded inclusively above (`..=end`).
#[stable(feature = "nonnull", since = "1.25.0")]
impl<T: ?Sized> Copy for NonNull<T> { }
-#[stable(feature = "nonnull", since = "1.25.0")]
+#[unstable(feature = "coerce_unsized", issue = "27732")]
impl<T: ?Sized, U: ?Sized> CoerceUnsized<NonNull<U>> for NonNull<T> where T: Unsize<U> { }
#[stable(feature = "nonnull", since = "1.25.0")]
}
}
-#[stable(feature = "nonnull", since = "1.25.0")]
+#[unstable(feature = "ptr_internals", issue = "0")]
impl<T: ?Sized> From<Unique<T>> for NonNull<T> {
fn from(unique: Unique<T>) -> Self {
NonNull { pointer: unique.pointer }
{
// The addition might panic on overflow
// Use the len of the slice to hint optimizer to remove result index bounds check.
- let n = make_slice!(self.ptr, self.end).len();
+ 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) }
}).err()
- .map(|i| {
- unsafe { assume(i < n) };
- i
- })
+ // // FIXME(#48116/#45964):
+ // // This assume() causes misoptimization on LLVM 6.
+ // // Commented out until it is fixed again.
+ // .map(|i| {
+ // unsafe { assume(i < n) };
+ // i
+ // })
}
#[inline]
if predicate(x) { Err(i) }
else { Ok(i) }
}).err()
- .map(|i| {
- unsafe { assume(i < n) };
- i
- })
+ // // FIXME(#48116/#45964):
+ // // This assume() causes misoptimization on LLVM 6.
+ // // Commented out until it is fixed again.
+ // .map(|i| {
+ // unsafe { assume(i < n) };
+ // i
+ // })
}
}
// the second byte when searching for the third.
//
// However, this is totally okay. While we have the invariant that
- // self.finger is on a UTF8 boundary, this invariant is not relid upon
+ // self.finger is on a UTF8 boundary, this invariant is not relied upon
// within this method (it is relied upon in CharSearcher::next()).
//
// We only exit this method when we reach the end of the string, or if we
/// Save power or switch hyperthreads in a busy-wait spin-loop.
///
/// This function is deliberately more primitive than
-/// `std::thread::yield_now` and does not directly yield to the
-/// system's scheduler. In some cases it might be useful to use a
-/// combination of both functions. Careful benchmarking is advised.
+/// [`std::thread::yield_now`](../../../std/thread/fn.yield_now.html) and
+/// does not directly yield to the system's scheduler.
+/// In some cases it might be useful to use a combination of both functions.
+/// Careful benchmarking is advised.
///
/// On some platforms this function may not do anything at all.
#[inline]
(isize::MAX as usize + 2, Some(isize::MAX as usize + 2)));
}
+#[test]
+fn test_range_exhaustion() {
+ let mut r = 10..10;
+ assert!(r.is_empty());
+ assert_eq!(r.next(), None);
+ assert_eq!(r.next_back(), None);
+ assert_eq!(r, 10..10);
+
+ let mut r = 10..12;
+ assert_eq!(r.next(), Some(10));
+ assert_eq!(r.next(), Some(11));
+ assert!(r.is_empty());
+ assert_eq!(r, 12..12);
+ assert_eq!(r.next(), None);
+
+ let mut r = 10..12;
+ assert_eq!(r.next_back(), Some(11));
+ assert_eq!(r.next_back(), Some(10));
+ assert!(r.is_empty());
+ assert_eq!(r, 10..10);
+ assert_eq!(r.next_back(), None);
+
+ let mut r = 100..10;
+ assert!(r.is_empty());
+ assert_eq!(r.next(), None);
+ assert_eq!(r.next_back(), None);
+ assert_eq!(r, 100..10);
+}
+
#[test]
fn test_range_inclusive_exhaustion() {
let mut r = 10..=10;
assert_eq!(r.next(), Some(10));
- assert_eq!(r, 1..=0);
+ assert!(r.is_empty());
+ assert_eq!(r.next(), None);
+ assert_eq!(r.next(), None);
let mut r = 10..=10;
assert_eq!(r.next_back(), Some(10));
- assert_eq!(r, 1..=0);
+ assert!(r.is_empty());
+ assert_eq!(r.next_back(), None);
let mut r = 10..=12;
assert_eq!(r.next(), Some(10));
assert_eq!(r.next(), Some(11));
assert_eq!(r.next(), Some(12));
- assert_eq!(r, 1..=0);
+ assert!(r.is_empty());
+ assert_eq!(r.next(), None);
let mut r = 10..=12;
assert_eq!(r.next_back(), Some(12));
assert_eq!(r.next_back(), Some(11));
assert_eq!(r.next_back(), Some(10));
- assert_eq!(r, 1..=0);
+ assert!(r.is_empty());
+ assert_eq!(r.next_back(), None);
let mut r = 10..=12;
assert_eq!(r.nth(2), Some(12));
- assert_eq!(r, 1..=0);
+ assert!(r.is_empty());
+ assert_eq!(r.next(), None);
let mut r = 10..=12;
assert_eq!(r.nth(5), None);
- assert_eq!(r, 1..=0);
+ assert!(r.is_empty());
+ assert_eq!(r.next(), None);
let mut r = 100..=10;
assert_eq!(r.next(), None);
+ assert!(r.is_empty());
+ assert_eq!(r.next(), None);
+ assert_eq!(r.next(), None);
assert_eq!(r, 100..=10);
let mut r = 100..=10;
assert_eq!(r.next_back(), None);
+ assert!(r.is_empty());
+ assert_eq!(r.next_back(), None);
+ assert_eq!(r.next_back(), None);
assert_eq!(r, 100..=10);
}
assert_eq!(r.nth(2), Some(15));
assert_eq!(r, 16..=20);
assert_eq!(r.is_empty(), false);
+ assert_eq!(ExactSizeIterator::is_empty(&r), false);
assert_eq!(r.nth(10), None);
assert_eq!(r.is_empty(), true);
- assert_eq!(r, 1..=0); // We may not want to document/promise this detail
+ assert_eq!(ExactSizeIterator::is_empty(&r), true);
}
#[test]
let mut it = 10..=20;
assert_eq!(it.try_fold(0, |a,b| Some(a+b)), Some(165));
- assert_eq!(it, 1..=0);
+ assert!(it.is_empty());
let mut it = 10..=20;
assert_eq!(it.try_rfold(0, |a,b| Some(a+b)), Some(165));
- assert_eq!(it, 1..=0);
+ assert!(it.is_empty());
}
#[test]
assert_eq!(v, vec![42, 42, 42]);
}
+#[test]
+fn test_repeat_with() {
+ #[derive(PartialEq, Debug)]
+ struct NotClone(usize);
+ let mut it = repeat_with(|| NotClone(42));
+ assert_eq!(it.next(), Some(NotClone(42)));
+ assert_eq!(it.next(), Some(NotClone(42)));
+ assert_eq!(it.next(), Some(NotClone(42)));
+ assert_eq!(repeat_with(|| NotClone(42)).size_hint(), (usize::MAX, None));
+}
+
+#[test]
+fn test_repeat_with_rev() {
+ let mut curr = 1;
+ let mut pow2 = repeat_with(|| { let tmp = curr; curr *= 2; tmp })
+ .rev().take(4);
+ assert_eq!(pow2.next(), Some(1));
+ assert_eq!(pow2.next(), Some(2));
+ assert_eq!(pow2.next(), Some(4));
+ assert_eq!(pow2.next(), Some(8));
+ assert_eq!(pow2.next(), None);
+}
+
+#[test]
+fn test_repeat_with_take() {
+ let mut it = repeat_with(|| 42).take(3);
+ assert_eq!(it.next(), Some(42));
+ assert_eq!(it.next(), Some(42));
+ assert_eq!(it.next(), Some(42));
+ assert_eq!(it.next(), None);
+ is_trusted_len(repeat_with(|| 42).take(3));
+ assert_eq!(repeat_with(|| 42).take(3).size_hint(), (3, Some(3)));
+ assert_eq!(repeat_with(|| 42).take(0).size_hint(), (0, Some(0)));
+ assert_eq!(repeat_with(|| 42).take(usize::MAX).size_hint(),
+ (usize::MAX, Some(usize::MAX)));
+}
+
+#[test]
+fn test_repeat_with_take_collect() {
+ let mut curr = 1;
+ let v: Vec<_> = repeat_with(|| { let tmp = curr; curr *= 2; tmp })
+ .take(5).collect();
+ assert_eq!(v, vec![1, 2, 4, 8, 16]);
+}
+
#[test]
fn test_fuse() {
let mut it = 0..3;
#![feature(iterator_try_fold)]
#![feature(iter_rfind)]
#![feature(iter_rfold)]
+#![feature(iterator_repeat_with)]
#![feature(nonzero)]
#![feature(pattern)]
+#![feature(range_is_empty)]
#![feature(raw)]
#![feature(refcell_replace_swap)]
#![feature(sip_hash_13)]
assert_eq!(r.size_hint(), (0, Some(0)));
assert_eq!(r.next(), None);
}
+
+
+#[test]
+fn test_range_is_empty() {
+ use core::f32::*;
+
+ assert!(!(0.0 .. 10.0).is_empty());
+ assert!( (-0.0 .. 0.0).is_empty());
+ assert!( (10.0 .. 0.0).is_empty());
+
+ assert!(!(NEG_INFINITY .. INFINITY).is_empty());
+ assert!( (EPSILON .. NAN).is_empty());
+ assert!( (NAN .. EPSILON).is_empty());
+ assert!( (NAN .. NAN).is_empty());
+
+ assert!(!(0.0 ..= 10.0).is_empty());
+ assert!(!(-0.0 ..= 0.0).is_empty());
+ assert!( (10.0 ..= 0.0).is_empty());
+
+ assert!(!(NEG_INFINITY ..= INFINITY).is_empty());
+ assert!( (EPSILON ..= NAN).is_empty());
+ assert!( (NAN ..= EPSILON).is_empty());
+ assert!( (NAN ..= NAN).is_empty());
+}
// <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")]
+#![stable(feature = "duration_core", since = "1.25.0")]
//! Temporal quantification.
//!
///
/// let ten_millis = Duration::from_millis(10);
/// ```
-#[stable(feature = "duration_core", since = "1.24.0")]
+#[stable(feature = "duration", since = "1.3.0")]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash, Default)]
pub struct Duration {
secs: u64,
// except according to those terms.
use super::*;
-
use dep_graph::{DepGraph, DepKind, DepNodeIndex};
+use hir::def_id::{LOCAL_CRATE, CrateNum};
use hir::intravisit::{Visitor, NestedVisitorMap};
use hir::svh::Svh;
use middle::cstore::CrateStore;
use session::CrateDisambiguator;
use std::iter::repeat;
use syntax::ast::{NodeId, CRATE_NODE_ID};
+use syntax::codemap::CodeMap;
use syntax_pos::Span;
use ich::StableHashingContext;
pub(super) fn finalize_and_compute_crate_hash(self,
crate_disambiguator: CrateDisambiguator,
cstore: &CrateStore,
+ codemap: &CodeMap,
commandline_args_hash: u64)
-> (Vec<MapEntry<'hir>>, Svh) {
let mut node_hashes: Vec<_> = self
(name1, dis1).cmp(&(name2, dis2))
});
+ // We hash the final, remapped names of all local source files so we
+ // don't have to include the path prefix remapping commandline args.
+ // If we included the full mapping in the SVH, we could only have
+ // reproducible builds by compiling from the same directory. So we just
+ // hash the result of the mapping instead of the mapping itself.
+ let mut source_file_names: Vec<_> = codemap
+ .files()
+ .iter()
+ .filter(|filemap| CrateNum::from_u32(filemap.crate_of_origin) == LOCAL_CRATE)
+ .map(|filemap| filemap.name_hash)
+ .collect();
+
+ source_file_names.sort_unstable();
+
let (_, crate_dep_node_index) = self
.dep_graph
.with_task(DepNode::new_no_params(DepKind::Krate),
&self.hcx,
- ((node_hashes, upstream_crates),
+ (((node_hashes, upstream_crates), source_file_names),
(commandline_args_hash,
crate_disambiguator.to_fingerprint())),
identity_fn);
let cmdline_args = sess.opts.dep_tracking_hash();
collector.finalize_and_compute_crate_hash(crate_disambiguator,
cstore,
+ sess.codemap(),
cmdline_args)
};
err.emit();
this.session.abort_if_errors();
} else {
+ if this.session.teach(&err.get_code().unwrap()) {
+ err.note("If you don't know the basics of Rust, you can go look to the Rust Book \
+ to get started: https://doc.rust-lang.org/book/");
+ }
err.emit();
}
}
"set the optimization fuel quota for a crate"),
print_fuel: Option<String> = (None, parse_opt_string, [TRACKED],
"make Rustc print the total optimization fuel used by a crate"),
- remap_path_prefix_from: Vec<PathBuf> = (vec![], parse_pathbuf_push, [TRACKED],
+ remap_path_prefix_from: Vec<PathBuf> = (vec![], parse_pathbuf_push, [UNTRACKED],
"add a source pattern to the file path remapping config"),
- remap_path_prefix_to: Vec<PathBuf> = (vec![], parse_pathbuf_push, [TRACKED],
+ remap_path_prefix_to: Vec<PathBuf> = (vec![], parse_pathbuf_push, [UNTRACKED],
"add a mapping target to the file path remapping config"),
force_unstable_if_unmarked: bool = (false, parse_bool, [TRACKED],
"force all crates to be `rustc_private` unstable"),
"The epoch to build Rust with. Newer epochs may include features
that require breaking changes. The default epoch is 2015 (the first
epoch). Crates compiled with different epochs can be linked together."),
+ run_dsymutil: Option<bool> = (None, parse_opt_bool, [TRACKED],
+ "run `dsymutil` and delete intermediate object files"),
}
pub fn default_lib_output() -> CrateType {
}
let remap_path_prefix_sources = debugging_opts.remap_path_prefix_from.len();
- let remap_path_prefix_targets = debugging_opts.remap_path_prefix_from.len();
+ let remap_path_prefix_targets = debugging_opts.remap_path_prefix_to.len();
if remap_path_prefix_targets < remap_path_prefix_sources {
for source in &debugging_opts.remap_path_prefix_from[remap_path_prefix_targets..] {
{
self.note_obligation_cause_code(err,
&obligation.predicate,
- &obligation.cause.code);
+ &obligation.cause.code,
+ &mut vec![]);
}
fn note_obligation_cause_code<T>(&self,
err: &mut DiagnosticBuilder,
predicate: &T,
- cause_code: &ObligationCauseCode<'tcx>)
+ cause_code: &ObligationCauseCode<'tcx>,
+ obligated_types: &mut Vec<&ty::TyS<'tcx>>)
where T: fmt::Display
{
let tcx = self.tcx;
}
ObligationCauseCode::BuiltinDerivedObligation(ref data) => {
let parent_trait_ref = self.resolve_type_vars_if_possible(&data.parent_trait_ref);
- err.note(&format!("required because it appears within the type `{}`",
- parent_trait_ref.0.self_ty()));
+ let ty = parent_trait_ref.0.self_ty();
+ err.note(&format!("required because it appears within the type `{}`", ty));
+ obligated_types.push(ty);
+
let parent_predicate = parent_trait_ref.to_predicate();
- self.note_obligation_cause_code(err,
- &parent_predicate,
- &data.parent_code);
+ if !self.is_recursive_obligation(obligated_types, &data.parent_code) {
+ self.note_obligation_cause_code(err,
+ &parent_predicate,
+ &data.parent_code,
+ obligated_types);
+ }
}
ObligationCauseCode::ImplDerivedObligation(ref data) => {
let parent_trait_ref = self.resolve_type_vars_if_possible(&data.parent_trait_ref);
parent_trait_ref.0.self_ty()));
let parent_predicate = parent_trait_ref.to_predicate();
self.note_obligation_cause_code(err,
- &parent_predicate,
- &data.parent_code);
+ &parent_predicate,
+ &data.parent_code,
+ obligated_types);
}
ObligationCauseCode::CompareImplMethodObligation { .. } => {
err.note(
err.help(&format!("consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate",
suggested_limit));
}
+
+ fn is_recursive_obligation(&self,
+ obligated_types: &mut Vec<&ty::TyS<'tcx>>,
+ cause_code: &ObligationCauseCode<'tcx>) -> bool {
+ if let ObligationCauseCode::BuiltinDerivedObligation(ref data) = cause_code {
+ let parent_trait_ref = self.resolve_type_vars_if_possible(&data.parent_trait_ref);
+ for obligated_type in obligated_types {
+ if obligated_type == &parent_trait_ref.0.self_ty() {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
}
enum ArgKind {
// a way that memoizes and does dep-graph tracking,
// wrapping around the actual chain of providers that
// the driver creates (using several `rustc_*` crates).
+//
+// The result of query must implement Clone. They must also implement ty::maps::values::Value
+// which produces an appropiate error value if the query resulted in a query cycle.
+// Queries marked with `fatal_cycle` do not need that implementation
+// as they will raise an fatal error on query cycles instead.
define_maps! { <'tcx>
/// Records the type of every item.
[] fn type_of: TypeOfItem(DefId) -> Ty<'tcx>,
[] fn dylib_dependency_formats: DylibDepFormats(CrateNum)
-> Rc<Vec<(CrateNum, LinkagePreference)>>,
- [] fn is_panic_runtime: IsPanicRuntime(CrateNum) -> bool,
- [] fn is_compiler_builtins: IsCompilerBuiltins(CrateNum) -> bool,
- [] fn has_global_allocator: HasGlobalAllocator(CrateNum) -> bool,
- [] fn is_sanitizer_runtime: IsSanitizerRuntime(CrateNum) -> bool,
- [] fn is_profiler_runtime: IsProfilerRuntime(CrateNum) -> bool,
- [] fn panic_strategy: GetPanicStrategy(CrateNum) -> PanicStrategy,
- [] fn is_no_builtins: IsNoBuiltins(CrateNum) -> bool,
+ [fatal_cycle] fn is_panic_runtime: IsPanicRuntime(CrateNum) -> bool,
+ [fatal_cycle] fn is_compiler_builtins: IsCompilerBuiltins(CrateNum) -> bool,
+ [fatal_cycle] fn has_global_allocator: HasGlobalAllocator(CrateNum) -> bool,
+ [fatal_cycle] fn is_sanitizer_runtime: IsSanitizerRuntime(CrateNum) -> bool,
+ [fatal_cycle] fn is_profiler_runtime: IsProfilerRuntime(CrateNum) -> bool,
+ [fatal_cycle] fn panic_strategy: GetPanicStrategy(CrateNum) -> PanicStrategy,
+ [fatal_cycle] fn is_no_builtins: IsNoBuiltins(CrateNum) -> bool,
[] fn extern_crate: ExternCrate(DefId) -> Rc<Option<ExternCrate>>,
}
}
+macro_rules! handle_cycle_error {
+ ([][$this: expr]) => {{
+ Value::from_cycle_error($this.global_tcx())
+ }};
+ ([fatal_cycle$(, $modifiers:ident)*][$this:expr]) => {{
+ $this.tcx.sess.abort_if_errors();
+ unreachable!();
+ }};
+ ([$other:ident$(, $modifiers:ident)*][$($args:tt)*]) => {
+ handle_cycle_error!([$($modifiers),*][$($args)*])
+ };
+}
+
macro_rules! define_maps {
(<$tcx:tt>
$($(#[$attr:meta])*
pub fn $name(self, key: $K) -> $V {
queries::$name::try_get(self.tcx, self.span, key).unwrap_or_else(|mut e| {
e.emit();
- Value::from_cycle_error(self.global_tcx())
+ handle_cycle_error!([$($modifiers)*][self])
})
})*
}
macro_rules! define_map_struct {
(tcx: $tcx:tt,
- input: ($(([$(modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => {
+ input: ($(([$($modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => {
pub struct Maps<$tcx> {
providers: IndexVec<CrateNum, Providers<$tcx>>,
query_stack: RefCell<Vec<(Span, Query<$tcx>)>>,
}
}
+ pub fn is_ty_infer(&self) -> bool {
+ match self.sty {
+ TyInfer(_) => true,
+ _ => false,
+ }
+ }
+
pub fn is_phantom_data(&self) -> bool {
if let TyAdt(def, _) = self.sty {
def.is_phantom_data()
disambiguator,
);
+ if sess.opts.incremental.is_some() {
+ time(time_passes, "garbage collect incremental cache directory", || {
+ if let Err(e) = rustc_incremental::garbage_collect_session_directories(sess) {
+ warn!("Error while trying to garbage collect incremental \
+ compilation cache directory: {}", e);
+ }
+ });
+ }
+
// If necessary, compute the dependency graph (in the background).
let future_dep_graph = if sess.opts.build_dep_graph() {
Some(rustc_incremental::load_dep_graph(sess, time_passes))
pub use persist::prepare_session_directory;
pub use persist::finalize_session_directory;
pub use persist::delete_workproduct_files;
+pub use persist::garbage_collect_session_directories;
}
fn string_to_timestamp(s: &str) -> Result<SystemTime, ()> {
- let micros_since_unix_epoch = u64::from_str_radix(s, 36);
+ let micros_since_unix_epoch = u64::from_str_radix(s, INT_ENCODE_BASE as u32);
if micros_since_unix_epoch.is_err() {
return Err(())
})
.collect();
+ // Delete all session directories that don't have a lock file.
+ for directory_name in session_directories {
+ if !lock_file_to_session_dir.values().any(|dir| *dir == directory_name) {
+ let path = crate_directory.join(directory_name);
+ if let Err(err) = safe_remove_dir_all(&path) {
+ sess.warn(&format!("Failed to garbage collect invalid incremental \
+ compilation session directory `{}`: {}",
+ path.display(),
+ err));
+ }
+ }
+ }
+
+ // Now garbage collect the valid session directories.
let mut deletion_candidates = vec![];
let mut definitely_delete = vec![];
mod work_product;
mod file_format;
-pub use self::fs::prepare_session_directory;
pub use self::fs::finalize_session_directory;
+pub use self::fs::garbage_collect_session_directories;
pub use self::fs::in_incr_comp_dir;
+pub use self::fs::prepare_session_directory;
pub use self::load::dep_graph_tcx_init;
pub use self::load::load_dep_graph;
pub use self::load::load_query_result_cache;
#![allow(non_snake_case)]
use rustc::hir::def_id::DefId;
+use rustc::hir::map as hir_map;
use rustc::ty::subst::Substs;
use rustc::ty::{self, AdtKind, Ty, TyCtxt};
use rustc::ty::layout::{self, LayoutOf};
_ => bug!(),
};
if lit_val < min || lit_val > max {
+ let parent_id = cx.tcx.hir.get_parent_node(e.id);
+ if let hir_map::NodeExpr(parent_expr) = cx.tcx.hir.get(parent_id) {
+ if let hir::ExprCast(..) = parent_expr.node {
+ if let ty::TyChar = cx.tables.expr_ty(parent_expr).sty {
+ let mut err = cx.struct_span_lint(
+ OVERFLOWING_LITERALS,
+ parent_expr.span,
+ "only u8 can be casted into char");
+ err.span_suggestion(parent_expr.span,
+ &"use a char literal instead",
+ format!("'\\u{{{:X}}}'", lit_val));
+ err.emit();
+ return
+ }
+ }
+ }
cx.span_lint(OVERFLOWING_LITERALS,
e.span,
&format!("literal out of range for {:?}", t));
cfg.file("../rustllvm/PassWrapper.cpp")
.file("../rustllvm/RustWrapper.cpp")
.file("../rustllvm/ArchiveWrapper.cpp")
+ .file("../rustllvm/Linker.cpp")
.cpp(true)
.cpp_link_stdlib(None) // we handle this below
.compile("rustllvm");
#[allow(missing_copy_implementations)]
pub enum OperandBundleDef_opaque {}
pub type OperandBundleDefRef = *mut OperandBundleDef_opaque;
+#[allow(missing_copy_implementations)]
+pub enum Linker_opaque {}
+pub type LinkerRef = *mut Linker_opaque;
pub type DiagnosticHandler = unsafe extern "C" fn(DiagnosticInfoRef, *mut c_void);
pub type InlineAsmDiagHandler = unsafe extern "C" fn(SMDiagnosticRef, *const c_void, c_uint);
pub fn LLVMRustPrintPasses();
pub fn LLVMRustSetNormalizedTarget(M: ModuleRef, triple: *const c_char);
pub fn LLVMRustAddAlwaysInlinePass(P: PassManagerBuilderRef, AddLifetimes: bool);
- pub fn LLVMRustLinkInExternalBitcode(M: ModuleRef, bc: *const c_char, len: size_t) -> bool;
pub fn LLVMRustRunRestrictionPass(M: ModuleRef, syms: *const *const c_char, len: size_t);
pub fn LLVMRustMarkAllFunctionsNounwind(M: ModuleRef);
CU2: *mut *mut c_void);
pub fn LLVMRustThinLTOPatchDICompileUnit(M: ModuleRef, CU: *mut c_void);
pub fn LLVMRustThinLTORemoveAvailableExternally(M: ModuleRef);
+
+ pub fn LLVMRustLinkerNew(M: ModuleRef) -> LinkerRef;
+ pub fn LLVMRustLinkerAdd(linker: LinkerRef,
+ bytecode: *const c_char,
+ bytecode_len: usize) -> bool;
+ pub fn LLVMRustLinkerFree(linker: LinkerRef);
}
target: _,
unwind: _,
} => {
- self.access_place(
- ContextKind::Drop.new(loc),
- (drop_place, span),
- (Deep, Write(WriteKind::StorageDeadOrDrop)),
- LocalMutationIsAllowed::Yes,
- flow_state,
- );
+ let gcx = self.tcx.global_tcx();
+
+ // Compute the type with accurate region information.
+ let drop_place_ty = drop_place.ty(self.mir, self.tcx);
+
+ // Erase the regions.
+ let drop_place_ty = self.tcx.erase_regions(&drop_place_ty).to_ty(self.tcx);
+
+ // "Lift" into the gcx -- once regions are erased, this type should be in the
+ // global arenas; this "lift" operation basically just asserts that is true, but
+ // that is useful later.
+ let drop_place_ty = gcx.lift(&drop_place_ty).unwrap();
+
+ self.visit_terminator_drop(loc, term, flow_state, drop_place, drop_place_ty, span);
}
TerminatorKind::DropAndReplace {
location: ref drop_place,
self.tcx.sess.opts.debugging_opts.two_phase_beyond_autoref)
}
+ /// Invokes `access_place` as appropriate for dropping the value
+ /// at `drop_place`. Note that the *actual* `Drop` in the MIR is
+ /// always for a variable (e.g., `Drop(x)`) -- but we recursively
+ /// break this variable down into subpaths (e.g., `Drop(x.foo)`)
+ /// to indicate more precisely which fields might actually be
+ /// accessed by a destructor.
+ fn visit_terminator_drop(
+ &mut self,
+ loc: Location,
+ term: &Terminator<'tcx>,
+ flow_state: &Flows<'cx, 'gcx, 'tcx>,
+ drop_place: &Place<'tcx>,
+ erased_drop_place_ty: ty::Ty<'gcx>,
+ span: Span,
+ ) {
+ match erased_drop_place_ty.sty {
+ // When a struct is being dropped, we need to check
+ // whether it has a destructor, if it does, then we can
+ // call it, if it does not then we need to check the
+ // individual fields instead. This way if `foo` has a
+ // destructor but `bar` does not, we will only check for
+ // borrows of `x.foo` and not `x.bar`. See #47703.
+ ty::TyAdt(def, substs) if def.is_struct() && !def.has_dtor(self.tcx) => {
+ for (index, field) in def.all_fields().enumerate() {
+ let gcx = self.tcx.global_tcx();
+ let field_ty = field.ty(gcx, substs);
+ let field_ty = gcx.normalize_associated_type_in_env(&field_ty, self.param_env);
+ let place = drop_place.clone().field(Field::new(index), field_ty);
+
+ self.visit_terminator_drop(
+ loc,
+ term,
+ flow_state,
+ &place,
+ field_ty,
+ span,
+ );
+ }
+ },
+ _ => {
+ // We have now refined the type of the value being
+ // dropped (potentially) to just the type of a
+ // subfield; so check whether that field's type still
+ // "needs drop". If so, we assume that the destructor
+ // may access any data it likes (i.e., a Deep Write).
+ let gcx = self.tcx.global_tcx();
+ if erased_drop_place_ty.needs_drop(gcx, self.param_env) {
+ self.access_place(
+ ContextKind::Drop.new(loc),
+ (drop_place, span),
+ (Deep, Write(WriteKind::StorageDeadOrDrop)),
+ LocalMutationIsAllowed::Yes,
+ flow_state,
+ );
+ }
+ },
+ }
+ }
+
/// Checks an access to the given place to see if it is allowed. Examines the set of borrows
/// that are in scope, as well as which paths have been initialized, to ensure that (a) the
/// place is initialized and (b) it is not borrowed in some way that would prevent this
self.tcx.data_layout.pointer_size.bytes()
}
- pub fn endianess(&self) -> layout::Endian {
+ pub fn endianness(&self) -> layout::Endian {
self.tcx.data_layout.endian
}
pub fn read_primval(&self, ptr: MemoryPointer, ptr_align: Align, size: u64, signed: bool) -> EvalResult<'tcx, PrimVal> {
self.check_relocation_edges(ptr, size)?; // Make sure we don't read part of a pointer as a pointer
- let endianess = self.endianess();
+ let endianness = self.endianness();
let bytes = self.get_bytes_unchecked(ptr, size, ptr_align.min(self.int_align(size)))?;
// Undef check happens *after* we established that the alignment is correct.
// We must not return Ok() for unaligned pointers!
}
// Now we do the actual reading
let bytes = if signed {
- read_target_int(endianess, bytes).unwrap() as u128
+ read_target_int(endianness, bytes).unwrap() as u128
} else {
- read_target_uint(endianess, bytes).unwrap()
+ read_target_uint(endianness, bytes).unwrap()
};
// See if we got a pointer
if size != self.pointer_size() {
}
pub fn write_primval(&mut self, ptr: MemoryPointer, ptr_align: Align, val: PrimVal, size: u64, signed: bool) -> EvalResult<'tcx> {
- let endianess = self.endianess();
+ let endianness = self.endianness();
let bytes = match val {
PrimVal::Ptr(val) => {
let align = self.int_align(size);
let dst = self.get_bytes_mut(ptr, size, ptr_align.min(align))?;
if signed {
- write_target_int(endianess, dst, bytes as i128).unwrap();
+ write_target_int(endianness, dst, bytes as i128).unwrap();
} else {
- write_target_uint(endianess, dst, bytes).unwrap();
+ write_target_uint(endianness, dst, bytes).unwrap();
}
}
}
////////////////////////////////////////////////////////////////////////////////
-// Methods to access integers in the target endianess
+// Methods to access integers in the target endianness
////////////////////////////////////////////////////////////////////////////////
fn write_target_uint(
- endianess: layout::Endian,
+ endianness: layout::Endian,
mut target: &mut [u8],
data: u128,
) -> Result<(), io::Error> {
let len = target.len();
- match endianess {
+ match endianness {
layout::Endian::Little => target.write_uint128::<LittleEndian>(data, len),
layout::Endian::Big => target.write_uint128::<BigEndian>(data, len),
}
}
fn write_target_int(
- endianess: layout::Endian,
+ endianness: layout::Endian,
mut target: &mut [u8],
data: i128,
) -> Result<(), io::Error> {
let len = target.len();
- match endianess {
+ match endianness {
layout::Endian::Little => target.write_int128::<LittleEndian>(data, len),
layout::Endian::Big => target.write_int128::<BigEndian>(data, len),
}
}
-fn read_target_uint(endianess: layout::Endian, mut source: &[u8]) -> Result<u128, io::Error> {
- match endianess {
+fn read_target_uint(endianness: layout::Endian, mut source: &[u8]) -> Result<u128, io::Error> {
+ match endianness {
layout::Endian::Little => source.read_uint128::<LittleEndian>(source.len()),
layout::Endian::Big => source.read_uint128::<BigEndian>(source.len()),
}
}
-fn read_target_int(endianess: layout::Endian, mut source: &[u8]) -> Result<i128, io::Error> {
- match endianess {
+fn read_target_int(endianness: layout::Endian, mut source: &[u8]) -> Result<i128, io::Error> {
+ match endianness {
layout::Endian::Little => source.read_int128::<LittleEndian>(source.len()),
layout::Endian::Big => source.read_int128::<BigEndian>(source.len()),
}
pub mod generator;
pub mod inline;
pub mod lower_128bit;
+pub mod uniform_array_move_out;
pub(crate) fn provide(providers: &mut Providers) {
self::qualify_consts::provide(providers);
simplify::SimplifyCfg::new("initial"),
type_check::TypeckMir,
rustc_peek::SanityCheck,
+ uniform_array_move_out::UniformArrayMoveOut,
];
tcx.alloc_steal_mir(mir)
}
lower_128bit::Lower128Bit,
+
// Optimizations begin.
inline::Inline,
instcombine::InstCombine,
fn not_const(&mut self) {
self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
- span_err!(self.tcx.sess, self.span, E0019,
- "{} contains unimplemented expression type", self.mode);
+ let mut err = struct_span_err!(
+ self.tcx.sess,
+ self.span,
+ E0019,
+ "{} contains unimplemented expression type",
+ self.mode
+ );
+ if self.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note("A function call isn't allowed in the const's initialization expression \
+ because the expression's value must be known at compile-time.");
+ err.note("Remember: you can't use a function call inside a const's initialization \
+ expression! However, you can use it anywhere else.");
+ }
+ err.emit();
}
}
fn statement_like(&mut self) {
self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
- span_err!(self.tcx.sess, self.span, E0016,
- "blocks in {}s are limited to items and tail expressions",
- self.mode);
+ let mut err = struct_span_err!(
+ self.tcx.sess,
+ self.span,
+ E0016,
+ "blocks in {}s are limited to items and tail expressions",
+ self.mode
+ );
+ if self.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note("Blocks in constants may only contain items (such as constant, function \
+ definition, etc...) and a tail expression.");
+ err.help("To avoid it, you have to replace the non-item object.");
+ }
+ err.emit();
}
}
}
if self.mode == Mode::Const || self.mode == Mode::ConstFn {
- span_err!(self.tcx.sess, self.span, E0013,
- "{}s cannot refer to statics, use \
- a constant instead", self.mode);
+ let mut err = struct_span_err!(self.tcx.sess, self.span, E0013,
+ "{}s cannot refer to statics, use \
+ a constant instead", self.mode);
+ if self.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note(
+ "Static and const variables can refer to other const variables. But a \
+ const variable cannot refer to a static variable."
+ );
+ err.help(
+ "To fix this, the value can be extracted as a const and then used."
+ );
+ }
+ err.emit()
}
}
Place::Projection(ref proj) => {
this.add(Qualif::STATIC);
}
+ this.add(Qualif::NOT_CONST);
+
let base_ty = proj.base.ty(this.mir, this.tcx).to_ty(this.tcx);
if let ty::TyRawPtr(_) = base_ty.sty {
- this.add(Qualif::NOT_CONST);
if this.mode != Mode::Fn {
- struct_span_err!(this.tcx.sess,
- this.span, E0396,
+ let mut err = struct_span_err!(
+ this.tcx.sess,
+ this.span,
+ E0396,
"raw pointers cannot be dereferenced in {}s",
- this.mode)
- .span_label(this.span,
- "dereference of raw pointer in constant")
- .emit();
+ this.mode
+ );
+ err.span_label(this.span,
+ "dereference of raw pointer in constant");
+ if this.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note(
+ "The value behind a raw pointer can't be determined \
+ at compile-time (or even link-time), which means it \
+ can't be used in a constant expression."
+ );
+ err.help("A possible fix is to dereference your pointer \
+ at some point in run-time.");
+ }
+ err.emit();
}
}
}
fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
// Recurse through operands and places.
- self.super_rvalue(rvalue, location);
+ if let Rvalue::Ref(region, kind, ref place) = *rvalue {
+ let mut is_reborrow = false;
+ if let Place::Projection(ref proj) = *place {
+ if let ProjectionElem::Deref = proj.elem {
+ let base_ty = proj.base.ty(self.mir, self.tcx).to_ty(self.tcx);
+ if let ty::TyRef(..) = base_ty.sty {
+ is_reborrow = true;
+ }
+ }
+ }
+
+ if is_reborrow {
+ self.nest(|this| {
+ this.super_place(place, PlaceContext::Borrow {
+ region,
+ kind
+ }, location);
+ if !this.try_consume() {
+ return;
+ }
+
+ if this.qualif.intersects(Qualif::STATIC_REF) {
+ this.qualif = this.qualif - Qualif::STATIC_REF;
+ this.add(Qualif::STATIC);
+ }
+ });
+ } else {
+ self.super_rvalue(rvalue, location);
+ }
+ } else {
+ self.super_rvalue(rvalue, location);
+ }
match *rvalue {
Rvalue::Use(_) |
if !allow {
self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
- struct_span_err!(self.tcx.sess, self.span, E0017,
- "references in {}s may only refer \
- to immutable values", self.mode)
- .span_label(self.span, format!("{}s require immutable values",
- self.mode))
- .emit();
+ let mut err = struct_span_err!(self.tcx.sess, self.span, E0017,
+ "references in {}s may only refer \
+ to immutable values", self.mode);
+ err.span_label(self.span, format!("{}s require immutable values",
+ self.mode));
+ if self.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note("References in statics and constants may only refer to \
+ immutable values.\n\n\
+ Statics are shared everywhere, and if they refer to \
+ mutable data one might violate memory safety since \
+ holding multiple mutable references to shared data is \
+ not allowed.\n\n\
+ If you really want global mutable state, try using \
+ static mut or a global UnsafeCell.");
+ }
+ err.emit();
}
}
} else {
(CastTy::FnPtr, CastTy::Int(_)) => {
self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
- span_err!(self.tcx.sess, self.span, E0018,
- "raw pointers cannot be cast to integers in {}s",
- self.mode);
+ let mut err = struct_span_err!(
+ self.tcx.sess,
+ self.span,
+ E0018,
+ "raw pointers cannot be cast to integers in {}s",
+ self.mode
+ );
+ if self.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note("\
+The value of static and constant integers must be known at compile time. You can't cast a pointer \
+to an integer because the address of a pointer can vary.
+
+For example, if you write:
+
+```
+static MY_STATIC: u32 = 42;
+static MY_STATIC_ADDR: usize = &MY_STATIC as *const _ as usize;
+static WHAT: usize = (MY_STATIC_ADDR^17) + MY_STATIC_ADDR;
+```
+
+Then `MY_STATIC_ADDR` would contain the address of `MY_STATIC`. However, the address can change \
+when the program is linked, as well as change between different executions due to ASLR, and many \
+linkers would not be able to calculate the value of `WHAT`.
+
+On the other hand, static and constant pointers can point either to a known numeric address or to \
+the address of a symbol.
+
+```
+static MY_STATIC: u32 = 42;
+static MY_STATIC_ADDR: &'static u32 = &MY_STATIC;
+const CONST_ADDR: *const u8 = 0x5f3759df as *const u8;
+```
+
+This does not pose a problem by itself because they can't be accessed directly.");
+ }
+ err.emit();
}
}
_ => {}
Rvalue::NullaryOp(NullOp::Box, _) => {
self.add(Qualif::NOT_CONST);
if self.mode != Mode::Fn {
- struct_span_err!(self.tcx.sess, self.span, E0010,
- "allocations are not allowed in {}s", self.mode)
- .span_label(self.span, format!("allocation not allowed in {}s", self.mode))
- .emit();
+ let mut err = struct_span_err!(self.tcx.sess, self.span, E0010,
+ "allocations are not allowed in {}s", self.mode);
+ err.span_label(self.span, format!("allocation not allowed in {}s", self.mode));
+ if self.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note(
+ "The value of statics and constants must be known at compile time, \
+ and they live for the entire lifetime of a program. Creating a boxed \
+ value allocates memory on the heap at runtime, and therefore cannot \
+ be done at compile time."
+ );
+ }
+ err.emit();
}
}
// Avoid a generic error for other uses of arguments.
if self.qualif.intersects(Qualif::FN_ARGUMENT) {
let decl = &self.mir.local_decls[index];
- span_err!(self.tcx.sess, decl.source_info.span, E0022,
- "arguments of constant functions can only \
- be immutable by-value bindings");
+ let mut err = struct_span_err!(
+ self.tcx.sess,
+ decl.source_info.span,
+ E0022,
+ "arguments of constant functions can only be immutable by-value bindings"
+ );
+ if self.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note("Constant functions are not allowed to mutate anything. Thus, \
+ binding to an argument with a mutable pattern is not allowed.");
+ err.note("Remove any mutable bindings from the argument list to fix this \
+ error. In case you need to mutate the argument, try lazily \
+ initializing a global variable instead of using a const fn, or \
+ refactoring the code to a functional style to avoid mutation if \
+ possible.");
+ }
+ err.emit();
return;
}
}
--- /dev/null
+// Copyright 2015 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.
+
+// This pass converts move out from array by Subslice and
+// ConstIndex{.., from_end: true} to ConstIndex move out(s) from begin
+// of array. It allows detect error by mir borrowck and elaborate
+// drops for array without additional work.
+//
+// Example:
+//
+// let a = [ box 1,box 2, box 3];
+// if b {
+// let [_a.., _] = a;
+// } else {
+// let [.., _b] = a;
+// }
+//
+// mir statement _10 = move _2[:-1]; replaced by:
+// StorageLive(_12);
+// _12 = move _2[0 of 3];
+// StorageLive(_13);
+// _13 = move _2[1 of 3];
+// _10 = [move _12, move _13]
+// StorageDead(_12);
+// StorageDead(_13);
+//
+// and mir statement _11 = move _2[-1 of 1]; replaced by:
+// _11 = move _2[2 of 3];
+//
+// FIXME: convert to Subslice back for performance reason
+// FIXME: integrate this transformation to the mir build
+
+use rustc::ty;
+use rustc::ty::TyCtxt;
+use rustc::mir::*;
+use rustc::mir::visit::Visitor;
+use transform::{MirPass, MirSource};
+use util::patch::MirPatch;
+
+pub struct UniformArrayMoveOut;
+
+impl MirPass for UniformArrayMoveOut {
+ fn run_pass<'a, 'tcx>(&self,
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ _src: MirSource,
+ mir: &mut Mir<'tcx>) {
+ let mut patch = MirPatch::new(mir);
+ {
+ let mut visitor = UniformArrayMoveOutVisitor{mir, patch: &mut patch, tcx};
+ visitor.visit_mir(mir);
+ }
+ patch.apply(mir);
+ }
+}
+
+struct UniformArrayMoveOutVisitor<'a, 'tcx: 'a> {
+ mir: &'a Mir<'tcx>,
+ patch: &'a mut MirPatch<'tcx>,
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for UniformArrayMoveOutVisitor<'a, 'tcx> {
+ fn visit_statement(&mut self,
+ block: BasicBlock,
+ statement: &Statement<'tcx>,
+ location: Location) {
+ if let StatementKind::Assign(ref dst_place,
+ Rvalue::Use(Operand::Move(ref src_place))) = statement.kind {
+ if let Place::Projection(ref proj) = *src_place {
+ if let ProjectionElem::ConstantIndex{offset: _,
+ min_length: _,
+ from_end: false} = proj.elem {
+ // no need to transformation
+ } else {
+ let place_ty = proj.base.ty(self.mir, self.tcx).to_ty(self.tcx);
+ if let ty::TyArray(item_ty, const_size) = place_ty.sty {
+ if let Some(size) = const_size.val.to_const_int().and_then(|v| v.to_u64()) {
+ assert!(size <= (u32::max_value() as u64),
+ "unform array move out doesn't supported
+ for array bigger then u32");
+ self.uniform(location, dst_place, proj, item_ty, size as u32);
+ }
+ }
+
+ }
+ }
+ }
+ return self.super_statement(block, statement, location);
+ }
+}
+
+impl<'a, 'tcx> UniformArrayMoveOutVisitor<'a, 'tcx> {
+ fn uniform(&mut self,
+ location: Location,
+ dst_place: &Place<'tcx>,
+ proj: &PlaceProjection<'tcx>,
+ item_ty: &'tcx ty::TyS<'tcx>,
+ size: u32) {
+ match proj.elem {
+ // uniform _10 = move _2[:-1];
+ ProjectionElem::Subslice{from, to} => {
+ self.patch.make_nop(location);
+ let temps : Vec<_> = (from..(size-to)).map(|i| {
+ let temp = self.patch.new_temp(item_ty, self.mir.source_info(location).span);
+ self.patch.add_statement(location, StatementKind::StorageLive(temp));
+ self.patch.add_assign(location,
+ Place::Local(temp),
+ Rvalue::Use(
+ Operand::Move(
+ Place::Projection(box PlaceProjection{
+ base: proj.base.clone(),
+ elem: ProjectionElem::ConstantIndex{
+ offset: i,
+ min_length: size,
+ from_end: false}
+ }))));
+ temp
+ }).collect();
+ self.patch.add_assign(location,
+ dst_place.clone(),
+ Rvalue::Aggregate(box AggregateKind::Array(item_ty),
+ temps.iter().map(
+ |x| Operand::Move(Place::Local(*x))).collect()
+ ));
+ for temp in temps {
+ self.patch.add_statement(location, StatementKind::StorageDead(temp));
+ }
+ }
+ // _11 = move _2[-1 of 1];
+ ProjectionElem::ConstantIndex{offset, min_length: _, from_end: true} => {
+ self.patch.make_nop(location);
+ self.patch.add_assign(location,
+ dst_place.clone(),
+ Rvalue::Use(
+ Operand::Move(
+ Place::Projection(box PlaceProjection{
+ base: proj.base.clone(),
+ elem: ProjectionElem::ConstantIndex{
+ offset: size - offset,
+ min_length: size,
+ from_end: false }}))));
+ }
+ _ => {}
+ }
+ }
+}
new_locals: Vec<LocalDecl<'tcx>>,
resume_block: BasicBlock,
next_local: usize,
+ make_nop: Vec<Location>,
}
impl<'tcx> MirPatch<'tcx> {
new_statements: vec![],
new_locals: vec![],
next_local: mir.local_decls.len(),
- resume_block: START_BLOCK
+ resume_block: START_BLOCK,
+ make_nop: vec![]
};
// make sure the MIR we create has a resume block. It is
self.add_statement(loc, StatementKind::Assign(place, rv));
}
+ pub fn make_nop(&mut self, loc: Location) {
+ self.make_nop.push(loc);
+ }
+
pub fn apply(self, mir: &mut Mir<'tcx>) {
+ debug!("MirPatch: make nops at: {:?}", self.make_nop);
+ for loc in self.make_nop {
+ mir.make_statement_nop(loc);
+ }
debug!("MirPatch: {:?} new temps, starting from index {}: {:?}",
self.new_locals.len(), mir.local_decls.len(), self.new_locals);
debug!("MirPatch: {} new blocks, starting from index {}",
Ok(Ordering::Less) |
Ok(Ordering::Equal) => {}
Ok(Ordering::Greater) => {
- struct_span_err!(self.tcx.sess, start.span, E0030,
- "lower range bound must be less than or equal to upper")
- .span_label(start.span, "lower bound larger than upper bound")
- .emit();
+ let mut err = struct_span_err!(
+ self.tcx.sess,
+ start.span,
+ E0030,
+ "lower range bound must be less than or equal to upper"
+ );
+ err.span_label(start.span, "lower bound larger than upper bound");
+ if self.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note("When matching against a range, the compiler verifies that \
+ the range is non-empty. Range patterns include both \
+ end-points, so this is equivalent to requiring the start of \
+ the range to be less than or equal to the end of the range.");
+ }
+ err.emit();
}
Err(ErrorReported) => {}
}
hir::ExprBox(_) => {
v.promotable = false;
}
- hir::ExprUnary(op, ref inner) => {
- match v.tables.node_id_to_type(inner.hir_id).sty {
- ty::TyRawPtr(_) => {
- assert!(op == hir::UnDeref);
-
- v.promotable = false;
- }
- _ => {}
+ hir::ExprUnary(op, _) => {
+ if op == hir::UnDeref {
+ v.promotable = false;
}
}
hir::ExprBinary(op, ref lhs, _) => {
fn check_adjustments<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr) {
use rustc::ty::adjustment::*;
- for adjustment in v.tables.expr_adjustments(e) {
+ let mut adjustments = v.tables.expr_adjustments(e).iter().peekable();
+ while let Some(adjustment) = adjustments.next() {
match adjustment.kind {
Adjust::NeverToAny |
Adjust::ReifyFnPointer |
Adjust::Borrow(_) |
Adjust::Unsize => {}
- Adjust::Deref(ref overloaded) => {
- if overloaded.is_some() {
- v.promotable = false;
- break;
+ Adjust::Deref(_) => {
+ if let Some(next_adjustment) = adjustments.peek() {
+ if let Adjust::Borrow(_) = next_adjustment.kind {
+ continue;
+ }
}
+ v.promotable = false;
+ break;
}
}
}
if names.is_empty() {
import_directive_subclass_to_string(subclass)
} else {
+ // FIXME: Remove this entire logic after #48116 is fixed.
+ //
// Note that this code looks a little wonky, it's currently here to
// hopefully help debug #48116, but otherwise isn't intended to
// cause any problems.
names_to_string(names),
import_directive_subclass_to_string(subclass),
);
- assert!(!names.is_empty());
- assert!(!x.starts_with("::"));
+ if names.is_empty() || x.starts_with("::") {
+ span_bug!(
+ span,
+ "invalid name `{}` at {:?}; global = {}, names = {:?}, subclass = {:?}",
+ x,
+ span,
+ global,
+ names,
+ subclass
+ );
+ }
return x
}
}
assert_eq!(cnum, LOCAL_CRATE);
Rc::new(llvm_util::target_feature_whitelist(tcx.sess)
.iter()
- .map(|c| c.to_str().unwrap().to_string())
+ .map(|c| c.to_string())
.collect())
};
let value = value.as_str();
for feature in value.split(',') {
if whitelist.contains(feature) {
- target_features.push(format!("+{}", feature));
+ let llvm_feature = llvm_util::to_llvm_feature(feature);
+ target_features.push(format!("+{}", llvm_feature));
continue
}
// Remove the temporary object file and metadata if we aren't saving temps
if !sess.opts.cg.save_temps {
- if sess.opts.output_types.should_trans() {
+ if sess.opts.output_types.should_trans() &&
+ !preserve_objects_for_their_debuginfo(sess)
+ {
for obj in trans.modules.iter().filter_map(|m| m.object.as_ref()) {
remove(sess, obj);
}
out_filenames
}
+/// Returns a boolean indicating whether we should preserve the object files on
+/// the filesystem for their debug information. This is often useful with
+/// split-dwarf like schemes.
+fn preserve_objects_for_their_debuginfo(sess: &Session) -> bool {
+ // If the objects don't have debuginfo there's nothing to preserve.
+ if sess.opts.debuginfo == NoDebugInfo {
+ return false
+ }
+
+ // If we're only producing artifacts that are archives, no need to preserve
+ // the objects as they're losslessly contained inside the archives.
+ let output_linked = sess.crate_types.borrow()
+ .iter()
+ .any(|x| *x != config::CrateTypeRlib && *x != config::CrateTypeStaticlib);
+ if !output_linked {
+ return false
+ }
+
+ // If we're on OSX then the equivalent of split dwarf is turned on by
+ // default. The final executable won't actually have any debug information
+ // except it'll have pointers to elsewhere. Historically we've always run
+ // `dsymutil` to "link all the dwarf together" but this is actually sort of
+ // a bummer for incremental compilation! (the whole point of split dwarf is
+ // that you don't do this sort of dwarf link).
+ //
+ // Basically as a result this just means that if we're on OSX and we're
+ // *not* running dsymutil then the object files are the only source of truth
+ // for debug information, so we must preserve them.
+ if sess.target.target.options.is_like_osx {
+ match sess.opts.debugging_opts.run_dsymutil {
+ // dsymutil is not being run, preserve objects
+ Some(false) => return true,
+
+ // dsymutil is being run, no need to preserve the objects
+ Some(true) => return false,
+
+ // The default historical behavior was to always run dsymutil, so
+ // we're preserving that temporarily, but we're likely to switch the
+ // default soon.
+ None => return false,
+ }
+ }
+
+ false
+}
+
fn filename_for_metadata(sess: &Session, crate_name: &str, outputs: &OutputFilenames) -> PathBuf {
let out_filename = outputs.single_output_file.clone()
.unwrap_or(outputs
// On macOS, debuggers need this utility to get run to do some munging of
- // the symbols
- if sess.target.target.options.is_like_osx && sess.opts.debuginfo != NoDebugInfo {
+ // the symbols. Note, though, that if the object files are being preserved
+ // for their debug information there's no need for us to run dsymutil.
+ if sess.target.target.options.is_like_osx &&
+ sess.opts.debuginfo != NoDebugInfo &&
+ !preserve_objects_for_their_debuginfo(sess)
+ {
match Command::new("dsymutil").arg(out_filename).output() {
Ok(..) => {}
Err(e) => sess.fatal(&format!("failed to run dsymutil: {}", e)),
// know much about the memory management here so we err on the side of being
// save and persist everything with the original module.
let mut serialized_bitcode = Vec::new();
+ let mut linker = Linker::new(llmod);
for (bc_decoded, name) in serialized_modules {
info!("linking {:?}", name);
- time(cgcx.time_passes, &format!("ll link {:?}", name), || unsafe {
+ time(cgcx.time_passes, &format!("ll link {:?}", name), || {
let data = bc_decoded.data();
- if llvm::LLVMRustLinkInExternalBitcode(llmod,
- data.as_ptr() as *const libc::c_char,
- data.len() as libc::size_t) {
- Ok(())
- } else {
+ linker.add(&data).map_err(|()| {
let msg = format!("failed to load bc of {:?}", name);
- Err(write::llvm_err(&diag_handler, msg))
- }
+ write::llvm_err(&diag_handler, msg)
+ })
})?;
timeline.record(&format!("link {:?}", name));
serialized_bitcode.push(bc_decoded);
}
+ drop(linker);
cgcx.save_temp_bitcode(&module, "lto.input");
// Internalize everything that *isn't* in our whitelist to help strip out
}])
}
+struct Linker(llvm::LinkerRef);
+
+impl Linker {
+ fn new(llmod: ModuleRef) -> Linker {
+ unsafe { Linker(llvm::LLVMRustLinkerNew(llmod)) }
+ }
+
+ fn add(&mut self, bytecode: &[u8]) -> Result<(), ()> {
+ unsafe {
+ if llvm::LLVMRustLinkerAdd(self.0,
+ bytecode.as_ptr() as *const libc::c_char,
+ bytecode.len()) {
+ Ok(())
+ } else {
+ Err(())
+ }
+ }
+ }
+}
+
+impl Drop for Linker {
+ fn drop(&mut self) {
+ unsafe { llvm::LLVMRustLinkerFree(self.0); }
+ }
+}
+
/// Prepare "thin" LTO to get run on these modules.
///
/// The general structure of ThinLTO is quite different from the structure of
None => None,
Some(Class::Int) => {
*i += 1;
- Some(match size.bytes() {
- 1 => Reg::i8(),
- 2 => Reg::i16(),
- 3 |
- 4 => Reg::i32(),
- _ => Reg::i64()
+ Some(if size.bytes() < 8 {
+ Reg {
+ kind: RegKind::Integer,
+ size
+ }
+ } else {
+ Reg::i64()
})
}
Some(Class::Sse) => {
use rustc::session::Session;
use rustc::session::config::PrintRequest;
use libc::c_int;
-use std::ffi::{CStr, CString};
+use std::ffi::CString;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Once;
// detection code will walk past the end of the feature array,
// leading to crashes.
-const ARM_WHITELIST: &'static [&'static str] = &["neon\0", "v7\0", "vfp2\0", "vfp3\0", "vfp4\0"];
+const ARM_WHITELIST: &'static [&'static str] = &["neon", "v7", "vfp2", "vfp3", "vfp4"];
-const AARCH64_WHITELIST: &'static [&'static str] = &["neon\0", "v7\0"];
+const AARCH64_WHITELIST: &'static [&'static str] = &["neon", "v7"];
-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", "aes\0",
- "avx512bw\0", "avx512cd\0",
- "avx512dq\0", "avx512er\0",
- "avx512f\0", "avx512ifma\0",
- "avx512pf\0", "avx512vbmi\0",
- "avx512vl\0", "avx512vpopcntdq\0",
- "mmx\0", "fxsr\0"];
+const X86_WHITELIST: &'static [&'static str] = &["avx", "avx2", "bmi", "bmi2", "sse",
+ "sse2", "sse3", "sse4.1", "sse4.2",
+ "ssse3", "tbm", "lzcnt", "popcnt",
+ "sse4a", "rdrnd", "rdseed", "fma",
+ "xsave", "xsaveopt", "xsavec",
+ "xsaves", "aes", "pclmulqdq",
+ "avx512bw", "avx512cd",
+ "avx512dq", "avx512er",
+ "avx512f", "avx512ifma",
+ "avx512pf", "avx512vbmi",
+ "avx512vl", "avx512vpopcntdq",
+ "mmx", "fxsr"];
-const HEXAGON_WHITELIST: &'static [&'static str] = &["hvx\0", "hvx-double\0"];
+const HEXAGON_WHITELIST: &'static [&'static str] = &["hvx", "hvx-double"];
-const POWERPC_WHITELIST: &'static [&'static str] = &["altivec\0",
- "power8-altivec\0", "power9-altivec\0",
- "power8-vector\0", "power9-vector\0",
- "vsx\0"];
+const POWERPC_WHITELIST: &'static [&'static str] = &["altivec",
+ "power8-altivec", "power9-altivec",
+ "power8-vector", "power9-vector",
+ "vsx"];
-const MIPS_WHITELIST: &'static [&'static str] = &["msa\0"];
+const MIPS_WHITELIST: &'static [&'static str] = &["msa"];
+
+pub fn to_llvm_feature(s: &str) -> &str {
+ match s {
+ "pclmulqdq" => "pclmul",
+ s => s,
+ }
+}
pub fn target_features(sess: &Session) -> Vec<Symbol> {
- let whitelist = target_feature_whitelist(sess);
let target_machine = create_target_machine(sess);
- let mut features = Vec::new();
- for feat in whitelist {
- if unsafe { llvm::LLVMRustHasFeature(target_machine, feat.as_ptr()) } {
- features.push(Symbol::intern(feat.to_str().unwrap()));
- }
- }
- features
+ target_feature_whitelist(sess)
+ .iter()
+ .filter(|feature| {
+ let llvm_feature = to_llvm_feature(feature);
+ let cstr = CString::new(llvm_feature).unwrap();
+ unsafe { llvm::LLVMRustHasFeature(target_machine, cstr.as_ptr()) }
+ })
+ .map(|feature| Symbol::intern(feature)).collect()
}
-pub fn target_feature_whitelist(sess: &Session) -> Vec<&CStr> {
- let whitelist = match &*sess.target.target.arch {
+pub fn target_feature_whitelist(sess: &Session) -> &'static [&'static str] {
+ match &*sess.target.target.arch {
"arm" => ARM_WHITELIST,
"aarch64" => AARCH64_WHITELIST,
"x86" | "x86_64" => X86_WHITELIST,
"mips" | "mips64" => MIPS_WHITELIST,
"powerpc" | "powerpc64" => POWERPC_WHITELIST,
_ => &[],
- };
- whitelist.iter().map(|m| {
- CStr::from_bytes_with_nul(m.as_bytes()).unwrap()
- }).collect()
+ }
}
pub fn print_version() {
end.span
};
- struct_span_err!(tcx.sess, span, E0029,
- "only char and numeric types are allowed in range patterns")
- .span_label(span, "ranges require char or numeric types")
- .note(&format!("start type: {}", self.ty_to_string(lhs_ty)))
- .note(&format!("end type: {}", self.ty_to_string(rhs_ty)))
- .emit();
+ let mut err = struct_span_err!(
+ tcx.sess,
+ span,
+ E0029,
+ "only char and numeric types are allowed in range patterns"
+ );
+ err.span_label(span, "ranges require char or numeric types");
+ err.note(&format!("start type: {}", self.ty_to_string(lhs_ty)));
+ err.note(&format!("end type: {}", self.ty_to_string(rhs_ty)));
+ if tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note(
+ "In a match expression, only numbers and characters can be matched \
+ against a range. This is because the compiler checks that the range \
+ is non-empty at compile-time, and is unable to evaluate arbitrary \
+ comparison functions. If you want to capture values of an orderable \
+ type between two end-points, you can use a guard."
+ );
+ }
+ err.emit();
return;
}
// This is "x = SomeTrait" being reduced from
// "let &x = &SomeTrait" or "let box x = Box<SomeTrait>", an error.
let type_str = self.ty_to_string(expected);
- struct_span_err!(self.tcx.sess, span, E0033,
- "type `{}` cannot be dereferenced", type_str)
- .span_label(span, format!("type `{}` cannot be dereferenced", type_str))
- .emit();
+ let mut err = struct_span_err!(
+ self.tcx.sess,
+ span,
+ E0033,
+ "type `{}` cannot be dereferenced",
+ type_str
+ );
+ err.span_label(span, format!("type `{}` cannot be dereferenced", type_str));
+ if self.tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note("\
+This error indicates that a pointer to a trait type cannot be implicitly dereferenced by a \
+pattern. Every trait defines a type, but because the size of trait implementors isn't fixed, \
+this type has no compile-time size. Therefore, all accesses to trait types must be through \
+pointers. If you encounter this error you should try to avoid dereferencing the pointer.
+
+You can read more about trait objects in the Trait Objects section of the Reference: \
+https://doc.rust-lang.org/reference/types.html#trait-objects");
+ }
+ err.emit();
return false
}
}
self.field_ty(span, f, substs)
})
.unwrap_or_else(|| {
- struct_span_err!(tcx.sess, span, E0026,
- "{} `{}` does not have a field named `{}`",
- kind_name,
- tcx.item_path_str(variant.did),
- field.name)
- .span_label(span,
- format!("{} `{}` does not have field `{}`",
- kind_name,
- tcx.item_path_str(variant.did),
- field.name))
- .emit();
+ let mut err = struct_span_err!(
+ tcx.sess,
+ span,
+ E0026,
+ "{} `{}` does not have a field named `{}`",
+ kind_name,
+ tcx.item_path_str(variant.did),
+ field.name
+ );
+ err.span_label(span,
+ format!("{} `{}` does not have field `{}`",
+ kind_name,
+ tcx.item_path_str(variant.did),
+ field.name));
+ if tcx.sess.teach(&err.get_code().unwrap()) {
+ err.note(
+ "This error indicates that a struct pattern attempted to \
+ extract a non-existent field from a struct. Struct fields \
+ are identified by the name used before the colon : so struct \
+ patterns should resemble the declaration of the struct type \
+ being matched.\n\n\
+ If you are using shorthand field patterns but want to refer \
+ to the struct field by a different name, you should rename \
+ it explicitly."
+ );
+ }
+ err.emit();
tcx.types.err
})
if variant.ctor_kind == CtorKind::Fn {
diag.note("trying to match a tuple variant with a struct variant pattern");
}
+ if tcx.sess.teach(&diag.get_code().unwrap()) {
+ diag.note(
+ "This error indicates that a pattern for a struct fails to specify a \
+ sub-pattern for every one of the struct's fields. Ensure that each field \
+ from the struct's definition is mentioned in the pattern, or use `..` to \
+ ignore unwanted fields."
+ );
+ }
diag.emit();
}
}
fcx
};
- fcx.select_all_obligations_and_apply_defaults();
- fcx.closure_analyze(body);
+ // All type checking constraints were added, try to fallback unsolved variables.
+ fcx.select_obligations_where_possible();
+ for ty in &fcx.unsolved_variables() {
+ fcx.fallback_if_possible(ty);
+ }
fcx.select_obligations_where_possible();
+
+ // Even though coercion casts provide type hints, we check casts after fallback for
+ // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
fcx.check_casts();
+
+ // Closure and generater analysis may run after fallback
+ // because they don't constrain other type variables.
+ fcx.closure_analyze(body);
+ assert!(fcx.deferred_call_resolutions.borrow().is_empty());
fcx.resolve_generator_interiors(def_id);
fcx.select_all_obligations_or_error();
.map(|node_item| !node_item.node.is_from_trait())
.unwrap_or(false);
- if !is_implemented {
+ if !is_implemented && !tcx.impl_is_default(impl_id) {
if !trait_item.defaultness.has_value() {
missing_items.push(trait_item);
} else if associated_type_overridden {
}
}
- /// Apply "fallbacks" to some types
- /// unconstrained types get replaced with ! or () (depending on whether
- /// feature(never_type) is enabled), unconstrained ints with i32, and
- /// unconstrained floats with f64.
- fn default_type_parameters(&self) {
+ // Tries to apply a fallback to `ty` if it is an unsolved variable.
+ // Non-numerics get replaced with ! or () (depending on whether
+ // feature(never_type) is enabled), unconstrained ints with i32,
+ // unconstrained floats with f64.
+ // Fallback becomes very dubious if we have encountered type-checking errors.
+ // In that case, fallback to TyError.
+ fn fallback_if_possible(&self, ty: Ty<'tcx>) {
use rustc::ty::error::UnconstrainedNumeric::Neither;
use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
- // Defaulting inference variables becomes very dubious if we have
- // encountered type-checking errors. Therefore, if we think we saw
- // some errors in this function, just resolve all uninstanted type
- // varibles to TyError.
- if self.is_tainted_by_errors() {
- for ty in &self.unsolved_variables() {
- if let ty::TyInfer(_) = self.shallow_resolve(ty).sty {
- debug!("default_type_parameters: defaulting `{:?}` to error", ty);
- self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx().types.err);
- }
- }
- return;
- }
-
- for ty in &self.unsolved_variables() {
- let resolved = self.resolve_type_vars_if_possible(ty);
- if self.type_var_diverges(resolved) {
- debug!("default_type_parameters: defaulting `{:?}` to `!` because it diverges",
- resolved);
- self.demand_eqtype(syntax_pos::DUMMY_SP, *ty,
- self.tcx.mk_diverging_default());
- } else {
- match self.type_is_unconstrained_numeric(resolved) {
- UnconstrainedInt => {
- debug!("default_type_parameters: defaulting `{:?}` to `i32`",
- resolved);
- self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.i32)
- },
- UnconstrainedFloat => {
- debug!("default_type_parameters: defaulting `{:?}` to `f32`",
- resolved);
- self.demand_eqtype(syntax_pos::DUMMY_SP, *ty, self.tcx.types.f64)
- }
- Neither => { }
- }
- }
- }
- }
-
- // Implements type inference fallback algorithm
- fn select_all_obligations_and_apply_defaults(&self) {
- self.select_obligations_where_possible();
- self.default_type_parameters();
- self.select_obligations_where_possible();
+ assert!(ty.is_ty_infer());
+ let fallback = match self.type_is_unconstrained_numeric(ty) {
+ _ if self.is_tainted_by_errors() => self.tcx().types.err,
+ UnconstrainedInt => self.tcx.types.i32,
+ UnconstrainedFloat => self.tcx.types.f64,
+ Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
+ Neither => return
+ };
+ debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
+ self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
}
fn select_all_obligations_or_error(&self) {
debug!("select_all_obligations_or_error");
-
- // upvar inference should have ensured that all deferred call
- // resolutions are handled by now.
- assert!(self.deferred_call_resolutions.borrow().is_empty());
-
- self.select_all_obligations_and_apply_defaults();
-
- let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
-
- match fulfillment_cx.select_all_or_error(self) {
- Ok(()) => { }
- Err(errors) => { self.report_fulfillment_errors(&errors, self.inh.body_id); }
+ if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
+ self.report_fulfillment_errors(&errors, self.inh.body_id);
}
}
});
}
- fn structurally_resolve_type_or_else<F>(&self, sp: Span, ty: Ty<'tcx>, f: F)
- -> Ty<'tcx>
- where F: Fn() -> Ty<'tcx>
- {
- let mut ty = self.resolve_type_vars_with_obligations(ty);
-
- if ty.is_ty_var() {
- let alternative = f();
-
- // If not, error.
- if alternative.is_ty_var() || alternative.references_error() {
- if !self.is_tainted_by_errors() {
- type_error_struct!(self.tcx.sess, sp, ty, E0619,
- "the type of this value must be known in this context")
- .emit();
- }
- self.demand_suptype(sp, self.tcx.types.err, ty);
- ty = self.tcx.types.err;
- } else {
- self.demand_suptype(sp, alternative, ty);
- ty = alternative;
- }
- }
-
- ty
- }
-
- // Resolves `typ` by a single level if `typ` is a type variable. If no
- // resolution is possible, then an error is reported.
+ // Resolves `typ` by a single level if `typ` is a type variable.
+ // If no resolution is possible, then an error is reported.
+ // Numeric inference variables may be left unresolved.
pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
- self.structurally_resolve_type_or_else(sp, ty, || {
+ let ty = self.resolve_type_vars_with_obligations(ty);
+ if !ty.is_ty_var() {
+ ty
+ } else {
+ if !self.is_tainted_by_errors() {
+ type_error_struct!(self.tcx.sess, sp, ty, E0619,
+ "the type of this value must be known in this context")
+ .emit();
+ }
+ self.demand_suptype(sp, self.tcx.types.err, ty);
self.tcx.types.err
- })
+ }
}
fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
let node = tcx.hir.get(node_id);
let mut is_trait = None;
+ let mut is_default_impl_trait = None;
let icx = ItemCtxt::new(tcx, def_id);
let no_generics = hir::Generics::empty();
NodeItem(item) => {
match item.node {
+ ItemImpl(_, _, defaultness, ref generics, ..) => {
+ if defaultness.is_default() {
+ is_default_impl_trait = tcx.impl_trait_ref(def_id);
+ }
+ generics
+ }
ItemFn(.., ref generics, _) |
- ItemImpl(_, _, _, ref generics, ..) |
ItemTy(_, ref generics) |
ItemEnum(_, ref generics) |
ItemStruct(_, ref generics) |
predicates.push(trait_ref.to_poly_trait_ref().to_predicate());
}
+ // In default impls, we can assume that the self type implements
+ // the trait. So in:
+ //
+ // default impl Foo for Bar { .. }
+ //
+ // we add a default where clause `Foo: Bar`. We do a similar thing for traits
+ // (see below). Recall that a default impl is not itself an impl, but rather a
+ // set of defaults that can be incorporated into another impl.
+ if let Some(trait_ref) = is_default_impl_trait {
+ predicates.push(trait_ref.to_poly_trait_ref().to_predicate());
+ }
+
// Collect the region predicates that were declared inline as
// well. In the case of parameters declared on a fn or method, we
// have to be careful to only iterate over early-bound regions.
.content .highlighted.primitive { background-color: #00708a; }
.content span.enum, .content a.enum, .block a.current.enum { color: #82b089; }
-.content span.struct, .content a.struct, .block a.current.struct { color: #ff794d; }
+.content span.struct, .content a.struct, .block a.current.struct { color: #2dbfb8; }
.content span.type, .content a.type, .block a.current.type { color: #ff7f00; }
.content span.foreigntype, .content a.foreigntype, .block a.current.foreigntype { color: #dd7de8; }
.content span.macro, .content a.macro, .block a.current.macro { color: #09bd00; }
.content .highlighted.primitive { background-color: #9aecff; }
.content span.enum, .content a.enum, .block a.current.enum { color: #508157; }
-.content span.struct, .content a.struct, .block a.current.struct { color: #df3600; }
+.content span.struct, .content a.struct, .block a.current.struct { color: #ad448e; }
.content span.type, .content a.type, .block a.current.type { color: #ba5d00; }
.content span.foreigntype, .content a.foreigntype, .block a.current.foreigntype { color: #cd00e2; }
.content span.macro, .content a.macro, .block a.current.macro { color: #068000; }
opts: &TestOptions)
-> (String, usize) {
let (crate_attrs, everything_else) = partition_source(s);
+ let everything_else = everything_else.trim();
let mut line_offset = 0;
let mut prog = String::new();
.any(|code| code.contains("fn main"));
if dont_insert_main || already_has_main {
- prog.push_str(&everything_else);
+ prog.push_str(everything_else);
} else {
prog.push_str("fn main() {\n");
line_offset += 1;
- prog.push_str(&everything_else);
- prog = prog.trim().into();
+ prog.push_str(everything_else);
prog.push_str("\n}");
}
self.visit_testable(macro_def.name.to_string(), ¯o_def.attrs, |_| ());
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::{TestOptions, make_test};
+
+ #[test]
+ fn make_test_basic() {
+ //basic use: wraps with `fn main`, adds `#![allow(unused)]`
+ let opts = TestOptions::default();
+ let input =
+"assert_eq!(2+2, 4);";
+ let expected =
+"#![allow(unused)]
+fn main() {
+assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, None, false, &opts);
+ assert_eq!(output, (expected.clone(), 2));
+ }
+
+ #[test]
+ fn make_test_crate_name_no_use() {
+ //if you give a crate name but *don't* use it within the test, it won't bother inserting
+ //the `extern crate` statement
+ let opts = TestOptions::default();
+ let input =
+"assert_eq!(2+2, 4);";
+ let expected =
+"#![allow(unused)]
+fn main() {
+assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, Some("asdf"), false, &opts);
+ assert_eq!(output, (expected, 2));
+ }
+
+ #[test]
+ fn make_test_crate_name() {
+ //if you give a crate name and use it within the test, it will insert an `extern crate`
+ //statement before `fn main`
+ let opts = TestOptions::default();
+ let input =
+"use asdf::qwop;
+assert_eq!(2+2, 4);";
+ let expected =
+"#![allow(unused)]
+extern crate asdf;
+fn main() {
+use asdf::qwop;
+assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, Some("asdf"), false, &opts);
+ assert_eq!(output, (expected, 3));
+ }
+
+ #[test]
+ fn make_test_no_crate_inject() {
+ //even if you do use the crate within the test, setting `opts.no_crate_inject` will skip
+ //adding it anyway
+ let opts = TestOptions {
+ no_crate_inject: true,
+ attrs: vec![],
+ };
+ let input =
+"use asdf::qwop;
+assert_eq!(2+2, 4);";
+ let expected =
+"#![allow(unused)]
+fn main() {
+use asdf::qwop;
+assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, Some("asdf"), false, &opts);
+ assert_eq!(output, (expected, 2));
+ }
+
+ #[test]
+ fn make_test_ignore_std() {
+ //even if you include a crate name, and use it in the doctest, we still won't include an
+ //`extern crate` statement if the crate is "std" - that's included already by the compiler!
+ let opts = TestOptions::default();
+ let input =
+"use std::*;
+assert_eq!(2+2, 4);";
+ let expected =
+"#![allow(unused)]
+fn main() {
+use std::*;
+assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, Some("std"), false, &opts);
+ assert_eq!(output, (expected, 2));
+ }
+
+ #[test]
+ fn make_test_manual_extern_crate() {
+ //when you manually include an `extern crate` statement in your doctest, make_test assumes
+ //you've included one for your own crate too
+ let opts = TestOptions::default();
+ let input =
+"extern crate asdf;
+use asdf::qwop;
+assert_eq!(2+2, 4);";
+ let expected =
+"#![allow(unused)]
+fn main() {
+extern crate asdf;
+use asdf::qwop;
+assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, Some("asdf"), false, &opts);
+ assert_eq!(output, (expected, 2));
+ }
+
+ #[test]
+ fn make_test_opts_attrs() {
+ //if you supplied some doctest attributes with #![doc(test(attr(...)))], it will use those
+ //instead of the stock #![allow(unused)]
+ let mut opts = TestOptions::default();
+ opts.attrs.push("feature(sick_rad)".to_string());
+ let input =
+"use asdf::qwop;
+assert_eq!(2+2, 4);";
+ let expected =
+"#![feature(sick_rad)]
+extern crate asdf;
+fn main() {
+use asdf::qwop;
+assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, Some("asdf"), false, &opts);
+ assert_eq!(output, (expected, 3));
+
+ //adding more will also bump the returned line offset
+ opts.attrs.push("feature(hella_dope)".to_string());
+ let expected =
+"#![feature(sick_rad)]
+#![feature(hella_dope)]
+extern crate asdf;
+fn main() {
+use asdf::qwop;
+assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, Some("asdf"), false, &opts);
+ assert_eq!(output, (expected, 4));
+ }
+
+ #[test]
+ fn make_test_crate_attrs() {
+ //including inner attributes in your doctest will apply them to the whole "crate", pasting
+ //them outside the generated main function
+ let opts = TestOptions::default();
+ let input =
+"#![feature(sick_rad)]
+assert_eq!(2+2, 4);";
+ let expected =
+"#![allow(unused)]
+#![feature(sick_rad)]
+fn main() {
+assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, None, false, &opts);
+ assert_eq!(output, (expected, 2));
+ }
+
+ #[test]
+ fn make_test_with_main() {
+ //including your own `fn main` wrapper lets the test use it verbatim
+ let opts = TestOptions::default();
+ let input =
+"fn main() {
+ assert_eq!(2+2, 4);
+}";
+ let expected =
+"#![allow(unused)]
+fn main() {
+ assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, None, false, &opts);
+ assert_eq!(output, (expected, 1));
+ }
+
+ #[test]
+ fn make_test_fake_main() {
+ //...but putting it in a comment will still provide a wrapper
+ let opts = TestOptions::default();
+ let input =
+"//Ceci n'est pas une `fn main`
+assert_eq!(2+2, 4);";
+ let expected =
+"#![allow(unused)]
+fn main() {
+//Ceci n'est pas une `fn main`
+assert_eq!(2+2, 4);
+}".to_string();
+ let output = make_test(input, None, false, &opts);
+ assert_eq!(output, (expected.clone(), 2));
+ }
+
+ #[test]
+ fn make_test_dont_insert_main() {
+ //even with that, if you set `dont_insert_main`, it won't create the `fn main` wrapper
+ let opts = TestOptions::default();
+ let input =
+"//Ceci n'est pas une `fn main`
+assert_eq!(2+2, 4);";
+ let expected =
+"#![allow(unused)]
+//Ceci n'est pas une `fn main`
+assert_eq!(2+2, 4);".to_string();
+ let output = make_test(input, None, true, &opts);
+ assert_eq!(output, (expected.clone(), 1));
+ }
+}
}
/// Search for a pre-hashed key.
+/// If you don't already know the hash, use search or search_mut instead
#[inline]
-fn search_hashed<K, V, M, F>(table: M, hash: SafeHash, mut is_match: F) -> InternalEntry<K, V, M>
+fn search_hashed<K, V, M, F>(table: M, hash: SafeHash, is_match: F) -> InternalEntry<K, V, M>
where M: Deref<Target = RawTable<K, V>>,
F: FnMut(&K) -> bool
{
return InternalEntry::TableIsEmpty;
}
+ search_hashed_nonempty(table, hash, is_match)
+}
+
+/// Search for a pre-hashed key when the hash map is known to be non-empty.
+#[inline]
+fn search_hashed_nonempty<K, V, M, F>(table: M, hash: SafeHash, mut is_match: F)
+ -> InternalEntry<K, V, M>
+ where M: Deref<Target = RawTable<K, V>>,
+ F: FnMut(&K) -> bool
+{
+ // Do not check the capacity as an extra branch could slow the lookup.
+
let size = table.size();
let mut probe = Bucket::new(table, hash);
let mut displacement = 0;
}
/// Search for a key, yielding the index if it's found in the hashtable.
- /// If you already have the hash for the key lying around, use
- /// search_hashed.
+ /// If you already have the hash for the key lying around, or if you need an
+ /// InternalEntry, use search_hashed or search_hashed_nonempty.
#[inline]
- fn search<'a, Q: ?Sized>(&'a self, q: &Q) -> InternalEntry<K, V, &'a RawTable<K, V>>
+ fn search<'a, Q: ?Sized>(&'a self, q: &Q)
+ -> Option<FullBucket<K, V, &'a RawTable<K, V>>>
where K: Borrow<Q>,
Q: Eq + Hash
{
+ if self.is_empty() {
+ return None;
+ }
+
let hash = self.make_hash(q);
- search_hashed(&self.table, hash, |k| q.eq(k.borrow()))
+ search_hashed_nonempty(&self.table, hash, |k| q.eq(k.borrow()))
+ .into_occupied_bucket()
}
#[inline]
- fn search_mut<'a, Q: ?Sized>(&'a mut self, q: &Q) -> InternalEntry<K, V, &'a mut RawTable<K, V>>
+ fn search_mut<'a, Q: ?Sized>(&'a mut self, q: &Q)
+ -> Option<FullBucket<K, V, &'a mut RawTable<K, V>>>
where K: Borrow<Q>,
Q: Eq + Hash
{
+ if self.is_empty() {
+ return None;
+ }
+
let hash = self.make_hash(q);
- search_hashed(&mut self.table, hash, |k| q.eq(k.borrow()))
+ search_hashed_nonempty(&mut self.table, hash, |k| q.eq(k.borrow()))
+ .into_occupied_bucket()
}
// The caller should ensure that invariants by Robin Hood Hashing hold
where K: Borrow<Q>,
Q: Hash + Eq
{
- self.search(k).into_occupied_bucket().map(|bucket| bucket.into_refs().1)
+ self.search(k).map(|bucket| bucket.into_refs().1)
}
/// Returns true if the map contains a value for the specified key.
where K: Borrow<Q>,
Q: Hash + Eq
{
- self.search(k).into_occupied_bucket().is_some()
+ self.search(k).is_some()
}
/// Returns a mutable reference to the value corresponding to the key.
where K: Borrow<Q>,
Q: Hash + Eq
{
- self.search_mut(k).into_occupied_bucket().map(|bucket| bucket.into_mut_refs().1)
+ self.search_mut(k).map(|bucket| bucket.into_mut_refs().1)
}
/// Inserts a key-value pair into the map.
where K: Borrow<Q>,
Q: Hash + Eq
{
- if self.table.size() == 0 {
- return None;
- }
-
- self.search_mut(k).into_occupied_bucket().map(|bucket| pop_internal(bucket).1)
+ self.search_mut(k).map(|bucket| pop_internal(bucket).1)
}
/// Removes a key from the map, returning the stored key and value if the
where K: Borrow<Q>,
Q: Hash + Eq
{
- if self.table.size() == 0 {
- return None;
- }
-
self.search_mut(k)
- .into_occupied_bucket()
.map(|bucket| {
let (k, v, _) = pop_internal(bucket);
(k, v)
#[inline]
fn get(&self, key: &Q) -> Option<&K> {
- self.search(key).into_occupied_bucket().map(|bucket| bucket.into_refs().0)
+ self.search(key).map(|bucket| bucket.into_refs().0)
}
fn take(&mut self, key: &Q) -> Option<K> {
- if self.table.size() == 0 {
- return None;
- }
-
- self.search_mut(key).into_occupied_bucket().map(|bucket| pop_internal(bucket).0)
+ self.search_mut(key).map(|bucket| pop_internal(bucket).0)
}
#[inline]
ArgsOs { inner: sys::args::args() }
}
+#[stable(feature = "env_unimpl_send_sync", since = "1.25.0")]
+impl !Send for Args {}
+
+#[stable(feature = "env_unimpl_send_sync", since = "1.25.0")]
+impl !Sync for Args {}
+
#[stable(feature = "env", since = "1.0.0")]
impl Iterator for Args {
type Item = String;
}
}
+#[stable(feature = "env_unimpl_send_sync", since = "1.25.0")]
+impl !Send for ArgsOs {}
+
+#[stable(feature = "env_unimpl_send_sync", since = "1.25.0")]
+impl !Sync for ArgsOs {}
+
#[stable(feature = "env", since = "1.0.0")]
impl Iterator for ArgsOs {
type Item = OsString;
/// This is currently identical to `transmute::<u32, f32>(v)` on all platforms.
/// It turns out this is incredibly portable, for two reasons:
///
- /// * Floats and Ints have the same endianess on all supported platforms.
+ /// * Floats and Ints have the same endianness on all supported platforms.
/// * IEEE-754 very precisely specifies the bit layout of floats.
///
/// However there is one caveat: prior to the 2008 version of IEEE-754, how
/// This is currently identical to `transmute::<u64, f64>(v)` on all platforms.
/// It turns out this is incredibly portable, for two reasons:
///
- /// * Floats and Ints have the same endianess on all supported platforms.
+ /// * Floats and Ints have the same endianness on all supported platforms.
/// * IEEE-754 very precisely specifies the bit layout of floats.
///
/// However there is one caveat: prior to the 2008 version of IEEE-754, how
fn flush(&mut self) -> io::Result<()> { Ok(()) }
}
-#[unstable(feature = "cursor_mut_vec", issue = "30132")]
+#[stable(feature = "cursor_mut_vec", since = "1.25.0")]
impl<'a> Write for Cursor<&'a mut Vec<u8>> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
vec_write(&mut self.pos, self.inner, buf)
///
/// If successful, this function will return the total number of bytes read.
///
- /// An empty buffer returned indicates that the stream has reached EOF.
- ///
/// # Errors
///
/// This function will ignore all instances of [`ErrorKind::Interrupted`] and
}
}
-#[stable(feature = "path_component_asref", since = "1.24.0")]
+#[stable(feature = "path_component_asref", since = "1.25.0")]
impl<'a> AsRef<Path> for Component<'a> {
fn as_ref(&self) -> &Path {
self.as_os_str().as_ref()
/// The 8-bit signed integer type.
///
/// *[See also the `std::i8` module](i8/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `i64` in there.
-///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_i8 { }
/// The 16-bit signed integer type.
///
/// *[See also the `std::i16` module](i16/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `i32` in there.
-///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_i16 { }
/// The 32-bit signed integer type.
///
/// *[See also the `std::i32` module](i32/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `i16` in there.
-///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_i32 { }
/// The 64-bit signed integer type.
///
/// *[See also the `std::i64` module](i64/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `i8` in there.
-///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_i64 { }
/// The 128-bit signed integer type.
///
/// *[See also the `std::i128` module](i128/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `i8` in there.
-///
#[unstable(feature = "i128", issue="35118")]
mod prim_i128 { }
/// The 8-bit unsigned integer type.
///
/// *[See also the `std::u8` module](u8/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `u64` in there.
-///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_u8 { }
/// The 16-bit unsigned integer type.
///
/// *[See also the `std::u16` module](u16/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `u32` in there.
-///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_u16 { }
/// The 32-bit unsigned integer type.
///
/// *[See also the `std::u32` module](u32/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `u16` in there.
-///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_u32 { }
/// The 64-bit unsigned integer type.
///
/// *[See also the `std::u64` module](u64/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `u8` in there.
-///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_u64 { }
/// The 128-bit unsigned integer type.
///
/// *[See also the `std::u128` module](u128/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `u8` in there.
-///
#[unstable(feature = "i128", issue="35118")]
mod prim_u128 { }
/// and on a 64 bit target, this is 8 bytes.
///
/// *[See also the `std::isize` module](isize/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `usize` in there.
-///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_isize { }
/// and on a 64 bit target, this is 8 bytes.
///
/// *[See also the `std::usize` module](usize/index.html).*
-///
-/// However, please note that examples are shared between primitive integer
-/// types. So it's normal if you see usage of types like `isize` in there.
-///
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_usize { }
///
/// thread::spawn(move|| {
/// let &(ref lock, ref cvar) = &*pair2;
+ ///
+ /// // Let's wait 20 milliseconds before notifying the condvar.
+ /// thread::sleep(Duration::from_millis(20));
+ ///
/// let mut started = lock.lock().unwrap();
/// // We update the boolean value.
/// *started = true;
- /// // Let's wait 20 milliseconds before notifying the condvar.
- /// thread::sleep(Duration::from_millis(20));
/// cvar.notify_one();
/// });
///
fn file_size(&self) -> u64 { self.as_inner().size() }
}
+/// Add support for the Windows specific fact that a symbolic link knows whether it is a file
+/// or directory.
+#[unstable(feature = "windows_file_type_ext", issue = "0")]
+pub trait FileTypeExt {
+ /// Returns whether this file type is a symbolic link that is also a directory.
+ #[unstable(feature = "windows_file_type_ext", issue = "0")]
+ fn is_symlink_dir(&self) -> bool;
+ /// Returns whether this file type is a symbolic link that is also a file.
+ #[unstable(feature = "windows_file_type_ext", issue = "0")]
+ fn is_symlink_file(&self) -> bool;
+}
+
+#[unstable(feature = "windows_file_type_ext", issue = "0")]
+impl FileTypeExt for fs::FileType {
+ fn is_symlink_dir(&self) -> bool { self.as_inner().is_symlink_dir() }
+ fn is_symlink_file(&self) -> bool { self.as_inner().is_symlink_file() }
+}
+
/// Creates a new file symbolic link on the filesystem.
///
/// The `dst` path will be a file symbolic link pointing to the `src`
}
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-pub enum FileType {
- Dir, File, SymlinkFile, SymlinkDir, ReparsePoint, MountPoint,
+pub struct FileType {
+ attributes: c::DWORD,
+ reparse_tag: c::DWORD,
}
pub struct ReadDir {
impl FileType {
fn new(attrs: c::DWORD, reparse_tag: c::DWORD) -> FileType {
- match (attrs & c::FILE_ATTRIBUTE_DIRECTORY != 0,
- attrs & c::FILE_ATTRIBUTE_REPARSE_POINT != 0,
- reparse_tag) {
- (false, false, _) => FileType::File,
- (true, false, _) => FileType::Dir,
- (false, true, c::IO_REPARSE_TAG_SYMLINK) => FileType::SymlinkFile,
- (true, true, c::IO_REPARSE_TAG_SYMLINK) => FileType::SymlinkDir,
- (true, true, c::IO_REPARSE_TAG_MOUNT_POINT) => FileType::MountPoint,
- (_, true, _) => FileType::ReparsePoint,
- // Note: if a _file_ has a reparse tag of the type IO_REPARSE_TAG_MOUNT_POINT it is
- // invalid, as junctions always have to be dirs. We set the filetype to ReparsePoint
- // to indicate it is something symlink-like, but not something you can follow.
+ FileType {
+ attributes: attrs,
+ reparse_tag: reparse_tag,
}
}
-
- pub fn is_dir(&self) -> bool { *self == FileType::Dir }
- pub fn is_file(&self) -> bool { *self == FileType::File }
+ pub fn is_dir(&self) -> bool {
+ !self.is_symlink() && self.is_directory()
+ }
+ pub fn is_file(&self) -> bool {
+ !self.is_symlink() && !self.is_directory()
+ }
pub fn is_symlink(&self) -> bool {
- *self == FileType::SymlinkFile ||
- *self == FileType::SymlinkDir ||
- *self == FileType::MountPoint
+ self.is_reparse_point() && self.is_reparse_tag_name_surrogate()
}
pub fn is_symlink_dir(&self) -> bool {
- *self == FileType::SymlinkDir || *self == FileType::MountPoint
+ self.is_symlink() && self.is_directory()
+ }
+ pub fn is_symlink_file(&self) -> bool {
+ self.is_symlink() && !self.is_directory()
+ }
+ fn is_directory(&self) -> bool {
+ self.attributes & c::FILE_ATTRIBUTE_DIRECTORY != 0
+ }
+ fn is_reparse_point(&self) -> bool {
+ self.attributes & c::FILE_ATTRIBUTE_REPARSE_POINT != 0
+ }
+ fn is_reparse_tag_name_surrogate(&self) -> bool {
+ self.reparse_tag & 0x20000000 != 0
}
}
pub fn mk_substr_filename(&self, sp: Span) -> String {
let pos = self.lookup_char_pos(sp.lo());
- (format!("<{}:{}:{}>",
+ format!("<{}:{}:{}>",
pos.file.name,
pos.line,
- pos.col.to_usize() + 1)).to_string()
+ pos.col.to_usize() + 1)
}
// If there is a doctest_offset, apply it to the line
let lo = self.lookup_char_pos_adj(sp.lo());
let hi = self.lookup_char_pos_adj(sp.hi());
- return (format!("{}:{}:{}: {}:{}",
+ format!("{}:{}:{}: {}:{}",
lo.filename,
lo.line,
lo.col.to_usize() + 1,
hi.line,
- hi.col.to_usize() + 1)).to_string()
+ hi.col.to_usize() + 1)
}
pub fn span_to_filename(&self, sp: Span) -> FileName {
return 1;
}
+ let src = local_begin.fm.external_src.borrow();
+
// 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() {
+ (&src[start_index..len])
+ } else if let Some(src) = src.get_source() {
let len = src.len();
- (&src[start_index..len]).to_string()
+ (&src[start_index..len])
} else {
return 1;
};
match_hi: usize,
// Specifically used if we are matching a repetition. If we aren't both should be `None`.
+ /// The KleeneOp of this sequence if we are in a repetition.
+ seq_op: Option<quoted::KleeneOp>,
/// 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
stack: vec![],
// Haven't descended into any sequences, so both of these are `None`.
+ seq_op: None,
sep: None,
up: None,
})
}
}
// We don't need a separator. Move the "dot" back to the beginning of the matcher
- // and try to match again.
- else {
+ // and try to match again UNLESS we are only allowed to have _one_ repetition.
+ else if item.seq_op != Some(quoted::KleeneOp::ZeroOrOne) {
item.match_cur = item.match_lo;
item.idx = 0;
cur_items.push(item);
match item.top_elts.get_tt(idx) {
// 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
+ // Examine the case where there are 0 matches of this sequence
+ if seq.op == quoted::KleeneOp::ZeroOrMore
+ || seq.op == quoted::KleeneOp::ZeroOrOne
+ {
let mut new_item = item.clone();
new_item.match_cur += seq.num_captures;
new_item.idx += 1;
cur_items.push(new_item);
}
- // Examine the case where there is at least one match of this sequence
let matches = create_matches(item.matches.len());
cur_items.push(Box::new(MatcherPos {
stack: vec![],
sep: seq.separator.clone(),
+ seq_op: Some(seq.op),
idx: 0,
matches,
match_lo: item.match_cur,
s.iter().map(|m| {
if let MatchedNonterminal(ref nt) = *m {
if let NtTT(ref tt) = **nt {
- let tt = quoted::parse(tt.clone().into(), true, sess).pop().unwrap();
+ let tt = quoted::parse(tt.clone().into(), true, sess, features, &def.attrs)
+ .pop().unwrap();
valid &= check_lhs_nt_follows(sess, features, &def.attrs, &tt);
return tt;
}
s.iter().map(|m| {
if let MatchedNonterminal(ref nt) = *m {
if let NtTT(ref tt) = **nt {
- return quoted::parse(tt.clone().into(), false, sess).pop().unwrap();
+ return quoted::parse(tt.clone().into(), false, sess, features, &def.attrs)
+ .pop().unwrap();
}
}
sess.span_diagnostic.span_bug(def.span, "wrong-structured lhs")
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use ast;
+use {ast, attr};
use ext::tt::macro_parser;
+use feature_gate::{self, emit_feature_err, Features, GateIssue};
use parse::{token, ParseSess};
use print::pprust;
use symbol::keywords;
use syntax_pos::{BytePos, Span, DUMMY_SP};
use tokenstream;
+use std::cell::RefCell;
+use std::iter::Peekable;
use std::rc::Rc;
/// Contains the sub-token-trees of a "delimited" token tree, such as the contents of `(`. Note
ZeroOrMore,
/// Kleene plus (`+`) for one or more repetitions
OneOrMore,
+ ZeroOrOne,
}
/// Similar to `tokenstream::TokenTree`, except that `$i`, `$i:ident`, 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.
+/// - `features`, `attrs`: language feature flags and attributes so that we know whether to use
+/// unstable features or not.
///
/// # Returns
///
input: tokenstream::TokenStream,
expect_matchers: bool,
sess: &ParseSess,
+ features: &RefCell<Features>,
+ attrs: &[ast::Attribute],
) -> 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();
+ let mut trees = input.trees().peekable();
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`).
+ let tree = parse_tree(tree, &mut trees, expect_matchers, sess, features, attrs);
match tree {
TokenTree::MetaVar(start_sp, ident) if expect_matchers => {
let span = match trees.next() {
/// converting `tree`
/// - `expect_matchers`: same as for `parse` (see above).
/// - `sess`: the parsing session. Any errors will be emitted to this session.
+/// - `features`, `attrs`: language feature flags and attributes so that we know whether to use
+/// unstable features or not.
fn parse_tree<I>(
tree: tokenstream::TokenTree,
- trees: &mut I,
+ trees: &mut Peekable<I>,
expect_matchers: bool,
sess: &ParseSess,
+ features: &RefCell<Features>,
+ attrs: &[ast::Attribute],
) -> TokenTree
where
I: Iterator<Item = tokenstream::TokenTree>,
sess.span_diagnostic.span_err(span, &msg);
}
// Parse the contents of the sequence itself
- let sequence = parse(delimited.tts.into(), expect_matchers, sess);
+ let sequence = parse(delimited.tts.into(), expect_matchers, sess, features, attrs);
// Get the Kleene operator and optional separator
- let (separator, op) = parse_sep_and_kleene_op(trees, span, sess);
+ let (separator, op) = parse_sep_and_kleene_op(trees, span, sess, features, attrs);
// Count the number of captured "names" (i.e. named metavars)
let name_captures = macro_parser::count_names(&sequence);
TokenTree::Sequence(
span,
Rc::new(Delimited {
delim: delimited.delim,
- tts: parse(delimited.tts.into(), expect_matchers, sess),
+ tts: parse(delimited.tts.into(), expect_matchers, sess, features, attrs),
}),
),
}
}
+/// Takes a token and returns `Some(KleeneOp)` if the token is `+` `*` or `?`. Otherwise, return
+/// `None`.
+fn kleene_op(token: &token::Token) -> Option<KleeneOp> {
+ match *token {
+ token::BinOp(token::Star) => Some(KleeneOp::ZeroOrMore),
+ token::BinOp(token::Plus) => Some(KleeneOp::OneOrMore),
+ token::Question => Some(KleeneOp::ZeroOrOne),
+ _ => None,
+ }
+}
+
+/// Parse the next token tree of the input looking for a KleeneOp. Returns
+///
+/// - Ok(Ok(op)) if the next token tree is a KleeneOp
+/// - Ok(Err(tok, span)) if the next token tree is a token but not a KleeneOp
+/// - Err(span) if the next token tree is not a token
+fn parse_kleene_op<I>(
+ input: &mut I,
+ span: Span,
+) -> Result<Result<KleeneOp, (token::Token, Span)>, Span>
+where
+ I: Iterator<Item = tokenstream::TokenTree>,
+{
+ match input.next() {
+ Some(tokenstream::TokenTree::Token(span, tok)) => match kleene_op(&tok) {
+ Some(op) => Ok(Ok(op)),
+ None => Ok(Err((tok, span))),
+ },
+ tree => Err(tree.as_ref()
+ .map(tokenstream::TokenTree::span)
+ .unwrap_or(span)),
+ }
+}
+
/// 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
/// 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,
+ input: &mut Peekable<I>,
span: Span,
sess: &ParseSess,
+ features: &RefCell<Features>,
+ attrs: &[ast::Attribute],
) -> (Option<token::Token>, KleeneOp)
where
I: Iterator<Item = tokenstream::TokenTree>,
{
- fn kleene_op(token: &token::Token) -> Option<KleeneOp> {
- match *token {
- token::BinOp(token::Star) => Some(KleeneOp::ZeroOrMore),
- token::BinOp(token::Plus) => Some(KleeneOp::OneOrMore),
- _ => None,
+ // We basically look at two token trees here, denoted as #1 and #2 below
+ let span = match parse_kleene_op(input, span) {
+ // #1 is a `+` or `*` KleeneOp
+ //
+ // `?` is ambiguous: it could be a separator or a Kleene::ZeroOrOne, so we need to look
+ // ahead one more token to be sure.
+ Ok(Ok(op)) if op != KleeneOp::ZeroOrOne => return (None, op),
+
+ // #1 is `?` token, but it could be a Kleene::ZeroOrOne without a separator or it could
+ // be a `?` separator followed by any Kleene operator. We need to look ahead 1 token to
+ // find out which.
+ Ok(Ok(op)) => {
+ assert_eq!(op, KleeneOp::ZeroOrOne);
+
+ // Lookahead at #2. If it is a KleenOp, then #1 is a separator.
+ let is_1_sep = if let Some(&tokenstream::TokenTree::Token(_, ref tok2)) = input.peek() {
+ kleene_op(tok2).is_some()
+ } else {
+ false
+ };
+
+ if is_1_sep {
+ // #1 is a separator and #2 should be a KleepeOp::*
+ // (N.B. We need to advance the input iterator.)
+ match parse_kleene_op(input, span) {
+ // #2 is a KleeneOp (this is the only valid option) :)
+ Ok(Ok(op)) if op == KleeneOp::ZeroOrOne => {
+ if !features.borrow().macro_at_most_once_rep
+ && !attr::contains_name(attrs, "allow_internal_unstable")
+ {
+ let explain = feature_gate::EXPLAIN_MACRO_AT_MOST_ONCE_REP;
+ emit_feature_err(
+ sess,
+ "macro_at_most_once_rep",
+ span,
+ GateIssue::Language,
+ explain,
+ );
+ }
+ return (Some(token::Question), op);
+ }
+ Ok(Ok(op)) => return (Some(token::Question), op),
+
+ // #2 is a random token (this is an error) :(
+ Ok(Err((_, span))) => span,
+
+ // #2 is not even a token at all :(
+ Err(span) => span,
+ }
+ } else {
+ if !features.borrow().macro_at_most_once_rep
+ && !attr::contains_name(attrs, "allow_internal_unstable")
+ {
+ let explain = feature_gate::EXPLAIN_MACRO_AT_MOST_ONCE_REP;
+ emit_feature_err(
+ sess,
+ "macro_at_most_once_rep",
+ span,
+ GateIssue::Language,
+ explain,
+ );
+ }
+
+ // #2 is a random tree and #1 is KleeneOp::ZeroOrOne
+ return (None, op);
+ }
}
- }
- // 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,
- },
-
- // #2 is not a token at all... error
- tree => tree.as_ref()
- .map(tokenstream::TokenTree::span)
- .unwrap_or(span),
- },
+ // #1 is a separator followed by #2, a KleeneOp
+ Ok(Err((tok, span))) => match parse_kleene_op(input, span) {
+ // #2 is a KleeneOp :D
+ Ok(Ok(op)) if op == KleeneOp::ZeroOrOne => {
+ if !features.borrow().macro_at_most_once_rep
+ && !attr::contains_name(attrs, "allow_internal_unstable")
+ {
+ let explain = feature_gate::EXPLAIN_MACRO_AT_MOST_ONCE_REP;
+ emit_feature_err(
+ sess,
+ "macro_at_most_once_rep",
+ span,
+ GateIssue::Language,
+ explain,
+ );
+ }
+ return (Some(tok), op);
+ }
+ Ok(Ok(op)) => return (Some(tok), op),
+
+ // #2 is a random token :(
+ Ok(Err((_, span))) => span,
+
+ // #2 is not a token at all :(
+ Err(span) => span,
},
- // #1 is not a token at all... error
- tree => tree.as_ref()
- .map(tokenstream::TokenTree::span)
- .unwrap_or(span),
+ // #1 is not a token
+ Err(span) => span,
};
- // Error...
- sess.span_diagnostic.span_err(span, "expected `*` or `+`");
+ if !features.borrow().macro_at_most_once_rep
+ && !attr::contains_name(attrs, "allow_internal_unstable")
+ {
+ sess.span_diagnostic
+ .span_err(span, "expected one of: `*`, `+`, or `?`");
+ } else {
+ sess.span_diagnostic.span_err(span, "expected `*` or `+`");
+ }
(None, KleeneOp::ZeroOrMore)
}
// Allows `#[repr(transparent)]` attribute on newtype structs
(active, repr_transparent, "1.25.0", Some(43036)),
+
+ // Use `?` as the Kleene "at most one" operator
+ (active, macro_at_most_once_rep, "1.25.0", Some(48075)),
);
declare_features! (
// instead of just the platforms on which it is the C ABI
(accepted, abi_sysv64, "1.24.0", Some(36167)),
// Allows `repr(align(16))` struct attribute (RFC 1358)
- (accepted, repr_align, "1.24.0", Some(33626)),
+ (accepted, repr_align, "1.25.0", Some(33626)),
// allow '|' at beginning of match arms (RFC 1925)
(accepted, match_beginning_vert, "1.25.0", Some(44101)),
// Nested groups in `use` (RFC 2128)
pub const EXPLAIN_UNSIZED_TUPLE_COERCION: &'static str =
"Unsized tuple coercion is not stable enough for use and is subject to change";
+pub const EXPLAIN_MACRO_AT_MOST_ONCE_REP: &'static str =
+ "Using the `?` macro Kleene operator for \"at most one\" repetition is unstable";
+
struct PostExpansionVisitor<'a> {
context: &'a Context<'a>,
}
|p| {
if p.token == token::DotDotDot {
p.bump();
+ variadic = true;
if allow_variadic {
if p.token != token::CloseDelim(token::Paren) {
let span = p.span;
p.span_err(span,
"`...` must be last in argument list for variadic function");
}
+ Ok(None)
} else {
- let span = p.span;
- p.span_err(span,
- "only foreign functions are allowed to be variadic");
+ let span = p.prev_span;
+ if p.token == token::CloseDelim(token::Paren) {
+ // continue parsing to present any further errors
+ p.struct_span_err(
+ span,
+ "only foreign functions are allowed to be variadic"
+ ).emit();
+ Ok(Some(dummy_arg(span)))
+ } else {
+ // this function definition looks beyond recovery, stop parsing
+ p.span_err(span,
+ "only foreign functions are allowed to be variadic");
+ Ok(None)
+ }
}
- variadic = true;
- Ok(None)
} else {
match p.parse_arg_general(named_args) {
Ok(arg) => Ok(Some(arg)),
--- /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.
+
+#include "llvm/Linker/Linker.h"
+
+#include "rustllvm.h"
+
+using namespace llvm;
+
+struct RustLinker {
+ Linker L;
+ LLVMContext &Ctx;
+
+ RustLinker(Module &M) :
+ L(M),
+ Ctx(M.getContext())
+ {}
+};
+
+extern "C" RustLinker*
+LLVMRustLinkerNew(LLVMModuleRef DstRef) {
+ Module *Dst = unwrap(DstRef);
+
+ auto Ret = llvm::make_unique<RustLinker>(*Dst);
+ return Ret.release();
+}
+
+extern "C" void
+LLVMRustLinkerFree(RustLinker *L) {
+ delete L;
+}
+
+extern "C" bool
+LLVMRustLinkerAdd(RustLinker *L, char *BC, size_t Len) {
+ std::unique_ptr<MemoryBuffer> Buf =
+ MemoryBuffer::getMemBufferCopy(StringRef(BC, Len));
+
+#if LLVM_VERSION_GE(4, 0)
+ Expected<std::unique_ptr<Module>> SrcOrError =
+ llvm::getLazyBitcodeModule(Buf->getMemBufferRef(), L->Ctx);
+ if (!SrcOrError) {
+ LLVMRustSetLastError(toString(SrcOrError.takeError()).c_str());
+ return false;
+ }
+
+ auto Src = std::move(*SrcOrError);
+#else
+ ErrorOr<std::unique_ptr<Module>> Src =
+ llvm::getLazyBitcodeModule(std::move(Buf), L->Ctx);
+ if (!Src) {
+ LLVMRustSetLastError(Src.getError().message().c_str());
+ return false;
+ }
+#endif
+
+#if LLVM_VERSION_GE(4, 0)
+ if (L->L.linkInModule(std::move(Src))) {
+#else
+ if (L->L.linkInModule(std::move(Src.get()))) {
+#endif
+ LLVMRustSetLastError("");
+ return false;
+ }
+ return true;
+}
}
}
-extern "C" bool LLVMRustLinkInExternalBitcode(LLVMModuleRef DstRef, char *BC,
- size_t Len) {
- Module *Dst = unwrap(DstRef);
-
- std::unique_ptr<MemoryBuffer> Buf =
- MemoryBuffer::getMemBufferCopy(StringRef(BC, Len));
-
-#if LLVM_VERSION_GE(4, 0)
- Expected<std::unique_ptr<Module>> SrcOrError =
- llvm::getLazyBitcodeModule(Buf->getMemBufferRef(), Dst->getContext());
- if (!SrcOrError) {
- LLVMRustSetLastError(toString(SrcOrError.takeError()).c_str());
- return false;
- }
-
- auto Src = std::move(*SrcOrError);
-#else
- ErrorOr<std::unique_ptr<Module>> Src =
- llvm::getLazyBitcodeModule(std::move(Buf), Dst->getContext());
- if (!Src) {
- LLVMRustSetLastError(Src.getError().message().c_str());
- return false;
- }
-#endif
-
- std::string Err;
-
- raw_string_ostream Stream(Err);
- DiagnosticPrinterRawOStream DP(Stream);
-#if LLVM_VERSION_GE(4, 0)
- if (Linker::linkModules(*Dst, std::move(Src))) {
-#else
- if (Linker::linkModules(*Dst, std::move(Src.get()))) {
-#endif
- LLVMRustSetLastError(Err.c_str());
- return false;
- }
- return true;
-}
-
// Note that the two following functions look quite similar to the
// LLVMGetSectionName function. Sadly, it appears that this function only
// returns a char* pointer, which isn't guaranteed to be null-terminated. The
--- /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.
+
+// only-x86_64
+
+// compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+pub struct S24 {
+ a: i8,
+ b: i8,
+ c: i8,
+}
+
+pub struct S48 {
+ a: i16,
+ b: i16,
+ c: i8,
+}
+
+// CHECK: i24 @struct_24_bits(i24
+#[no_mangle]
+pub extern "sysv64" fn struct_24_bits(a: S24) -> S24 {
+ a
+}
+
+// CHECK: i48 @struct_48_bits(i48
+#[no_mangle]
+pub extern "sysv64" fn struct_48_bits(a: S48) -> S48 {
+ a
+}
--- /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.
+
+// only-x86_64
+
+// compile-flags: -C no-prepopulate-passes
+
+#![crate_type="lib"]
+#![feature(repr_transparent)]
+
+#[repr(C)]
+pub struct Rgb8 { r: u8, g: u8, b: u8 }
+
+#[repr(transparent)]
+pub struct Rgb8Wrap(Rgb8);
+
+// CHECK: i24 @test_Rgb8Wrap(i24)
+#[no_mangle]
+pub extern "sysv64" fn test_Rgb8Wrap(_: Rgb8Wrap) -> Rgb8Wrap { loop {} }
+
+#[repr(C)]
+pub union FloatBits {
+ float: f32,
+ bits: u32,
+}
+
+#[repr(transparent)]
+pub struct SmallUnion(FloatBits);
+
+// CHECK: i32 @test_SmallUnion(i32)
+#[no_mangle]
+pub extern "sysv64" fn test_SmallUnion(_: SmallUnion) -> SmallUnion { loop {} }
pub extern fn test_Projection(_: StructWithProjection) -> StructWithProjection { loop {} }
-// The rest of this file tests newtypes around small aggregates on an ABI where small aggregates are
-// packed into one register. This is ABI-dependent, so instead we focus on one ABI and supply a
-// dummy definition for other ABIs to keep FileCheck happy.
+// All that remains to be tested are aggregates. They are tested in separate files called repr-
+// transparent-*.rs with `only-*` or `ignore-*` directives, because the expected LLVM IR
+// function signatures vary so much that it's not reasonably possible to cover all of them with a
+// single CHECK line.
//
-// Bigger aggregates are tested in separate files called repr-transparent-aggregate-*.rs because
-// there, the expected LLVM IR function signatures vary so much that it's not reasonably possible to
-// cover all of them with a single CHECK line. Instead we group ABIs by the general "shape" of the
-// signature and have a separate test file for each bin.
-//
-// PS: You may be wondering why we don't just compare the return types and argument types for
-// equality with FileCheck regex captures. Well, rustc doesn't perform newtype unwrapping on
-// newtypes containing aggregates. This is OK on all ABIs we support, but because LLVM has not
-// gotten rid of pointee types yet, the IR function signature will be syntactically different (%Foo*
-// vs %FooWrapper*).
-
-#[repr(C)]
-pub struct Rgb8 { r: u8, g: u8, b: u8 }
-
-#[repr(transparent)]
-pub struct Rgb8Wrap(Rgb8);
-
-// NB: closing parenthesis is missing because sometimes the argument has a name and sometimes not
-// CHECK: define i32 @test_Rgb8Wrap(i32
-#[no_mangle]
-#[cfg(all(target_arch="x86_64", target_os="linux"))]
-pub extern fn test_Rgb8Wrap(_: Rgb8Wrap) -> Rgb8Wrap { loop {} }
-
-#[cfg(not(all(target_arch="x86_64", target_os="linux")))]
-#[no_mangle]
-pub extern fn test_Rgb8Wrap(_: u32) -> u32 { loop {} }
-
-// Same as with the small struct above: ABI-dependent, we only test the interesting case
-// (ABIs that pack the aggregate into a scalar) and stub it out on other ABIs
-
-#[repr(C)]
-pub union FloatBits {
- float: f32,
- bits: u32,
-}
-
-#[repr(transparent)]
-pub struct SmallUnion(FloatBits);
-
-// NB: closing parenthesis is missing because sometimes the argument has a name and sometimes not
-// CHECK: define i32 @test_SmallUnion(i32
-#[no_mangle]
-#[cfg(all(target_arch="x86_64", target_os="linux"))]
-pub extern fn test_SmallUnion(_: SmallUnion) -> SmallUnion { loop {} }
-
-#[cfg(not(all(target_arch="x86_64", target_os="linux")))]
-#[no_mangle]
-pub extern fn test_SmallUnion(_: u32) -> u32 { loop {} }
+// You may be wondering why we don't just compare the return types and argument types for equality
+// with FileCheck regex captures. Well, rustc doesn't perform newtype unwrapping on newtypes
+// containing aggregates. This is OK on all ABIs we support, but because LLVM has not gotten rid of
+// pointee types yet, the IR function signature will be syntactically different (%Foo* vs
+// %FooWrapper*).
+++ /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.
-
-#![deny(unreachable_patterns)]
-
-fn main() {
- let foo = Some(1);
- match foo {
- Some(_) => {/* ... */}
- None => {/* ... */}
- _ => {/* ... */} //~ ERROR unreachable pattern
- }
-}
+++ /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.
-
-fn main() {
- let x = Some(1);
-
- match x { } //~ ERROR E0004
-}
+++ /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.
-
-enum Terminator {
- HastaLaVistaBaby,
- TalkToMyHand,
-}
-
-fn main() {
- let x = Terminator::HastaLaVistaBaby;
-
- match x { //~ ERROR E0004
- Terminator::TalkToMyHand => {}
- }
-}
+++ /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.
-
-fn main() {
- let x = Some(1);
- let Some(y) = x; //~ ERROR E0005
-}
+++ /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.
-
-fn main() {
- let x = Some("s".to_string());
- match x {
- op_string @ Some(s) => {},
- //~^ ERROR E0007
- //~| ERROR E0303
- None => {},
- }
-}
+++ /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.
-
-fn main() {
- match Some("hi".to_string()) {
- Some(s) if s.len() == 0 => {},
- //~^ ERROR E0008
- _ => {},
- }
-}
+++ /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.
-
-fn main() {
- struct X { x: (), }
- let x = Some((X { x: () }, X { x: () }));
- match x {
- Some((y, ref z)) => {},
- //~^ ERROR E0009
- None => panic!()
- }
-}
+++ /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.
-
-#![feature(box_syntax)]
-#![allow(warnings)]
-
-const CON : Box<i32> = box 0; //~ ERROR E0010
-
-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.
-
-static X: i32 = 1;
-const C: i32 = 2;
-
-const CR: &'static mut i32 = &mut C; //~ ERROR E0017
-static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
- //~| ERROR cannot borrow
-static CONST_REF: &'static mut i32 = &mut C; //~ ERROR E0017
-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.
-
-enum Fruit {
- Apple(String, String),
- Pear(u32),
-}
-
-
-fn main() {
- let x = Fruit::Apple(String::new(), String::new());
- match x {
- Fruit::Apple(a) => {}, //~ ERROR E0023
- Fruit::Apple(a, b, c) => {}, //~ ERROR E0023
- Fruit::Pear(1, 2) => {}, //~ ERROR E0023
- }
-}
+++ /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.
-
-struct Foo {
- a: u8,
- b: u8,
-}
-
-fn main() {
- let x = Foo { a:1, b:2 };
- let Foo { a: x, a: y, b: 0 } = x;
- //~^ ERROR field `a` bound multiple times in the pattern
-}
+++ /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.
-
-struct Thing {
- x: u32,
- y: u32
-}
-
-fn main() {
- let thing = Thing { x: 0, y: 0 };
- match thing {
- Thing { x, y, z } => {}
- //~^ ERROR struct `Thing` does not have a field named `z` [E0026]
- }
-}
+++ /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.
-
-struct Dog {
- name: String,
- age: u32,
-}
-
-fn main() {
- let d = Dog { name: "Rusty".to_string(), age: 8 };
-
- match d {
- Dog { age: x } => {}
- //~^ ERROR pattern does not mention field `name`
- }
-}
+++ /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.
-
-fn main() {
- let s = "hoho";
-
- match s {
- "hello" ... "world" => {}
- //~^ ERROR only char and numeric types are allowed in range patterns
- //~| ERROR non-reference pattern used to match a reference
- _ => {}
- }
-}
+++ /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.
-
-
-fn main() {
- match 5u32 {
- 1000 ... 5 => {}
- //~^ ERROR lower range bound must be less than or equal to upper
- }
-}
+++ /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.
-
-trait SomeTrait {
- fn foo();
-}
-
-fn main() {
- let trait_obj: &SomeTrait = SomeTrait;
- //~^ ERROR expected value, found trait `SomeTrait`
- //~| ERROR E0038
- //~| method `foo` has no receiver
-
- let &invalid = trait_obj;
- //~^ ERROR E0033
-}
+++ /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.
-
-struct Test;
-
-trait Trait1 {
- fn foo();
-}
-
-trait Trait2 {
- fn foo();
-}
-
-impl Trait1 for Test {
- fn foo() {}
-}
-
-impl Trait2 for Test {
- fn foo() {}
-}
-
-fn main() {
- Test::foo() //~ ERROR multiple applicable items in scope
-}
+++ /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.
-
-trait Trait {
- fn foo(&self) -> Self;
-}
-
-fn call_foo(x: Box<Trait>) {
- //~^ ERROR E0038
- let y = x.foo();
-}
-
-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.
-
-struct Foo {
- x: i32,
-}
-
-impl Drop for Foo {
- fn drop(&mut self) {
- println!("kaboom");
- }
-}
-
-fn main() {
- let mut x = Foo { x: -7 };
- x.drop();
- //~^ ERROR E0040
-}
+++ /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.
-
-extern { fn some_func<T>(x: T); } //~ ERROR E0044
-
-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.
-
-extern "Rust" { fn foo(x: u8, ...); } //~ ERROR E0045
-
-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.
-
-trait Foo {
- fn foo<T: Default>(x: T) -> Self;
-}
-
-struct Bar;
-
-impl Foo for Bar {
- fn foo(x: bool) -> Self { Bar } //~ ERROR E0049
-}
-
-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.
-
-trait Foo {
- fn foo(&self, x: u8) -> bool;
- fn bar(&self, x: u8, y: u8, z: u8);
- fn less(&self);
-}
-
-struct Bar;
-
-impl Foo for Bar {
- fn foo(&self) -> bool { true } //~ ERROR E0050
- fn bar(&self) { } //~ ERROR E0050
- fn less(&self, x: u8, y: u8, z: u8) { } //~ ERROR E0050
-}
-
-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.
-
-fn main() {
- let x = 5;
- let x_is_nonzero = x as bool; //~ ERROR E0054
-}
+++ /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.
-
-#![recursion_limit="2"]
-struct Foo;
-
-impl Foo {
- fn foo(&self) {}
-}
-
-fn main() {
- let foo = Foo;
- let ref_foo = &&Foo;
- ref_foo.foo();
- //~^ ERROR E0055
-}
+++ /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.
-
-fn main() {
- let f = |x| x * 3;
- let a = f(); //~ ERROR E0057
- let b = f(4);
- let c = f(2, 3); //~ ERROR E0057
-}
+++ /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.
-
-#![feature(unboxed_closures)]
-
-fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) } //~ ERROR E0059
-
-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.
-
-extern "C" {
- fn printf(_: *const u8, ...) -> u32;
-}
-
-fn main() {
- unsafe { printf(); }
- //~^ ERROR E0060
- //~| expected at least 1 parameter
-}
+++ /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.
-
-fn f(a: u16, b: &str) {}
-
-fn f2(a: u16) {}
-
-fn main() {
- f(0);
- //~^ ERROR E0061
- //~| expected 2 parameters
-
- f2();
- //~^ ERROR E0061
- //~| expected 1 parameter
-}
+++ /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.
-
-struct Foo {
- x: i32
-}
-
-fn main() {
- let x = Foo {
- x: 0,
- x: 0,
- //~^ ERROR E0062
- };
-}
+++ /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.
-
-// ignore-tidy-linelength
-
-struct SingleFoo {
- x: i32
-}
-
-struct PluralFoo {
- x: i32,
- y: i32,
- z: i32
-}
-
-struct TruncatedFoo {
- a: i32,
- b: i32,
- x: i32,
- y: i32,
- z: i32
-}
-
-struct TruncatedPluralFoo {
- a: i32,
- b: i32,
- c: i32,
- x: i32,
- y: i32,
- z: i32
-}
-
-
-fn main() {
- let w = SingleFoo { };
- //~^ ERROR missing field `x` in initializer of `SingleFoo`
- let x = PluralFoo {x: 1};
- //~^ ERROR missing fields `y`, `z` in initializer of `PluralFoo`
- let y = TruncatedFoo{x:1};
- //~^ missing fields `a`, `b`, `y` and 1 other field in initializer of `TruncatedFoo`
- let z = TruncatedPluralFoo{x:1};
- //~^ ERROR missing fields `a`, `b`, `c` and 2 other fields in initializer of `TruncatedPluralFoo`
-}
+++ /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.
-
-use std::collections::LinkedList;
-
-fn main() {
- LinkedList::new() += 1; //~ ERROR E0368
- //~^ ERROR E0067
-}
+++ /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.
-
-fn foo() -> u8 {
- return;
- //~^ ERROR `return;` in a function whose return type is not `()`
-}
-
-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.
-
-const SOME_CONST : i32 = 12;
-
-fn some_other_func() {}
-
-fn some_function() {
- SOME_CONST = 14; //~ ERROR E0070
- 1 = 3; //~ ERROR E0070
- some_other_func() = 4; //~ ERROR E0070
- //~^ ERROR E0308
-}
-
-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.
-
-enum Foo {}
-type FooAlias = Foo;
-
-fn main() {
- let u = FooAlias { value: 0 };
- //~^ ERROR expected struct, variant or union type, found enum `Foo` [E0071]
-}
+++ /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.
-
-#![feature(repr_simd)]
-
-#[repr(simd)]
-struct Bad; //~ ERROR E0075
-
-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.
-
-#![feature(repr_simd)]
-
-#[repr(simd)]
-struct Bad(u16, u32, u32);
-//~^ ERROR E0076
-
-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.
-
-#![feature(repr_simd)]
-
-#[repr(simd)]
-struct Bad(String); //~ ERROR E0077
-
-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.
-
-enum Enum {
- X = (1 << 500), //~ ERROR E0080
- //~| WARNING shift left with overflow
- Y = (1 / 0) //~ ERROR E0080
- //~| WARNING divide by zero
-}
-
-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.
-
-enum Enum {
- P = 3,
- X = 3,
- //~^ ERROR discriminant value `3isize` already exists
- Y = 5
-}
-
-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.
-
-#[repr(i32)] //~ ERROR: E0084
-enum Foo {}
-
-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.
-
-fn foo() {}
-fn bar<T>() {}
-
-fn main() {
- foo::<f64>(); //~ ERROR expected at most 0 type parameters, found 1 type parameter [E0087]
-
- bar::<f64, u64>(); //~ ERROR expected at most 1 type parameter, found 2 type parameters [E0087]
-}
+++ /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.
-
-fn f() {}
-fn g<'a>() -> &'a u8 { loop {} }
-
-fn main() {
- f::<'static>(); //~ ERROR E0088
- g::<'static, 'static>(); //~ ERROR E0088
-}
+++ /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.
-
-fn foo<T, U>() {}
-
-fn main() {
- foo::<f64>(); //~ ERROR expected 2 type parameters, found 1 type parameter [E0089]
-}
+++ /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.
-
-fn foo<'a: 'b, 'b: 'a>() {}
-
-fn main() {
- foo::<'static>(); //~ ERROR expected 2 lifetime parameters, found 1 lifetime parameter [E0090]
-}
+++ /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.
-
-type Foo<T> = u32; //~ ERROR E0091
-type Foo2<A, B> = Box<A>; //~ ERROR E0091
-
-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.
-
-#![feature(intrinsics)]
-extern "rust-intrinsic" {
- fn atomic_foo(); //~ ERROR E0092
-}
-
-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.
-
-#![feature(intrinsics)]
-extern "rust-intrinsic" {
- fn foo();
- //~^ ERROR E0093
-}
-
-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.
-
-#![feature(intrinsics)]
-extern "rust-intrinsic" {
- fn size_of<T, U>() -> usize; //~ ERROR E0094
-}
-
-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.
-
-struct Foo {
- x: &bool,
- //~^ ERROR E0106
-}
-enum Bar {
- A(u8),
- B(&bool),
- //~^ ERROR E0106
-}
-type MyStr = &str;
- //~^ ERROR E0106
-
-struct Baz<'a>(&'a str);
-struct Buzz<'a, 'b>(&'a str, &'b str);
-
-struct Quux {
- baz: Baz,
- //~^ ERROR E0106
- //~| expected lifetime parameter
- buzz: Buzz,
- //~^ ERROR E0106
- //~| expected 2 lifetime parameters
-}
-
-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.
-
-struct Foo<'a>(&'a str);
-struct Buzz<'a, 'b>(&'a str, &'b str);
-
-enum Bar {
- A,
- B,
- C,
-}
-
-struct Baz<'a, 'b, 'c> {
- buzz: Buzz<'a>,
- //~^ ERROR E0107
- //~| expected 2 lifetime parameters
- bar: Bar<'a>,
- //~^ ERROR E0107
- //~| unexpected lifetime parameter
- foo2: Foo<'a, 'b, 'c>,
- //~^ ERROR E0107
- //~| 2 unexpected lifetime parameters
-}
-
-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.
-
-type X = u32<i32>; //~ ERROR E0109
-
-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.
-
-type X = u32<'static>; //~ ERROR E0110
-
-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.
-
-impl Vec<u8> {}
-//~^ ERROR E0116
-
-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.
-
-impl Drop for u32 {} //~ ERROR E0117
-//~| ERROR the Drop trait may only be implemented on structures
-//~| implementing Drop requires a struct
-
-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.
-
-impl (u8, u8) { //~ ERROR E0118
- fn get_state(&self) -> String {
- String::new()
- }
-}
-
-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.
-
-trait MyTrait {
- fn get(&self) -> usize;
-}
-
-impl<T> MyTrait for T {
- fn get(&self) -> usize { 0 }
-}
-
-struct Foo {
- value: usize
-}
-
-impl MyTrait for Foo { //~ ERROR E0119
- fn get(&self) -> usize { self.value }
-}
-
-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.
-
-trait MyTrait { fn foo() {} }
-
-impl Drop for MyTrait {
- //~^ ERROR E0120
- fn drop(&mut self) {}
-}
-
-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.
-
-fn foo() -> _ { 5 } //~ ERROR E0121
-
-static BAR: _ = "test"; //~ ERROR E0121
-
-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.
-
-struct Foo {
- field1: i32,
- field1: i32,
- //~^ ERROR field `field1` is already declared [E0124]
-}
-
-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.
-
-struct Foo<T=U, U=()> { //~ ERROR E0128
- field1: T,
- field2: U,
-}
-
-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.
-
-extern {
- fn foo((a, b): (u32, u32));
- //~^ ERROR E0130
-}
-
-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.
-
-fn main<T>() {
- //~^ ERROR E0131
-}
+++ /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.
-
-#![feature(start)]
-
-#[start]
-fn f< T >() {} //~ ERROR E0132
-
-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.
-
-unsafe fn f() { return; }
-
-fn main() {
- f();
- //~^ ERROR E0133
-}
+++ /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.
-
-#![feature(main)]
-
-#[main]
-fn foo() {}
-
-#[main]
-fn f() {}
-//~^ ERROR E0137
+++ /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.
-
-#![feature(start)]
-
-#[start]
-fn foo(argc: isize, argv: *const *const u8) -> isize { 0 }
-
-#[start]
-fn f(argc: isize, argv: *const *const u8) -> isize { 0 }
-//~^ ERROR E0138
+++ /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.
-
-#![feature(lang_items)]
-
-#[lang = "panic_fmt"]
-struct Foo; //~ ERROR E0152
-
-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.
-
-#![feature(box_syntax)]
-
-fn main() {
- let _x: Box<str> = box *"hello"; //~ ERROR E0161
- //~^ ERROR E0507
-}
+++ /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.
-
-struct Irrefutable(i32);
-
-fn main() {
- let irr = Irrefutable(0);
- if let Irrefutable(x) = irr { //~ ERROR E0162
- println!("{}", x);
- }
-}
+++ /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.
-
-
-enum Foo {}
-
-impl Foo {
- const B: u8 = 0;
-}
-
-fn bar(foo: Foo) -> u32 {
- match foo {
- Foo::B(i) => i, //~ ERROR E0164
- }
-}
-
-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.
-
-struct Irrefutable(i32);
-
-fn main() {
- let irr = Irrefutable(0);
- while let Irrefutable(x) = irr { //~ ERROR E0165
- //~| irrefutable pattern
- // ...
- }
-}
+++ /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.
-
-#[derive(Copy)] //~ ERROR E0184
-struct Foo;
-
-impl Drop for Foo {
- fn drop(&mut self) {
- }
-}
-
-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.
-
-trait Foo {
- fn foo();
- //~^ NOTE trait method declared without `&self`
-}
-
-struct Bar;
-
-impl Foo for Bar {
- fn foo(&self) {}
- //~^ ERROR E0185
- //~| NOTE `&self` used in impl
-}
-
-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.
-
-trait Foo {
- fn foo(&self); //~ `&self` used in trait
-}
-
-struct Bar;
-
-impl Foo for Bar {
- fn foo() {} //~ ERROR E0186
- //~^ expected `&self` in impl
-}
-
-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.
-
-trait Trait {
- type Bar;
-}
-
-type Foo = Trait; //~ ERROR E0191
-
-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.
-
-#![feature(optin_builtin_traits)]
-
-trait Trait {
- type Bar;
-}
-
-struct Foo;
-
-impl !Trait for Foo { } //~ ERROR E0192
-
-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.
-
-trait Foo<T> {
- fn do_something(&self) -> T;
- fn do_something_else<T: Clone>(&self, bar: T);
- //~^ ERROR E0194
-}
-
-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.
-
-trait Trait {
- fn bar<'a,'b:'a>(x: &'a str, y: &'b str);
- //~^ NOTE lifetimes in impl do not match this method in trait
-}
-
-struct Foo;
-
-impl Trait for Foo {
- fn bar<'a,'b>(x: &'a str, y: &'b str) { //~ ERROR E0195
- //~^ NOTE lifetimes do not match method in trait
- }
-}
-
-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.
-
-struct Foo;
-
-unsafe impl Foo { } //~ ERROR E0197
-
-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.
-
-#![feature(optin_builtin_traits)]
-
-struct Foo;
-
-unsafe impl !Send for Foo { } //~ ERROR E0198
-
-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.
-
-#![feature(optin_builtin_traits)]
-
-struct Foo;
-
-trait Bar { }
-unsafe impl Bar for Foo { } //~ ERROR implementing the trait `Bar` is not unsafe [E0199]
-
-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.
-
-struct Foo;
-
-unsafe trait Bar { }
-
-impl Bar for Foo { } //~ ERROR E0200
-
-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.
-
-struct Foo(u8);
-
-impl Foo {
- fn bar(&self) -> bool { self.0 > 5 }
- fn bar() {} //~ ERROR E0201
-}
-
-trait Baz {
- type Quux;
- fn baz(&self) -> bool;
-}
-
-impl Baz for Foo {
- type Quux = u32;
-
- fn baz(&self) -> bool { true }
- fn baz(&self) -> bool { self.0 > 5 } //~ ERROR E0201
- type Quux = u32; //~ ERROR E0201
-}
-
-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.
-
-type Foo = i32;
-
-impl Copy for Foo { }
-//~^ ERROR the trait `Copy` may not be implemented for this type
-//~| ERROR only traits defined in the current crate can be implemented for arbitrary types
-
-#[derive(Copy, Clone)]
-struct Bar;
-
-impl Copy for &'static Bar { }
-//~^ ERROR the trait `Copy` may not be implemented for this type
-
-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.
-
-struct Foo;
-
-impl<T: Default> Foo { //~ ERROR E0207
- fn get(&self) -> T {
- <T as Default>::default()
- }
-}
-
-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.
-
-fn main() {
- let v: Vec(&str) = vec!["foo"];
- //~^ ERROR E0214
-}
+++ /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.
-
-trait Trait {
- type Bar;
-}
-
-type Foo = Trait<F=i32>; //~ ERROR E0220
- //~| ERROR E0191
-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.
-
-trait T1 {}
-trait T2 {}
-
-trait Foo {
- type A: T1;
-}
-
-trait Bar : Foo {
- type A: T2;
- fn do_something() {
- let _: Self::A;
- //~^ ERROR E0221
- }
-}
-
-trait T3 {}
-
-trait My : std::str::FromStr {
- type Err: T3;
- fn test() {
- let _: Self::Err;
- //~^ ERROR E0221
- }
-}
-
-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.
-
-trait MyTrait { type X; }
-
-fn main() {
- let foo: MyTrait::X;
- //~^ ERROR ambiguous associated type
-}
+++ /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.
-
-fn main() {
- let _: Box<std::io::Read + std::io::Write>;
- //~^ ERROR only auto traits can be used as additional traits in a trait object [E0225]
-}
+++ /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.
-
-pub trait Foo {
- type A;
- fn boo(&self) -> <Self as Foo>::A;
-}
-
-struct Bar;
-
-impl Foo for isize {
- type A = usize;
- fn boo(&self) -> usize { 42 }
-}
-
-fn baz<I>(x: &<I as Foo<A=Bar>>::A) {}
-//~^ ERROR associated type bindings are not allowed here [E0229]
-
-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.
-
-#![feature(on_unimplemented)]
-
-#[rustc_on_unimplemented]
-//~^ ERROR E0232
-trait Bar {}
-
-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.
-
-struct Foo<T> { x: T }
-struct Bar { x: Foo }
- //~^ ERROR wrong number of type arguments: expected 1, found 0 [E0243]
-
-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.
-
-struct Foo { x: bool }
-struct Bar<S, T> { x: Foo<S, T> }
- //~^ ERROR wrong number of type arguments: expected 0, found 2 [E0244]
-
-
-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.
-
-use foo::baz;
-use bar::baz; //~ ERROR E0252
-
-mod foo {
- pub struct baz;
-}
-
-mod bar {
- pub mod baz {}
-}
-
-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.
-
-mod foo {
- pub trait MyTrait {
- fn do_something();
- }
-}
-
-use foo::MyTrait::do_something;
- //~^ ERROR E0253
-
-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.
-
-#![feature(alloc)]
-#![allow(unused_extern_crates)]
-
-extern crate alloc;
-
-mod foo {
- pub trait alloc {
- fn do_something();
- }
-}
-
-use foo::alloc;
-//~^ ERROR E0254
-
-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.
-
-use bar::foo;
-
-fn foo() {} //~ ERROR E0255
-
-mod bar {
- pub fn foo() {}
-}
-
-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.
-
-#![feature(alloc, libc)]
-#![allow(unused_extern_crates)]
-
-extern crate alloc;
-
-extern crate libc as alloc;
-//~^ ERROR E0259
-
-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.
-
-#![feature(alloc)]
-#![allow(unused_extern_crates)]
-
-extern crate alloc;
-
-mod alloc {
-//~^ ERROR the name `alloc` is defined multiple times [E0260]
- pub trait MyTrait {
- fn do_something();
- }
-}
-
-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.
-
-fn foo(x: &'a str) { } //~ ERROR E0261
- //~| undeclared lifetime
-
-struct Foo {
- x: &'a str, //~ ERROR E0261
- //~| undeclared lifetime
-}
-
-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.
-
-fn foo<'static>(x: &'static str) { } //~ ERROR E0262
- //~| 'static is a reserved lifetime name
-
-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.
-
-fn foo<'a, 'b, 'a>(x: &'a str, y: &'b str) {
- //~^ ERROR E0263
-}
-
-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.
-
-#![feature(lang_items)]
-
-extern "C" {
- #[lang = "cake"]
- fn cake(); //~ ERROR E0264
-}
-
-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.
-
-fn main() {
- let w = || { break; }; //~ ERROR E0267
-}
+++ /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.
-
-fn main() {
- break; //~ ERROR E0268
-}
+++ /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.
-
-trait Trait { type AssociatedType; }
-
-fn foo<T>(t: T) where T: Trait<AssociatedType=u32> {
- println!("in foo");
-}
-
-impl Trait for i8 { type AssociatedType = &'static str; }
-
-fn main() {
- foo(3_i8); //~ ERROR E0271
-}
+++ /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.
-
-trait Foo {}
-
-struct Bar<T>(T);
-
-impl<T> Foo for T where Bar<T>: Foo {} //~ ERROR E0275
-
-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.
-
-trait Foo {
- fn foo<T>(x: T);
-}
-
-impl Foo for bool {
- fn foo<T>(x: T) where T: Copy {} //~ ERROR E0276
-}
-
-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.
-
-struct Foo {
- bar: Bar
-}
-
-struct Bar {
- baz: Baz
-}
-
-struct Baz {
- x: *const u8
-}
-
-fn is_send<T: Send>() { }
-
-fn main() {
- is_send::<Foo>();
- //~^ ERROR the trait bound `*const u8: std::marker::Send` is not satisfied in `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.
-
-// ignore-cloudabi no std::path
-
-use std::path::Path;
-
-trait Foo {
- fn bar(&self);
-}
-
-fn some_func<T: Foo>(foo: T) {
- foo.bar();
-}
-
-fn f(p: Path) { }
-//~^ ERROR the trait bound `[u8]: std::marker::Sized` is not satisfied in `std::path::Path`
-
-fn main() {
- some_func(5i32);
- //~^ ERROR the trait bound `i32: Foo` is not satisfied
-}
+++ /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.
-
-fn main() {
- let x = "hello".chars().rev().collect(); //~ ERROR E0282
-}
+++ /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.
-
-trait Generator {
- fn create() -> u32;
-}
-
-struct Impl;
-
-impl Generator for Impl {
- fn create() -> u32 { 1 }
-}
-
-struct AnotherImpl;
-
-impl Generator for AnotherImpl {
- fn create() -> u32 { 2 }
-}
-
-fn main() {
- let cont: u32 = Generator::create(); //~ ERROR E0283
-}
+++ /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.
-
-#![recursion_limit] //~ ERROR E0296
-
-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.
-
-fn main() {
- let xs : Vec<Option<i32>> = vec![Some(1), None];
-
- for Some(x) in xs {}
- //~^ ERROR E0005
-}
+++ /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.
-
-fn main() {
- match Some(()) {
- None => { },
- option if option.take().is_none() => {}, //~ ERROR E0301
- Some(_) => { }
- }
-}
+++ /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.
-
-fn main() {
- match Some(()) {
- None => { },
- option if { option = None; false } => { }, //~ ERROR E0302
- Some(_) => { }
- }
-}
+++ /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.
-
-fn main() {
- match Some("hi".to_string()) {
- ref op_string_ref @ Some(s) => {},
- //~^ ERROR pattern bindings are not allowed after an `@` [E0303]
- //~| ERROR E0009
- None => {},
- }
-}
+++ /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.
-
-fn main() {
- let x = 1u8;
- match x {
- 0u8...3i8 => (), //~ ERROR E0308
- _ => ()
- }
-}
+++ /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.
-
-#![feature(intrinsics)]
-
-extern "rust-intrinsic" {
- fn size_of<T>(); //~ ERROR E0308
-}
-
-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.
-
-mod foo {
- pub const X: u32 = 1;
-}
-
-pub use foo as foo2;
-//~^ ERROR `foo` is private, and cannot be re-exported [E0365]
-
-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.
-
-#![allow(dead_code)]
-
-#[deny(overflowing_literals)]
-#[repr(i64)]
-enum Foo {
- X = 0x7fffffffffffffff,
- Y, //~ ERROR E0370
-}
-
-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.
-
-#![feature(coerce_unsized)]
-use std::ops::CoerceUnsized;
-
-struct Foo<T: ?Sized> {
- a: i32,
-}
-
-impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> //~ ERROR E0374
- where T: CoerceUnsized<U> {}
-
-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.
-
-// ignore-tidy-linelength
-
-#![feature(coerce_unsized)]
-use std::ops::CoerceUnsized;
-
-struct Foo<T: ?Sized, U: ?Sized> {
- a: i32,
- b: T,
- c: U,
-}
-
-impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {}
-//~^ ERROR E0375
-
-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.
-
-#![feature(coerce_unsized)]
-use std::ops::CoerceUnsized;
-
-struct Foo<T: ?Sized> {
- a: T,
-}
-
-impl<T, U> CoerceUnsized<U> for Foo<T> {} //~ ERROR E0376
-
-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.
-
-static X: i32 = 1;
-const C: i32 = 2;
-
-const CR: &'static mut i32 = &mut C; //~ ERROR E0017
-static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
- //~| ERROR cannot borrow
-static CONST_REF: &'static mut i32 = &mut C; //~ ERROR E0017
-
-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.
-
-struct FancyNum {
- num: u8,
-}
-
-fn main() {
- let mut fancy = FancyNum{ num: 5 };
- let fancy_ref = &(&mut fancy);
- fancy_ref.num = 6; //~ ERROR E0389
- println!("{}", fancy_ref.num);
-}
+++ /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.
-
-struct Foo {
- x: i32
-}
-
-impl *mut Foo {} //~ ERROR E0390
-
-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.
-
-enum Foo<T> { Bar } //~ ERROR E0392
-
-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.
-
-trait A<T=Self> {}
-
-fn together_we_will_rule_the_galaxy(son: &A) {}
-//~^ ERROR E0393
-
-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.
-
-#![allow(warnings)]
-
-static A: u32 = 0;
-static B: u32 = A;
-//~^ ERROR E0394
-
-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.
-
-static FOO: i32 = 42;
-static BAR: i32 = 42;
-
-static BAZ: bool = { (&FOO as *const i32) == (&BAR as *const i32) }; //~ ERROR E0395
-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.
-
-const REG_ADDR: *const u8 = 0x5f3759df as *const u8;
-
-const VALUE: u8 = unsafe { *REG_ADDR }; //~ ERROR E0396
-
-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.
-
-fn foo<T>(x: T) {
- fn bar(y: T) { //~ ERROR E0401
- }
- bar(x);
-}
-
-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.
-
-fn foo<T, T>(s: T, u: T) {} //~ ERROR E0403
-
-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.
-
-struct Foo;
-struct Bar;
-
-impl Foo for Bar {} //~ ERROR E0404
-
-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.
-
-struct Foo;
-
-impl SomeTrait for Foo {} //~ ERROR E0405
-
-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.
-
-trait Foo {
- fn a();
-}
-
-struct Bar;
-
-impl Foo for Bar {
- fn a() {}
- fn b() {}
- //~^ ERROR E0407
-}
-
-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.
-
-fn main() {
- let x = Some(0);
-
- match x {
- Some(y) | None => {} //~ ERROR variable `y` is not bound in all patterns
- _ => ()
- }
-}
+++ /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.
-
-fn main() {
- <Self>::foo; //~ ERROR E0411
-}
+++ /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.
-
-impl Something {} //~ ERROR E0412
-
-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.
-
-fn foo(f: i32, f: i32) {} //~ ERROR E0415
-
-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.
-
-fn main() {
- match (1, 2) {
- (x, x) => {} //~ ERROR E0416
- }
-}
+++ /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.
-
-fn main () {
- struct Foo { a: bool };
-
- let f = Foo(); //~ ERROR E0423
-}
+++ /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.
-
-struct Foo;
-
-impl Foo {
- fn bar(self) {}
-
- fn foo() {
- self.bar(); //~ ERROR E0424
- }
-}
-
-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.
-
-trait Foo {
- fn bar() {
- elf; //~ ERROR E0425
- }
-}
-
-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.
-
-fn main () {
- loop {
- break 'a;
- //~^ ERROR E0426
- }
-}
+++ /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.
-
-struct Bar; //~ previous definition of the type `Bar` here
-struct Bar; //~ ERROR E0428
-
-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.
-
-use std::fmt::self; //~ ERROR E0429
-
-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.
-
-use std::fmt::{self, self}; //~ ERROR E0430
- //~^ ERROR E0252
-
-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.
-
-use {self}; //~ ERROR E0431
-
-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.
-
-use something::Foo; //~ ERROR E0432
-
-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.
-
-fn main () {
- let map = HashMap::new(); //~ ERROR E0433
-}
+++ /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.
-
-fn foo() {
- let y = 5;
- fn bar() -> u32 {
- y //~ ERROR E0434
- }
-}
-
-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.
-
-fn main () {
- let foo = 42u32;
- let _: [u8; foo]; //~ ERROR E0435
-}
+++ /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.
-
-trait Foo {}
-
-impl Foo for i32 {
- type Bar = bool; //~ ERROR E0437
-}
-
-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.
-
-
-trait Bar {}
-
-impl Bar for i32 {
- const BAR: bool = true; //~ ERROR E0438
-}
-
-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.
-
-#![feature(platform_intrinsics)]
-
-extern "platform-intrinsic" {
- fn simd_shuffle<A,B>(a: A, b: A, c: [u32; 8]) -> B; //~ ERROR E0439
-}
-
-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.
-
-#![feature(repr_simd)]
-#![feature(platform_intrinsics)]
-
-#[repr(simd)]
-struct f64x2(f64, f64);
-
-extern "platform-intrinsic" {
- fn x86_mm_movemask_pd<T>(x: f64x2) -> i32; //~ ERROR E0440
-}
-
-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.
-
-#![feature(repr_simd)]
-#![feature(platform_intrinsics)]
-
-#[repr(simd)]
-struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
-
-extern "platform-intrinsic" {
- fn x86_mm_adds_ep16(x: i16x8, y: i16x8) -> i16x8; //~ ERROR E0441
-}
-
-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.
-
-#![feature(repr_simd)]
-#![feature(platform_intrinsics)]
-
-#[repr(simd)]
-struct i8x16(i8, i8, i8, i8, i8, i8, i8, i8,
- i8, i8, i8, i8, i8, i8, i8, i8);
-#[repr(simd)]
-struct i32x4(i32, i32, i32, i32);
-#[repr(simd)]
-struct i64x2(i64, i64);
-
-extern "platform-intrinsic" {
- fn x86_mm_adds_epi16(x: i8x16, y: i32x4) -> i64x2;
- //~^ ERROR E0442
- //~| ERROR E0442
- //~| ERROR E0442
-}
-
-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.
-
-#![feature(repr_simd)]
-#![feature(platform_intrinsics)]
-
-#[repr(simd)]
-struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
-#[repr(simd)]
-struct i64x8(i64, i64, i64, i64, i64, i64, i64, i64);
-
-extern "platform-intrinsic" {
- fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i64x8; //~ ERROR E0443
-}
-
-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.
-
-#![feature(repr_simd)]
-#![feature(platform_intrinsics)]
-
-#[repr(simd)]
-struct f64x2(f64, f64);
-
-extern "platform-intrinsic" {
- fn x86_mm_movemask_pd(x: f64x2, y: f64x2, z: f64x2) -> i32; //~ ERROR E0444
-}
-
-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.
-
-trait Foo {
- fn dummy(&self) { }
-}
-
-pub trait Bar : Foo {}
-//~^ ERROR private trait `Foo` in public interface [E0445]
-//~| NOTE can't leak private trait
-pub struct Bar2<T: Foo>(pub T);
-//~^ ERROR private trait `Foo` in public interface [E0445]
-//~| NOTE can't leak private trait
-pub fn foo<T: Foo> (t: T) {}
-//~^ ERROR private trait `Foo` in public interface [E0445]
-//~| NOTE can't leak private trait
-
-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.
-
-mod Foo {
- struct Bar(u32);
-
- pub fn bar() -> Bar { //~ ERROR E0446
- Bar(0)
- }
-}
-
-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.
-
-struct Bar;
-
-trait Foo {
- fn foo();
-}
-
-pub impl Bar {} //~ ERROR E0449
-
-pub impl Foo for Bar { //~ ERROR E0449
- pub fn foo() {} //~ ERROR E0449
-}
-
-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.
-
-mod Bar {
- pub struct Foo {
- pub a: isize,
- b: isize,
- }
-
- pub struct FooTuple (
- pub isize,
- isize,
- );
-}
-
-fn pat_match(foo: Bar::Foo) {
- let Bar::Foo{a:a, b:b} = foo; //~ ERROR E0451
-}
-
-fn main() {
- let f = Bar::Foo{ a: 0, b: 0 }; //~ ERROR E0451
-}
+++ /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.
-
-#![allow(foo = "")] //~ ERROR E0452
-
-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.
-
-#![forbid(non_snake_case)]
-
-#[allow(non_snake_case)]
-//~^ ERROR allow(non_snake_case) overruled by outer forbid(non_snake_case)
-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.
-
-#[link(name = "")] extern {}
-//~^ ERROR E0454
-
-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.
-
-#[link(kind = "wonderful_unicorn")] extern {} //~ ERROR E0458
- //~| ERROR E0459
-
-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.
-
-#[link(kind = "dylib")] extern {} //~ ERROR E0459
-
-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.
-
-#![feature(plugin)]
-#![plugin(cookie_monster)]
-//~^ ERROR E0463
-extern crate cake_is_a_lie;
-
-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.
-
-trait Wedding<'t>: 't { }
-
-struct Prince<'kiss, 'SnowWhite> {
- child: Box<Wedding<'kiss> + 'SnowWhite>, //~ ERROR E0478
-}
-
-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.
-
-use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
-
-const A: AtomicUsize = ATOMIC_USIZE_INIT;
-static B: &'static AtomicUsize = &A; //~ ERROR E0492
-
-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.
-
-struct Foo {
- a: u32
-}
-
-static S : Foo = Foo { a : 0 };
-static A : &'static u32 = &S.a; //~ ERROR E0494
-
-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.
-
-struct Foo<'a> {
- a: &'a i32,
-}
-
-impl<'a> Foo<'a> {
- fn f<'a>(x: &'a i32) { //~ ERROR E0496
- }
-}
-
-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.
-
-fn main() {
- let mut i = 0;
- let mut x = &mut i;
- let mut a = &mut i; //~ ERROR E0499
-}
+++ /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.
-
-fn bar(x: &mut i32) {}
-fn foo(a: &mut i32) {
- let ref y = a;
- bar(a); //~ ERROR E0502
-}
-
-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.
-
-fn main() {
- let mut value = 3;
- let _borrow = &mut value;
- let _sum = value + 1; //~ ERROR E0503
-}
+++ /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.
-
-struct FancyNum {
- num: u8,
-}
-
-fn main() {
- let fancy_num = FancyNum { num: 5 };
- let fancy_ref = &fancy_num;
-
- let x = move || {
- println!("child function: {}", fancy_num.num); //~ ERROR E0504
- };
-
- x();
- println!("main function: {}", fancy_ref.num);
-}
+++ /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.
-
-struct Value {}
-
-fn eat(val: Value) {}
-
-fn main() {
- let x = Value{};
- {
- let _ref_to_val: &Value = &x;
- eat(x); //~ ERROR E0505
- }
-}
+++ /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.
-
-use std::cell::RefCell;
-
-struct TheDarkKnight;
-
-impl TheDarkKnight {
- fn nothing_is_true(self) {}
-}
-
-fn main() {
- let x = RefCell::new(TheDarkKnight);
-
- x.borrow().nothing_is_true(); //~ ERROR E0507
-}
+++ /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.
-
-struct FancyNum {
- num: usize
-}
-
-struct DropStruct {
- fancy: FancyNum
-}
-
-impl Drop for DropStruct {
- fn drop(&mut self) {
- }
-}
-
-fn main() {
- let drop_struct = DropStruct{fancy: FancyNum{num: 5}};
- let fancy_field = drop_struct.fancy; //~ ERROR E0509
- println!("Fancy: {}", fancy_field.num);
-}
+++ /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.
-
-#![feature(platform_intrinsics)]
-
-extern "platform-intrinsic" {
- fn simd_add<T>(a: T, b: T) -> T;
-}
-
-fn main() {
- unsafe { simd_add(0, 1); } //~ ERROR E0511
-}
+++ /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.
-
-fn takes_u8(_: u8) {}
-
-fn main() {
- unsafe { takes_u8(::std::mem::transmute(0u16)); } //~ ERROR E0512
-}
+++ /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.
-
-fn main() {
- let x: typeof(92) = 92; //~ ERROR E0516
- //~| reserved keyword
-}
+++ /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.
-
-#[repr(C)] //~ ERROR: E0517
-type Foo = u8;
-
-#[repr(packed)] //~ ERROR: E0517
-enum Foo2 {Bar, Baz}
-
-#[repr(u8)] //~ ERROR: E0517
-struct Foo3 {bar: bool, baz: bool}
-
-#[repr(C)] //~ ERROR: E0517
-impl Foo3 {
-}
-
-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.
-
-#[inline(always)] //~ ERROR: E0518
-struct Foo;
-
-#[inline(never)] //~ ERROR: E0518
-impl Foo {
-}
-
-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.
-
-#![feature(specialization)]
-
-trait SpaceLlama {
- fn fly(&self);
-}
-
-impl<T> SpaceLlama for T {
- default fn fly(&self) {}
-}
-
-impl<T: Clone> SpaceLlama for T {
- fn fly(&self) {}
-}
-
-impl SpaceLlama for i32 {
- default fn fly(&self) {}
- //~^ ERROR E0520
-}
-
-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.
-
-#![feature(lang_items)]
-
-#[lang = "cookie"]
-fn cookie() -> ! {
-//~^^ ERROR definition of an unknown language item: `cookie` [E0522]
- loop {}
-}
+++ /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.
-
-#![feature(slice_patterns)]
-
-fn main() {
- let r = &[1, 2, 3, 4];
- match r {
- &[a, b] => {
- //~^ ERROR E0527
- println!("a={}, b={}", a, b);
- }
- }
-}
+++ /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.
-
-#![feature(slice_patterns)]
-
-fn main() {
- let r = &[1, 2];
- match r {
- &[a, b, c, rest..] => {
- //~^ ERROR E0528
- }
- }
-}
+++ /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.
-
-#![feature(slice_patterns)]
-
-fn main() {
- let r: f32 = 1.0;
- match r {
- [a, b] => {
- //~^ ERROR E0529
- }
- }
-}
+++ /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.
-
-fn main() {
- static TEST: i32 = 0;
-
- let r: (i32, i32) = (0, 0);
- match r {
- TEST => {} //~ ERROR E0530
- }
-}
+++ /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.
-
-fn main() {
- let value = 1;
-
- match SomeStruct(value) {
- StructConst1(_) => { },
- //~^ ERROR expected tuple struct/variant, found constant `StructConst1`
- _ => { },
- }
-
- struct SomeStruct(u8);
-
- const StructConst1 : SomeStruct = SomeStruct(1);
- const StructConst2 : SomeStruct = SomeStruct(2);
-}
+++ /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.
-
-#[inline()] //~ ERROR E0534
-pub fn something() {}
-
-fn main() {
- something();
-}
+++ /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.
-
-#[export_name]
-//~^ ERROR E0558
-
-pub fn something() {}
-
-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.
-
-enum Field {
- Fool { x: u32 },
-}
-
-fn main() {
- let s = Field::Fool { joke: 0 };
- //~^ ERROR E0559
-}
+++ /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.
-
-struct Simba {
- mother: u32,
-}
-
-fn main() {
- let s = Simba { mother: 1, father: 0 };
- //~^ ERROR E0560
-}
+++ /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.
-
-#![feature(attr_literals)]
-
-// deprecated doesn't currently support literals
-#[deprecated("since")] //~ ERROR E0565
-fn f() { }
-
-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.
-
-#![feature(attr_literals)]
-
-// repr currently doesn't support literals
-#[repr("C")] //~ ERROR E0565
-struct A { }
-
-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.
-
-const FOO: u32 = return 0; //~ ERROR E0572
-
-fn main() {}
+++ /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.
-
-// This test was derived from the wasm and parsell crates. They
-// stopped compiling when #32330 is fixed.
-
-#![allow(dead_code, unused_variables)]
-
-use std::str::Chars;
-
-pub trait HasOutput<Ch, Str> {
- type Output;
-}
-
-#[derive(Clone, PartialEq, Eq, Hash, Ord, PartialOrd, Debug)]
-pub enum Token<'a> {
- Begin(&'a str)
-}
-
-fn mk_unexpected_char_err<'a>() -> Option<&'a i32> {
- unimplemented!()
-}
-
-fn foo<'a>(data: &mut Chars<'a>) {
- bar(mk_unexpected_char_err)
-}
-
-fn bar<F>(t: F)
- // No type can satisfy this requirement, since `'a` does not
- // appear in any of the input types:
- where F: for<'a> Fn() -> Option<&'a i32>
- //~^ ERROR E0582
-{
-}
-
-fn baz<F>(t: F)
- // No type can satisfy this requirement, since `'a` does not
- // appear in any of the input types:
- where F: for<'a> Iterator<Item=&'a i32>
- //~^ ERROR E0582
-{
-}
-
-fn main() {
-}
+++ /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.
-
-fn main() {
- /// Hello! I'm useless...
- //~^ ERROR E0585
-}
+++ /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.
-
-fn main() {
- let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
- let x = &tmp[1..=]; //~ ERROR E0586
-}
+++ /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.
-
-struct Foo<'a> {
- x: Option<&'a u32>,
-}
-
-fn main() {
- let mut x = Foo { x: None };
- let y = 0;
- x.x = Some(&y);
- //~^ `y` does not live long enough [E0597]
-}
+++ /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.
-
-struct Foo;
-
-fn main() {
- || if let Foo::NotEvenReal() = Foo {}; //~ ERROR E0599
-}
+++ /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.
-
-fn main() {
- !"a"; //~ ERROR E0600
-}
+++ /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:-D bogus
-
-// error-pattern:E0602
-// error-pattern:requested on the command line with `-D bogus`
-
-fn main() {}
+++ /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.
-
-mod SomeModule {
- const PRIVATE: u32 = 0x_a_bad_1dea_u32;
-}
-
-fn main() {
- SomeModule::PRIVATE; //~ ERROR E0603
-}
+++ /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.
-
-fn main() {
- 1u32 as char; //~ ERROR E0604
-}
+++ /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.
-
-fn main() {
- let x = 0u8;
- x as Vec<u8>; //~ ERROR E0605
-
- let v = 0 as *const u8;
- v as &u8; //~ ERROR E0605
-}
+++ /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.
-
-fn main() {
- &0u8 as u8; //~ ERROR E0606
-}
+++ /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.
-
-fn main() {
- let v = 0 as *const u8;
- v as *const [u8]; //~ ERROR E0607
-}
+++ /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.
-
-fn main() {
- 0u8[2]; //~ ERROR E0608
-}
+++ /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.
-
-struct Foo {
- x: u32,
-}
-struct Bar;
-
-fn main() {
- let x = Foo { x: 0 };
- let _ = x.foo; //~ ERROR E0609
-
- let y = Bar;
- y.1; //~ ERROR E0609
-}
+++ /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.
-
-fn main() {
- let x = 0;
- let _ = x.foo; //~ ERROR E0610
-}
+++ /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.
-
-mod a {
- pub struct Foo(u32);
-
- impl Foo {
- pub fn new() -> Foo { Foo(0) }
- }
-}
-
-fn main() {
- let y = a::Foo::new();
- y.0; //~ ERROR E0611
-}
+++ /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.
-
-struct Foo(u32);
-
-fn main() {
- let y = Foo(0);
- y.1; //~ ERROR E0612
-}
+++ /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.
-
-fn main() {
- let y = 0u32;
- *y; //~ ERROR E0614
-}
+++ /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.
-
-struct Foo {
- x: u32,
-}
-
-impl Foo {
- fn method(&self) {}
-}
-
-fn main() {
- let f = Foo { x: 0 };
- f.method; //~ ERROR E0615
-}
+++ /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.
-
-mod a {
- pub struct Foo {
- x: u32,
- }
-
- impl Foo {
- pub fn new() -> Foo { Foo { x: 0 } }
- }
-}
-
-fn main() {
- let f = a::Foo::new();
- f.x; //~ ERROR E0616
-}
+++ /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.
-
-// ignore-tidy-linelength
-
-extern {
- fn printf(c: *const i8, ...);
-}
-
-fn main() {
- unsafe {
- printf(::std::ptr::null(), 0f32);
- //~^ ERROR can't pass `f32` to variadic function
- //~| HELP cast the value to `c_double`
- printf(::std::ptr::null(), 0i8);
- //~^ ERROR can't pass `i8` to variadic function
- //~| HELP cast the value to `c_int`
- printf(::std::ptr::null(), 0i16);
- //~^ ERROR can't pass `i16` to variadic function
- //~| HELP cast the value to `c_int`
- printf(::std::ptr::null(), 0u8);
- //~^ ERROR can't pass `u8` to variadic function
- //~| HELP cast the value to `c_uint`
- printf(::std::ptr::null(), 0u16);
- //~^ ERROR can't pass `u16` to variadic function
- //~| HELP cast the value to `c_uint`
- printf(::std::ptr::null(), printf);
- //~^ ERROR can't pass `unsafe extern "C" fn(*const i8, ...) {printf}` to variadic function
- //~| HELP cast the value to `unsafe extern "C" fn(*const i8, ...)`
- }
-}
+++ /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.
-
-enum X {
- Entry,
-}
-
-fn main() {
- X::Entry();
- //~^ ERROR expected function, found enum variant `X::Entry` [E0618]
- let x = 0i32;
- x();
- //~^ ERROR expected function, found `i32` [E0618]
-}
+++ /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.
-
-fn main() {
- let x;
-
- match x {
- (..) => {} //~ ERROR E0619
- _ => {}
- }
-}
-
+++ /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.
-
-fn main() {
- let _foo = &[1_usize, 2] as [usize]; //~ ERROR E0620
-}
+++ /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.
-
-// Test that we give the generic E0495 when one of the free regions is
-// bound in a closure (rather than suggesting a change to the signature
-// of the closure, which is not specified in `foo` but rather in `invoke`).
-
-// FIXME - This might be better as a UI test, but the finer details
-// of the error seem to vary on different machines.
-fn invoke<'a, F>(x: &'a i32, f: F) -> &'a i32
-where F: FnOnce(&'a i32, &i32) -> &'a i32
-{
- let y = 22;
- f(x, &y)
-}
-
-fn foo<'a>(x: &'a i32) {
- invoke(&x, |a, b| if a > b { a } else { b }); //~ ERROR E0495
-}
-
-fn main() {}
+++ /dev/null
-// Copyright 2015 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(intrinsics)]
-extern "rust-intrinsic" {
- pub static breakpoint : unsafe extern "rust-intrinsic" fn();
- //~^ ERROR intrinsic must be a function [E0622]
-}
-fn main() { unsafe { breakpoint(); } }
+++ /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.
-
-mod inner {
- pub struct Foo;
-
- impl Foo {
- fn method(&self) {}
- }
-}
-
-fn main() {
- let foo = inner::Foo;
- foo.method(); //~ ERROR method `method` is private [E0624]
-}
+++ /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.
-#![feature(underscore_lifetimes)]
-
-struct Foo<'a: '_>(&'a u8); //~ ERROR invalid lifetime bound name: `'_`
-fn foo<'a: '_>(_: &'a u8) {} //~ ERROR invalid lifetime bound name: `'_`
-
-struct Bar<'a>(&'a u8);
-impl<'a: '_> Bar<'a> { //~ ERROR invalid lifetime bound name: `'_`
- fn bar() {}
-}
-
-fn main() {}
+++ /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.
-#![allow(warnings)]
-#![feature(conservative_impl_trait, nested_impl_trait)]
-
-trait Id<T> {}
-trait Lt<'a> {}
-
-impl<'a> Lt<'a> for () {}
-impl<T> Id<T> for T {}
-
-fn free_fn_capture_hrtb_in_impl_trait()
- -> impl for<'a> Id<impl Lt<'a>>
- //~^ ERROR `impl Trait` can only capture lifetimes bound at the fn or impl level [E0657]
-{
- ()
-}
-
-struct Foo;
-impl Foo {
- fn impl_fn_capture_hrtb_in_impl_trait()
- -> impl for<'a> Id<impl Lt<'a>>
- //~^ ERROR `impl Trait` can only capture lifetimes bound at the fn or impl level
- {
- ()
- }
-}
-
-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 main() {
- let _ = ::std::u128::MAX; //~ ERROR E0658
-}
+++ /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.
-
-mod moon {
- pub fn foo() {}
-}
-
-mod earth {
- pub fn foo() {}
-}
-
-mod collider {
- pub use moon::*;
- pub use earth::*;
-}
-
-fn main() {
- collider::foo(); //~ ERROR E0659
-}
--- /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.
+
+// revisions: ast mir
+//[mir]compile-flags: -Z borrowck=mir
+
+#![feature(box_syntax, slice_patterns, advanced_slice_patterns)]
+
+fn move_out_from_begin_and_end() {
+ let a = [box 1, box 2];
+ let [_, _x] = a;
+ let [.., _y] = a; //[ast]~ ERROR [E0382]
+ //[mir]~^ ERROR [E0382]
+}
+
+fn move_out_by_const_index_and_subslice() {
+ let a = [box 1, box 2];
+ let [_x, _] = a;
+ let [_y..] = a; //[ast]~ ERROR [E0382]
+ //[mir]~^ ERROR [E0382]
+}
+
+fn main() {}
#![allow(unused_macros)]
macro_rules! assign {
- (($($a:tt)*) = ($($b:tt))*) => { //~ ERROR expected `*` or `+`
+ (($($a:tt)*) = ($($b:tt))*) => { //~ ERROR expected one of: `*`, `+`, or `?`
$($a)* = $($b)*
}
}
--- /dev/null
+// Copyright 2012 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.
+
+// The logic for parsing Kleene operators in macros has a special case to disambiguate `?`.
+// Specifically, `$(pat)?` is the ZeroOrOne operator whereas `$(pat)?+` or `$(pat)?*` are the
+// ZeroOrMore and OneOrMore operators using `?` as a separator. These tests are intended to
+// exercise that logic in the macro parser.
+//
+// Moreover, we also throw in some tests for using a separator with `?`, which is meaningless but
+// included for consistency with `+` and `*`.
+//
+// This test focuses on error cases.
+
+#![feature(macro_at_most_once_rep)]
+
+macro_rules! foo {
+ ($(a)?) => {}
+}
+
+macro_rules! baz {
+ ($(a),?) => {} // comma separator is meaningless for `?`
+}
+
+macro_rules! barplus {
+ ($(a)?+) => {}
+}
+
+macro_rules! barstar {
+ ($(a)?*) => {}
+}
+
+pub fn main() {
+ foo!(a?a?a); //~ ERROR no rules expected the token `?`
+ foo!(a?a); //~ ERROR no rules expected the token `?`
+ foo!(a?); //~ ERROR no rules expected the token `?`
+ baz!(a?a?a); //~ ERROR no rules expected the token `?`
+ baz!(a?a); //~ ERROR no rules expected the token `?`
+ baz!(a?); //~ ERROR no rules expected the token `?`
+ baz!(a,); //~ ERROR unexpected end of macro invocation
+ baz!(a?a?a,); //~ ERROR no rules expected the token `?`
+ baz!(a?a,); //~ ERROR no rules expected the token `?`
+ baz!(a?,); //~ ERROR no rules expected the token `?`
+ barplus!(); //~ ERROR unexpected end of macro invocation
+ barplus!(a?); //~ ERROR unexpected end of macro invocation
+ barstar!(a?); //~ ERROR unexpected end of macro invocation
+}
+++ /dev/null
-// Copyright 2015 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(specialization)]
-
-// Make sure we can't project defaulted associated types
-
-trait Foo {
- type Assoc;
-}
-
-default impl<T> Foo for T {
- type Assoc = ();
-}
-
-impl Foo for u8 {
- type Assoc = String;
-}
-
-fn generic<T>() -> <T as Foo>::Assoc {
- // `T` could be some downstream crate type that specializes (or,
- // for that matter, `u8`).
-
- () //~ ERROR mismatched types
-}
-
-fn monomorphic() -> () {
- // Even though we know that `()` is not specialized in a
- // downstream crate, typeck refuses to project here.
-
- generic::<()>() //~ ERROR mismatched types
-}
-
-fn main() {
- // No error here, we CAN project from `u8`, as there is no `default`
- // in that impl.
- let s: String = generic::<u8>();
- println!("{}", s); // bad news if this all compiles
-}
+++ /dev/null
-// Copyright 2015 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.
-
-// It should not be possible to use the concrete value of a defaulted
-// associated type in the impl defining it -- otherwise, what happens
-// if it's overridden?
-
-#![feature(specialization)]
-
-trait Example {
- type Output;
- fn generate(self) -> Self::Output;
-}
-
-default impl<T> Example for T {
- type Output = Box<T>;
- fn generate(self) -> Self::Output {
- Box::new(self) //~ ERROR mismatched types
- }
-}
-
-impl Example for bool {
- type Output = bool;
- fn generate(self) -> bool { self }
-}
-
-fn trouble<T>(t: T) -> Box<T> {
- Example::generate(t) //~ ERROR mismatched types
-}
-
-fn weaponize() -> bool {
- let b: Box<bool> = trouble(true);
- *b
-}
-
-fn main() {
- weaponize();
-}
--- /dev/null
+// Copyright 2015 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.
+
+// Tests that default impls do not have to supply all items but regular impls do.
+
+#![feature(specialization)]
+
+trait Foo {
+ fn foo_one(&self) -> &'static str;
+ fn foo_two(&self) -> &'static str;
+}
+
+struct MyStruct;
+
+default impl<T> Foo for T {
+ fn foo_one(&self) -> &'static str {
+ "generic"
+ }
+}
+
+impl Foo for MyStruct {}
+//~^ ERROR not all trait items implemented, missing: `foo_two` [E0046]
+
+fn main() {
+ println!("{}", MyStruct.foo_one());
+}
--- /dev/null
+// Copyright 2015 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.
+
+// Tests that:
+// - default impls do not have to supply all items and
+// - a default impl does not count as an impl (in this case, an incomplete default impl).
+
+#![feature(specialization)]
+
+trait Foo {
+ fn foo_one(&self) -> &'static str;
+ fn foo_two(&self) -> &'static str;
+}
+
+struct MyStruct;
+
+default impl<T> Foo for T {
+ fn foo_one(&self) -> &'static str {
+ "generic"
+ }
+}
+
+
+fn main() {
+ println!("{}", MyStruct.foo_one());
+ //~^ ERROR no method named `foo_one` found for type `MyStruct` in the current scope
+}
--- /dev/null
+// Copyright 2015 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.
+
+// Tests that a default impl still has to have a WF trait ref.
+
+#![feature(specialization)]
+
+trait Foo<'a, T: Eq + 'a> { }
+
+default impl<U> Foo<'static, U> for () {}
+//~^ ERROR the trait bound `U: std::cmp::Eq` is not satisfied
+
+fn main(){}
--- /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.
+
+#![feature(box_syntax, slice_patterns, advanced_slice_patterns)]
+
+fn move_out_from_end() {
+ let a = [box 1, box 2];
+ let [.., _y] = a;
+}
+
+fn move_out_by_subslice() {
+ let a = [box 1, box 2];
+ let [_y..] = a;
+}
+
+fn main() {
+ move_out_by_subslice();
+ move_out_from_end();
+}
+
+// END RUST SOURCE
+
+// START rustc.move_out_from_end.UniformArrayMoveOut.before.mir
+// StorageLive(_6);
+// _6 = move _1[-1 of 1];
+// _0 = ();
+// END rustc.move_out_from_end.UniformArrayMoveOut.before.mir
+
+// START rustc.move_out_from_end.UniformArrayMoveOut.after.mir
+// StorageLive(_6);
+// _6 = move _1[1 of 2];
+// nop;
+// _0 = ();
+// END rustc.move_out_from_end.UniformArrayMoveOut.after.mir
+
+// START rustc.move_out_by_subslice.UniformArrayMoveOut.before.mir
+// StorageLive(_6);
+// _6 = move _1[0:];
+// END rustc.move_out_by_subslice.UniformArrayMoveOut.before.mir
+
+// START rustc.move_out_by_subslice.UniformArrayMoveOut.after.mir
+// StorageLive(_6);
+// StorageLive(_7);
+// _7 = move _1[0 of 2];
+// StorageLive(_8);
+// _8 = move _1[1 of 2];
+// _6 = [move _7, move _8];
+// StorageDead(_7);
+// StorageDead(_8);
+// nop;
+// _0 = ();
+// END rustc.move_out_by_subslice.UniformArrayMoveOut.after.mir
macro_rules! foo {
{ $+ } => { //~ ERROR expected identifier, found `+`
//~^ ERROR missing fragment specifier
- $(x)(y) //~ ERROR expected `*` or `+`
+ $(x)(y) //~ ERROR expected one of: `*`, `+`, or `?`
}
}
extern crate rustc;
extern crate rustc_plugin;
+use syntax::feature_gate::Features;
use syntax::parse::token::{NtExpr, NtPat};
use syntax::ast::{Ident, Pat};
use syntax::tokenstream::{TokenTree};
use syntax_pos::Span;
use rustc_plugin::Registry;
+use std::cell::RefCell;
+
fn expand_mbe_matches(cx: &mut ExtCtxt, _: Span, args: &[TokenTree])
-> Box<MacResult + 'static> {
let mbe_matcher = quote_tokens!(cx, $$matched:expr, $$($$pat:pat)|+);
- let mbe_matcher = quoted::parse(mbe_matcher.into_iter().collect(), true, cx.parse_sess);
+ let mbe_matcher = quoted::parse(mbe_matcher.into_iter().collect(),
+ true,
+ cx.parse_sess,
+ &RefCell::new(Features::new()),
+ &[]);
let map = match TokenTree::parse(cx, &mbe_matcher, args.iter().cloned().collect()) {
Success(map) => map,
Failure(_, tok) => {
--- /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.
+
+pub fn main() {
+ // Test that these type check correctly.
+ (&42u8 >> 4) as usize;
+ (&42u8 << 4) as usize;
+
+ let cap = 512 * 512;
+ cap as u8;
+ // Assert `cap` did not get inferred to `u8` and overflowed.
+ assert_ne!(cap, 0);
+}
};
}
+fn subslice_pattern_from_end(a: &Allocator, arg: bool) {
+ let a = [a.alloc(), a.alloc(), a.alloc()];
+ if arg {
+ let[.., _x, _] = a;
+ } else {
+ let[_, _y..] = a;
+ }
+}
+
+fn subslice_pattern_from_end_with_drop(a: &Allocator, arg: bool, arg2: bool) {
+ let a = [a.alloc(), a.alloc(), a.alloc(), a.alloc(), a.alloc()];
+ if arg2 {
+ drop(a);
+ return;
+ }
+
+ if arg {
+ let[.., _x, _] = a;
+ } else {
+ let[_, _y..] = a;
+ }
+}
+
+fn slice_pattern_reassign(a: &Allocator) {
+ let mut ar = [a.alloc(), a.alloc()];
+ let[_, _x] = ar;
+ ar = [a.alloc(), a.alloc()];
+ let[.., _y] = ar;
+}
+
+fn subslice_pattern_reassign(a: &Allocator) {
+ let mut ar = [a.alloc(), a.alloc(), a.alloc()];
+ let[_, _, _x] = ar;
+ ar = [a.alloc(), a.alloc(), a.alloc()];
+ let[_, _y..] = ar;
+}
+
fn run_test<F>(mut f: F)
where F: FnMut(&Allocator)
{
run_test(|a| slice_pattern_one_of(a, 2));
run_test(|a| slice_pattern_one_of(a, 3));
+ run_test(|a| subslice_pattern_from_end(a, true));
+ run_test(|a| subslice_pattern_from_end(a, false));
+ run_test(|a| subslice_pattern_from_end_with_drop(a, true, true));
+ run_test(|a| subslice_pattern_from_end_with_drop(a, true, false));
+ run_test(|a| subslice_pattern_from_end_with_drop(a, false, true));
+ run_test(|a| subslice_pattern_from_end_with_drop(a, false, false));
+ run_test(|a| slice_pattern_reassign(a));
+ run_test(|a| subslice_pattern_reassign(a));
+
run_test_nopanic(|a| union1(a));
}
--- /dev/null
+// Copyright 2012 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(nll)]
+
+struct AtomicRefMut<'a> {
+ value: &'a mut i32,
+ borrow: AtomicBorrowRefMut,
+}
+
+struct AtomicBorrowRefMut {
+}
+
+impl Drop for AtomicBorrowRefMut {
+ fn drop(&mut self) {
+ }
+}
+
+fn map(orig: AtomicRefMut) -> AtomicRefMut {
+ AtomicRefMut {
+ value: orig.value,
+ borrow: orig.borrow,
+ }
+}
+
+fn main() {}
--- /dev/null
+// Copyright 2012 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(nll)]
+
+struct MyStruct<'a> {
+ field: &'a mut (),
+ field2: WithDrop
+}
+
+struct WithDrop;
+
+impl Drop for WithDrop {
+ fn drop(&mut self) {}
+}
+
+impl<'a> MyStruct<'a> {
+ fn consume(self) -> &'a mut () { self.field }
+}
+
+fn main() {}
--- /dev/null
+// Copyright 2012 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.
+
+// The logic for parsing Kleene operators in macros has a special case to disambiguate `?`.
+// Specifically, `$(pat)?` is the ZeroOrOne operator whereas `$(pat)?+` or `$(pat)?*` are the
+// ZeroOrMore and OneOrMore operators using `?` as a separator. These tests are intended to
+// exercise that logic in the macro parser.
+//
+// Moreover, we also throw in some tests for using a separator with `?`, which is meaningless but
+// included for consistency with `+` and `*`.
+//
+// This test focuses on non-error cases and making sure the correct number of repetitions happen.
+
+#![feature(macro_at_most_once_rep)]
+
+macro_rules! foo {
+ ($($a:ident)? ; $num:expr) => { {
+ let mut x = 0;
+
+ $(
+ x += $a;
+ )?
+
+ assert_eq!(x, $num);
+ } }
+}
+
+macro_rules! baz {
+ ($($a:ident),? ; $num:expr) => { { // comma separator is meaningless for `?`
+ let mut x = 0;
+
+ $(
+ x += $a;
+ )?
+
+ assert_eq!(x, $num);
+ } }
+}
+
+macro_rules! barplus {
+ ($($a:ident)?+ ; $num:expr) => { {
+ let mut x = 0;
+
+ $(
+ x += $a;
+ )+
+
+ assert_eq!(x, $num);
+ } }
+}
+
+macro_rules! barstar {
+ ($($a:ident)?* ; $num:expr) => { {
+ let mut x = 0;
+
+ $(
+ x += $a;
+ )*
+
+ assert_eq!(x, $num);
+ } }
+}
+
+pub fn main() {
+ let a = 1;
+
+ // accept 0 or 1 repetitions
+ foo!( ; 0);
+ foo!(a ; 1);
+ baz!( ; 0);
+ baz!(a ; 1);
+
+ // Make sure using ? as a separator works as before
+ barplus!(a ; 1);
+ barplus!(a?a ; 2);
+ barplus!(a?a?a ; 3);
+ barstar!( ; 0);
+ barstar!(a ; 1);
+ barstar!(a?a ; 2);
+ barstar!(a?a?a ; 3);
+}
+++ /dev/null
-// Copyright 2015 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 that non-method associated functions can be specialized
-
-#![feature(specialization)]
-
-trait Foo {
- fn mk() -> Self;
-}
-
-default impl<T: Default> Foo for T {
- fn mk() -> T {
- T::default()
- }
-}
-
-impl Foo for Vec<u8> {
- fn mk() -> Vec<u8> {
- vec![0]
- }
-}
-
-fn main() {
- let v1: Vec<i32> = Foo::mk();
- let v2: Vec<u8> = Foo::mk();
-
- assert!(v1.len() == 0);
- assert!(v2.len() == 1);
-}
+++ /dev/null
-// Copyright 2015 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(specialization)]
-
-pub trait Foo {
- fn foo(&self) -> &'static str;
-}
-
-default impl<T> Foo for T {
- fn foo(&self) -> &'static str {
- "generic"
- }
-}
-
-default impl<T: Clone> Foo for T {
- fn foo(&self) -> &'static str {
- "generic Clone"
- }
-}
-
-default impl<T, U> Foo for (T, U) where T: Clone, U: Clone {
- fn foo(&self) -> &'static str {
- "generic pair"
- }
-}
-
-default impl<T: Clone> Foo for (T, T) {
- fn foo(&self) -> &'static str {
- "generic uniform pair"
- }
-}
-
-default impl Foo for (u8, u32) {
- fn foo(&self) -> &'static str {
- "(u8, u32)"
- }
-}
-
-default impl Foo for (u8, u8) {
- fn foo(&self) -> &'static str {
- "(u8, u8)"
- }
-}
-
-default impl<T: Clone> Foo for Vec<T> {
- fn foo(&self) -> &'static str {
- "generic Vec"
- }
-}
-
-impl Foo for Vec<i32> {
- fn foo(&self) -> &'static str {
- "Vec<i32>"
- }
-}
-
-impl Foo for String {
- fn foo(&self) -> &'static str {
- "String"
- }
-}
-
-impl Foo for i32 {
- fn foo(&self) -> &'static str {
- "i32"
- }
-}
-
-pub trait MyMarker {}
-default impl<T: Clone + MyMarker> Foo for T {
- fn foo(&self) -> &'static str {
- "generic Clone + MyMarker"
- }
-}
+++ /dev/null
-// Copyright 2015 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(specialization)]
-
-// First, test only use of explicit `default` items:
-
-pub trait Foo {
- fn foo(&self) -> bool;
-}
-
-default impl<T> Foo for T {
- fn foo(&self) -> bool { false }
-}
-
-impl Foo for i32 {}
-
-impl Foo for i64 {
- fn foo(&self) -> bool { true }
-}
-
-// Next, test mixture of explicit `default` and provided methods:
-
-pub trait Bar {
- fn bar(&self) -> i32 { 0 }
-}
-
-impl<T> Bar for T {} // use the provided method
-
-impl Bar for i32 {
- fn bar(&self) -> i32 { 1 }
-}
-impl<'a> Bar for &'a str {}
-
-default impl<T> Bar for Vec<T> {
- fn bar(&self) -> i32 { 2 }
-}
-impl Bar for Vec<i32> {}
-impl Bar for Vec<i64> {
- fn bar(&self) -> i32 { 3 }
-}
+++ /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.
-
-#![feature(specialization)]
-
-// Tests a variety of basic specialization scenarios and method
-// dispatch for them.
-
-unsafe trait Foo {
- fn foo(&self) -> &'static str;
-}
-
-default unsafe impl<T> Foo for T {
- fn foo(&self) -> &'static str {
- "generic"
- }
-}
-
-default unsafe impl<T: Clone> Foo for T {
- fn foo(&self) -> &'static str {
- "generic Clone"
- }
-}
-
-default unsafe impl<T, U> Foo for (T, U) where T: Clone, U: Clone {
- fn foo(&self) -> &'static str {
- "generic pair"
- }
-}
-
-default unsafe impl<T: Clone> Foo for (T, T) {
- fn foo(&self) -> &'static str {
- "generic uniform pair"
- }
-}
-
-default unsafe impl Foo for (u8, u32) {
- fn foo(&self) -> &'static str {
- "(u8, u32)"
- }
-}
-
-default unsafe impl Foo for (u8, u8) {
- fn foo(&self) -> &'static str {
- "(u8, u8)"
- }
-}
-
-default unsafe impl<T: Clone> Foo for Vec<T> {
- fn foo(&self) -> &'static str {
- "generic Vec"
- }
-}
-
-default unsafe impl Foo for Vec<i32> {
- fn foo(&self) -> &'static str {
- "Vec<i32>"
- }
-}
-
-default unsafe impl Foo for String {
- fn foo(&self) -> &'static str {
- "String"
- }
-}
-
-default unsafe impl Foo for i32 {
- fn foo(&self) -> &'static str {
- "i32"
- }
-}
-
-struct NotClone;
-
-unsafe trait MyMarker {}
-default unsafe impl<T: Clone + MyMarker> Foo for T {
- fn foo(&self) -> &'static str {
- "generic Clone + MyMarker"
- }
-}
-
-#[derive(Clone)]
-struct MarkedAndClone;
-unsafe impl MyMarker for MarkedAndClone {}
-
-fn main() {
- assert!(NotClone.foo() == "generic");
- assert!(0u8.foo() == "generic Clone");
- assert!(vec![NotClone].foo() == "generic");
- assert!(vec![0u8].foo() == "generic Vec");
- assert!(vec![0i32].foo() == "Vec<i32>");
- assert!(0i32.foo() == "i32");
- assert!(String::new().foo() == "String");
- assert!(((), 0).foo() == "generic pair");
- assert!(((), ()).foo() == "generic uniform pair");
- assert!((0u8, 0u32).foo() == "(u8, u32)");
- assert!((0u8, 0u8).foo() == "(u8, u8)");
- assert!(MarkedAndClone.foo() == "generic Clone + MyMarker");
-}
+++ /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.
-
-#![feature(specialization)]
-
-// Tests a variety of basic specialization scenarios and method
-// dispatch for them.
-
-trait Foo {
- fn foo(&self) -> &'static str;
-}
-
-default impl<T> Foo for T {
- fn foo(&self) -> &'static str {
- "generic"
- }
-}
-
-default impl<T: Clone> Foo for T {
- fn foo(&self) -> &'static str {
- "generic Clone"
- }
-}
-
-default impl<T, U> Foo for (T, U) where T: Clone, U: Clone {
- fn foo(&self) -> &'static str {
- "generic pair"
- }
-}
-
-default impl<T: Clone> Foo for (T, T) {
- fn foo(&self) -> &'static str {
- "generic uniform pair"
- }
-}
-
-default impl Foo for (u8, u32) {
- fn foo(&self) -> &'static str {
- "(u8, u32)"
- }
-}
-
-default impl Foo for (u8, u8) {
- fn foo(&self) -> &'static str {
- "(u8, u8)"
- }
-}
-
-default impl<T: Clone> Foo for Vec<T> {
- fn foo(&self) -> &'static str {
- "generic Vec"
- }
-}
-
-impl Foo for Vec<i32> {
- fn foo(&self) -> &'static str {
- "Vec<i32>"
- }
-}
-
-impl Foo for String {
- fn foo(&self) -> &'static str {
- "String"
- }
-}
-
-impl Foo for i32 {
- fn foo(&self) -> &'static str {
- "i32"
- }
-}
-
-struct NotClone;
-
-trait MyMarker {}
-default impl<T: Clone + MyMarker> Foo for T {
- fn foo(&self) -> &'static str {
- "generic Clone + MyMarker"
- }
-}
-
-#[derive(Clone)]
-struct MarkedAndClone;
-impl MyMarker for MarkedAndClone {}
-
-fn main() {
- assert!(NotClone.foo() == "generic");
- assert!(0u8.foo() == "generic Clone");
- assert!(vec![NotClone].foo() == "generic");
- assert!(vec![0u8].foo() == "generic Vec");
- assert!(vec![0i32].foo() == "Vec<i32>");
- assert!(0i32.foo() == "i32");
- assert!(String::new().foo() == "String");
- assert!(((), 0).foo() == "generic pair");
- assert!(((), ()).foo() == "generic uniform pair");
- assert!((0u8, 0u32).foo() == "(u8, u32)");
- assert!((0u8, 0u8).foo() == "(u8, u8)");
- assert!(MarkedAndClone.foo() == "generic Clone + MyMarker");
-}
+++ /dev/null
-// Copyright 2015 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.
-
-// aux-build:cross_crate_defaults.rs
-
-#![feature(specialization)]
-
-extern crate cross_crate_defaults;
-
-use cross_crate_defaults::*;
-
-struct LocalDefault;
-struct LocalOverride;
-
-impl Foo for LocalDefault {}
-
-impl Foo for LocalOverride {
- fn foo(&self) -> bool { true }
-}
-
-fn test_foo() {
- assert!(!0i8.foo());
- assert!(!0i32.foo());
- assert!(0i64.foo());
-
- assert!(!LocalDefault.foo());
- assert!(LocalOverride.foo());
-}
-
-fn test_bar() {
- assert!(0u8.bar() == 0);
- assert!(0i32.bar() == 1);
- assert!("hello".bar() == 0);
- assert!(vec![()].bar() == 2);
- assert!(vec![0i32].bar() == 2);
- assert!(vec![0i64].bar() == 3);
-}
-
-fn main() {
- test_foo();
- test_bar();
-}
+++ /dev/null
-// Copyright 2015 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 that specialization works even if only the upstream crate enables it
-
-// aux-build:cross_crate.rs
-
-extern crate cross_crate;
-
-use cross_crate::*;
-
-fn main() {
- assert!(0u8.foo() == "generic Clone");
- assert!(vec![0u8].foo() == "generic Vec");
- assert!(vec![0i32].foo() == "Vec<i32>");
- assert!(0i32.foo() == "i32");
- assert!(String::new().foo() == "String");
- assert!(((), 0).foo() == "generic pair");
- assert!(((), ()).foo() == "generic uniform pair");
- assert!((0u8, 0u32).foo() == "(u8, u32)");
- assert!((0u8, 0u8).foo() == "(u8, u8)");
-}
+++ /dev/null
-// Copyright 2015 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.
-
-// aux-build:cross_crate.rs
-
-#![feature(specialization)]
-
-extern crate cross_crate;
-
-use cross_crate::*;
-
-struct NotClone;
-
-#[derive(Clone)]
-struct MarkedAndClone;
-impl MyMarker for MarkedAndClone {}
-
-struct MyType<T>(T);
-default impl<T> Foo for MyType<T> {
- fn foo(&self) -> &'static str {
- "generic MyType"
- }
-}
-
-impl Foo for MyType<u8> {
- fn foo(&self) -> &'static str {
- "MyType<u8>"
- }
-}
-
-struct MyOtherType;
-impl Foo for MyOtherType {}
-
-fn main() {
- assert!(NotClone.foo() == "generic");
- assert!(0u8.foo() == "generic Clone");
- assert!(vec![NotClone].foo() == "generic");
- assert!(vec![0u8].foo() == "generic Vec");
- assert!(vec![0i32].foo() == "Vec<i32>");
- assert!(0i32.foo() == "i32");
- assert!(String::new().foo() == "String");
- assert!(((), 0).foo() == "generic pair");
- assert!(((), ()).foo() == "generic uniform pair");
- assert!((0u8, 0u32).foo() == "(u8, u32)");
- assert!((0u8, 0u8).foo() == "(u8, u8)");
- assert!(MarkedAndClone.foo() == "generic Clone + MyMarker");
-
- assert!(MyType(()).foo() == "generic MyType");
- assert!(MyType(0u8).foo() == "MyType<u8>");
- assert!(MyOtherType.foo() == "generic");
-}
+++ /dev/null
-// Copyright 2015 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(specialization)]
-
-// Test that default methods are cascaded correctly
-
-// First, test only use of explicit `default` items:
-
-trait Foo {
- fn foo(&self) -> bool;
-}
-
-// Specialization tree for Foo:
-//
-// T
-// / \
-// i32 i64
-
-default impl<T> Foo for T {
- fn foo(&self) -> bool { false }
-}
-
-impl Foo for i32 {}
-
-impl Foo for i64 {
- fn foo(&self) -> bool { true }
-}
-
-fn test_foo() {
- assert!(!0i8.foo());
- assert!(!0i32.foo());
- assert!(0i64.foo());
-}
-
-// Next, test mixture of explicit `default` and provided methods:
-
-trait Bar {
- fn bar(&self) -> i32 { 0 }
-}
-
-// Specialization tree for Bar.
-// Uses of $ designate that method is provided
-//
-// $Bar (the trait)
-// |
-// T
-// /|\
-// / | \
-// / | \
-// / | \
-// / | \
-// / | \
-// $i32 &str $Vec<T>
-// /\
-// / \
-// Vec<i32> $Vec<i64>
-
-// use the provided method
-impl<T> Bar for T {}
-
-impl Bar for i32 {
- fn bar(&self) -> i32 { 1 }
-}
-impl<'a> Bar for &'a str {}
-
-default impl<T> Bar for Vec<T> {
- fn bar(&self) -> i32 { 2 }
-}
-impl Bar for Vec<i32> {}
-impl Bar for Vec<i64> {
- fn bar(&self) -> i32 { 3 }
-}
-
-fn test_bar() {
- assert!(0u8.bar() == 0);
- assert!(0i32.bar() == 1);
- assert!("hello".bar() == 0);
- assert!(vec![()].bar() == 2);
- assert!(vec![0i32].bar() == 2);
- assert!(vec![0i64].bar() == 3);
-}
-
-fn main() {
- test_foo();
- test_bar();
-}
+++ /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.
-
-#![feature(specialization)]
-
-// Regression test for ICE when combining specialized associated types and type
-// aliases
-
-trait Id_ {
- type Out;
-}
-
-type Id<T> = <T as Id_>::Out;
-
-default impl<T> Id_ for T {
- type Out = T;
-}
-
-fn test_proection() {
- let x: Id<bool> = panic!();
-}
-
-fn main() {
-
-}
--- /dev/null
+// Copyright 2015 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.
+
+// Tests that we can combine a default impl that supplies one method with a
+// full impl that supplies the other, and they can invoke one another.
+
+#![feature(specialization)]
+
+trait Foo {
+ fn foo_one(&self) -> &'static str;
+ fn foo_two(&self) -> &'static str;
+ fn foo_three(&self) -> &'static str;
+}
+
+struct MyStruct;
+
+default impl<T> Foo for T {
+ fn foo_one(&self) -> &'static str {
+ self.foo_three()
+ }
+}
+
+impl Foo for MyStruct {
+ fn foo_two(&self) -> &'static str {
+ self.foo_one()
+ }
+
+ fn foo_three(&self) -> &'static str {
+ "generic"
+ }
+}
+
+fn main() {
+ assert!(MyStruct.foo_two() == "generic");
+}
//! }
//! ```
-// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0A%20%20%20%20println!(%22Hello%2C%20world!%22)%3B%0A%7D%0A"]' "Run"
+// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0A%20%20%20%20println!(%22Hello%2C%20world!%22)%3B%0A%7D"]' "Run"
// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Aprintln!(%22Hello%2C%20world!%22)%3B%0A%7D"]' "Run"
-// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=%23!%5Ballow(unused)%5D%0A%23!%5Bfeature(something)%5D%0A%0Afn%20main()%20%7B%0A%20%20%20%20println!(%22Hello%2C%20world!%22)%3B%0A%7D%0A&version=nightly"]' "Run"
+// @matches foo/index.html '//a[@class="test-arrow"][@href="https://www.example.com/?code=%23!%5Ballow(unused)%5D%0A%23!%5Bfeature(something)%5D%0A%0Afn%20main()%20%7B%0A%20%20%20%20println!(%22Hello%2C%20world!%22)%3B%0A%7D&version=nightly"]' "Run"
--- /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.
+
+#![deny(overflowing_literals)]
+
+fn main() {
+ const XYZ: char = 0x1F888 as char;
+ //~^ ERROR only u8 can be casted into char
+ const XY: char = 129160 as char;
+ //~^ ERROR only u8 can be casted into char
+ const ZYX: char = '\u{01F888}';
+ println!("{}", XYZ);
+}
--- /dev/null
+error: only u8 can be casted into char
+ --> $DIR/cast_char.rs:14:23
+ |
+14 | const XYZ: char = 0x1F888 as char;
+ | ^^^^^^^^^^^^^^^ help: use a char literal instead: `'/u{1F888}'`
+ |
+note: lint level defined here
+ --> $DIR/cast_char.rs:11:9
+ |
+11 | #![deny(overflowing_literals)]
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: only u8 can be casted into char
+ --> $DIR/cast_char.rs:16:22
+ |
+16 | const XY: char = 129160 as char;
+ | ^^^^^^^^^^^^^^ help: use a char literal instead: `'/u{1F888}'`
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+#![deny(unreachable_patterns)]
+
+fn main() {
+ let foo = Some(1);
+ match foo {
+ Some(_) => {/* ... */}
+ None => {/* ... */}
+ _ => {/* ... */} //~ ERROR unreachable pattern
+ }
+}
--- /dev/null
+error: unreachable pattern
+ --> $DIR/E0001.rs:18:9
+ |
+18 | _ => {/* ... */} //~ ERROR unreachable pattern
+ | ^
+ |
+note: lint level defined here
+ --> $DIR/E0001.rs:11:9
+ |
+11 | #![deny(unreachable_patterns)]
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let x = Some(1);
+
+ match x { } //~ ERROR E0004
+}
--- /dev/null
+error[E0004]: non-exhaustive patterns: type std::option::Option<i32> is non-empty
+ --> $DIR/E0004-2.rs:14:11
+ |
+14 | match x { } //~ ERROR E0004
+ | ^
+ |
+help: Please ensure that all possible cases are being handled; possibly adding wildcards or more match arms.
+ --> $DIR/E0004-2.rs:14:11
+ |
+14 | match x { } //~ ERROR E0004
+ | ^
+
+error: aborting due to previous error
+
--- /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.
+
+enum Terminator {
+ HastaLaVistaBaby,
+ TalkToMyHand,
+}
+
+fn main() {
+ let x = Terminator::HastaLaVistaBaby;
+
+ match x { //~ ERROR E0004
+ Terminator::TalkToMyHand => {}
+ }
+}
--- /dev/null
+error[E0004]: non-exhaustive patterns: `HastaLaVistaBaby` not covered
+ --> $DIR/E0004.rs:19:11
+ |
+19 | match x { //~ ERROR E0004
+ | ^ pattern `HastaLaVistaBaby` not covered
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let x = Some(1);
+ let Some(y) = x; //~ ERROR E0005
+}
--- /dev/null
+error[E0005]: refutable pattern in local binding: `None` not covered
+ --> $DIR/E0005.rs:13:9
+ |
+13 | let Some(y) = x; //~ ERROR E0005
+ | ^^^^^^^ pattern `None` not covered
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let x = Some("s".to_string());
+ match x {
+ op_string @ Some(s) => {},
+ //~^ ERROR E0007
+ //~| ERROR E0303
+ None => {},
+ }
+}
--- /dev/null
+error[E0007]: cannot bind by-move with sub-bindings
+ --> $DIR/E0007.rs:14:9
+ |
+14 | op_string @ Some(s) => {},
+ | ^^^^^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
+
+error[E0303]: pattern bindings are not allowed after an `@`
+ --> $DIR/E0007.rs:14:26
+ |
+14 | op_string @ Some(s) => {},
+ | ^ not allowed after `@`
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn main() {
+ match Some("hi".to_string()) {
+ Some(s) if s.len() == 0 => {},
+ //~^ ERROR E0008
+ _ => {},
+ }
+}
--- /dev/null
+error[E0008]: cannot bind by-move into a pattern guard
+ --> $DIR/E0008.rs:13:14
+ |
+13 | Some(s) if s.len() == 0 => {},
+ | ^ moves value into pattern guard
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ struct X { x: (), }
+ let x = Some((X { x: () }, X { x: () }));
+ match x {
+ Some((y, ref z)) => {},
+ //~^ ERROR E0009
+ None => panic!()
+ }
+}
--- /dev/null
+error[E0009]: cannot bind by-move and by-ref in the same pattern
+ --> $DIR/E0009.rs:15:15
+ |
+15 | Some((y, ref z)) => {},
+ | ^ ----- both by-ref and by-move used
+ | |
+ | by-move pattern here
+
+error: aborting due to previous error
+
--- /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.
+
+// compile-flags: -Z teach
+
+#![feature(box_syntax)]
+#![allow(warnings)]
+
+const CON : Box<i32> = box 0; //~ ERROR E0010
+
+fn main() {}
--- /dev/null
+error[E0010]: allocations are not allowed in constants
+ --> $DIR/E0010-teach.rs:16:24
+ |
+16 | const CON : Box<i32> = box 0; //~ ERROR E0010
+ | ^^^^^ allocation not allowed in constants
+ |
+ = note: The value of statics and constants must be known at compile time, and they live for the entire lifetime of a program. Creating a boxed value allocates memory on the heap at runtime, and therefore cannot be done at compile time.
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(box_syntax)]
+#![allow(warnings)]
+
+const CON : Box<i32> = box 0; //~ ERROR E0010
+
+fn main() {}
--- /dev/null
+error[E0010]: allocations are not allowed in constants
+ --> $DIR/E0010.rs:14:24
+ |
+14 | const CON : Box<i32> = box 0; //~ ERROR E0010
+ | ^^^^^ allocation not allowed in constants
+
+error: aborting due to previous error
+
--- /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.
+
+static X: i32 = 1;
+const C: i32 = 2;
+
+const CR: &'static mut i32 = &mut C; //~ ERROR E0017
+static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
+ //~| ERROR cannot borrow
+static CONST_REF: &'static mut i32 = &mut C; //~ ERROR E0017
+fn main() {}
--- /dev/null
+error[E0017]: references in constants may only refer to immutable values
+ --> $DIR/E0017.rs:14:30
+ |
+14 | const CR: &'static mut i32 = &mut C; //~ ERROR E0017
+ | ^^^^^^ constants require immutable values
+
+error[E0017]: references in statics may only refer to immutable values
+ --> $DIR/E0017.rs:15:39
+ |
+15 | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
+ | ^^^^^^ statics require immutable values
+
+error[E0596]: cannot borrow immutable static item as mutable
+ --> $DIR/E0017.rs:15:44
+ |
+15 | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
+ | ^
+
+error[E0017]: references in statics may only refer to immutable values
+ --> $DIR/E0017.rs:17:38
+ |
+17 | static CONST_REF: &'static mut i32 = &mut C; //~ ERROR E0017
+ | ^^^^^^ statics require immutable values
+
+error: aborting due to 4 previous errors
+
--- /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.
+
+enum Fruit {
+ Apple(String, String),
+ Pear(u32),
+}
+
+
+fn main() {
+ let x = Fruit::Apple(String::new(), String::new());
+ match x {
+ Fruit::Apple(a) => {}, //~ ERROR E0023
+ Fruit::Apple(a, b, c) => {}, //~ ERROR E0023
+ Fruit::Pear(1, 2) => {}, //~ ERROR E0023
+ }
+}
--- /dev/null
+error[E0023]: this pattern has 1 field, but the corresponding tuple variant has 2 fields
+ --> $DIR/E0023.rs:20:9
+ |
+20 | Fruit::Apple(a) => {}, //~ ERROR E0023
+ | ^^^^^^^^^^^^^^^ expected 2 fields, found 1
+
+error[E0023]: this pattern has 3 fields, but the corresponding tuple variant has 2 fields
+ --> $DIR/E0023.rs:21:9
+ |
+21 | Fruit::Apple(a, b, c) => {}, //~ ERROR E0023
+ | ^^^^^^^^^^^^^^^^^^^^^ expected 2 fields, found 3
+
+error[E0023]: this pattern has 2 fields, but the corresponding tuple variant has 1 field
+ --> $DIR/E0023.rs:22:9
+ |
+22 | Fruit::Pear(1, 2) => {}, //~ ERROR E0023
+ | ^^^^^^^^^^^^^^^^^ expected 1 field, found 2
+
+error: aborting due to 3 previous errors
+
--- /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.
+
+struct Foo {
+ a: u8,
+ b: u8,
+}
+
+fn main() {
+ let x = Foo { a:1, b:2 };
+ let Foo { a: x, a: y, b: 0 } = x;
+ //~^ ERROR field `a` bound multiple times in the pattern
+}
--- /dev/null
+error[E0025]: field `a` bound multiple times in the pattern
+ --> $DIR/E0025.rs:18:21
+ |
+18 | let Foo { a: x, a: y, b: 0 } = x;
+ | ---- ^^^^ multiple uses of `a` in pattern
+ | |
+ | first use of `a`
+
+error: aborting due to previous error
+
--- /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.
+
+// compile-flags: -Z teach
+
+struct Thing {
+ x: u32,
+ y: u32
+}
+
+fn main() {
+ let thing = Thing { x: 0, y: 0 };
+ match thing {
+ Thing { x, y, z } => {}
+ //~^ ERROR struct `Thing` does not have a field named `z` [E0026]
+ }
+}
--- /dev/null
+error[E0026]: struct `Thing` does not have a field named `z`
+ --> $DIR/E0026-teach.rs:21:23
+ |
+21 | Thing { x, y, z } => {}
+ | ^ struct `Thing` does not have field `z`
+ |
+ = note: This error indicates that a struct pattern attempted to extract a non-existent field from a struct. Struct fields are identified by the name used before the colon : so struct patterns should resemble the declaration of the struct type being matched.
+
+ If you are using shorthand field patterns but want to refer to the struct field by a different name, you should rename it explicitly.
+
+error: aborting due to previous error
+
--- /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.
+
+struct Thing {
+ x: u32,
+ y: u32
+}
+
+fn main() {
+ let thing = Thing { x: 0, y: 0 };
+ match thing {
+ Thing { x, y, z } => {}
+ //~^ ERROR struct `Thing` does not have a field named `z` [E0026]
+ }
+}
--- /dev/null
+error[E0026]: struct `Thing` does not have a field named `z`
+ --> $DIR/E0026.rs:19:23
+ |
+19 | Thing { x, y, z } => {}
+ | ^ struct `Thing` does not have field `z`
+
+error: aborting due to previous error
+
--- /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.
+
+// compile-flags: -Z teach
+
+struct Dog {
+ name: String,
+ age: u32,
+}
+
+fn main() {
+ let d = Dog { name: "Rusty".to_string(), age: 8 };
+
+ match d {
+ Dog { age: x } => {}
+ //~^ ERROR pattern does not mention field `name`
+ }
+}
--- /dev/null
+error[E0027]: pattern does not mention field `name`
+ --> $DIR/E0027-teach.rs:22:9
+ |
+22 | Dog { age: x } => {}
+ | ^^^^^^^^^^^^^^ missing field `name`
+ |
+ = note: This error indicates that a pattern for a struct fails to specify a sub-pattern for every one of the struct's fields. Ensure that each field from the struct's definition is mentioned in the pattern, or use `..` to ignore unwanted fields.
+
+error: aborting due to previous error
+
--- /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.
+
+struct Dog {
+ name: String,
+ age: u32,
+}
+
+fn main() {
+ let d = Dog { name: "Rusty".to_string(), age: 8 };
+
+ match d {
+ Dog { age: x } => {}
+ //~^ ERROR pattern does not mention field `name`
+ }
+}
--- /dev/null
+error[E0027]: pattern does not mention field `name`
+ --> $DIR/E0027.rs:20:9
+ |
+20 | Dog { age: x } => {}
+ | ^^^^^^^^^^^^^^ missing field `name`
+
+error: aborting due to previous error
+
--- /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.
+
+// compile-flags: -Z teach
+
+fn main() {
+ let s = "hoho";
+
+ match s {
+ "hello" ... "world" => {}
+ //~^ ERROR only char and numeric types are allowed in range patterns
+ //~| ERROR non-reference pattern used to match a reference
+ _ => {}
+ }
+}
--- /dev/null
+error[E0658]: non-reference pattern used to match a reference (see issue #42640)
+ --> $DIR/E0029-teach.rs:17:9
+ |
+17 | "hello" ... "world" => {}
+ | ^^^^^^^^^^^^^^^^^^^ help: consider using a reference: `&"hello" ... "world"`
+ |
+ = help: add #![feature(match_default_bindings)] to the crate attributes to enable
+
+error[E0029]: only char and numeric types are allowed in range patterns
+ --> $DIR/E0029-teach.rs:17:9
+ |
+17 | "hello" ... "world" => {}
+ | ^^^^^^^^^^^^^^^^^^^ ranges require char or numeric types
+ |
+ = note: start type: &'static str
+ = note: end type: &'static str
+ = note: In a match expression, only numbers and characters can be matched against a range. This is because the compiler checks that the range is non-empty at compile-time, and is unable to evaluate arbitrary comparison functions. If you want to capture values of an orderable type between two end-points, you can use a guard.
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn main() {
+ let s = "hoho";
+
+ match s {
+ "hello" ... "world" => {}
+ //~^ ERROR only char and numeric types are allowed in range patterns
+ //~| ERROR non-reference pattern used to match a reference
+ _ => {}
+ }
+}
--- /dev/null
+error[E0658]: non-reference pattern used to match a reference (see issue #42640)
+ --> $DIR/E0029.rs:15:9
+ |
+15 | "hello" ... "world" => {}
+ | ^^^^^^^^^^^^^^^^^^^ help: consider using a reference: `&"hello" ... "world"`
+ |
+ = help: add #![feature(match_default_bindings)] to the crate attributes to enable
+
+error[E0029]: only char and numeric types are allowed in range patterns
+ --> $DIR/E0029.rs:15:9
+ |
+15 | "hello" ... "world" => {}
+ | ^^^^^^^^^^^^^^^^^^^ ranges require char or numeric types
+ |
+ = note: start type: &'static str
+ = note: end type: &'static str
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+// compile-flags: -Z teach
+
+fn main() {
+ match 5u32 {
+ 1000 ... 5 => {}
+ //~^ ERROR lower range bound must be less than or equal to upper
+ }
+}
--- /dev/null
+error[E0030]: lower range bound must be less than or equal to upper
+ --> $DIR/E0030-teach.rs:15:9
+ |
+15 | 1000 ... 5 => {}
+ | ^^^^ lower bound larger than upper bound
+ |
+ = note: When matching against a range, the compiler verifies that the range is non-empty. Range patterns include both end-points, so this is equivalent to requiring the start of the range to be less than or equal to the end of the range.
+
+error: aborting due to previous error
+
--- /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.
+
+
+fn main() {
+ match 5u32 {
+ 1000 ... 5 => {}
+ //~^ ERROR lower range bound must be less than or equal to upper
+ }
+}
--- /dev/null
+error[E0030]: lower range bound must be less than or equal to upper
+ --> $DIR/E0030.rs:14:9
+ |
+14 | 1000 ... 5 => {}
+ | ^^^^ lower bound larger than upper bound
+
+error: aborting due to previous error
+
--- /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.
+
+// compile-flags: -Z teach
+
+trait SomeTrait {
+ fn foo();
+}
+
+fn main() {
+ let trait_obj: &SomeTrait = SomeTrait;
+ //~^ ERROR expected value, found trait `SomeTrait`
+ //~| ERROR E0038
+ //~| method `foo` has no receiver
+
+ let &invalid = trait_obj;
+ //~^ ERROR E0033
+}
--- /dev/null
+error[E0423]: expected value, found trait `SomeTrait`
+ --> $DIR/E0033-teach.rs:18:33
+ |
+18 | let trait_obj: &SomeTrait = SomeTrait;
+ | ^^^^^^^^^ not a value
+
+error[E0038]: the trait `SomeTrait` cannot be made into an object
+ --> $DIR/E0033-teach.rs:18:20
+ |
+18 | let trait_obj: &SomeTrait = SomeTrait;
+ | ^^^^^^^^^^ the trait `SomeTrait` cannot be made into an object
+ |
+ = note: method `foo` has no receiver
+
+error[E0033]: type `&SomeTrait` cannot be dereferenced
+ --> $DIR/E0033-teach.rs:23:9
+ |
+23 | let &invalid = trait_obj;
+ | ^^^^^^^^ type `&SomeTrait` cannot be dereferenced
+ |
+ = note: This error indicates that a pointer to a trait type cannot be implicitly dereferenced by a pattern. Every trait defines a type, but because the size of trait implementors isn't fixed, this type has no compile-time size. Therefore, all accesses to trait types must be through pointers. If you encounter this error you should try to avoid dereferencing the pointer.
+
+ You can read more about trait objects in the Trait Objects section of the Reference: https://doc.rust-lang.org/reference/types.html#trait-objects
+
+error: aborting due to 3 previous errors
+
--- /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.
+
+trait SomeTrait {
+ fn foo();
+}
+
+fn main() {
+ let trait_obj: &SomeTrait = SomeTrait;
+ //~^ ERROR expected value, found trait `SomeTrait`
+ //~| ERROR E0038
+ //~| method `foo` has no receiver
+
+ let &invalid = trait_obj;
+ //~^ ERROR E0033
+}
--- /dev/null
+error[E0423]: expected value, found trait `SomeTrait`
+ --> $DIR/E0033.rs:16:33
+ |
+16 | let trait_obj: &SomeTrait = SomeTrait;
+ | ^^^^^^^^^ not a value
+
+error[E0038]: the trait `SomeTrait` cannot be made into an object
+ --> $DIR/E0033.rs:16:20
+ |
+16 | let trait_obj: &SomeTrait = SomeTrait;
+ | ^^^^^^^^^^ the trait `SomeTrait` cannot be made into an object
+ |
+ = note: method `foo` has no receiver
+
+error[E0033]: type `&SomeTrait` cannot be dereferenced
+ --> $DIR/E0033.rs:21:9
+ |
+21 | let &invalid = trait_obj;
+ | ^^^^^^^^ type `&SomeTrait` cannot be dereferenced
+
+error: aborting due to 3 previous errors
+
--- /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.
+
+struct Test;
+
+trait Trait1 {
+ fn foo();
+}
+
+trait Trait2 {
+ fn foo();
+}
+
+impl Trait1 for Test {
+ fn foo() {}
+}
+
+impl Trait2 for Test {
+ fn foo() {}
+}
+
+fn main() {
+ Test::foo() //~ ERROR multiple applicable items in scope
+}
--- /dev/null
+error[E0034]: multiple applicable items in scope
+ --> $DIR/E0034.rs:30:5
+ |
+30 | Test::foo() //~ ERROR multiple applicable items in scope
+ | ^^^^^^^^^ multiple `foo` found
+ |
+note: candidate #1 is defined in an impl of the trait `Trait1` for the type `Test`
+ --> $DIR/E0034.rs:22:5
+ |
+22 | fn foo() {}
+ | ^^^^^^^^
+note: candidate #2 is defined in an impl of the trait `Trait2` for the type `Test`
+ --> $DIR/E0034.rs:26:5
+ |
+26 | fn foo() {}
+ | ^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+trait Trait {
+ fn foo(&self) -> Self;
+}
+
+fn call_foo(x: Box<Trait>) {
+ //~^ ERROR E0038
+ let y = x.foo();
+}
+
+fn main() {
+}
--- /dev/null
+error[E0038]: the trait `Trait` cannot be made into an object
+ --> $DIR/E0038.rs:15:1
+ |
+15 | fn call_foo(x: Box<Trait>) {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait` cannot be made into an object
+ |
+ = note: method `foo` references the `Self` type in its arguments or return type
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo {
+ x: i32,
+}
+
+impl Drop for Foo {
+ fn drop(&mut self) {
+ println!("kaboom");
+ }
+}
+
+fn main() {
+ let mut x = Foo { x: -7 };
+ x.drop();
+ //~^ ERROR E0040
+}
--- /dev/null
+error[E0040]: explicit use of destructor method
+ --> $DIR/E0040.rs:23:7
+ |
+23 | x.drop();
+ | ^^^^ explicit destructor calls not allowed
+
+error: aborting due to previous error
+
--- /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.
+
+extern { fn some_func<T>(x: T); } //~ ERROR E0044
+
+fn main() {
+}
--- /dev/null
+error[E0044]: foreign items may not have type parameters
+ --> $DIR/E0044.rs:11:10
+ |
+11 | extern { fn some_func<T>(x: T); } //~ ERROR E0044
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider using specialization instead of type parameters
+ --> $DIR/E0044.rs:11:10
+ |
+11 | extern { fn some_func<T>(x: T); } //~ ERROR E0044
+ | ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+extern "Rust" { fn foo(x: u8, ...); } //~ ERROR E0045
+
+fn main() {
+}
--- /dev/null
+error[E0045]: variadic function must have C or cdecl calling convention
+ --> $DIR/E0045.rs:11:17
+ |
+11 | extern "Rust" { fn foo(x: u8, ...); } //~ ERROR E0045
+ | ^^^^^^^^^^^^^^^^^^^ variadics require C or cdecl calling convention
+
+error: aborting due to previous error
+
--- /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.
+
+trait Foo {
+ fn foo<T: Default>(x: T) -> Self;
+}
+
+struct Bar;
+
+impl Foo for Bar {
+ fn foo(x: bool) -> Self { Bar } //~ ERROR E0049
+}
+
+fn main() {
+}
--- /dev/null
+error[E0049]: method `foo` has 0 type parameters but its trait declaration has 1 type parameter
+ --> $DIR/E0049.rs:18:5
+ |
+12 | fn foo<T: Default>(x: T) -> Self;
+ | --------------------------------- expected 1 type parameter
+...
+18 | fn foo(x: bool) -> Self { Bar } //~ ERROR E0049
+ | ^^^^^^^^^^^^^^^^^^^^^^^ found 0 type parameters
+
+error: aborting due to previous error
+
--- /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.
+
+trait Foo {
+ fn foo(&self, x: u8) -> bool;
+ fn bar(&self, x: u8, y: u8, z: u8);
+ fn less(&self);
+}
+
+struct Bar;
+
+impl Foo for Bar {
+ fn foo(&self) -> bool { true } //~ ERROR E0050
+ fn bar(&self) { } //~ ERROR E0050
+ fn less(&self, x: u8, y: u8, z: u8) { } //~ ERROR E0050
+}
+
+fn main() {
+}
--- /dev/null
+error[E0050]: method `foo` has 1 parameter but the declaration in trait `Foo::foo` has 2
+ --> $DIR/E0050.rs:20:12
+ |
+12 | fn foo(&self, x: u8) -> bool;
+ | -- trait requires 2 parameters
+...
+20 | fn foo(&self) -> bool { true } //~ ERROR E0050
+ | ^^^^^ expected 2 parameters, found 1
+
+error[E0050]: method `bar` has 1 parameter but the declaration in trait `Foo::bar` has 4
+ --> $DIR/E0050.rs:21:12
+ |
+13 | fn bar(&self, x: u8, y: u8, z: u8);
+ | -- trait requires 4 parameters
+...
+21 | fn bar(&self) { } //~ ERROR E0050
+ | ^^^^^ expected 4 parameters, found 1
+
+error[E0050]: method `less` has 4 parameters but the declaration in trait `Foo::less` has 1
+ --> $DIR/E0050.rs:22:37
+ |
+14 | fn less(&self);
+ | ----- trait requires 1 parameter
+...
+22 | fn less(&self, x: u8, y: u8, z: u8) { } //~ ERROR E0050
+ | ^^ expected 1 parameter, found 4
+
+error: aborting due to 3 previous errors
+
--- /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.
+
+fn main() {
+ let x = 5;
+ let x_is_nonzero = x as bool; //~ ERROR E0054
+}
--- /dev/null
+error[E0054]: cannot cast as `bool`
+ --> $DIR/E0054.rs:13:24
+ |
+13 | let x_is_nonzero = x as bool; //~ ERROR E0054
+ | ^^^^^^^^^ unsupported cast
+ |
+ = help: compare with zero instead
+
+error: aborting due to previous error
+
--- /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.
+
+#![recursion_limit="2"]
+struct Foo;
+
+impl Foo {
+ fn foo(&self) {}
+}
+
+fn main() {
+ let foo = Foo;
+ let ref_foo = &&Foo;
+ ref_foo.foo();
+ //~^ ERROR E0055
+}
--- /dev/null
+error[E0055]: reached the recursion limit while auto-dereferencing Foo
+ --> $DIR/E0055.rs:21:13
+ |
+21 | ref_foo.foo();
+ | ^^^ deref recursion limit reached
+ |
+ = help: consider adding a `#![recursion_limit="4"]` attribute to your crate
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let f = |x| x * 3;
+ let a = f(); //~ ERROR E0057
+ let b = f(4);
+ let c = f(2, 3); //~ ERROR E0057
+}
--- /dev/null
+error[E0057]: this function takes 1 parameter but 0 parameters were supplied
+ --> $DIR/E0057.rs:13:13
+ |
+13 | let a = f(); //~ ERROR E0057
+ | ^^^ expected 1 parameter
+
+error[E0057]: this function takes 1 parameter but 2 parameters were supplied
+ --> $DIR/E0057.rs:15:13
+ |
+15 | let c = f(2, 3); //~ ERROR E0057
+ | ^^^^^^^ expected 1 parameter
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+#![feature(unboxed_closures)]
+
+fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) } //~ ERROR E0059
+
+fn main() {
+}
--- /dev/null
+error[E0059]: cannot use call notation; the first type parameter for the function trait is neither a tuple nor unit
+ --> $DIR/E0059.rs:13:41
+ |
+13 | fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) } //~ ERROR E0059
+ | ^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+extern "C" {
+ fn printf(_: *const u8, ...) -> u32;
+}
+
+fn main() {
+ unsafe { printf(); }
+ //~^ ERROR E0060
+ //~| expected at least 1 parameter
+}
--- /dev/null
+error[E0060]: this function takes at least 1 parameter but 0 parameters were supplied
+ --> $DIR/E0060.rs:16:14
+ |
+12 | fn printf(_: *const u8, ...) -> u32;
+ | ------------------------------------ defined here
+...
+16 | unsafe { printf(); }
+ | ^^^^^^^^ expected at least 1 parameter
+
+error: aborting due to previous error
+
--- /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.
+
+fn f(a: u16, b: &str) {}
+
+fn f2(a: u16) {}
+
+fn main() {
+ f(0);
+ //~^ ERROR E0061
+ //~| expected 2 parameters
+
+ f2();
+ //~^ ERROR E0061
+ //~| expected 1 parameter
+}
--- /dev/null
+error[E0061]: this function takes 2 parameters but 1 parameter was supplied
+ --> $DIR/E0061.rs:16:5
+ |
+11 | fn f(a: u16, b: &str) {}
+ | --------------------- defined here
+...
+16 | f(0);
+ | ^^^^ expected 2 parameters
+
+error[E0061]: this function takes 1 parameter but 0 parameters were supplied
+ --> $DIR/E0061.rs:20:5
+ |
+13 | fn f2(a: u16) {}
+ | ------------- defined here
+...
+20 | f2();
+ | ^^^^ expected 1 parameter
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+struct Foo {
+ x: i32
+}
+
+fn main() {
+ let x = Foo {
+ x: 0,
+ x: 0,
+ //~^ ERROR E0062
+ };
+}
--- /dev/null
+error[E0062]: field `x` specified more than once
+ --> $DIR/E0062.rs:18:9
+ |
+17 | x: 0,
+ | ---- first use of `x`
+18 | x: 0,
+ | ^^ used more than once
+
+error: aborting due to previous error
+
--- /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.
+
+// ignore-tidy-linelength
+
+struct SingleFoo {
+ x: i32
+}
+
+struct PluralFoo {
+ x: i32,
+ y: i32,
+ z: i32
+}
+
+struct TruncatedFoo {
+ a: i32,
+ b: i32,
+ x: i32,
+ y: i32,
+ z: i32
+}
+
+struct TruncatedPluralFoo {
+ a: i32,
+ b: i32,
+ c: i32,
+ x: i32,
+ y: i32,
+ z: i32
+}
+
+
+fn main() {
+ let w = SingleFoo { };
+ //~^ ERROR missing field `x` in initializer of `SingleFoo`
+ let x = PluralFoo {x: 1};
+ //~^ ERROR missing fields `y`, `z` in initializer of `PluralFoo`
+ let y = TruncatedFoo{x:1};
+ //~^ missing fields `a`, `b`, `y` and 1 other field in initializer of `TruncatedFoo`
+ let z = TruncatedPluralFoo{x:1};
+ //~^ ERROR missing fields `a`, `b`, `c` and 2 other fields in initializer of `TruncatedPluralFoo`
+}
--- /dev/null
+error[E0063]: missing field `x` in initializer of `SingleFoo`
+ --> $DIR/E0063.rs:42:13
+ |
+42 | let w = SingleFoo { };
+ | ^^^^^^^^^ missing `x`
+
+error[E0063]: missing fields `y`, `z` in initializer of `PluralFoo`
+ --> $DIR/E0063.rs:44:13
+ |
+44 | let x = PluralFoo {x: 1};
+ | ^^^^^^^^^ missing `y`, `z`
+
+error[E0063]: missing fields `a`, `b`, `y` and 1 other field in initializer of `TruncatedFoo`
+ --> $DIR/E0063.rs:46:13
+ |
+46 | let y = TruncatedFoo{x:1};
+ | ^^^^^^^^^^^^ missing `a`, `b`, `y` and 1 other field
+
+error[E0063]: missing fields `a`, `b`, `c` and 2 other fields in initializer of `TruncatedPluralFoo`
+ --> $DIR/E0063.rs:48:13
+ |
+48 | let z = TruncatedPluralFoo{x:1};
+ | ^^^^^^^^^^^^^^^^^^ missing `a`, `b`, `c` and 2 other fields
+
+error: aborting due to 4 previous errors
+
--- /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.
+
+use std::collections::LinkedList;
+
+fn main() {
+ LinkedList::new() += 1; //~ ERROR E0368
+ //~^ ERROR E0067
+}
--- /dev/null
+error[E0368]: binary assignment operation `+=` cannot be applied to type `std::collections::LinkedList<_>`
+ --> $DIR/E0067.rs:14:5
+ |
+14 | LinkedList::new() += 1; //~ ERROR E0368
+ | -----------------^^^^^
+ | |
+ | cannot use `+=` on type `std::collections::LinkedList<_>`
+
+error[E0067]: invalid left-hand side expression
+ --> $DIR/E0067.rs:14:5
+ |
+14 | LinkedList::new() += 1; //~ ERROR E0368
+ | ^^^^^^^^^^^^^^^^^ invalid expression for left-hand side
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn foo() -> u8 {
+ return;
+ //~^ ERROR `return;` in a function whose return type is not `()`
+}
+
+fn main() {
+}
--- /dev/null
+error[E0069]: `return;` in a function whose return type is not `()`
+ --> $DIR/E0069.rs:12:5
+ |
+12 | return;
+ | ^^^^^^ return type is not ()
+
+error: aborting due to previous error
+
--- /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.
+
+const SOME_CONST : i32 = 12;
+
+fn some_other_func() {}
+
+fn some_function() {
+ SOME_CONST = 14; //~ ERROR E0070
+ 1 = 3; //~ ERROR E0070
+ some_other_func() = 4; //~ ERROR E0070
+ //~^ ERROR E0308
+}
+
+fn main() {
+}
--- /dev/null
+error[E0070]: invalid left-hand side expression
+ --> $DIR/E0070.rs:16:5
+ |
+16 | SOME_CONST = 14; //~ ERROR E0070
+ | ^^^^^^^^^^^^^^^ left-hand of expression not valid
+
+error[E0070]: invalid left-hand side expression
+ --> $DIR/E0070.rs:17:5
+ |
+17 | 1 = 3; //~ ERROR E0070
+ | ^^^^^ left-hand of expression not valid
+
+error[E0308]: mismatched types
+ --> $DIR/E0070.rs:18:25
+ |
+18 | some_other_func() = 4; //~ ERROR E0070
+ | ^ expected (), found integral variable
+ |
+ = note: expected type `()`
+ found type `{integer}`
+
+error[E0070]: invalid left-hand side expression
+ --> $DIR/E0070.rs:18:5
+ |
+18 | some_other_func() = 4; //~ ERROR E0070
+ | ^^^^^^^^^^^^^^^^^^^^^ left-hand of expression not valid
+
+error: aborting due to 4 previous errors
+
--- /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.
+
+enum Foo {}
+type FooAlias = Foo;
+
+fn main() {
+ let u = FooAlias { value: 0 };
+ //~^ ERROR expected struct, variant or union type, found enum `Foo` [E0071]
+}
--- /dev/null
+error[E0071]: expected struct, variant or union type, found enum `Foo`
+ --> $DIR/E0071.rs:15:13
+ |
+15 | let u = FooAlias { value: 0 };
+ | ^^^^^^^^ not a struct
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(repr_simd)]
+
+#[repr(simd)]
+struct Bad; //~ ERROR E0075
+
+fn main() {
+}
--- /dev/null
+error[E0075]: SIMD vector cannot be empty
+ --> $DIR/E0075.rs:14:1
+ |
+14 | struct Bad; //~ ERROR E0075
+ | ^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(repr_simd)]
+
+#[repr(simd)]
+struct Bad(u16, u32, u32);
+//~^ ERROR E0076
+
+fn main() {
+}
--- /dev/null
+error[E0076]: SIMD vector should be homogeneous
+ --> $DIR/E0076.rs:14:1
+ |
+14 | struct Bad(u16, u32, u32);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ SIMD elements must have the same type
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(repr_simd)]
+
+#[repr(simd)]
+struct Bad(String); //~ ERROR E0077
+
+fn main() {
+}
--- /dev/null
+error[E0077]: SIMD vector element type should be machine type
+ --> $DIR/E0077.rs:14:1
+ |
+14 | struct Bad(String); //~ ERROR E0077
+ | ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+enum Enum {
+ X = (1 << 500), //~ ERROR E0080
+ //~| WARNING shift left with overflow
+ Y = (1 / 0) //~ ERROR E0080
+ //~| WARNING divide by zero
+}
+
+fn main() {
+}
--- /dev/null
+warning: constant evaluation error: attempt to shift left with overflow
+ --> $DIR/E0080.rs:12:9
+ |
+12 | X = (1 << 500), //~ ERROR E0080
+ | ^^^^^^^^^^
+ |
+ = note: #[warn(const_err)] on by default
+
+error[E0080]: constant evaluation error
+ --> $DIR/E0080.rs:12:9
+ |
+12 | X = (1 << 500), //~ ERROR E0080
+ | ^^^^^^^^^^ attempt to shift left with overflow
+
+warning: constant evaluation error: attempt to divide by zero
+ --> $DIR/E0080.rs:14:9
+ |
+14 | Y = (1 / 0) //~ ERROR E0080
+ | ^^^^^^^
+
+error[E0080]: constant evaluation error
+ --> $DIR/E0080.rs:14:9
+ |
+14 | Y = (1 / 0) //~ ERROR E0080
+ | ^^^^^^^ attempt to divide by zero
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+enum Enum {
+ P = 3,
+ X = 3,
+ //~^ ERROR discriminant value `3isize` already exists
+ Y = 5
+}
+
+fn main() {
+}
--- /dev/null
+error[E0081]: discriminant value `3isize` already exists
+ --> $DIR/E0081.rs:13:9
+ |
+12 | P = 3,
+ | - first use of `3isize`
+13 | X = 3,
+ | ^ enum already has `3isize`
+
+error: aborting due to previous error
+
--- /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.
+
+#[repr(i32)] //~ ERROR: E0084
+enum Foo {}
+
+fn main() {
+}
--- /dev/null
+error[E0084]: unsupported representation for zero-variant enum
+ --> $DIR/E0084.rs:11:1
+ |
+11 | #[repr(i32)] //~ ERROR: E0084
+ | ^^^^^^^^^^^^
+12 | enum Foo {}
+ | ----------- zero-variant enum
+
+error: aborting due to previous error
+
--- /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.
+
+fn foo() {}
+fn bar<T>() {}
+
+fn main() {
+ foo::<f64>(); //~ ERROR expected at most 0 type parameters, found 1 type parameter [E0087]
+
+ bar::<f64, u64>(); //~ ERROR expected at most 1 type parameter, found 2 type parameters [E0087]
+}
--- /dev/null
+error[E0087]: too many type parameters provided: expected at most 0 type parameters, found 1 type parameter
+ --> $DIR/E0087.rs:15:11
+ |
+15 | foo::<f64>(); //~ ERROR expected at most 0 type parameters, found 1 type parameter [E0087]
+ | ^^^ expected 0 type parameters
+
+error[E0087]: too many type parameters provided: expected at most 1 type parameter, found 2 type parameters
+ --> $DIR/E0087.rs:17:16
+ |
+17 | bar::<f64, u64>(); //~ ERROR expected at most 1 type parameter, found 2 type parameters [E0087]
+ | ^^^ expected 1 type parameter
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn f() {}
+fn g<'a>() -> &'a u8 { loop {} }
+
+fn main() {
+ f::<'static>(); //~ ERROR E0088
+ g::<'static, 'static>(); //~ ERROR E0088
+}
--- /dev/null
+error[E0088]: too many lifetime parameters provided: expected at most 0 lifetime parameters, found 1 lifetime parameter
+ --> $DIR/E0088.rs:15:9
+ |
+15 | f::<'static>(); //~ ERROR E0088
+ | ^^^^^^^ expected 0 lifetime parameters
+
+error[E0088]: too many lifetime parameters provided: expected at most 1 lifetime parameter, found 2 lifetime parameters
+ --> $DIR/E0088.rs:16:18
+ |
+16 | g::<'static, 'static>(); //~ ERROR E0088
+ | ^^^^^^^ expected 1 lifetime parameter
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn foo<T, U>() {}
+
+fn main() {
+ foo::<f64>(); //~ ERROR expected 2 type parameters, found 1 type parameter [E0089]
+}
--- /dev/null
+error[E0089]: too few type parameters provided: expected 2 type parameters, found 1 type parameter
+ --> $DIR/E0089.rs:14:5
+ |
+14 | foo::<f64>(); //~ ERROR expected 2 type parameters, found 1 type parameter [E0089]
+ | ^^^^^^^^^^ expected 2 type parameters
+
+error: aborting due to previous error
+
--- /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.
+
+fn foo<'a: 'b, 'b: 'a>() {}
+
+fn main() {
+ foo::<'static>(); //~ ERROR expected 2 lifetime parameters, found 1 lifetime parameter [E0090]
+}
--- /dev/null
+error[E0090]: too few lifetime parameters provided: expected 2 lifetime parameters, found 1 lifetime parameter
+ --> $DIR/E0090.rs:14:5
+ |
+14 | foo::<'static>(); //~ ERROR expected 2 lifetime parameters, found 1 lifetime parameter [E0090]
+ | ^^^^^^^^^^^^^^ expected 2 lifetime parameters
+
+error: aborting due to previous error
+
--- /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.
+
+type Foo<T> = u32; //~ ERROR E0091
+type Foo2<A, B> = Box<A>; //~ ERROR E0091
+
+fn main() {
+}
--- /dev/null
+error[E0091]: type parameter `T` is unused
+ --> $DIR/E0091.rs:11:10
+ |
+11 | type Foo<T> = u32; //~ ERROR E0091
+ | ^ unused type parameter
+
+error[E0091]: type parameter `B` is unused
+ --> $DIR/E0091.rs:12:14
+ |
+12 | type Foo2<A, B> = Box<A>; //~ ERROR E0091
+ | ^ unused type parameter
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+#![feature(intrinsics)]
+extern "rust-intrinsic" {
+ fn atomic_foo(); //~ ERROR E0092
+}
+
+fn main() {
+}
--- /dev/null
+error[E0092]: unrecognized atomic operation function: `foo`
+ --> $DIR/E0092.rs:13:5
+ |
+13 | fn atomic_foo(); //~ ERROR E0092
+ | ^^^^^^^^^^^^^^^^ unrecognized atomic operation
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(intrinsics)]
+extern "rust-intrinsic" {
+ fn foo();
+ //~^ ERROR E0093
+}
+
+fn main() {
+}
--- /dev/null
+error[E0093]: unrecognized intrinsic function: `foo`
+ --> $DIR/E0093.rs:13:5
+ |
+13 | fn foo();
+ | ^^^^^^^^^ unrecognized intrinsic
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(intrinsics)]
+extern "rust-intrinsic" {
+ fn size_of<T, U>() -> usize; //~ ERROR E0094
+}
+
+fn main() {
+}
--- /dev/null
+error[E0094]: intrinsic has wrong number of type parameters: found 2, expected 1
+ --> $DIR/E0094.rs:13:15
+ |
+13 | fn size_of<T, U>() -> usize; //~ ERROR E0094
+ | ^^^^^^ expected 1 type parameter
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo {
+ x: &bool,
+ //~^ ERROR E0106
+}
+enum Bar {
+ A(u8),
+ B(&bool),
+ //~^ ERROR E0106
+}
+type MyStr = &str;
+ //~^ ERROR E0106
+
+struct Baz<'a>(&'a str);
+struct Buzz<'a, 'b>(&'a str, &'b str);
+
+struct Quux {
+ baz: Baz,
+ //~^ ERROR E0106
+ //~| expected lifetime parameter
+ buzz: Buzz,
+ //~^ ERROR E0106
+ //~| expected 2 lifetime parameters
+}
+
+fn main() {
+}
--- /dev/null
+error[E0106]: missing lifetime specifier
+ --> $DIR/E0106.rs:12:8
+ |
+12 | x: &bool,
+ | ^ expected lifetime parameter
+
+error[E0106]: missing lifetime specifier
+ --> $DIR/E0106.rs:17:7
+ |
+17 | B(&bool),
+ | ^ expected lifetime parameter
+
+error[E0106]: missing lifetime specifier
+ --> $DIR/E0106.rs:20:14
+ |
+20 | type MyStr = &str;
+ | ^ expected lifetime parameter
+
+error[E0106]: missing lifetime specifier
+ --> $DIR/E0106.rs:27:10
+ |
+27 | baz: Baz,
+ | ^^^ expected lifetime parameter
+
+error[E0106]: missing lifetime specifiers
+ --> $DIR/E0106.rs:30:11
+ |
+30 | buzz: Buzz,
+ | ^^^^ expected 2 lifetime parameters
+
+error: aborting due to 5 previous errors
+
--- /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.
+
+struct Foo<'a>(&'a str);
+struct Buzz<'a, 'b>(&'a str, &'b str);
+
+enum Bar {
+ A,
+ B,
+ C,
+}
+
+struct Baz<'a, 'b, 'c> {
+ buzz: Buzz<'a>,
+ //~^ ERROR E0107
+ //~| expected 2 lifetime parameters
+ bar: Bar<'a>,
+ //~^ ERROR E0107
+ //~| unexpected lifetime parameter
+ foo2: Foo<'a, 'b, 'c>,
+ //~^ ERROR E0107
+ //~| 2 unexpected lifetime parameters
+}
+
+fn main() {
+}
--- /dev/null
+error[E0107]: wrong number of lifetime parameters: expected 2, found 1
+ --> $DIR/E0107.rs:21:11
+ |
+21 | buzz: Buzz<'a>,
+ | ^^^^^^^^ expected 2 lifetime parameters
+
+error[E0107]: wrong number of lifetime parameters: expected 0, found 1
+ --> $DIR/E0107.rs:24:10
+ |
+24 | bar: Bar<'a>,
+ | ^^^^^^^ unexpected lifetime parameter
+
+error[E0107]: wrong number of lifetime parameters: expected 1, found 3
+ --> $DIR/E0107.rs:27:11
+ |
+27 | foo2: Foo<'a, 'b, 'c>,
+ | ^^^^^^^^^^^^^^^ 2 unexpected lifetime parameters
+
+error: aborting due to 3 previous errors
+
--- /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.
+
+type X = u32<i32>; //~ ERROR E0109
+
+fn main() {
+}
--- /dev/null
+error[E0109]: type parameters are not allowed on this type
+ --> $DIR/E0109.rs:11:14
+ |
+11 | type X = u32<i32>; //~ ERROR E0109
+ | ^^^ type parameter not allowed
+
+error: aborting due to previous error
+
--- /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.
+
+type X = u32<'static>; //~ ERROR E0110
+
+fn main() {
+}
--- /dev/null
+error[E0110]: lifetime parameters are not allowed on this type
+ --> $DIR/E0110.rs:11:14
+ |
+11 | type X = u32<'static>; //~ ERROR E0110
+ | ^^^^^^^ lifetime parameter not allowed on this type
+
+error: aborting due to previous error
+
--- /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.
+
+impl Vec<u8> {}
+//~^ ERROR E0116
+
+fn main() {
+}
--- /dev/null
+error[E0116]: cannot define inherent `impl` for a type outside of the crate where the type is defined
+ --> $DIR/E0116.rs:11:1
+ |
+11 | impl Vec<u8> {}
+ | ^^^^^^^^^^^^^^^ impl for type defined outside of crate.
+ |
+ = note: define and implement a trait or new type instead
+
+error: aborting due to previous error
+
--- /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.
+
+impl Drop for u32 {} //~ ERROR E0117
+//~| ERROR the Drop trait may only be implemented on structures
+//~| implementing Drop requires a struct
+
+fn main() {
+}
--- /dev/null
+error[E0120]: the Drop trait may only be implemented on structures
+ --> $DIR/E0117.rs:11:15
+ |
+11 | impl Drop for u32 {} //~ ERROR E0117
+ | ^^^ implementing Drop requires a struct
+
+error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
+ --> $DIR/E0117.rs:11:1
+ |
+11 | impl Drop for u32 {} //~ ERROR E0117
+ | ^^^^^^^^^^^^^^^^^^^^ impl doesn't use types inside crate
+ |
+ = note: the impl does not reference any types defined in this crate
+ = note: define and implement a trait or new type instead
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+impl (u8, u8) { //~ ERROR E0118
+ fn get_state(&self) -> String {
+ String::new()
+ }
+}
+
+fn main() {
+}
--- /dev/null
+error[E0118]: no base type found for inherent implementation
+ --> $DIR/E0118.rs:11:6
+ |
+11 | impl (u8, u8) { //~ ERROR E0118
+ | ^^^^^^^^ impl requires a base type
+ |
+ = note: either implement a trait on it or create a newtype to wrap it instead
+
+error: aborting due to previous error
+
--- /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.
+
+trait MyTrait {
+ fn get(&self) -> usize;
+}
+
+impl<T> MyTrait for T {
+ fn get(&self) -> usize { 0 }
+}
+
+struct Foo {
+ value: usize
+}
+
+impl MyTrait for Foo { //~ ERROR E0119
+ fn get(&self) -> usize { self.value }
+}
+
+fn main() {
+}
--- /dev/null
+error[E0119]: conflicting implementations of trait `MyTrait` for type `Foo`:
+ --> $DIR/E0119.rs:23:1
+ |
+15 | impl<T> MyTrait for T {
+ | --------------------- first implementation here
+...
+23 | impl MyTrait for Foo { //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Foo`
+
+error: aborting due to previous error
+
--- /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.
+
+trait MyTrait { fn foo() {} }
+
+impl Drop for MyTrait {
+ //~^ ERROR E0120
+ fn drop(&mut self) {}
+}
+
+fn main() {
+}
--- /dev/null
+error[E0120]: the Drop trait may only be implemented on structures
+ --> $DIR/E0120.rs:13:15
+ |
+13 | impl Drop for MyTrait {
+ | ^^^^^^^ implementing Drop requires a struct
+
+error: aborting due to previous error
+
--- /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.
+
+fn foo() -> _ { 5 } //~ ERROR E0121
+
+static BAR: _ = "test"; //~ ERROR E0121
+
+fn main() {
+}
--- /dev/null
+error[E0121]: the type placeholder `_` is not allowed within types on item signatures
+ --> $DIR/E0121.rs:11:13
+ |
+11 | fn foo() -> _ { 5 } //~ ERROR E0121
+ | ^ not allowed in type signatures
+
+error[E0121]: the type placeholder `_` is not allowed within types on item signatures
+ --> $DIR/E0121.rs:13:13
+ |
+13 | static BAR: _ = "test"; //~ ERROR E0121
+ | ^ not allowed in type signatures
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+struct Foo {
+ field1: i32,
+ field1: i32,
+ //~^ ERROR field `field1` is already declared [E0124]
+}
+
+fn main() {
+}
--- /dev/null
+error[E0124]: field `field1` is already declared
+ --> $DIR/E0124.rs:13:5
+ |
+12 | field1: i32,
+ | ----------- `field1` first declared here
+13 | field1: i32,
+ | ^^^^^^^^^^^ field already declared
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo<T=U, U=()> { //~ ERROR E0128
+ field1: T,
+ field2: U,
+}
+
+fn main() {
+}
--- /dev/null
+error[E0128]: type parameters with a default cannot use forward declared identifiers
+ --> $DIR/E0128.rs:11:14
+ |
+11 | struct Foo<T=U, U=()> { //~ ERROR E0128
+ | ^ defaulted type parameters cannot be forward declared
+
+error: aborting due to previous error
+
--- /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.
+
+extern {
+ fn foo((a, b): (u32, u32));
+ //~^ ERROR E0130
+}
+
+fn main() {
+}
--- /dev/null
+error[E0130]: patterns aren't allowed in foreign function declarations
+ --> $DIR/E0130.rs:12:12
+ |
+12 | fn foo((a, b): (u32, u32));
+ | ^^^^^^ pattern not allowed in foreign function
+
+error: aborting due to previous error
+
--- /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.
+
+fn main<T>() {
+ //~^ ERROR E0131
+}
--- /dev/null
+error[E0131]: main function is not allowed to have type parameters
+ --> $DIR/E0131.rs:11:8
+ |
+11 | fn main<T>() {
+ | ^^^ main cannot have type parameters
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(start)]
+
+#[start]
+fn f< T >() {} //~ ERROR E0132
+
+fn main() {
+}
--- /dev/null
+error[E0132]: start function is not allowed to have type parameters
+ --> $DIR/E0132.rs:14:5
+ |
+14 | fn f< T >() {} //~ ERROR E0132
+ | ^^^^^ start function cannot have type parameters
+
+error: aborting due to previous error
+
--- /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.
+
+unsafe fn f() { return; }
+
+fn main() {
+ f();
+ //~^ ERROR E0133
+}
--- /dev/null
+error[E0133]: call to unsafe function requires unsafe function or block
+ --> $DIR/E0133.rs:14:5
+ |
+14 | f();
+ | ^^^ call to unsafe function
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(main)]
+
+#[main]
+fn foo() {}
+
+#[main]
+fn f() {}
+//~^ ERROR E0137
--- /dev/null
+error[E0137]: multiple functions with a #[main] attribute
+ --> $DIR/E0137.rs:17:1
+ |
+14 | fn foo() {}
+ | ----------- first #[main] function
+...
+17 | fn f() {}
+ | ^^^^^^^^^ additional #[main] function
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(start)]
+
+#[start]
+fn foo(argc: isize, argv: *const *const u8) -> isize { 0 }
+
+#[start]
+fn f(argc: isize, argv: *const *const u8) -> isize { 0 }
+//~^ ERROR E0138
--- /dev/null
+error[E0138]: multiple 'start' functions
+ --> $DIR/E0138.rs:17:1
+ |
+14 | fn foo(argc: isize, argv: *const *const u8) -> isize { 0 }
+ | ---------------------------------------------------------- previous `start` function here
+...
+17 | fn f(argc: isize, argv: *const *const u8) -> isize { 0 }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ multiple `start` functions
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(lang_items)]
+
+#[lang = "panic_fmt"]
+struct Foo; //~ ERROR E0152
+
+fn main() {
+}
--- /dev/null
+error[E0152]: duplicate lang item found: `panic_fmt`.
+ --> $DIR/E0152.rs:14:1
+ |
+14 | struct Foo; //~ ERROR E0152
+ | ^^^^^^^^^^^
+ |
+ = note: first defined in crate `std`.
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(box_syntax)]
+
+fn main() {
+ let _x: Box<str> = box *"hello"; //~ ERROR E0161
+ //~^ ERROR E0507
+}
--- /dev/null
+error[E0161]: cannot move a value of type str: the size of str cannot be statically determined
+ --> $DIR/E0161.rs:14:28
+ |
+14 | let _x: Box<str> = box *"hello"; //~ ERROR E0161
+ | ^^^^^^^^
+
+error[E0507]: cannot move out of borrowed content
+ --> $DIR/E0161.rs:14:28
+ |
+14 | let _x: Box<str> = box *"hello"; //~ ERROR E0161
+ | ^^^^^^^^ cannot move out of borrowed content
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+struct Irrefutable(i32);
+
+fn main() {
+ let irr = Irrefutable(0);
+ if let Irrefutable(x) = irr { //~ ERROR E0162
+ println!("{}", x);
+ }
+}
--- /dev/null
+error[E0162]: irrefutable if-let pattern
+ --> $DIR/E0162.rs:15:12
+ |
+15 | if let Irrefutable(x) = irr { //~ ERROR E0162
+ | ^^^^^^^^^^^^^^ irrefutable pattern
+
+error: aborting due to previous error
+
--- /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.
+
+
+enum Foo {}
+
+impl Foo {
+ const B: u8 = 0;
+}
+
+fn bar(foo: Foo) -> u32 {
+ match foo {
+ Foo::B(i) => i, //~ ERROR E0164
+ }
+}
+
+fn main() {
+}
--- /dev/null
+error[E0164]: expected tuple struct/variant, found associated constant `<Foo>::B`
+ --> $DIR/E0164.rs:20:9
+ |
+20 | Foo::B(i) => i, //~ ERROR E0164
+ | ^^^^^^^^^ not a tuple variant or struct
+
+error: aborting due to previous error
+
--- /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.
+
+struct Irrefutable(i32);
+
+fn main() {
+ let irr = Irrefutable(0);
+ while let Irrefutable(x) = irr { //~ ERROR E0165
+ //~| irrefutable pattern
+ // ...
+ }
+}
--- /dev/null
+error[E0165]: irrefutable while-let pattern
+ --> $DIR/E0165.rs:15:15
+ |
+15 | while let Irrefutable(x) = irr { //~ ERROR E0165
+ | ^^^^^^^^^^^^^^ irrefutable pattern
+
+error: aborting due to previous error
+
--- /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.
+
+#[derive(Copy)] //~ ERROR E0184
+struct Foo;
+
+impl Drop for Foo {
+ fn drop(&mut self) {
+ }
+}
+
+fn main() {
+}
--- /dev/null
+error[E0184]: the trait `Copy` may not be implemented for this type; the type has a destructor
+ --> $DIR/E0184.rs:11:10
+ |
+11 | #[derive(Copy)] //~ ERROR E0184
+ | ^^^^ Copy not allowed on types with destructors
+
+error: aborting due to previous error
+
--- /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.
+
+trait Foo {
+ fn foo();
+ //~^ NOTE trait method declared without `&self`
+}
+
+struct Bar;
+
+impl Foo for Bar {
+ fn foo(&self) {}
+ //~^ ERROR E0185
+ //~| NOTE `&self` used in impl
+}
+
+fn main() {
+}
--- /dev/null
+error[E0185]: method `foo` has a `&self` declaration in the impl, but not in the trait
+ --> $DIR/E0185.rs:19:5
+ |
+12 | fn foo();
+ | --------- trait method declared without `&self`
+...
+19 | fn foo(&self) {}
+ | ^^^^^^^^^^^^^ `&self` used in impl
+
+error: aborting due to previous error
+
--- /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.
+
+trait Foo {
+ fn foo(&self); //~ `&self` used in trait
+}
+
+struct Bar;
+
+impl Foo for Bar {
+ fn foo() {} //~ ERROR E0186
+ //~^ expected `&self` in impl
+}
+
+fn main() {
+}
--- /dev/null
+error[E0186]: method `foo` has a `&self` declaration in the trait, but not in the impl
+ --> $DIR/E0186.rs:18:5
+ |
+12 | fn foo(&self); //~ `&self` used in trait
+ | -------------- `&self` used in trait
+...
+18 | fn foo() {} //~ ERROR E0186
+ | ^^^^^^^^ expected `&self` in impl
+
+error: aborting due to previous error
+
--- /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.
+
+trait Trait {
+ type Bar;
+}
+
+type Foo = Trait; //~ ERROR E0191
+
+fn main() {
+}
--- /dev/null
+error[E0191]: the value of the associated type `Bar` (from the trait `Trait`) must be specified
+ --> $DIR/E0191.rs:15:12
+ |
+15 | type Foo = Trait; //~ ERROR E0191
+ | ^^^^^ missing associated type `Bar` value
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(optin_builtin_traits)]
+
+trait Trait {
+ type Bar;
+}
+
+struct Foo;
+
+impl !Trait for Foo { } //~ ERROR E0192
+
+fn main() {
+}
--- /dev/null
+error[E0192]: negative impls are only allowed for auto traits (e.g., `Send` and `Sync`)
+ --> $DIR/E0192.rs:19:1
+ |
+19 | impl !Trait for Foo { } //~ ERROR E0192
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+trait Foo<T> {
+ fn do_something(&self) -> T;
+ fn do_something_else<T: Clone>(&self, bar: T);
+ //~^ ERROR E0194
+}
+
+fn main() {
+}
--- /dev/null
+error[E0194]: type parameter `T` shadows another type parameter of the same name
+ --> $DIR/E0194.rs:13:26
+ |
+11 | trait Foo<T> {
+ | - first `T` declared here
+12 | fn do_something(&self) -> T;
+13 | fn do_something_else<T: Clone>(&self, bar: T);
+ | ^ shadows another type parameter
+
+error: aborting due to previous error
+
--- /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.
+
+trait Trait {
+ fn bar<'a,'b:'a>(x: &'a str, y: &'b str);
+ //~^ NOTE lifetimes in impl do not match this method in trait
+}
+
+struct Foo;
+
+impl Trait for Foo {
+ fn bar<'a,'b>(x: &'a str, y: &'b str) { //~ ERROR E0195
+ //~^ NOTE lifetimes do not match method in trait
+ }
+}
+
+fn main() {
+}
--- /dev/null
+error[E0195]: lifetime parameters or bounds on method `bar` do not match the trait declaration
+ --> $DIR/E0195.rs:19:5
+ |
+12 | fn bar<'a,'b:'a>(x: &'a str, y: &'b str);
+ | ----------------------------------------- lifetimes in impl do not match this method in trait
+...
+19 | fn bar<'a,'b>(x: &'a str, y: &'b str) { //~ ERROR E0195
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ lifetimes do not match method in trait
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo;
+
+unsafe impl Foo { } //~ ERROR E0197
+
+fn main() {
+}
--- /dev/null
+error[E0197]: inherent impls cannot be unsafe
+ --> $DIR/E0197.rs:13:1
+ |
+13 | unsafe impl Foo { } //~ ERROR E0197
+ | ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(optin_builtin_traits)]
+
+struct Foo;
+
+unsafe impl !Send for Foo { } //~ ERROR E0198
+
+fn main() {
+}
--- /dev/null
+error[E0198]: negative impls cannot be unsafe
+ --> $DIR/E0198.rs:15:1
+ |
+15 | unsafe impl !Send for Foo { } //~ ERROR E0198
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(optin_builtin_traits)]
+
+struct Foo;
+
+trait Bar { }
+unsafe impl Bar for Foo { } //~ ERROR implementing the trait `Bar` is not unsafe [E0199]
+
+fn main() {
+}
--- /dev/null
+error[E0199]: implementing the trait `Bar` is not unsafe
+ --> $DIR/E0199.rs:16:1
+ |
+16 | unsafe impl Bar for Foo { } //~ ERROR implementing the trait `Bar` is not unsafe [E0199]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo;
+
+unsafe trait Bar { }
+
+impl Bar for Foo { } //~ ERROR E0200
+
+fn main() {
+}
--- /dev/null
+error[E0200]: the trait `Bar` requires an `unsafe impl` declaration
+ --> $DIR/E0200.rs:15:1
+ |
+15 | impl Bar for Foo { } //~ ERROR E0200
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo(u8);
+
+impl Foo {
+ fn bar(&self) -> bool { self.0 > 5 }
+ fn bar() {} //~ ERROR E0201
+}
+
+trait Baz {
+ type Quux;
+ fn baz(&self) -> bool;
+}
+
+impl Baz for Foo {
+ type Quux = u32;
+
+ fn baz(&self) -> bool { true }
+ fn baz(&self) -> bool { self.0 > 5 } //~ ERROR E0201
+ type Quux = u32; //~ ERROR E0201
+}
+
+fn main() {
+}
--- /dev/null
+error[E0201]: duplicate definitions with name `bar`:
+ --> $DIR/E0201.rs:15:5
+ |
+14 | fn bar(&self) -> bool { self.0 > 5 }
+ | ------------------------------------ previous definition of `bar` here
+15 | fn bar() {} //~ ERROR E0201
+ | ^^^^^^^^^^^ duplicate definition
+
+error[E0201]: duplicate definitions with name `baz`:
+ --> $DIR/E0201.rs:27:5
+ |
+26 | fn baz(&self) -> bool { true }
+ | ------------------------------ previous definition of `baz` here
+27 | fn baz(&self) -> bool { self.0 > 5 } //~ ERROR E0201
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definition
+
+error[E0201]: duplicate definitions with name `Quux`:
+ --> $DIR/E0201.rs:28:5
+ |
+24 | type Quux = u32;
+ | ---------------- previous definition of `Quux` here
+...
+28 | type Quux = u32; //~ ERROR E0201
+ | ^^^^^^^^^^^^^^^^ duplicate definition
+
+error: aborting due to 3 previous errors
+
--- /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.
+
+type Foo = i32;
+
+impl Copy for Foo { }
+//~^ ERROR the trait `Copy` may not be implemented for this type
+//~| ERROR only traits defined in the current crate can be implemented for arbitrary types
+
+#[derive(Copy, Clone)]
+struct Bar;
+
+impl Copy for &'static Bar { }
+//~^ ERROR the trait `Copy` may not be implemented for this type
+
+fn main() {
+}
--- /dev/null
+error[E0206]: the trait `Copy` may not be implemented for this type
+ --> $DIR/E0206.rs:13:15
+ |
+13 | impl Copy for Foo { }
+ | ^^^ type is not a structure or enumeration
+
+error[E0206]: the trait `Copy` may not be implemented for this type
+ --> $DIR/E0206.rs:20:15
+ |
+20 | impl Copy for &'static Bar { }
+ | ^^^^^^^^^^^^ type is not a structure or enumeration
+
+error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
+ --> $DIR/E0206.rs:13:1
+ |
+13 | impl Copy for Foo { }
+ | ^^^^^^^^^^^^^^^^^^^^^ impl doesn't use types inside crate
+ |
+ = note: the impl does not reference any types defined in this crate
+ = note: define and implement a trait or new type instead
+
+error: aborting due to 3 previous errors
+
--- /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.
+
+struct Foo;
+
+impl<T: Default> Foo { //~ ERROR E0207
+ fn get(&self) -> T {
+ <T as Default>::default()
+ }
+}
+
+fn main() {
+}
--- /dev/null
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+ --> $DIR/E0207.rs:13:6
+ |
+13 | impl<T: Default> Foo { //~ ERROR E0207
+ | ^ unconstrained type parameter
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let v: Vec(&str) = vec!["foo"];
+ //~^ ERROR E0214
+}
--- /dev/null
+error[E0214]: parenthesized parameters may only be used with a trait
+ --> $DIR/E0214.rs:12:15
+ |
+12 | let v: Vec(&str) = vec!["foo"];
+ | ^^^^^^ only traits may use parentheses
+
+error: aborting due to previous error
+
--- /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.
+
+trait Trait {
+ type Bar;
+}
+
+type Foo = Trait<F=i32>; //~ ERROR E0220
+ //~| ERROR E0191
+fn main() {
+}
--- /dev/null
+error[E0220]: associated type `F` not found for `Trait`
+ --> $DIR/E0220.rs:15:18
+ |
+15 | type Foo = Trait<F=i32>; //~ ERROR E0220
+ | ^^^^^ associated type `F` not found
+
+error[E0191]: the value of the associated type `Bar` (from the trait `Trait`) must be specified
+ --> $DIR/E0220.rs:15:12
+ |
+15 | type Foo = Trait<F=i32>; //~ ERROR E0220
+ | ^^^^^^^^^^^^ missing associated type `Bar` value
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+trait T1 {}
+trait T2 {}
+
+trait Foo {
+ type A: T1;
+}
+
+trait Bar : Foo {
+ type A: T2;
+ fn do_something() {
+ let _: Self::A;
+ //~^ ERROR E0221
+ }
+}
+
+trait T3 {}
+
+trait My : std::str::FromStr {
+ type Err: T3;
+ fn test() {
+ let _: Self::Err;
+ //~^ ERROR E0221
+ }
+}
+
+fn main() {
+}
--- /dev/null
+error[E0221]: ambiguous associated type `A` in bounds of `Self`
+ --> $DIR/E0221.rs:21:16
+ |
+15 | type A: T1;
+ | ----------- ambiguous `A` from `Foo`
+...
+19 | type A: T2;
+ | ----------- ambiguous `A` from `Bar`
+20 | fn do_something() {
+21 | let _: Self::A;
+ | ^^^^^^^ ambiguous associated type `A`
+
+error[E0221]: ambiguous associated type `Err` in bounds of `Self`
+ --> $DIR/E0221.rs:31:16
+ |
+29 | type Err: T3;
+ | ------------- ambiguous `Err` from `My`
+30 | fn test() {
+31 | let _: Self::Err;
+ | ^^^^^^^^^ ambiguous associated type `Err`
+ |
+note: associated type `Self` could derive from `std::str::FromStr`
+ --> $DIR/E0221.rs:31:16
+ |
+31 | let _: Self::Err;
+ | ^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+trait MyTrait { type X; }
+
+fn main() {
+ let foo: MyTrait::X;
+ //~^ ERROR ambiguous associated type
+}
--- /dev/null
+error[E0223]: ambiguous associated type
+ --> $DIR/E0223.rs:14:14
+ |
+14 | let foo: MyTrait::X;
+ | ^^^^^^^^^^ ambiguous associated type
+ |
+ = note: specify the type using the syntax `<Type as MyTrait>::X`
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let _: Box<std::io::Read + std::io::Write>;
+ //~^ ERROR only auto traits can be used as additional traits in a trait object [E0225]
+}
--- /dev/null
+error[E0225]: only auto traits can be used as additional traits in a trait object
+ --> $DIR/E0225.rs:12:32
+ |
+12 | let _: Box<std::io::Read + std::io::Write>;
+ | ^^^^^^^^^^^^^^ non-auto additional trait
+
+error: aborting due to previous error
+
--- /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.
+
+pub trait Foo {
+ type A;
+ fn boo(&self) -> <Self as Foo>::A;
+}
+
+struct Bar;
+
+impl Foo for isize {
+ type A = usize;
+ fn boo(&self) -> usize { 42 }
+}
+
+fn baz<I>(x: &<I as Foo<A=Bar>>::A) {}
+//~^ ERROR associated type bindings are not allowed here [E0229]
+
+fn main() {
+}
--- /dev/null
+error[E0229]: associated type bindings are not allowed here
+ --> $DIR/E0229.rs:23:25
+ |
+23 | fn baz<I>(x: &<I as Foo<A=Bar>>::A) {}
+ | ^^^^^ associated type not allowed here
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(on_unimplemented)]
+
+#[rustc_on_unimplemented]
+//~^ ERROR E0232
+trait Bar {}
+
+fn main() {
+}
--- /dev/null
+error[E0232]: `#[rustc_on_unimplemented]` requires a value
+ --> $DIR/E0232.rs:13:1
+ |
+13 | #[rustc_on_unimplemented]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ value required here
+ |
+ = note: eg `#[rustc_on_unimplemented = "foo"]`
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo<T> { x: T }
+struct Bar { x: Foo }
+ //~^ ERROR wrong number of type arguments: expected 1, found 0 [E0243]
+
+fn main() {
+}
--- /dev/null
+error[E0243]: wrong number of type arguments: expected 1, found 0
+ --> $DIR/E0243.rs:12:17
+ |
+12 | struct Bar { x: Foo }
+ | ^^^ expected 1 type argument
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo { x: bool }
+struct Bar<S, T> { x: Foo<S, T> }
+ //~^ ERROR wrong number of type arguments: expected 0, found 2 [E0244]
+
+
+fn main() {
+}
--- /dev/null
+error[E0244]: wrong number of type arguments: expected 0, found 2
+ --> $DIR/E0244.rs:12:23
+ |
+12 | struct Bar<S, T> { x: Foo<S, T> }
+ | ^^^^^^^^^ expected no type arguments
+
+error: aborting due to previous error
+
--- /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.
+
+use foo::baz;
+use bar::baz; //~ ERROR E0252
+
+mod foo {
+ pub struct baz;
+}
+
+mod bar {
+ pub mod baz {}
+}
+
+fn main() {
+}
--- /dev/null
+error[E0252]: the name `baz` is defined multiple times
+ --> $DIR/E0252.rs:12:5
+ |
+11 | use foo::baz;
+ | -------- previous import of the type `baz` here
+12 | use bar::baz; //~ ERROR E0252
+ | ^^^^^^^^ `baz` reimported here
+ |
+ = note: `baz` 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
+ |
+12 | use bar::baz as other_baz; //~ ERROR E0252
+ | ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+mod foo {
+ pub trait MyTrait {
+ fn do_something();
+ }
+}
+
+use foo::MyTrait::do_something;
+ //~^ ERROR E0253
+
+fn main() {}
--- /dev/null
+error[E0253]: `do_something` is not directly importable
+ --> $DIR/E0253.rs:17:5
+ |
+17 | use foo::MyTrait::do_something;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot be imported directly
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(alloc)]
+#![allow(unused_extern_crates)]
+
+extern crate alloc;
+
+mod foo {
+ pub trait alloc {
+ fn do_something();
+ }
+}
+
+use foo::alloc;
+//~^ ERROR E0254
+
+fn main() {}
--- /dev/null
+error[E0254]: the name `alloc` is defined multiple times
+ --> $DIR/E0254.rs:22:5
+ |
+14 | extern crate alloc;
+ | ------------------- previous import of the extern crate `alloc` here
+...
+22 | use foo::alloc;
+ | ^^^^^^^^^^ `alloc` reimported here
+ |
+ = note: `alloc` 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
+ |
+22 | use foo::alloc as other_alloc;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+use bar::foo;
+
+fn foo() {} //~ ERROR E0255
+
+mod bar {
+ pub fn foo() {}
+}
+
+fn main() {}
--- /dev/null
+error[E0255]: the name `foo` is defined multiple times
+ --> $DIR/E0255.rs:13:1
+ |
+11 | use bar::foo;
+ | -------- previous import of the value `foo` here
+12 |
+13 | fn foo() {} //~ ERROR E0255
+ | ^^^^^^^^ `foo` redefined here
+ |
+ = 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
+ |
+11 | use bar::foo as other_foo;
+ | ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(alloc, libc)]
+#![allow(unused_extern_crates)]
+
+extern crate alloc;
+
+extern crate libc as alloc;
+//~^ ERROR E0259
+
+fn main() {}
--- /dev/null
+error[E0259]: the name `alloc` is defined multiple times
+ --> $DIR/E0259.rs:16:1
+ |
+14 | extern crate alloc;
+ | ------------------- previous import of the extern crate `alloc` here
+15 |
+16 | extern crate libc as alloc;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | `alloc` reimported here
+ | You can use `as` to change the binding name of the import
+ |
+ = note: `alloc` must be defined only once in the type namespace of this module
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(alloc)]
+#![allow(unused_extern_crates)]
+
+extern crate alloc;
+
+mod alloc {
+//~^ ERROR the name `alloc` is defined multiple times [E0260]
+ pub trait MyTrait {
+ fn do_something();
+ }
+}
+
+fn main() {}
--- /dev/null
+error[E0260]: the name `alloc` is defined multiple times
+ --> $DIR/E0260.rs:16:1
+ |
+14 | extern crate alloc;
+ | ------------------- previous import of the extern crate `alloc` here
+15 |
+16 | mod alloc {
+ | ^^^^^^^^^ `alloc` redefined here
+ |
+ = note: `alloc` 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 | extern crate alloc as other_alloc;
+ |
+
+error: aborting due to previous error
+
--- /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.
+
+fn foo(x: &'a str) { } //~ ERROR E0261
+ //~| undeclared lifetime
+
+struct Foo {
+ x: &'a str, //~ ERROR E0261
+ //~| undeclared lifetime
+}
+
+fn main() {}
--- /dev/null
+error[E0261]: use of undeclared lifetime name `'a`
+ --> $DIR/E0261.rs:11:12
+ |
+11 | fn foo(x: &'a str) { } //~ ERROR E0261
+ | ^^ undeclared lifetime
+
+error[E0261]: use of undeclared lifetime name `'a`
+ --> $DIR/E0261.rs:15:9
+ |
+15 | x: &'a str, //~ ERROR E0261
+ | ^^ undeclared lifetime
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn foo<'static>(x: &'static str) { } //~ ERROR E0262
+ //~| 'static is a reserved lifetime name
+
+fn main() {}
--- /dev/null
+error[E0262]: invalid lifetime parameter name: `'static`
+ --> $DIR/E0262.rs:11:8
+ |
+11 | fn foo<'static>(x: &'static str) { } //~ ERROR E0262
+ | ^^^^^^^ 'static is a reserved lifetime name
+
+error: aborting due to previous error
+
--- /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.
+
+fn foo<'a, 'b, 'a>(x: &'a str, y: &'b str) {
+ //~^ ERROR E0263
+}
+
+fn main() {}
--- /dev/null
+error[E0263]: lifetime name `'a` declared twice in the same scope
+ --> $DIR/E0263.rs:11:16
+ |
+11 | fn foo<'a, 'b, 'a>(x: &'a str, y: &'b str) {
+ | -- ^^ declared twice
+ | |
+ | previous declaration here
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(lang_items)]
+
+extern "C" {
+ #[lang = "cake"]
+ fn cake(); //~ ERROR E0264
+}
+
+fn main() {}
--- /dev/null
+error[E0264]: unknown external lang item: `cake`
+ --> $DIR/E0264.rs:15:5
+ |
+15 | fn cake(); //~ ERROR E0264
+ | ^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let w = || { break; }; //~ ERROR E0267
+}
--- /dev/null
+error[E0267]: `break` inside of a closure
+ --> $DIR/E0267.rs:12:18
+ |
+12 | let w = || { break; }; //~ ERROR E0267
+ | ^^^^^ cannot break inside of a closure
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ break; //~ ERROR E0268
+}
--- /dev/null
+error[E0268]: `break` outside of loop
+ --> $DIR/E0268.rs:12:5
+ |
+12 | break; //~ ERROR E0268
+ | ^^^^^ cannot break outside of a loop
+
+error: aborting due to previous error
+
--- /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.
+
+trait Trait { type AssociatedType; }
+
+fn foo<T>(t: T) where T: Trait<AssociatedType=u32> {
+ println!("in foo");
+}
+
+impl Trait for i8 { type AssociatedType = &'static str; }
+
+fn main() {
+ foo(3_i8); //~ ERROR E0271
+}
--- /dev/null
+error[E0271]: type mismatch resolving `<i8 as Trait>::AssociatedType == u32`
+ --> $DIR/E0271.rs:20:5
+ |
+20 | foo(3_i8); //~ ERROR E0271
+ | ^^^ expected reference, found u32
+ |
+ = note: expected type `&'static str`
+ found type `u32`
+note: required by `foo`
+ --> $DIR/E0271.rs:13:1
+ |
+13 | fn foo<T>(t: T) where T: Trait<AssociatedType=u32> {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+trait Foo {}
+
+struct Bar<T>(T);
+
+impl<T> Foo for T where Bar<T>: Foo {} //~ ERROR E0275
+
+fn main() {
+}
--- /dev/null
+error[E0275]: overflow evaluating the requirement `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>: std::marker::Sized`
+ --> $DIR/E0275.rs:15:1
+ |
+15 | impl<T> Foo for T where Bar<T>: Foo {} //~ ERROR E0275
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: consider adding a `#![recursion_limit="128"]` attribute to your crate
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<Bar<T>>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<Bar<T>>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<Bar<T>>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<Bar<T>>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<Bar<T>>`
+ = note: required because of the requirements on the impl of `Foo` for `Bar<T>`
+note: required by `Foo`
+ --> $DIR/E0275.rs:11:1
+ |
+11 | trait Foo {}
+ | ^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+trait Foo {
+ fn foo<T>(x: T);
+}
+
+impl Foo for bool {
+ fn foo<T>(x: T) where T: Copy {} //~ ERROR E0276
+}
+
+fn main() {
+}
--- /dev/null
+error[E0276]: impl has stricter requirements than trait
+ --> $DIR/E0276.rs:16:5
+ |
+12 | fn foo<T>(x: T);
+ | ---------------- definition of `foo` from trait
+...
+16 | fn foo<T>(x: T) where T: Copy {} //~ ERROR E0276
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ impl has extra requirement `T: std::marker::Copy`
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo {
+ bar: Bar
+}
+
+struct Bar {
+ baz: Baz
+}
+
+struct Baz {
+ x: *const u8
+}
+
+fn is_send<T: Send>() { }
+
+fn main() {
+ is_send::<Foo>();
+ //~^ ERROR the trait bound `*const u8: std::marker::Send` is not satisfied in `Foo`
+}
--- /dev/null
+error[E0277]: the trait bound `*const u8: std::marker::Send` is not satisfied in `Foo`
+ --> $DIR/E0277-2.rs:26:5
+ |
+26 | is_send::<Foo>();
+ | ^^^^^^^^^^^^^^ `*const u8` cannot be sent between threads safely
+ |
+ = help: within `Foo`, the trait `std::marker::Send` is not implemented for `*const u8`
+ = note: required because it appears within the type `Baz`
+ = note: required because it appears within the type `Bar`
+ = note: required because it appears within the type `Foo`
+note: required by `is_send`
+ --> $DIR/E0277-2.rs:23:1
+ |
+23 | fn is_send<T: Send>() { }
+ | ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+// ignore-cloudabi no std::path
+
+use std::path::Path;
+
+trait Foo {
+ fn bar(&self);
+}
+
+fn some_func<T: Foo>(foo: T) {
+ foo.bar();
+}
+
+fn f(p: Path) { }
+//~^ ERROR the trait bound `[u8]: std::marker::Sized` is not satisfied in `std::path::Path`
+
+fn main() {
+ some_func(5i32);
+ //~^ ERROR the trait bound `i32: Foo` is not satisfied
+}
--- /dev/null
+error[E0277]: the trait bound `[u8]: std::marker::Sized` is not satisfied in `std::path::Path`
+ --> $DIR/E0277.rs:23:6
+ |
+23 | fn f(p: Path) { }
+ | ^ `[u8]` does not have a constant size known at compile-time
+ |
+ = help: within `std::path::Path`, the trait `std::marker::Sized` is not implemented for `[u8]`
+ = note: required because it appears within the type `std::path::Path`
+ = note: all local variables must have a statically known size
+
+error[E0277]: the trait bound `i32: Foo` is not satisfied
+ --> $DIR/E0277.rs:27:5
+ |
+27 | some_func(5i32);
+ | ^^^^^^^^^ the trait `Foo` is not implemented for `i32`
+ |
+note: required by `some_func`
+ --> $DIR/E0277.rs:19:1
+ |
+19 | fn some_func<T: Foo>(foo: T) {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn main() {
+ let x = "hello".chars().rev().collect(); //~ ERROR E0282
+}
--- /dev/null
+error[E0282]: type annotations needed
+ --> $DIR/E0282.rs:12:9
+ |
+12 | let x = "hello".chars().rev().collect(); //~ ERROR E0282
+ | ^
+ | |
+ | cannot infer type for `_`
+ | consider giving `x` a type
+
+error: aborting due to previous error
+
--- /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.
+
+trait Generator {
+ fn create() -> u32;
+}
+
+struct Impl;
+
+impl Generator for Impl {
+ fn create() -> u32 { 1 }
+}
+
+struct AnotherImpl;
+
+impl Generator for AnotherImpl {
+ fn create() -> u32 { 2 }
+}
+
+fn main() {
+ let cont: u32 = Generator::create(); //~ ERROR E0283
+}
--- /dev/null
+error[E0283]: type annotations required: cannot resolve `_: Generator`
+ --> $DIR/E0283.rs:28:21
+ |
+28 | let cont: u32 = Generator::create(); //~ ERROR E0283
+ | ^^^^^^^^^^^^^^^^^
+ |
+note: required by `Generator::create`
+ --> $DIR/E0283.rs:12:5
+ |
+12 | fn create() -> u32;
+ | ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![recursion_limit] //~ ERROR E0296
+
+fn main() {}
--- /dev/null
+error[E0296]: malformed recursion limit attribute, expected #![recursion_limit="N"]
+ --> $DIR/E0296.rs:11:1
+ |
+11 | #![recursion_limit] //~ ERROR E0296
+ | ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let xs : Vec<Option<i32>> = vec![Some(1), None];
+
+ for Some(x) in xs {}
+ //~^ ERROR E0005
+}
--- /dev/null
+error[E0005]: refutable pattern in `for` loop binding: `None` not covered
+ --> $DIR/E0297.rs:14:9
+ |
+14 | for Some(x) in xs {}
+ | ^^^^^^^ pattern `None` not covered
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ match Some(()) {
+ None => { },
+ option if option.take().is_none() => {}, //~ ERROR E0301
+ Some(_) => { }
+ }
+}
--- /dev/null
+error[E0301]: cannot mutably borrow in a pattern guard
+ --> $DIR/E0301.rs:14:19
+ |
+14 | option if option.take().is_none() => {}, //~ ERROR E0301
+ | ^^^^^^ borrowed mutably in pattern guard
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ match Some(()) {
+ None => { },
+ option if { option = None; false } => { }, //~ ERROR E0302
+ Some(_) => { }
+ }
+}
--- /dev/null
+error[E0302]: cannot assign in a pattern guard
+ --> $DIR/E0302.rs:14:21
+ |
+14 | option if { option = None; false } => { }, //~ ERROR E0302
+ | ^^^^^^^^^^^^^ assignment in pattern guard
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ match Some("hi".to_string()) {
+ ref op_string_ref @ Some(s) => {},
+ //~^ ERROR pattern bindings are not allowed after an `@` [E0303]
+ //~| ERROR E0009
+ None => {},
+ }
+}
--- /dev/null
+error[E0009]: cannot bind by-move and by-ref in the same pattern
+ --> $DIR/E0303.rs:13:34
+ |
+13 | ref op_string_ref @ Some(s) => {},
+ | -------------------------^-
+ | | |
+ | | by-move pattern here
+ | both by-ref and by-move used
+
+error[E0303]: pattern bindings are not allowed after an `@`
+ --> $DIR/E0303.rs:13:34
+ |
+13 | ref op_string_ref @ Some(s) => {},
+ | ^ not allowed after `@`
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn main() {
+ let x = 1u8;
+ match x {
+ 0u8...3i8 => (), //~ ERROR E0308
+ _ => ()
+ }
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/E0308-4.rs:14:9
+ |
+14 | 0u8...3i8 => (), //~ ERROR E0308
+ | ^^^^^^^^^ expected u8, found i8
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(intrinsics)]
+
+extern "rust-intrinsic" {
+ fn size_of<T>(); //~ ERROR E0308
+}
+
+fn main() {
+}
--- /dev/null
+error[E0308]: intrinsic has wrong type
+ --> $DIR/E0308.rs:14:5
+ |
+14 | fn size_of<T>(); //~ ERROR E0308
+ | ^^^^^^^^^^^^^^^^ expected (), found usize
+ |
+ = note: expected type `unsafe extern "rust-intrinsic" fn()`
+ found type `unsafe extern "rust-intrinsic" fn() -> usize`
+
+error: aborting due to previous error
+
--- /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.
+
+mod foo {
+ pub const X: u32 = 1;
+}
+
+pub use foo as foo2;
+//~^ ERROR `foo` is private, and cannot be re-exported [E0365]
+
+fn main() {}
--- /dev/null
+error[E0365]: `foo` is private, and cannot be re-exported
+ --> $DIR/E0365.rs:15:9
+ |
+15 | pub use foo as foo2;
+ | ^^^^^^^^^^^ re-export of private `foo`
+ |
+ = note: consider declaring type or module `foo` with `pub`
+
+error: aborting due to previous error
+
--- /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.
+
+#![allow(dead_code)]
+
+#[deny(overflowing_literals)]
+#[repr(i64)]
+enum Foo {
+ X = 0x7fffffffffffffff,
+ Y, //~ ERROR E0370
+}
+
+fn main() {}
--- /dev/null
+error[E0370]: enum discriminant overflowed
+ --> $DIR/E0370.rs:17:5
+ |
+17 | Y, //~ ERROR E0370
+ | ^ overflowed on value after 9223372036854775807i64
+ |
+ = note: explicitly set `Y = -9223372036854775808i64` if that is desired outcome
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(coerce_unsized)]
+use std::ops::CoerceUnsized;
+
+struct Foo<T: ?Sized> {
+ a: i32,
+}
+
+impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> //~ ERROR E0374
+ where T: CoerceUnsized<U> {}
+
+fn main() {}
--- /dev/null
+error[E0374]: the trait `CoerceUnsized` may only be implemented for a coercion between structures with one field being coerced, none found
+ --> $DIR/E0374.rs:18:1
+ |
+18 | / impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> //~ ERROR E0374
+19 | | where T: CoerceUnsized<U> {}
+ | |________________________________^
+
+error: aborting due to previous error
+
--- /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.
+
+// ignore-tidy-linelength
+
+#![feature(coerce_unsized)]
+use std::ops::CoerceUnsized;
+
+struct Foo<T: ?Sized, U: ?Sized> {
+ a: i32,
+ b: T,
+ c: U,
+}
+
+impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {}
+//~^ ERROR E0375
+
+fn main() {}
--- /dev/null
+error[E0375]: implementing the trait `CoerceUnsized` requires multiple coercions
+ --> $DIR/E0375.rs:22:12
+ |
+22 | impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ requires multiple coercions
+ |
+ = note: `CoerceUnsized` may only be implemented for a coercion between structures with one field being coerced
+ = note: currently, 2 fields need coercions: b (T to U), c (U to T)
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(coerce_unsized)]
+use std::ops::CoerceUnsized;
+
+struct Foo<T: ?Sized> {
+ a: T,
+}
+
+impl<T, U> CoerceUnsized<U> for Foo<T> {} //~ ERROR E0376
+
+fn main() {}
--- /dev/null
+error[E0376]: the trait `CoerceUnsized` may only be implemented for a coercion between structures
+ --> $DIR/E0376.rs:18:1
+ |
+18 | impl<T, U> CoerceUnsized<U> for Foo<T> {} //~ ERROR E0376
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+static X: i32 = 1;
+const C: i32 = 2;
+
+const CR: &'static mut i32 = &mut C; //~ ERROR E0017
+static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
+ //~| ERROR cannot borrow
+static CONST_REF: &'static mut i32 = &mut C; //~ ERROR E0017
+
+fn main() {}
--- /dev/null
+error[E0017]: references in constants may only refer to immutable values
+ --> $DIR/E0388.rs:14:30
+ |
+14 | const CR: &'static mut i32 = &mut C; //~ ERROR E0017
+ | ^^^^^^ constants require immutable values
+
+error[E0017]: references in statics may only refer to immutable values
+ --> $DIR/E0388.rs:15:39
+ |
+15 | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
+ | ^^^^^^ statics require immutable values
+
+error[E0596]: cannot borrow immutable static item as mutable
+ --> $DIR/E0388.rs:15:44
+ |
+15 | static STATIC_REF: &'static mut i32 = &mut X; //~ ERROR E0017
+ | ^
+
+error[E0017]: references in statics may only refer to immutable values
+ --> $DIR/E0388.rs:17:38
+ |
+17 | static CONST_REF: &'static mut i32 = &mut C; //~ ERROR E0017
+ | ^^^^^^ statics require immutable values
+
+error: aborting due to 4 previous errors
+
--- /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.
+
+struct FancyNum {
+ num: u8,
+}
+
+fn main() {
+ let mut fancy = FancyNum{ num: 5 };
+ let fancy_ref = &(&mut fancy);
+ fancy_ref.num = 6; //~ ERROR E0389
+ println!("{}", fancy_ref.num);
+}
--- /dev/null
+error[E0389]: cannot assign to data in a `&` reference
+ --> $DIR/E0389.rs:18:5
+ |
+18 | fancy_ref.num = 6; //~ ERROR E0389
+ | ^^^^^^^^^^^^^^^^^ assignment into an immutable reference
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo {
+ x: i32
+}
+
+impl *mut Foo {} //~ ERROR E0390
+
+fn main() {
+}
--- /dev/null
+error[E0390]: only a single inherent implementation marked with `#[lang = "mut_ptr"]` is allowed for the `*mut T` primitive
+ --> $DIR/E0390.rs:15:1
+ |
+15 | impl *mut Foo {} //~ ERROR E0390
+ | ^^^^^^^^^^^^^^^^
+ |
+help: consider using a trait to implement these methods
+ --> $DIR/E0390.rs:15:1
+ |
+15 | impl *mut Foo {} //~ ERROR E0390
+ | ^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+enum Foo<T> { Bar } //~ ERROR E0392
+
+fn main() {
+}
--- /dev/null
+error[E0392]: parameter `T` is never used
+ --> $DIR/E0392.rs:11:10
+ |
+11 | enum Foo<T> { Bar } //~ ERROR E0392
+ | ^ unused type parameter
+ |
+ = help: consider removing `T` or using a marker such as `std::marker::PhantomData`
+
+error: aborting due to previous error
+
--- /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.
+
+trait A<T=Self> {}
+
+fn together_we_will_rule_the_galaxy(son: &A) {}
+//~^ ERROR E0393
+
+fn main() {
+}
--- /dev/null
+error[E0393]: the type parameter `T` must be explicitly specified
+ --> $DIR/E0393.rs:13:43
+ |
+13 | fn together_we_will_rule_the_galaxy(son: &A) {}
+ | ^ missing reference to `T`
+ |
+ = note: because of the default `Self` reference, type parameters must be specified on object types
+
+error: aborting due to previous error
+
--- /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.
+
+#![allow(warnings)]
+
+static A: u32 = 0;
+static B: u32 = A;
+//~^ ERROR E0394
+
+fn main() {
+}
--- /dev/null
+error[E0394]: cannot refer to other statics by value, use the address-of operator or a constant instead
+ --> $DIR/E0394.rs:14:17
+ |
+14 | static B: u32 = A;
+ | ^ referring to another static by value
+ |
+ = note: use the address-of operator or a constant instead
+
+error: aborting due to previous error
+
--- /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.
+
+static FOO: i32 = 42;
+static BAR: i32 = 42;
+
+static BAZ: bool = { (&FOO as *const i32) == (&BAR as *const i32) }; //~ ERROR E0395
+fn main() {
+}
--- /dev/null
+error[E0395]: raw pointers cannot be compared in statics
+ --> $DIR/E0395.rs:14:22
+ |
+14 | static BAZ: bool = { (&FOO as *const i32) == (&BAR as *const i32) }; //~ ERROR E0395
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ comparing raw pointers in static
+
+error: aborting due to previous error
+
--- /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.
+
+const REG_ADDR: *const u8 = 0x5f3759df as *const u8;
+
+const VALUE: u8 = unsafe { *REG_ADDR }; //~ ERROR E0396
+
+fn main() {
+}
--- /dev/null
+error[E0396]: raw pointers cannot be dereferenced in constants
+ --> $DIR/E0396.rs:13:28
+ |
+13 | const VALUE: u8 = unsafe { *REG_ADDR }; //~ ERROR E0396
+ | ^^^^^^^^^ dereference of raw pointer in constant
+
+error: aborting due to previous error
+
--- /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.
+
+fn foo<T>(x: T) {
+ fn bar(y: T) { //~ ERROR E0401
+ }
+ bar(x);
+}
+
+fn main() {
+}
--- /dev/null
+error[E0401]: can't use type parameters from outer function; try using a local type parameter instead
+ --> $DIR/E0401.rs:12:15
+ |
+12 | fn bar(y: T) { //~ ERROR E0401
+ | ^ use of type variable from outer function
+
+error: aborting due to previous error
+
--- /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.
+
+fn foo<T, T>(s: T, u: T) {} //~ ERROR E0403
+
+fn main() {
+}
--- /dev/null
+error[E0403]: the name `T` is already used for a type parameter in this type parameter list
+ --> $DIR/E0403.rs:11:11
+ |
+11 | fn foo<T, T>(s: T, u: T) {} //~ ERROR E0403
+ | - ^ already used
+ | |
+ | first use of `T`
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo;
+struct Bar;
+
+impl Foo for Bar {} //~ ERROR E0404
+
+fn main() {
+}
--- /dev/null
+error[E0404]: expected trait, found struct `Foo`
+ --> $DIR/E0404.rs:14:6
+ |
+14 | impl Foo for Bar {} //~ ERROR E0404
+ | ^^^ not a trait
+
+error: cannot continue compilation due to previous error
+
--- /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.
+
+struct Foo;
+
+impl SomeTrait for Foo {} //~ ERROR E0405
+
+fn main() {
+}
--- /dev/null
+error[E0405]: cannot find trait `SomeTrait` in this scope
+ --> $DIR/E0405.rs:13:6
+ |
+13 | impl SomeTrait for Foo {} //~ ERROR E0405
+ | ^^^^^^^^^ not found in this scope
+
+error: cannot continue compilation due to previous error
+
--- /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.
+
+trait Foo {
+ fn a();
+}
+
+struct Bar;
+
+impl Foo for Bar {
+ fn a() {}
+ fn b() {}
+ //~^ ERROR E0407
+}
+
+fn main() {
+}
--- /dev/null
+error[E0407]: method `b` is not a member of trait `Foo`
+ --> $DIR/E0407.rs:19:5
+ |
+19 | fn b() {}
+ | ^^^^^^^^^ not a member of trait `Foo`
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let x = Some(0);
+
+ match x {
+ Some(y) | None => {} //~ ERROR variable `y` is not bound in all patterns
+ _ => ()
+ }
+}
--- /dev/null
+error[E0408]: variable `y` is not bound in all patterns
+ --> $DIR/E0408.rs:15:19
+ |
+15 | Some(y) | None => {} //~ ERROR variable `y` is not bound in all patterns
+ | - ^^^^ pattern doesn't bind `y`
+ | |
+ | variable not in all patterns
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ <Self>::foo; //~ ERROR E0411
+}
--- /dev/null
+error[E0411]: cannot find type `Self` in this scope
+ --> $DIR/E0411.rs:12:6
+ |
+12 | <Self>::foo; //~ ERROR E0411
+ | ^^^^ `Self` is only available in traits and impls
+
+error: aborting due to previous error
+
--- /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.
+
+impl Something {} //~ ERROR E0412
+
+fn main() {
+}
--- /dev/null
+error[E0412]: cannot find type `Something` in this scope
+ --> $DIR/E0412.rs:11:6
+ |
+11 | impl Something {} //~ ERROR E0412
+ | ^^^^^^^^^ not found in this scope
+
+error: aborting due to previous error
+
--- /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.
+
+fn foo(f: i32, f: i32) {} //~ ERROR E0415
+
+fn main() {
+}
--- /dev/null
+error[E0415]: identifier `f` is bound more than once in this parameter list
+ --> $DIR/E0415.rs:11:16
+ |
+11 | fn foo(f: i32, f: i32) {} //~ ERROR E0415
+ | ^ used as parameter more than once
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ match (1, 2) {
+ (x, x) => {} //~ ERROR E0416
+ }
+}
--- /dev/null
+error[E0416]: identifier `x` is bound more than once in the same pattern
+ --> $DIR/E0416.rs:13:13
+ |
+13 | (x, x) => {} //~ ERROR E0416
+ | ^ used in a pattern more than once
+
+error: aborting due to previous error
+
--- /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.
+
+fn main () {
+ struct Foo { a: bool };
+
+ let f = Foo(); //~ ERROR E0423
+}
--- /dev/null
+error[E0423]: expected function, found struct `Foo`
+ --> $DIR/E0423.rs:14:13
+ |
+14 | let f = Foo(); //~ ERROR E0423
+ | ^^^ did you mean `Foo { /* fields */ }`?
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo;
+
+impl Foo {
+ fn bar(self) {}
+
+ fn foo() {
+ self.bar(); //~ ERROR E0424
+ }
+}
+
+fn main () {
+}
--- /dev/null
+error[E0424]: expected value, found module `self`
+ --> $DIR/E0424.rs:17:9
+ |
+17 | self.bar(); //~ ERROR E0424
+ | ^^^^ `self` value is only available in methods with `self` parameter
+
+error: aborting due to previous error
+
--- /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.
+
+trait Foo {
+ fn bar() {
+ elf; //~ ERROR E0425
+ }
+}
+
+fn main () {
+}
--- /dev/null
+error[E0425]: cannot find value `elf` in this scope
+ --> $DIR/E0425.rs:13:9
+ |
+13 | elf; //~ ERROR E0425
+ | ^^^ not found in this scope
+
+error: aborting due to previous error
+
--- /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.
+
+fn main () {
+ loop {
+ break 'a;
+ //~^ ERROR E0426
+ }
+}
--- /dev/null
+error[E0426]: use of undeclared label `'a`
+ --> $DIR/E0426.rs:13:15
+ |
+13 | break 'a;
+ | ^^ undeclared label `'a`
+
+error: aborting due to previous error
+
--- /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.
+
+struct Bar; //~ previous definition of the type `Bar` here
+struct Bar; //~ ERROR E0428
+
+fn main () {
+}
--- /dev/null
+error[E0428]: the name `Bar` is defined multiple times
+ --> $DIR/E0428.rs:12:1
+ |
+11 | struct Bar; //~ previous definition of the type `Bar` here
+ | ----------- previous definition of the type `Bar` here
+12 | struct Bar; //~ ERROR E0428
+ | ^^^^^^^^^^^ `Bar` redefined here
+ |
+ = note: `Bar` must be defined only once in the type namespace of this module
+
+error: aborting due to previous error
+
--- /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.
+
+use std::fmt::self; //~ ERROR E0429
+
+fn main () {
+}
--- /dev/null
+error[E0429]: `self` imports are only allowed within a { } list
+ --> $DIR/E0429.rs:11:5
+ |
+11 | use std::fmt::self; //~ ERROR E0429
+ | ^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+use std::fmt::{self, self}; //~ ERROR E0430
+ //~^ ERROR E0252
+
+fn main () {
+}
--- /dev/null
+error[E0430]: `self` import can only appear once in an import list
+ --> $DIR/E0430.rs:11:16
+ |
+11 | use std::fmt::{self, self}; //~ ERROR E0430
+ | ^^^^ ---- another `self` import appears here
+ | |
+ | can only appear once in an import list
+
+error[E0252]: the name `fmt` is defined multiple times
+ --> $DIR/E0430.rs:11:22
+ |
+11 | use std::fmt::{self, self}; //~ ERROR E0430
+ | ---- ^^^^ `fmt` reimported here
+ | |
+ | previous import of the module `fmt` here
+ |
+ = note: `fmt` 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 | use std::fmt::{self, self as other_fmt}; //~ ERROR E0430
+ | ^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+use {self}; //~ ERROR E0431
+
+fn main () {
+}
--- /dev/null
+error[E0431]: `self` import can only appear in an import list with a non-empty prefix
+ --> $DIR/E0431.rs:11:6
+ |
+11 | use {self}; //~ ERROR E0431
+ | ^^^^ can only appear in an import list with a non-empty prefix
+
+error: aborting due to previous error
+
--- /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.
+
+use something::Foo; //~ ERROR E0432
+
+fn main () {
+}
--- /dev/null
+error[E0432]: unresolved import `something`
+ --> $DIR/E0432.rs:11:5
+ |
+11 | use something::Foo; //~ ERROR E0432
+ | ^^^^^^^^^ Maybe a missing `extern crate something;`?
+
+error: aborting due to previous error
+
--- /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.
+
+fn main () {
+ let map = HashMap::new(); //~ ERROR E0433
+}
--- /dev/null
+error[E0433]: failed to resolve. Use of undeclared type or module `HashMap`
+ --> $DIR/E0433.rs:12:15
+ |
+12 | let map = HashMap::new(); //~ ERROR E0433
+ | ^^^^^^^ Use of undeclared type or module `HashMap`
+
+error: aborting due to previous error
+
--- /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.
+
+fn foo() {
+ let y = 5;
+ fn bar() -> u32 {
+ y //~ ERROR E0434
+ }
+}
+
+fn main () {
+}
--- /dev/null
+error[E0434]: can't capture dynamic environment in a fn item
+ --> $DIR/E0434.rs:14:9
+ |
+14 | y //~ ERROR E0434
+ | ^
+ |
+ = help: use the `|| { ... }` closure form instead
+
+error: aborting due to previous error
+
--- /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.
+
+fn main () {
+ let foo = 42u32;
+ let _: [u8; foo]; //~ ERROR E0435
+}
--- /dev/null
+error[E0435]: attempt to use a non-constant value in a constant
+ --> $DIR/E0435.rs:13:17
+ |
+13 | let _: [u8; foo]; //~ ERROR E0435
+ | ^^^ non-constant value
+
+error: aborting due to previous error
+
--- /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.
+
+trait Foo {}
+
+impl Foo for i32 {
+ type Bar = bool; //~ ERROR E0437
+}
+
+fn main () {
+}
--- /dev/null
+error[E0437]: type `Bar` is not a member of trait `Foo`
+ --> $DIR/E0437.rs:14:5
+ |
+14 | type Bar = bool; //~ ERROR E0437
+ | ^^^^^^^^^^^^^^^^ not a member of trait `Foo`
+
+error: aborting due to previous error
+
--- /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.
+
+
+trait Bar {}
+
+impl Bar for i32 {
+ const BAR: bool = true; //~ ERROR E0438
+}
+
+fn main () {
+}
--- /dev/null
+error[E0438]: const `BAR` is not a member of trait `Bar`
+ --> $DIR/E0438.rs:15:5
+ |
+15 | const BAR: bool = true; //~ ERROR E0438
+ | ^^^^^^^^^^^^^^^^^^^^^^^ not a member of trait `Bar`
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(platform_intrinsics)]
+
+extern "platform-intrinsic" {
+ fn simd_shuffle<A,B>(a: A, b: A, c: [u32; 8]) -> B; //~ ERROR E0439
+}
+
+fn main () {
+}
--- /dev/null
+error[E0439]: invalid `simd_shuffle`, needs length: `simd_shuffle`
+ --> $DIR/E0439.rs:14:5
+ |
+14 | fn simd_shuffle<A,B>(a: A, b: A, c: [u32; 8]) -> B; //~ ERROR E0439
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(repr_simd)]
+#![feature(platform_intrinsics)]
+
+#[repr(simd)]
+struct f64x2(f64, f64);
+
+extern "platform-intrinsic" {
+ fn x86_mm_movemask_pd<T>(x: f64x2) -> i32; //~ ERROR E0440
+}
+
+fn main () {
+}
--- /dev/null
+error[E0440]: platform-specific intrinsic has wrong number of type parameters: found 1, expected 0
+ --> $DIR/E0440.rs:18:5
+ |
+18 | fn x86_mm_movemask_pd<T>(x: f64x2) -> i32; //~ ERROR E0440
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(repr_simd)]
+#![feature(platform_intrinsics)]
+
+#[repr(simd)]
+struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
+
+extern "platform-intrinsic" {
+ fn x86_mm_adds_ep16(x: i16x8, y: i16x8) -> i16x8; //~ ERROR E0441
+}
+
+fn main() {}
--- /dev/null
+error[E0441]: unrecognized platform-specific intrinsic function: `x86_mm_adds_ep16`
+ --> $DIR/E0441.rs:18:5
+ |
+18 | fn x86_mm_adds_ep16(x: i16x8, y: i16x8) -> i16x8; //~ ERROR E0441
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(repr_simd)]
+#![feature(platform_intrinsics)]
+
+#[repr(simd)]
+struct i8x16(i8, i8, i8, i8, i8, i8, i8, i8,
+ i8, i8, i8, i8, i8, i8, i8, i8);
+#[repr(simd)]
+struct i32x4(i32, i32, i32, i32);
+#[repr(simd)]
+struct i64x2(i64, i64);
+
+extern "platform-intrinsic" {
+ fn x86_mm_adds_epi16(x: i8x16, y: i32x4) -> i64x2;
+ //~^ ERROR E0442
+ //~| ERROR E0442
+ //~| ERROR E0442
+}
+
+fn main() {}
--- /dev/null
+error[E0442]: intrinsic argument 1 has wrong type: found vector with length 16, expected length 8
+ --> $DIR/E0442.rs:23:5
+ |
+23 | fn x86_mm_adds_epi16(x: i8x16, y: i32x4) -> i64x2;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0442]: intrinsic argument 2 has wrong type: found vector with length 4, expected length 8
+ --> $DIR/E0442.rs:23:5
+ |
+23 | fn x86_mm_adds_epi16(x: i8x16, y: i32x4) -> i64x2;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0442]: intrinsic return value has wrong type: found vector with length 2, expected length 8
+ --> $DIR/E0442.rs:23:5
+ |
+23 | fn x86_mm_adds_epi16(x: i8x16, y: i32x4) -> i64x2;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
--- /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.
+
+#![feature(repr_simd)]
+#![feature(platform_intrinsics)]
+
+#[repr(simd)]
+struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
+#[repr(simd)]
+struct i64x8(i64, i64, i64, i64, i64, i64, i64, i64);
+
+extern "platform-intrinsic" {
+ fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i64x8; //~ ERROR E0443
+}
+
+fn main() {}
--- /dev/null
+error[E0443]: intrinsic return value has wrong type: found `i64x8`, expected `i16x8` which was used for this vector type previously in this signature
+ --> $DIR/E0443.rs:20:5
+ |
+20 | fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i64x8; //~ ERROR E0443
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(repr_simd)]
+#![feature(platform_intrinsics)]
+
+#[repr(simd)]
+struct f64x2(f64, f64);
+
+extern "platform-intrinsic" {
+ fn x86_mm_movemask_pd(x: f64x2, y: f64x2, z: f64x2) -> i32; //~ ERROR E0444
+}
+
+fn main() {}
--- /dev/null
+error[E0444]: platform-specific intrinsic has invalid number of arguments: found 3, expected 1
+ --> $DIR/E0444.rs:18:5
+ |
+18 | fn x86_mm_movemask_pd(x: f64x2, y: f64x2, z: f64x2) -> i32; //~ ERROR E0444
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+trait Foo {
+ fn dummy(&self) { }
+}
+
+pub trait Bar : Foo {}
+//~^ ERROR private trait `Foo` in public interface [E0445]
+//~| NOTE can't leak private trait
+pub struct Bar2<T: Foo>(pub T);
+//~^ ERROR private trait `Foo` in public interface [E0445]
+//~| NOTE can't leak private trait
+pub fn foo<T: Foo> (t: T) {}
+//~^ ERROR private trait `Foo` in public interface [E0445]
+//~| NOTE can't leak private trait
+
+fn main() {}
--- /dev/null
+error[E0445]: private trait `Foo` in public interface
+ --> $DIR/E0445.rs:15:1
+ |
+15 | pub trait Bar : Foo {}
+ | ^^^^^^^^^^^^^^^^^^^^^^ can't leak private trait
+
+error[E0445]: private trait `Foo` in public interface
+ --> $DIR/E0445.rs:18:1
+ |
+18 | pub struct Bar2<T: Foo>(pub T);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't leak private trait
+
+error[E0445]: private trait `Foo` in public interface
+ --> $DIR/E0445.rs:21:1
+ |
+21 | pub fn foo<T: Foo> (t: T) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't leak private trait
+
+error: aborting due to 3 previous errors
+
--- /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.
+
+mod Foo {
+ struct Bar(u32);
+
+ pub fn bar() -> Bar { //~ ERROR E0446
+ Bar(0)
+ }
+}
+
+fn main() {}
--- /dev/null
+error[E0446]: private type `Foo::Bar` in public interface
+ --> $DIR/E0446.rs:14:5
+ |
+14 | / pub fn bar() -> Bar { //~ ERROR E0446
+15 | | Bar(0)
+16 | | }
+ | |_____^ can't leak private type
+
+error: aborting due to previous error
+
--- /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.
+
+struct Bar;
+
+trait Foo {
+ fn foo();
+}
+
+pub impl Bar {} //~ ERROR E0449
+
+pub impl Foo for Bar { //~ ERROR E0449
+ pub fn foo() {} //~ ERROR E0449
+}
+
+fn main() {
+}
--- /dev/null
+error[E0449]: unnecessary visibility qualifier
+ --> $DIR/E0449.rs:17:1
+ |
+17 | pub impl Bar {} //~ ERROR E0449
+ | ^^^^^^^^^^^^^^^ `pub` not needed here
+ |
+ = note: place qualifiers on individual impl items instead
+
+error[E0449]: unnecessary visibility qualifier
+ --> $DIR/E0449.rs:19:1
+ |
+19 | / pub impl Foo for Bar { //~ ERROR E0449
+20 | | pub fn foo() {} //~ ERROR E0449
+21 | | }
+ | |_^ `pub` not needed here
+
+error[E0449]: unnecessary visibility qualifier
+ --> $DIR/E0449.rs:20:5
+ |
+20 | pub fn foo() {} //~ ERROR E0449
+ | ^^^^^^^^^^^^^^^ `pub` not needed here
+
+error: aborting due to 3 previous errors
+
--- /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.
+
+mod Bar {
+ pub struct Foo {
+ pub a: isize,
+ b: isize,
+ }
+
+ pub struct FooTuple (
+ pub isize,
+ isize,
+ );
+}
+
+fn pat_match(foo: Bar::Foo) {
+ let Bar::Foo{a:a, b:b} = foo; //~ ERROR E0451
+}
+
+fn main() {
+ let f = Bar::Foo{ a: 0, b: 0 }; //~ ERROR E0451
+}
--- /dev/null
+error[E0451]: field `b` of struct `Bar::Foo` is private
+ --> $DIR/E0451.rs:24:23
+ |
+24 | let Bar::Foo{a:a, b:b} = foo; //~ ERROR E0451
+ | ^^^ field `b` is private
+
+error[E0451]: field `b` of struct `Bar::Foo` is private
+ --> $DIR/E0451.rs:28:29
+ |
+28 | let f = Bar::Foo{ a: 0, b: 0 }; //~ ERROR E0451
+ | ^^^^ field `b` is private
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+#![allow(foo = "")] //~ ERROR E0452
+
+fn main() {
+}
--- /dev/null
+error[E0452]: malformed lint attribute
+ --> $DIR/E0452.rs:11:10
+ |
+11 | #![allow(foo = "")] //~ ERROR E0452
+ | ^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![forbid(non_snake_case)]
+
+#[allow(non_snake_case)]
+//~^ ERROR allow(non_snake_case) overruled by outer forbid(non_snake_case)
+fn main() {
+}
--- /dev/null
+error[E0453]: allow(non_snake_case) overruled by outer forbid(non_snake_case)
+ --> $DIR/E0453.rs:13:9
+ |
+11 | #![forbid(non_snake_case)]
+ | -------------- `forbid` level set here
+12 |
+13 | #[allow(non_snake_case)]
+ | ^^^^^^^^^^^^^^ overruled by previous forbid
+
+error: aborting due to previous error
+
--- /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.
+
+#[link(name = "")] extern {}
+//~^ ERROR E0454
+
+fn main() {
+}
--- /dev/null
+error[E0454]: #[link(name = "")] given with empty name
+ --> $DIR/E0454.rs:11:1
+ |
+11 | #[link(name = "")] extern {}
+ | ^^^^^^^^^^^^^^^^^^ empty name given
+
+error: aborting due to previous error
+
--- /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.
+
+#[link(kind = "wonderful_unicorn")] extern {} //~ ERROR E0458
+ //~| ERROR E0459
+
+fn main() {
+}
--- /dev/null
+error[E0458]: unknown kind: `wonderful_unicorn`
+ --> $DIR/E0458.rs:11:1
+ |
+11 | #[link(kind = "wonderful_unicorn")] extern {} //~ ERROR E0458
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unknown kind
+
+error[E0459]: #[link(...)] specified without `name = "foo"`
+ --> $DIR/E0458.rs:11:1
+ |
+11 | #[link(kind = "wonderful_unicorn")] extern {} //~ ERROR E0458
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `name` argument
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+#[link(kind = "dylib")] extern {} //~ ERROR E0459
+
+fn main() {
+}
--- /dev/null
+error[E0459]: #[link(...)] specified without `name = "foo"`
+ --> $DIR/E0459.rs:11:1
+ |
+11 | #[link(kind = "dylib")] extern {} //~ ERROR E0459
+ | ^^^^^^^^^^^^^^^^^^^^^^^ missing `name` argument
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(plugin)]
+#![plugin(cookie_monster)]
+//~^ ERROR E0463
+extern crate cake_is_a_lie;
+
+fn main() {
+}
--- /dev/null
+error[E0463]: can't find crate for `cookie_monster`
+ --> $DIR/E0463.rs:12:11
+ |
+12 | #![plugin(cookie_monster)]
+ | ^^^^^^^^^^^^^^ can't find crate
+
+error: aborting due to previous error
+
--- /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.
+
+trait Wedding<'t>: 't { }
+
+struct Prince<'kiss, 'SnowWhite> {
+ child: Box<Wedding<'kiss> + 'SnowWhite>, //~ ERROR E0478
+}
+
+fn main() {
+}
--- /dev/null
+error[E0478]: lifetime bound not satisfied
+ --> $DIR/E0478.rs:14:5
+ |
+14 | child: Box<Wedding<'kiss> + 'SnowWhite>, //~ ERROR E0478
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+note: lifetime parameter instantiated with the lifetime 'SnowWhite as defined on the struct at 13:1
+ --> $DIR/E0478.rs:13:1
+ |
+13 | struct Prince<'kiss, 'SnowWhite> {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: but lifetime parameter must outlive the lifetime 'kiss as defined on the struct at 13:1
+ --> $DIR/E0478.rs:13:1
+ |
+13 | struct Prince<'kiss, 'SnowWhite> {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
+
+const A: AtomicUsize = ATOMIC_USIZE_INIT;
+static B: &'static AtomicUsize = &A; //~ ERROR E0492
+
+fn main() {
+}
--- /dev/null
+error[E0492]: cannot borrow a constant which may contain interior mutability, create a static instead
+ --> $DIR/E0492.rs:14:34
+ |
+14 | static B: &'static AtomicUsize = &A; //~ ERROR E0492
+ | ^^
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo {
+ a: u32
+}
+
+static S : Foo = Foo { a : 0 };
+static A : &'static u32 = &S.a; //~ ERROR E0494
+
+fn main() {
+}
--- /dev/null
+error[E0494]: cannot refer to the interior of another static, use a constant instead
+ --> $DIR/E0494.rs:16:27
+ |
+16 | static A : &'static u32 = &S.a; //~ ERROR E0494
+ | ^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+struct Foo<'a> {
+ a: &'a i32,
+}
+
+impl<'a> Foo<'a> {
+ fn f<'a>(x: &'a i32) { //~ ERROR E0496
+ }
+}
+
+fn main() {
+}
--- /dev/null
+error[E0496]: lifetime name `'a` shadows a lifetime name that is already in scope
+ --> $DIR/E0496.rs:16:10
+ |
+15 | impl<'a> Foo<'a> {
+ | -- first declared here
+16 | fn f<'a>(x: &'a i32) { //~ ERROR E0496
+ | ^^ lifetime 'a already in scope
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let mut i = 0;
+ let mut x = &mut i;
+ let mut a = &mut i; //~ ERROR E0499
+}
--- /dev/null
+error[E0499]: cannot borrow `i` as mutable more than once at a time
+ --> $DIR/E0499.rs:14:22
+ |
+13 | let mut x = &mut i;
+ | - first mutable borrow occurs here
+14 | let mut a = &mut i; //~ ERROR E0499
+ | ^ second mutable borrow occurs here
+15 | }
+ | - first borrow ends here
+
+error: aborting due to previous error
+
--- /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.
+
+fn bar(x: &mut i32) {}
+fn foo(a: &mut i32) {
+ let ref y = a;
+ bar(a); //~ ERROR E0502
+}
+
+fn main() {
+}
--- /dev/null
+error[E0502]: cannot borrow `*a` as mutable because `a` is also borrowed as immutable
+ --> $DIR/E0502.rs:14:9
+ |
+13 | let ref y = a;
+ | ----- immutable borrow occurs here
+14 | bar(a); //~ ERROR E0502
+ | ^ mutable borrow occurs here
+15 | }
+ | - immutable borrow ends here
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let mut value = 3;
+ let _borrow = &mut value;
+ let _sum = value + 1; //~ ERROR E0503
+}
--- /dev/null
+error[E0503]: cannot use `value` because it was mutably borrowed
+ --> $DIR/E0503.rs:14:16
+ |
+13 | let _borrow = &mut value;
+ | ----- borrow of `value` occurs here
+14 | let _sum = value + 1; //~ ERROR E0503
+ | ^^^^^ use of borrowed `value`
+
+error: aborting due to previous error
+
--- /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.
+
+struct FancyNum {
+ num: u8,
+}
+
+fn main() {
+ let fancy_num = FancyNum { num: 5 };
+ let fancy_ref = &fancy_num;
+
+ let x = move || {
+ println!("child function: {}", fancy_num.num); //~ ERROR E0504
+ };
+
+ x();
+ println!("main function: {}", fancy_ref.num);
+}
--- /dev/null
+error[E0504]: cannot move `fancy_num` into closure because it is borrowed
+ --> $DIR/E0504.rs:20:40
+ |
+17 | let fancy_ref = &fancy_num;
+ | --------- borrow of `fancy_num` occurs here
+...
+20 | println!("child function: {}", fancy_num.num); //~ ERROR E0504
+ | ^^^^^^^^^ move into closure occurs here
+
+error: aborting due to previous error
+
--- /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.
+
+struct Value {}
+
+fn eat(val: Value) {}
+
+fn main() {
+ let x = Value{};
+ {
+ let _ref_to_val: &Value = &x;
+ eat(x); //~ ERROR E0505
+ }
+}
--- /dev/null
+error[E0505]: cannot move out of `x` because it is borrowed
+ --> $DIR/E0505.rs:19:13
+ |
+18 | let _ref_to_val: &Value = &x;
+ | - borrow of `x` occurs here
+19 | eat(x); //~ ERROR E0505
+ | ^ move out of `x` occurs here
+
+error: aborting due to previous error
+
--- /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.
+
+use std::cell::RefCell;
+
+struct TheDarkKnight;
+
+impl TheDarkKnight {
+ fn nothing_is_true(self) {}
+}
+
+fn main() {
+ let x = RefCell::new(TheDarkKnight);
+
+ x.borrow().nothing_is_true(); //~ ERROR E0507
+}
--- /dev/null
+error[E0507]: cannot move out of borrowed content
+ --> $DIR/E0507.rs:22:5
+ |
+22 | x.borrow().nothing_is_true(); //~ ERROR E0507
+ | ^^^^^^^^^^ cannot move out of borrowed content
+
+error: aborting due to previous error
+
--- /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.
+
+struct FancyNum {
+ num: usize
+}
+
+struct DropStruct {
+ fancy: FancyNum
+}
+
+impl Drop for DropStruct {
+ fn drop(&mut self) {
+ }
+}
+
+fn main() {
+ let drop_struct = DropStruct{fancy: FancyNum{num: 5}};
+ let fancy_field = drop_struct.fancy; //~ ERROR E0509
+ println!("Fancy: {}", fancy_field.num);
+}
--- /dev/null
+error[E0509]: cannot move out of type `DropStruct`, which implements the `Drop` trait
+ --> $DIR/E0509.rs:26:23
+ |
+26 | let fancy_field = drop_struct.fancy; //~ ERROR E0509
+ | ^^^^^^^^^^^^^^^^^
+ | |
+ | cannot move out of here
+ | help: consider using a reference instead: `&drop_struct.fancy`
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(platform_intrinsics)]
+
+extern "platform-intrinsic" {
+ fn simd_add<T>(a: T, b: T) -> T;
+}
+
+fn main() {
+ unsafe { simd_add(0, 1); } //~ ERROR E0511
+}
--- /dev/null
+error[E0511]: invalid monomorphization of `simd_add` intrinsic: expected SIMD input type, found non-SIMD `i32`
+ --> $DIR/E0511.rs:18:14
+ |
+18 | unsafe { simd_add(0, 1); } //~ ERROR E0511
+ | ^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+fn takes_u8(_: u8) {}
+
+fn main() {
+ unsafe { takes_u8(::std::mem::transmute(0u16)); } //~ ERROR E0512
+}
--- /dev/null
+error[E0512]: transmute called with types of different sizes
+ --> $DIR/E0512.rs:14:23
+ |
+14 | unsafe { takes_u8(::std::mem::transmute(0u16)); } //~ ERROR E0512
+ | ^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: source type: u16 (16 bits)
+ = note: target type: u8 (8 bits)
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ let x: typeof(92) = 92; //~ ERROR E0516
+ //~| reserved keyword
+}
--- /dev/null
+error[E0516]: `typeof` is a reserved keyword but unimplemented
+ --> $DIR/E0516.rs:12:12
+ |
+12 | let x: typeof(92) = 92; //~ ERROR E0516
+ | ^^^^^^^^^^ reserved keyword
+
+error: aborting due to previous error
+
--- /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.
+
+#[repr(C)] //~ ERROR: E0517
+type Foo = u8;
+
+#[repr(packed)] //~ ERROR: E0517
+enum Foo2 {Bar, Baz}
+
+#[repr(u8)] //~ ERROR: E0517
+struct Foo3 {bar: bool, baz: bool}
+
+#[repr(C)] //~ ERROR: E0517
+impl Foo3 {
+}
+
+fn main() {
+}
--- /dev/null
+error[E0517]: attribute should be applied to struct, enum or union
+ --> $DIR/E0517.rs:11:8
+ |
+11 | #[repr(C)] //~ ERROR: E0517
+ | ^
+12 | type Foo = u8;
+ | -------------- not a struct, enum or union
+
+error[E0517]: attribute should be applied to struct or union
+ --> $DIR/E0517.rs:14:8
+ |
+14 | #[repr(packed)] //~ ERROR: E0517
+ | ^^^^^^
+15 | enum Foo2 {Bar, Baz}
+ | -------------------- not a struct or union
+
+error[E0517]: attribute should be applied to enum
+ --> $DIR/E0517.rs:17:8
+ |
+17 | #[repr(u8)] //~ ERROR: E0517
+ | ^^
+18 | struct Foo3 {bar: bool, baz: bool}
+ | ---------------------------------- not an enum
+
+error[E0517]: attribute should be applied to struct, enum or union
+ --> $DIR/E0517.rs:20:8
+ |
+20 | #[repr(C)] //~ ERROR: E0517
+ | ^
+21 | / impl Foo3 {
+22 | | }
+ | |_- not a struct, enum or union
+
+error: aborting due to 4 previous errors
+
--- /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.
+
+#[inline(always)] //~ ERROR: E0518
+struct Foo;
+
+#[inline(never)] //~ ERROR: E0518
+impl Foo {
+}
+
+fn main() {
+}
--- /dev/null
+error[E0518]: attribute should be applied to function
+ --> $DIR/E0518.rs:11:1
+ |
+11 | #[inline(always)] //~ ERROR: E0518
+ | ^^^^^^^^^^^^^^^^^
+12 | struct Foo;
+ | ----------- not a function
+
+error[E0518]: attribute should be applied to function
+ --> $DIR/E0518.rs:14:1
+ |
+14 | #[inline(never)] //~ ERROR: E0518
+ | ^^^^^^^^^^^^^^^^
+15 | / impl Foo {
+16 | | }
+ | |_- not a function
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+#![feature(specialization)]
+
+trait SpaceLlama {
+ fn fly(&self);
+}
+
+impl<T> SpaceLlama for T {
+ default fn fly(&self) {}
+}
+
+impl<T: Clone> SpaceLlama for T {
+ fn fly(&self) {}
+}
+
+impl SpaceLlama for i32 {
+ default fn fly(&self) {}
+ //~^ ERROR E0520
+}
+
+fn main() {
+}
--- /dev/null
+error[E0520]: `fly` specializes an item from a parent `impl`, but that item is not marked `default`
+ --> $DIR/E0520.rs:26:5
+ |
+21 | / impl<T: Clone> SpaceLlama for T {
+22 | | fn fly(&self) {}
+23 | | }
+ | |_- parent `impl` is here
+...
+26 | default fn fly(&self) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ cannot specialize default item `fly`
+ |
+ = note: to specialize, `fly` in the parent `impl` must be marked `default`
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(lang_items)]
+
+#[lang = "cookie"]
+fn cookie() -> ! {
+//~^^ ERROR definition of an unknown language item: `cookie` [E0522]
+ loop {}
+}
--- /dev/null
+error[E0601]: main function not found
+
+error[E0522]: definition of an unknown language item: `cookie`
+ --> $DIR/E0522.rs:13:1
+ |
+13 | #[lang = "cookie"]
+ | ^^^^^^^^^^^^^^^^^^ definition of unknown language item `cookie`
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+#![feature(slice_patterns)]
+
+fn main() {
+ let r = &[1, 2, 3, 4];
+ match r {
+ &[a, b] => {
+ //~^ ERROR E0527
+ println!("a={}, b={}", a, b);
+ }
+ }
+}
--- /dev/null
+error[E0527]: pattern requires 2 elements but array has 4
+ --> $DIR/E0527.rs:16:10
+ |
+16 | &[a, b] => {
+ | ^^^^^^ expected 4 elements
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(slice_patterns)]
+
+fn main() {
+ let r = &[1, 2];
+ match r {
+ &[a, b, c, rest..] => {
+ //~^ ERROR E0528
+ }
+ }
+}
--- /dev/null
+error[E0528]: pattern requires at least 3 elements but array has 2
+ --> $DIR/E0528.rs:16:10
+ |
+16 | &[a, b, c, rest..] => {
+ | ^^^^^^^^^^^^^^^^^ pattern cannot match array of 2 elements
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(slice_patterns)]
+
+fn main() {
+ let r: f32 = 1.0;
+ match r {
+ [a, b] => {
+ //~^ ERROR E0529
+ }
+ }
+}
--- /dev/null
+error[E0529]: expected an array or slice, found `f32`
+ --> $DIR/E0529.rs:16:9
+ |
+16 | [a, b] => {
+ | ^^^^^^ pattern cannot match with input type `f32`
+
+error: aborting due to previous error
+
--- /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.
+
+fn main() {
+ static TEST: i32 = 0;
+
+ let r: (i32, i32) = (0, 0);
+ match r {
+ TEST => {} //~ ERROR E0530
+ }
+}
--- /dev/null
+error[E0530]: match bindings cannot shadow statics
+ --> $DIR/E0530.rs:16:9
+ |
+12 | static TEST: i32 = 0;
+ | --------------------- a static `TEST` is defined here
+...
+16 | TEST => {} //~ ERROR E0530
+ | ^^^^ cannot be named the same as a static
+
+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.
+
+fn main() {
+ let value = 1;
+
+ match SomeStruct(value) {
+ StructConst1(_) => { },
+ //~^ ERROR expected tuple struct/variant, found constant `StructConst1`
+ _ => { },
+ }
+
+ struct SomeStruct(u8);
+
+ const StructConst1 : SomeStruct = SomeStruct(1);
+ const StructConst2 : SomeStruct = SomeStruct(2);
+}
--- /dev/null
+error[E0532]: expected tuple struct/variant, found constant `StructConst1`
+ --> $DIR/E0532.rs:15:9
+ |
+15 | StructConst1(_) => { },
+ | ^^^^^^^^^^^^ not a tuple struct/variant
+
+error: aborting due to previous error
+
--- /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.
+
+#[inline()] //~ ERROR E0534
+pub fn something() {}
+
+fn main() {
+ something();
+}
--- /dev/null
+error[E0534]: expected one argument
+ --> $DIR/E0534.rs:11:1
+ |
+11 | #[inline()] //~ ERROR E0534
+ | ^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#[export_name]
+//~^ ERROR E0558
+
+pub fn something() {}
+
+fn main() {}
--- /dev/null
+error[E0558]: export_name attribute has invalid format
+ --> $DIR/E0558.rs:11:1
+ |
+11 | #[export_name]
+ | ^^^^^^^^^^^^^^ did you mean #[export_name="*"]?
+
+error: aborting due to previous error
+
--- /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.
+
+enum Field {
+ Fool { x: u32 },
+}
+
+fn main() {
+ let s = Field::Fool { joke: 0 };
+ //~^ ERROR E0559
+}
--- /dev/null
+error[E0559]: variant `Field::Fool` has no field named `joke`
+ --> $DIR/E0559.rs:16:27
+ |
+16 | let s = Field::Fool { joke: 0 };
+ | ^^^^^ `Field::Fool` does not have this field
+ |
+ = note: available fields are: `x`
+
+error: aborting due to previous error
+
--- /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.
+
+struct Simba {
+ mother: u32,
+}
+
+fn main() {
+ let s = Simba { mother: 1, father: 0 };
+ //~^ ERROR E0560
+}
--- /dev/null
+error[E0560]: struct `Simba` has no field named `father`
+ --> $DIR/E0560.rs:16:32
+ |
+16 | let s = Simba { mother: 1, father: 0 };
+ | ^^^^^^^ `Simba` does not have this field
+ |
+ = note: available fields are: `mother`
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(attr_literals)]
+
+// deprecated doesn't currently support literals
+#[deprecated("since")] //~ ERROR E0565
+fn f() { }
+
+fn main() { }
--- /dev/null
+error[E0565]: unsupported literal
+ --> $DIR/E0565-1.rs:14:14
+ |
+14 | #[deprecated("since")] //~ ERROR E0565
+ | ^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+#![feature(attr_literals)]
+
+// repr currently doesn't support literals
+#[repr("C")] //~ ERROR E0565
+struct A { }
+
+fn main() { }
--- /dev/null
+error[E0565]: unsupported literal
+ --> $DIR/E0565.rs:14:8
+ |
+14 | #[repr("C")] //~ ERROR E0565
+ | ^^^
+
+error: aborting due to previous error
+
--- /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.
+
+const FOO: u32 = return 0; //~ ERROR E0572
+
+fn main() {}
--- /dev/null
+error[E0572]: return statement outside of function body
+ --> $DIR/E0572.rs:11:18
+ |
+11 | const FOO: u32 = return 0; //~ ERROR E0572
+ | ^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+// This test was derived from the wasm and parsell crates. They
+// stopped compiling when #32330 is fixed.
+
+#![allow(dead_code, unused_variables)]
+
+use std::str::Chars;
+
+pub trait HasOutput<Ch, Str> {
+ type Output;
+}
+
+#[derive(Clone, PartialEq, Eq, Hash, Ord, PartialOrd, Debug)]
+pub enum Token<'a> {
+ Begin(&'a str)
+}
+
+fn mk_unexpected_char_err<'a>() -> Option<&'a i32> {
+ unimplemented!()
+}
+
+fn foo<'a>(data: &mut Chars<'a>) {
+ bar(mk_unexpected_char_err)
+}
+
+fn bar<F>(t: F)
+ // No type can satisfy this requirement, since `'a` does not
+ // appear in any of the input types:
+ where F: for<'a> Fn() -> Option<&'a i32>
+ //~^ ERROR E0582
+{
+}
+
+fn baz<F>(t: F)
+ // No type can satisfy this requirement, since `'a` does not
+ // appear in any of the input types:
+ where F: for<'a> Iterator<Item=&'a i32>
+ //~^ ERROR E0582
+{
+}
+
+fn main() {
+}
--- /dev/null
+error[E0582]: binding for associated type `Output` references lifetime `'a`, which does not appear in the trait input types
+ --> $DIR/E0582.rs:38:30
+ |
+38 | where F: for<'a> Fn() -> Option<&'a i32>
+ | ^^^^^^^^^^^^^^^
+
+error[E0582]: binding for associated type `Item` references lifetime `'a`, which does not appear in the trait input types
+ --> $DIR/E0582.rs:46:31
+ |
+46 | where F: for<'a> Iterator<Item=&'a i32>
+ | ^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn main() {
+ /// Hello! I'm useless...
+ //~^ ERROR E0585
+}
--- /dev/null
+error[E0585]: found a documentation comment that doesn't document anything
+ --> $DIR/E0585.rs:12:5
+ |
+12 | /// Hello! I'm useless...
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: doc comments must come before what they document, maybe a comment was intended with `//`?
+
+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.
+
+fn main() {
+ let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
+ let x = &tmp[1..=]; //~ ERROR E0586
+}
--- /dev/null
+error[E0586]: inclusive range with no end
+ --> $DIR/E0586.rs:13:22
+ |
+13 | let x = &tmp[1..=]; //~ ERROR E0586
+ | ^
+ |
+ = help: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
+
+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.
+
+struct Foo<'a> {
+ x: Option<&'a u32>,
+}
+
+fn main() {
+ let mut x = Foo { x: None };
+ let y = 0;
+ x.x = Some(&y);
+ //~^ `y` does not live long enough [E0597]
+}
--- /dev/null
+error[E0597]: `y` does not live long enough
+ --> $DIR/E0597.rs:18:17
+ |
+18 | x.x = Some(&y);
+ | ^ borrowed value does not live long enough
+19 | //~^ `y` does not live long enough [E0597]
+20 | }
+ | - `y` dropped here while still borrowed
+ |
+ = note: values in a scope are dropped in the opposite order they are created
+
+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.
+
+struct Foo;
+
+fn main() {
+ || if let Foo::NotEvenReal() = Foo {}; //~ ERROR E0599
+}
--- /dev/null
+error[E0599]: no associated item named `NotEvenReal` found for type `Foo` in the current scope
+ --> $DIR/E0599.rs:14:15
+ |
+11 | struct Foo;
+ | ----------- associated item `NotEvenReal` not found for this
+...
+14 | || if let Foo::NotEvenReal() = Foo {}; //~ ERROR E0599
+ | ^^^^^^^^^^^^^^^^^^ associated item not found in `Foo`
+
+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.
+
+fn main() {
+ !"a"; //~ ERROR E0600
+}
--- /dev/null
+error[E0600]: cannot apply unary operator `!` to type `&'static str`
+ --> $DIR/E0600.rs:12:5
+ |
+12 | !"a"; //~ ERROR E0600
+ | ^^^^
+
+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.
+
+// compile-flags:-D bogus
+
+// error-pattern:E0602
+// error-pattern:requested on the command line with `-D bogus`
+
+fn main() {}
--- /dev/null
+error[E0602]: unknown lint: `bogus`
+ |
+ = note: requested on the command line with `-D bogus`
+
+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.
+
+mod SomeModule {
+ const PRIVATE: u32 = 0x_a_bad_1dea_u32;
+}
+
+fn main() {
+ SomeModule::PRIVATE; //~ ERROR E0603
+}
--- /dev/null
+error[E0603]: constant `PRIVATE` is private
+ --> $DIR/E0603.rs:16:5
+ |
+16 | SomeModule::PRIVATE; //~ ERROR E0603
+ | ^^^^^^^^^^^^^^^^^^^
+
+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.
+
+fn main() {
+ 1u32 as char; //~ ERROR E0604
+}
--- /dev/null
+error[E0604]: only `u8` can be cast as `char`, not `u32`
+ --> $DIR/E0604.rs:12:5
+ |
+12 | 1u32 as char; //~ ERROR E0604
+ | ^^^^^^^^^^^^
+
+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.
+
+fn main() {
+ let x = 0u8;
+ x as Vec<u8>; //~ ERROR E0605
+
+ let v = 0 as *const u8;
+ v as &u8; //~ ERROR E0605
+}
--- /dev/null
+error[E0605]: non-primitive cast: `u8` as `std::vec::Vec<u8>`
+ --> $DIR/E0605.rs:13:5
+ |
+13 | x as Vec<u8>; //~ ERROR E0605
+ | ^^^^^^^^^^^^
+ |
+ = note: an `as` expression can only be used to convert between primitive types. Consider using the `From` trait
+
+error[E0605]: non-primitive cast: `*const u8` as `&u8`
+ --> $DIR/E0605.rs:16:5
+ |
+16 | v as &u8; //~ ERROR E0605
+ | ^^^^^^^^
+ |
+ = note: an `as` expression can only be used to convert between primitive types. Consider using the `From` trait
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn main() {
+ &0u8 as u8; //~ ERROR E0606
+}
--- /dev/null
+error[E0606]: casting `&u8` as `u8` is invalid
+ --> $DIR/E0606.rs:12:5
+ |
+12 | &0u8 as u8; //~ ERROR E0606
+ | ^^^^^^^^^^ cannot cast `&u8` as `u8`
+ |
+help: did you mean `*&0u8`?
+ --> $DIR/E0606.rs:12:5
+ |
+12 | &0u8 as u8; //~ ERROR E0606
+ | ^^^^
+
+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.
+
+fn main() {
+ let v = 0 as *const u8;
+ v as *const [u8]; //~ ERROR E0607
+}
--- /dev/null
+error[E0607]: cannot cast thin pointer `*const u8` to fat pointer `*const [u8]`
+ --> $DIR/E0607.rs:13:5
+ |
+13 | v as *const [u8]; //~ ERROR E0607
+ | ^^^^^^^^^^^^^^^^
+
+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.
+
+fn main() {
+ 0u8[2]; //~ ERROR E0608
+}
--- /dev/null
+error[E0608]: cannot index into a value of type `u8`
+ --> $DIR/E0608.rs:12:5
+ |
+12 | 0u8[2]; //~ ERROR E0608
+ | ^^^^^^
+
+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.
+
+struct Foo {
+ x: u32,
+}
+struct Bar;
+
+fn main() {
+ let x = Foo { x: 0 };
+ let _ = x.foo; //~ ERROR E0609
+
+ let y = Bar;
+ y.1; //~ ERROR E0609
+}
--- /dev/null
+error[E0609]: no field `foo` on type `Foo`
+ --> $DIR/E0609.rs:18:15
+ |
+18 | let _ = x.foo; //~ ERROR E0609
+ | ^^^ unknown field
+ |
+ = note: available fields are: `x`
+
+error[E0609]: no field `1` on type `Bar`
+ --> $DIR/E0609.rs:21:5
+ |
+21 | y.1; //~ ERROR E0609
+ | ^^^
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn main() {
+ let x = 0;
+ let _ = x.foo; //~ ERROR E0610
+}
--- /dev/null
+error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields
+ --> $DIR/E0610.rs:13:15
+ |
+13 | let _ = x.foo; //~ ERROR E0610
+ | ^^^
+
+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.
+
+mod a {
+ pub struct Foo(u32);
+
+ impl Foo {
+ pub fn new() -> Foo { Foo(0) }
+ }
+}
+
+fn main() {
+ let y = a::Foo::new();
+ y.0; //~ ERROR E0611
+}
--- /dev/null
+error[E0611]: field `0` of tuple-struct `a::Foo` is private
+ --> $DIR/E0611.rs:21:4
+ |
+21 | y.0; //~ ERROR E0611
+ | ^^^
+
+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.
+
+struct Foo(u32);
+
+fn main() {
+ let y = Foo(0);
+ y.1; //~ ERROR E0612
+}
--- /dev/null
+error[E0612]: attempted out-of-bounds tuple index `1` on type `Foo`
+ --> $DIR/E0612.rs:15:4
+ |
+15 | y.1; //~ ERROR E0612
+ | ^^^
+
+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.
+
+fn main() {
+ let y = 0u32;
+ *y; //~ ERROR E0614
+}
--- /dev/null
+error[E0614]: type `u32` cannot be dereferenced
+ --> $DIR/E0614.rs:13:5
+ |
+13 | *y; //~ ERROR E0614
+ | ^^
+
+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.
+
+struct Foo {
+ x: u32,
+}
+
+impl Foo {
+ fn method(&self) {}
+}
+
+fn main() {
+ let f = Foo { x: 0 };
+ f.method; //~ ERROR E0615
+}
--- /dev/null
+error[E0615]: attempted to take value of method `method` on type `Foo`
+ --> $DIR/E0615.rs:21:7
+ |
+21 | f.method; //~ ERROR E0615
+ | ^^^^^^
+ |
+ = help: maybe a `()` to call it is missing?
+
+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.
+
+mod a {
+ pub struct Foo {
+ x: u32,
+ }
+
+ impl Foo {
+ pub fn new() -> Foo { Foo { x: 0 } }
+ }
+}
+
+fn main() {
+ let f = a::Foo::new();
+ f.x; //~ ERROR E0616
+}
--- /dev/null
+error[E0616]: field `x` of struct `a::Foo` is private
+ --> $DIR/E0616.rs:23:5
+ |
+23 | f.x; //~ ERROR E0616
+ | ^^^
+
+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.
+
+// ignore-tidy-linelength
+
+extern {
+ fn printf(c: *const i8, ...);
+}
+
+fn main() {
+ unsafe {
+ printf(::std::ptr::null(), 0f32);
+ //~^ ERROR can't pass `f32` to variadic function
+ //~| HELP cast the value to `c_double`
+ printf(::std::ptr::null(), 0i8);
+ //~^ ERROR can't pass `i8` to variadic function
+ //~| HELP cast the value to `c_int`
+ printf(::std::ptr::null(), 0i16);
+ //~^ ERROR can't pass `i16` to variadic function
+ //~| HELP cast the value to `c_int`
+ printf(::std::ptr::null(), 0u8);
+ //~^ ERROR can't pass `u8` to variadic function
+ //~| HELP cast the value to `c_uint`
+ printf(::std::ptr::null(), 0u16);
+ //~^ ERROR can't pass `u16` to variadic function
+ //~| HELP cast the value to `c_uint`
+ printf(::std::ptr::null(), printf);
+ //~^ ERROR can't pass `unsafe extern "C" fn(*const i8, ...) {printf}` to variadic function
+ //~| HELP cast the value to `unsafe extern "C" fn(*const i8, ...)`
+ }
+}
--- /dev/null
+error[E0617]: can't pass `f32` to variadic function
+ --> $DIR/E0617.rs:19:36
+ |
+19 | printf(::std::ptr::null(), 0f32);
+ | ^^^^ help: cast the value to `c_double`: `0f32 as c_double`
+
+error[E0617]: can't pass `i8` to variadic function
+ --> $DIR/E0617.rs:22:36
+ |
+22 | printf(::std::ptr::null(), 0i8);
+ | ^^^ help: cast the value to `c_int`: `0i8 as c_int`
+
+error[E0617]: can't pass `i16` to variadic function
+ --> $DIR/E0617.rs:25:36
+ |
+25 | printf(::std::ptr::null(), 0i16);
+ | ^^^^ help: cast the value to `c_int`: `0i16 as c_int`
+
+error[E0617]: can't pass `u8` to variadic function
+ --> $DIR/E0617.rs:28:36
+ |
+28 | printf(::std::ptr::null(), 0u8);
+ | ^^^ help: cast the value to `c_uint`: `0u8 as c_uint`
+
+error[E0617]: can't pass `u16` to variadic function
+ --> $DIR/E0617.rs:31:36
+ |
+31 | printf(::std::ptr::null(), 0u16);
+ | ^^^^ help: cast the value to `c_uint`: `0u16 as c_uint`
+
+error[E0617]: can't pass `unsafe extern "C" fn(*const i8, ...) {printf}` to variadic function
+ --> $DIR/E0617.rs:34:36
+ |
+34 | printf(::std::ptr::null(), printf);
+ | ^^^^^^
+help: cast the value to `unsafe extern "C" fn(*const i8, ...)`
+ |
+34 | printf(::std::ptr::null(), printf as unsafe extern "C" fn(*const i8, ...));
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
+
--- /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.
+
+enum X {
+ Entry,
+}
+
+fn main() {
+ X::Entry();
+ //~^ ERROR expected function, found enum variant `X::Entry` [E0618]
+ let x = 0i32;
+ x();
+ //~^ ERROR expected function, found `i32` [E0618]
+}
--- /dev/null
+error[E0618]: expected function, found enum variant `X::Entry`
+ --> $DIR/E0618.rs:16:5
+ |
+12 | Entry,
+ | ----- `X::Entry` defined here
+...
+16 | X::Entry();
+ | ^^^^^^^^^^ not a function
+help: `X::Entry` is a unit variant, you need to write it without the parenthesis
+ |
+16 | X::Entry;
+ | ^^^^^^^^
+
+error[E0618]: expected function, found `i32`
+ --> $DIR/E0618.rs:19:5
+ |
+18 | let x = 0i32;
+ | - `i32` defined here
+19 | x();
+ | ^^^ not a function
+
+error: aborting due to 2 previous errors
+
--- /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.
+
+fn main() {
+ let x;
+
+ match x {
+ (..) => {} //~ ERROR E0619
+ _ => {}
+ }
+}
+
--- /dev/null
+error[E0619]: the type of this value must be known in this context
+ --> $DIR/E0619.rs:15:9
+ |
+15 | (..) => {} //~ ERROR E0619
+ | ^^^^
+
+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.
+
+fn main() {
+ let _foo = &[1_usize, 2] as [usize]; //~ ERROR E0620
+}
--- /dev/null
+error[E0620]: cast to unsized type: `&[usize; 2]` as `[usize]`
+ --> $DIR/E0620.rs:12:16
+ |
+12 | let _foo = &[1_usize, 2] as [usize]; //~ ERROR E0620
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+help: consider using an implicit coercion to `&[usize]` instead
+ --> $DIR/E0620.rs:12:16
+ |
+12 | let _foo = &[1_usize, 2] as [usize]; //~ ERROR E0620
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /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.
+
+// Test that we give the generic E0495 when one of the free regions is
+// bound in a closure (rather than suggesting a change to the signature
+// of the closure, which is not specified in `foo` but rather in `invoke`).
+
+// FIXME - This might be better as a UI test, but the finer details
+// of the error seem to vary on different machines.
+fn invoke<'a, F>(x: &'a i32, f: F) -> &'a i32
+where F: FnOnce(&'a i32, &i32) -> &'a i32
+{
+ let y = 22;
+ f(x, &y)
+}
+
+fn foo<'a>(x: &'a i32) {
+ invoke(&x, |a, b| if a > b { a } else { b }); //~ ERROR E0495
+}
+
+fn main() {}
--- /dev/null
+error[E0495]: cannot infer an appropriate lifetime for lifetime parameter `'a` due to conflicting requirements
+ --> $DIR/E0621-does-not-trigger-for-closures.rs:25:5
+ |
+25 | invoke(&x, |a, b| if a > b { a } else { b }); //~ ERROR E0495
+ | ^^^^^^
+ |
+note: first, the lifetime cannot outlive the anonymous lifetime #2 defined on the body at 25:16...
+ --> $DIR/E0621-does-not-trigger-for-closures.rs:25:16
+ |
+25 | invoke(&x, |a, b| if a > b { a } else { b }); //~ ERROR E0495
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...so that reference does not outlive borrowed content
+ --> $DIR/E0621-does-not-trigger-for-closures.rs:25:45
+ |
+25 | invoke(&x, |a, b| if a > b { a } else { b }); //~ ERROR E0495
+ | ^
+note: but, the lifetime must be valid for the call at 25:5...
+ --> $DIR/E0621-does-not-trigger-for-closures.rs:25:5
+ |
+25 | invoke(&x, |a, b| if a > b { a } else { b }); //~ ERROR E0495
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...so type `&i32` of expression is valid during the expression
+ --> $DIR/E0621-does-not-trigger-for-closures.rs:25:5
+ |
+25 | invoke(&x, |a, b| if a > b { a } else { b }); //~ ERROR E0495
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2015 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(intrinsics)]
+extern "rust-intrinsic" {
+ pub static breakpoint : unsafe extern "rust-intrinsic" fn();
+ //~^ ERROR intrinsic must be a function [E0622]
+}
+fn main() { unsafe { breakpoint(); } }
--- /dev/null
+error[E0622]: intrinsic must be a function
+ --> $DIR/E0622.rs:13:5
+ |
+13 | pub static breakpoint : unsafe extern "rust-intrinsic" fn();
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected a function
+
+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.
+
+mod inner {
+ pub struct Foo;
+
+ impl Foo {
+ fn method(&self) {}
+ }
+}
+
+fn main() {
+ let foo = inner::Foo;
+ foo.method(); //~ ERROR method `method` is private [E0624]
+}
--- /dev/null
+error[E0624]: method `method` is private
+ --> $DIR/E0624.rs:21:9
+ |
+21 | foo.method(); //~ ERROR method `method` is private [E0624]
+ | ^^^^^^
+
+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.
+#![feature(underscore_lifetimes)]
+
+struct Foo<'a: '_>(&'a u8); //~ ERROR invalid lifetime bound name: `'_`
+fn foo<'a: '_>(_: &'a u8) {} //~ ERROR invalid lifetime bound name: `'_`
+
+struct Bar<'a>(&'a u8);
+impl<'a: '_> Bar<'a> { //~ ERROR invalid lifetime bound name: `'_`
+ fn bar() {}
+}
+
+fn main() {}
--- /dev/null
+error[E0637]: invalid lifetime bound name: `'_`
+ --> $DIR/E0637.rs:12:16
+ |
+12 | struct Foo<'a: '_>(&'a u8); //~ ERROR invalid lifetime bound name: `'_`
+ | ^^ `'_` is a reserved lifetime name
+
+error[E0637]: invalid lifetime bound name: `'_`
+ --> $DIR/E0637.rs:13:12
+ |
+13 | fn foo<'a: '_>(_: &'a u8) {} //~ ERROR invalid lifetime bound name: `'_`
+ | ^^ `'_` is a reserved lifetime name
+
+error[E0637]: invalid lifetime bound name: `'_`
+ --> $DIR/E0637.rs:16:10
+ |
+16 | impl<'a: '_> Bar<'a> { //~ ERROR invalid lifetime bound name: `'_`
+ | ^^ `'_` is a reserved lifetime name
+
+error: aborting due to 3 previous errors
+
--- /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.
+#![allow(warnings)]
+#![feature(conservative_impl_trait, nested_impl_trait)]
+
+trait Id<T> {}
+trait Lt<'a> {}
+
+impl<'a> Lt<'a> for () {}
+impl<T> Id<T> for T {}
+
+fn free_fn_capture_hrtb_in_impl_trait()
+ -> impl for<'a> Id<impl Lt<'a>>
+ //~^ ERROR `impl Trait` can only capture lifetimes bound at the fn or impl level [E0657]
+{
+ ()
+}
+
+struct Foo;
+impl Foo {
+ fn impl_fn_capture_hrtb_in_impl_trait()
+ -> impl for<'a> Id<impl Lt<'a>>
+ //~^ ERROR `impl Trait` can only capture lifetimes bound at the fn or impl level
+ {
+ ()
+ }
+}
+
+fn main() {}
--- /dev/null
+error[E0657]: `impl Trait` can only capture lifetimes bound at the fn or impl level
+ --> $DIR/E0657.rs:20:32
+ |
+20 | -> impl for<'a> Id<impl Lt<'a>>
+ | ^^
+
+error[E0657]: `impl Trait` can only capture lifetimes bound at the fn or impl level
+ --> $DIR/E0657.rs:29:36
+ |
+29 | -> impl for<'a> Id<impl Lt<'a>>
+ | ^^
+
+error: aborting due to 2 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.
+
+fn main() {
+ let _ = ::std::u128::MAX; //~ ERROR E0658
+}
--- /dev/null
+error[E0658]: use of unstable library feature 'i128' (see issue #35118)
+ --> $DIR/E0658.rs:12:13
+ |
+12 | let _ = ::std::u128::MAX; //~ ERROR E0658
+ | ^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(i128)] to the crate attributes to enable
+
+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.
+
+mod moon {
+ pub fn foo() {}
+}
+
+mod earth {
+ pub fn foo() {}
+}
+
+mod collider {
+ pub use moon::*;
+ pub use earth::*;
+}
+
+fn main() {
+ collider::foo(); //~ ERROR E0659
+}
--- /dev/null
+error[E0659]: `foo` is ambiguous
+ --> $DIR/E0659.rs:25:5
+ |
+25 | collider::foo(); //~ ERROR E0659
+ | ^^^^^^^^^^^^^
+ |
+note: `foo` could refer to the name imported here
+ --> $DIR/E0659.rs:20:13
+ |
+20 | pub use moon::*;
+ | ^^^^^^^
+note: `foo` could also refer to the name imported here
+ --> $DIR/E0659.rs:21:13
+ |
+21 | pub use earth::*;
+ | ^^^^^^^^
+ = note: consider adding an explicit import of `foo` to disambiguate
+
+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.
+
+// Test that `?` macro Kleene operator can not be used when the `macro_at_most_once_rep` feature
+// gate is not used.
+
+macro_rules! m { ($(a)?) => {} }
+//~^ ERROR Using the `?` macro Kleene operator for "at most one" repetition is unstable
+
+fn main() {
+ m!();
+}
--- /dev/null
+error[E0658]: Using the `?` macro Kleene operator for "at most one" repetition is unstable (see issue #48075)
+ --> $DIR/feature-gate-macro_at_most_once_rep.rs:14:20
+ |
+14 | macro_rules! m { ($(a)?) => {} }
+ | ^^^
+ |
+ = help: add #![feature(macro_at_most_once_rep)] to the crate attributes to enable
+
+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.
+
+extern "C" fn foo(x: u8, ...);
+//~^ ERROR only foreign functions are allowed to be variadic
+//~| ERROR expected one of `->`, `where`, or `{`, found `;`
--- /dev/null
+error: only foreign functions are allowed to be variadic
+ --> $DIR/invalid-variadic-function.rs:11:26
+ |
+11 | extern "C" fn foo(x: u8, ...);
+ | ^^^
+
+error: expected one of `->`, `where`, or `{`, found `;`
+ --> $DIR/invalid-variadic-function.rs:11:30
+ |
+11 | extern "C" fn foo(x: u8, ...);
+ | ^ expected one of `->`, `where`, or `{` here
+
+error: aborting due to 2 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.
+
+use std::marker::PhantomData;
+
+struct AssertSync<T: Sync>(PhantomData<T>);
+
+pub struct Foo {
+ bar: *const Bar,
+ phantom: PhantomData<Bar>,
+}
+
+pub struct Bar {
+ foo: *const Foo,
+ phantom: PhantomData<Foo>,
+}
+
+fn main() {
+ let _: AssertSync<Foo> = unimplemented!(); //~ ERROR E0275
+}
--- /dev/null
+error[E0275]: overflow evaluating the requirement `Foo: std::marker::Sync`
+ --> $DIR/recursive-requirements.rs:26:12
+ |
+26 | let _: AssertSync<Foo> = unimplemented!(); //~ ERROR E0275
+ | ^^^^^^^^^^^^^^^
+ |
+ = help: consider adding a `#![recursion_limit="128"]` attribute to your crate
+ = note: required because it appears within the type `std::marker::PhantomData<Foo>`
+ = note: required because it appears within the type `Bar`
+ = note: required because it appears within the type `std::marker::PhantomData<Bar>`
+ = note: required because it appears within the type `Foo`
+
+error: aborting due to previous error
+
fds[0].events = libc::POLLIN;
fds[1].fd = err_pipe.as_raw_fd();
fds[1].events = libc::POLLIN;
- loop {
+ let mut nfds = 2;
+ let mut errfd = 1;
+
+ while nfds > 0 {
// wait for either pipe to become readable using `select`
- let r = unsafe { libc::poll(fds.as_mut_ptr(), 2, -1) };
+ let r = unsafe { libc::poll(fds.as_mut_ptr(), nfds, -1) };
if r == -1 {
let err = io::Error::last_os_error();
if err.kind() == io::ErrorKind::Interrupted {
}
}
};
- if !out_done && fds[0].revents != 0 && handle(out_pipe.read_to_end(&mut out))? {
- out_done = true;
- }
- data(true, &mut out, out_done);
- if !err_done && fds[1].revents != 0 && handle(err_pipe.read_to_end(&mut err))? {
+ if !err_done && fds[errfd].revents != 0 && handle(err_pipe.read_to_end(&mut err))? {
err_done = true;
+ nfds -= 1;
}
data(false, &mut err, err_done);
-
- if out_done && err_done {
- return Ok(())
+ if !out_done && fds[0].revents != 0 && handle(out_pipe.read_to_end(&mut out))? {
+ out_done = true;
+ fds[0].fd = err_pipe.as_raw_fd();
+ errfd = 0;
+ nfds -= 1;
}
+ data(true, &mut out, out_done);
}
+ Ok(())
}
}
fn run_cfail_test(&self) {
let proc_res = self.compile_test();
self.check_if_test_should_compile(&proc_res);
+ self.check_no_compiler_crash(&proc_res);
let output_to_check = self.get_output(&proc_res);
let expected_errors = errors::load_errors(&self.testpaths.file, self.revision);
self.check_error_patterns(&output_to_check, &proc_res);
}
- self.check_no_compiler_crash(&proc_res);
self.check_forbid_output(&output_to_check, &proc_res);
}
fn exec_compiled_test(&self) -> ProcRes {
let env = &self.props.exec_env;
- match &*self.config.target {
+ let proc_res = match &*self.config.target {
// This is pretty similar to below, we're transforming:
//
// program arg1 arg2
None,
)
}
+ };
+
+ if proc_res.status.success() {
+ // delete the executable after running it to save space.
+ // it is ok if the deletion failed.
+ let _ = fs::remove_file(self.make_exe_name());
}
+
+ proc_res
}
/// For each `aux-build: foo/bar` annotation, we check to find the
-Subproject commit dee42bda8156a28ead609080e27b02173bb9c29e
+Subproject commit f01491115e821e10217574ad4091b08015b7b1c8
"fuchsia-zircon", // BSD-3-Clause, rustdoc, rustc, cargo (jobserver & tempdir)
"cssparser-macros", // MPL-2.0, rustdoc
"selectors", // MPL-2.0, rustdoc
+ "clippy_lints", // MPL-2.0 rls
];
pub fn check(path: &Path, bad: &mut bool) {
projects / rust.git / commitdiff