user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #68831 - Dylan-DPC:rollup-j6x15y9, r=Dylan-DPC

Browse source 
Rollup of 7 pull requests

Successful merges:

 - #68282 (Instrument C / C++ in MemorySanitizer example)
 - #68758 (Fix 59191 - ICE when macro replaces crate root with non-module item)
 - #68805 (bootstrap: fix clippy warnings)
 - #68810 (Remove Copy impl from OnceWith)
 - #68815 (remove redundant imports (clippy::single_component_path_imports))
 - #68818 (fix couple of perf related clippy warnings)
 - #68819 (Suggest `split_at_mut` on multiple mutable index access)

Failed merges:

r? @ghost
This commit is contained in:
bors 2020-02-05 03:20:43 +00:00
commit 4ff8fb9cb2
52 changed files with 156 additions and 114 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/bootstrap/bin/rustc.rs
View file

@ -47,7 +47,7 @@ fn main() {
};
let stage = env::var("RUSTC_STAGE").expect("RUSTC_STAGE was not set");
let sysroot = env::var_os("RUSTC_SYSROOT").expect("RUSTC_SYSROOT was not set");
let on_fail = env::var_os("RUSTC_ON_FAIL").map(|of| Command::new(of));
let on_fail = env::var_os("RUSTC_ON_FAIL").map(Command::new);
let rustc = env::var_os(rustc).unwrap_or_else(|| panic!("{:?} was not set", rustc));
let libdir = env::var_os(libdir).unwrap_or_else(|| panic!("{:?} was not set", libdir));
@ -64,7 +64,7 @@ fn main() {
if let Some(crate_name) = crate_name {
if let Some(target) = env::var_os("RUSTC_TIME") {
if target == "all"
|| target.into_string().unwrap().split(",").any(|c| c.trim() == crate_name)
|| target.into_string().unwrap().split(',').any(|c| c.trim() == crate_name)
{
cmd.arg("-Ztime");
}
@ -189,7 +189,7 @@ fn main() {
crate_name,
is_test,
dur.as_secs(),
dur.subsec_nanos() / 1_000_000
dur.subsec_millis()
);
match status.code() {

2
src/bootstrap/bin/rustdoc.rs
View file

@ -61,7 +61,7 @@ fn main() {
}
// Needed to be able to run all rustdoc tests.
if let Some(_) = env::var_os("RUSTDOC_GENERATE_REDIRECT_PAGES") {
if env::var_os("RUSTDOC_GENERATE_REDIRECT_PAGES").is_some() {
// This "unstable-options" can be removed when `--generate-redirect-pages` is stabilized
if !has_unstable {
cmd.arg("-Z").arg("unstable-options");

24
src/bootstrap/builder.rs
View file

@ -510,7 +510,7 @@ impl<'a> Builder<'a> {
Subcommand::Format { .. } | Subcommand::Clean { .. } => panic!(),
};
let builder = Builder {
Builder {
build,
top_stage: build.config.stage.unwrap_or(2),
kind,
@ -518,9 +518,7 @@ impl<'a> Builder<'a> {
stack: RefCell::new(Vec::new()),
time_spent_on_dependencies: Cell::new(Duration::new(0, 0)),
paths: paths.to_owned(),
};
builder
}
}
pub fn execute_cli(&self) {
@ -753,13 +751,12 @@ impl<'a> Builder<'a> {
cargo.env("RUST_CHECK", "1");
}
let stage;
if compiler.stage == 0 && self.local_rebuild {
let stage = if compiler.stage == 0 && self.local_rebuild {
// Assume the local-rebuild rustc already has stage1 features.
stage = 1;
1
} else {
stage = compiler.stage;
}
compiler.stage
};
let mut rustflags = Rustflags::new(&target);
if stage != 0 {
@ -1252,12 +1249,7 @@ impl<'a> Builder<'a> {
};
if self.config.print_step_timings && dur > Duration::from_millis(100) {
println!(
"[TIMING] {:?} -- {}.{:03}",
step,
dur.as_secs(),
dur.subsec_nanos() / 1_000_000
);
println!("[TIMING] {:?} -- {}.{:03}", step, dur.as_secs(), dur.subsec_millis());
}
{
@ -1302,7 +1294,7 @@ impl Rustflags {
fn arg(&mut self, arg: &str) -> &mut Self {
assert_eq!(arg.split_whitespace().count(), 1);
if self.0.len() > 0 {
if !self.0.is_empty() {
self.0.push_str(" ");
}
self.0.push_str(arg);

1
src/bootstrap/builder/tests.rs
View file

@ -19,7 +19,6 @@ fn configure(host: &[&str], target: &[&str]) -> Config {
config.out = dir;
config.build = INTERNER.intern_str("A");
config.hosts = vec![config.build]
.clone()
.into_iter()
.chain(host.iter().map(|s| INTERNER.intern_str(s)))
.collect::<Vec<_>>();

20
src/bootstrap/compile.rs
View file

@ -18,7 +18,6 @@ use std::str;
use build_helper::{output, t, up_to_date};
use filetime::FileTime;
use serde::Deserialize;
use serde_json;
use crate::builder::Cargo;
use crate::dist;
@ -149,7 +148,8 @@ fn copy_third_party_objects(
// which is provided by std for this target.
if target == "x86_64-fortanix-unknown-sgx" {
let src_path_env = "X86_FORTANIX_SGX_LIBS";
let src = env::var(src_path_env).expect(&format!("{} not found in env", src_path_env));
let src =
env::var(src_path_env).unwrap_or_else(|_| panic!("{} not found in env", src_path_env));
copy_and_stamp(Path::new(&src), "libunwind.a");
}
@ -361,7 +361,7 @@ impl Step for StartupObjects {
);
}
let target = sysroot_dir.join(file.to_string() + ".o");
let target = sysroot_dir.join((*file).to_string() + ".o");
builder.copy(dst_file, &target);
target_deps.push(target);
}
@ -515,7 +515,7 @@ pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Cargo, target: Interne
.env("CFG_VERSION", builder.rust_version())
.env("CFG_PREFIX", builder.config.prefix.clone().unwrap_or_default());
let libdir_relative = builder.config.libdir_relative().unwrap_or(Path::new("lib"));
let libdir_relative = builder.config.libdir_relative().unwrap_or_else(|| Path::new("lib"));
cargo.env("CFG_LIBDIR_RELATIVE", libdir_relative);
if let Some(ref ver_date) = builder.rust_info.commit_date() {
@ -843,11 +843,11 @@ pub fn run_cargo(
};
for filename in filenames {
// Skip files like executables
if !filename.ends_with(".rlib")
&& !filename.ends_with(".lib")
&& !filename.ends_with(".a")
&& !is_dylib(&filename)
&& !(is_check && filename.ends_with(".rmeta"))
if !(filename.ends_with(".rlib")
|| filename.ends_with(".lib")
|| filename.ends_with(".a")
|| is_dylib(&filename)
|| (is_check && filename.ends_with(".rmeta")))
{
continue;
}
@ -905,7 +905,7 @@ pub fn run_cargo(
for (prefix, extension, expected_len) in toplevel {
let candidates = contents.iter().filter(|&&(_, ref filename, ref meta)| {
filename.starts_with(&prefix[..])
&& filename[prefix.len()..].starts_with("-")
&& filename[prefix.len()..].starts_with('-')
&& filename.ends_with(&extension[..])
&& meta.len() == expected_len
});

7
src/bootstrap/config.rs
View file

@ -16,7 +16,6 @@ use crate::flags::Flags;
pub use crate::flags::Subcommand;
use build_helper::t;
use serde::Deserialize;
use toml;
/// Global configuration for the entire build and/or bootstrap.
///
@ -440,7 +439,7 @@ impl Config {
}
}
})
.unwrap_or_else(|| TomlConfig::default());
.unwrap_or_else(TomlConfig::default);
let build = toml.build.clone().unwrap_or_default();
// set by bootstrap.py
@ -539,7 +538,7 @@ impl Config {
config.llvm_ldflags = llvm.ldflags.clone();
set(&mut config.llvm_use_libcxx, llvm.use_libcxx);
config.llvm_use_linker = llvm.use_linker.clone();
config.llvm_allow_old_toolchain = llvm.allow_old_toolchain.clone();
config.llvm_allow_old_toolchain = llvm.allow_old_toolchain;
}
if let Some(ref rust) = toml.rust {
@ -606,7 +605,7 @@ impl Config {
target.ar = cfg.ar.clone().map(PathBuf::from);
target.ranlib = cfg.ranlib.clone().map(PathBuf::from);
target.linker = cfg.linker.clone().map(PathBuf::from);
target.crt_static = cfg.crt_static.clone();
target.crt_static = cfg.crt_static;
target.musl_root = cfg.musl_root.clone().map(PathBuf::from);
target.wasi_root = cfg.wasi_root.clone().map(PathBuf::from);
target.qemu_rootfs = cfg.qemu_rootfs.clone().map(PathBuf::from);

4
src/bootstrap/dist.rs
View file

@ -828,7 +828,7 @@ impl Step for Analysis {
assert!(builder.config.extended);
let name = pkgname(builder, "rust-analysis");
if &compiler.host != builder.config.build {
if compiler.host != builder.config.build {
return distdir(builder).join(format!("{}-{}.tar.gz", name, target));
}
@ -877,7 +877,7 @@ fn copy_src_dirs(builder: &Builder<'_>, src_dirs: &[&str], exclude_dirs: &[&str]
Some(path) => path,
None => return false,
};
if spath.ends_with("~") || spath.ends_with(".pyc") {
if spath.ends_with('~') || spath.ends_with(".pyc") {
return false;
}

2
src/bootstrap/doc.rs
View file

@ -560,7 +560,7 @@ impl Step for Rustdoc {
builder.ensure(Rustc { stage, target });
// Build rustdoc.
builder.ensure(tool::Rustdoc { compiler: compiler });
builder.ensure(tool::Rustdoc { compiler });
// Symlink compiler docs to the output directory of rustdoc documentation.
let out_dir = builder.stage_out(compiler, Mode::ToolRustc).join(target).join("doc");

2
src/bootstrap/flags.rs
View file

@ -571,7 +571,7 @@ fn split(s: &[String]) -> Vec<String> {
}
fn parse_deny_warnings(matches: &getopts::Matches) -> Option<bool> {
match matches.opt_str("warnings").as_ref().map(|v| v.as_str()) {
match matches.opt_str("warnings").as_deref() {
Some("deny") => Some(true),
Some("warn") => Some(false),
Some(value) => {

5
src/bootstrap/install.rs
View file

@ -126,9 +126,8 @@ fn add_destdir(path: &Path, destdir: &Option<PathBuf>) -> PathBuf {
None => return path.to_path_buf(),
};
for part in path.components() {
match part {
Component::Normal(s) => ret.push(s),
_ => {}
if let Component::Normal(s) = part {
ret.push(s)
}
}
ret

4
src/bootstrap/lib.rs
View file

@ -444,7 +444,7 @@ impl Build {
builder.execute_cli();
} else {
let builder = builder::Builder::new(&self);
let _ = builder.execute_cli();
builder.execute_cli();
}
// Check for postponed failures from `test --no-fail-fast`.
@ -839,7 +839,7 @@ impl Build {
.target_config
.get(&target)
.and_then(|t| t.musl_root.as_ref())
.or(self.config.musl_root.as_ref())
.or_else(|| self.config.musl_root.as_ref())
.map(|p| &**p)
}

1
src/bootstrap/metadata.rs
View file

@ -5,7 +5,6 @@ use std::process::Command;
use build_helper::output;
use serde::Deserialize;
use serde_json;
use crate::cache::INTERNER;
use crate::{Build, Crate};

4
src/bootstrap/native.rs
View file

@ -15,8 +15,6 @@ use std::path::{Path, PathBuf};
use std::process::Command;
use build_helper::{output, t};
use cc;
use cmake;
use crate::builder::{Builder, RunConfig, ShouldRun, Step};
use crate::cache::Interned;
@ -205,7 +203,7 @@ impl Step for Llvm {
cfg.define("LLVM_ENABLE_LIBXML2", "OFF");
}
if enabled_llvm_projects.len() > 0 {
if !enabled_llvm_projects.is_empty() {
enabled_llvm_projects.sort();
enabled_llvm_projects.dedup();
cfg.define("LLVM_ENABLE_PROJECTS", enabled_llvm_projects.join(";"));

9
src/bootstrap/test.rs
View file

@ -1424,13 +1424,10 @@ impl Step for ErrorIndex {
}
fn markdown_test(builder: &Builder<'_>, compiler: Compiler, markdown: &Path) -> bool {
match fs::read_to_string(markdown) {
Ok(contents) => {
if !contents.contains("```") {
return true;
}
if let Ok(contents) = fs::read_to_string(markdown) {
if !contents.contains("```") {
return true;
}
Err(_) => {}
}
builder.info(&format!("doc tests for: {}", markdown.display()));

2
src/bootstrap/tool.rs
View file

@ -234,7 +234,7 @@ pub fn prepare_tool_cargo(
cargo.env("RUSTC_EXTERNAL_TOOL", "1");
}
let mut features = extra_features.iter().cloned().collect::<Vec<_>>();
let mut features = extra_features.to_vec();
if builder.build.config.cargo_native_static {
if path.ends_with("cargo")
|| path.ends_with("rls")

2
src/bootstrap/toolstate.rs
View file

@ -124,7 +124,7 @@ fn check_changed_files(toolstates: &HashMap<Box<str>, ToolState>) {
let output = t!(String::from_utf8(output.stdout));
for (tool, submodule) in STABLE_TOOLS.iter().chain(NIGHTLY_TOOLS.iter()) {
let changed = output.lines().any(|l| l.starts_with("M") && l.ends_with(submodule));
let changed = output.lines().any(|l| l.starts_with('M') && l.ends_with(submodule));
eprintln!("Verifying status of {}...", tool);
if !changed {
continue;

2
src/bootstrap/util.rs
View file

@ -98,7 +98,7 @@ impl Drop for TimeIt {
fn drop(&mut self) {
let time = self.1.elapsed();
if !self.0 {
println!("\tfinished in {}.{:03}", time.as_secs(), time.subsec_nanos() / 1_000_000);
println!("\tfinished in {}.{:03}", time.as_secs(), time.subsec_millis());
}
}
}

12
src/doc/unstable-book/src/compiler-flags/sanitizer.md
View file

@ -170,7 +170,7 @@ Shadow byte legend (one shadow byte represents 8 application bytes):
## MemorySanitizer
Use of uninitialized memory. Note that we are using `-Zbuild-std` to instrument
standard library, and passing `-msan-track-origins=2` to the LLVM to track
the standard library, and passing `-Zsanitizer-track-origins` to track the
origins of uninitialized memory:
```shell
@ -185,7 +185,15 @@ fn main() {
}
}
$ env RUSTFLAGS="-Zsanitizer=memory -Cllvm-args=-msan-track-origins=2" cargo -Zbuild-std run --target x86_64-unknown-linux-gnu
$ export \
CC=clang \
CXX=clang++ \
CFLAGS='-fsanitize=memory -fsanitize-memory-track-origins' \
CXXFLAGS='-fsanitize=memory -fsanitize-memory-track-origins' \
RUSTFLAGS='-Zsanitizer=memory -Zsanitizer-memory-track-origins' \
RUSTDOCFLAGS='-Zsanitizer=memory -Zsanitizer-memory-track-origins'
$ cargo clean
$ cargo -Zbuild-std run --target x86_64-unknown-linux-gnu
==9416==WARNING: MemorySanitizer: use-of-uninitialized-value
#0 0x560c04f7488a in core::fmt::num::imp::fmt_u64::haa293b0b098501ca $RUST/build/x86_64-unknown-linux-gnu/stage1/lib/rustlib/src/rust/src/libcore/fmt/num.rs:202:16
...

2
src/libcore/iter/sources.rs
View file

@ -398,7 +398,7 @@ pub fn once<T>(value: T) -> Once<T> {
/// See its documentation for more.
///
/// [`once_with`]: fn.once_with.html
#[derive(Copy, Clone, Debug)]
#[derive(Clone, Debug)]
#[stable(feature = "iter_once_with", since = "1.43.0")]
pub struct OnceWith<F> {
gen: Option<F>,

1
src/librustc/traits/mod.rs
View file

@ -31,7 +31,6 @@ use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
use crate::ty::subst::{InternalSubsts, SubstsRef};
use crate::ty::{self, AdtKind, GenericParamDefKind, List, ToPredicate, Ty, TyCtxt, WithConstness};
use crate::util::common::ErrorReported;
use chalk_engine;
use rustc_hir as hir;
use rustc_hir::def_id::DefId;
use rustc_macros::HashStable;

1
src/librustc/traits/structural_impls.rs
View file

@ -2,7 +2,6 @@ use crate::traits;
use crate::traits::project::Normalized;
use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
use crate::ty::{self, Lift, Ty, TyCtxt};
use chalk_engine;
use rustc_span::symbol::Symbol;
use smallvec::SmallVec;

3
src/librustc/ty/mod.rs
View file

@ -46,7 +46,6 @@ use rustc_target::abi::Align;
use syntax::ast::{self, Constness, Ident, Name};
use syntax::node_id::{NodeId, NodeMap, NodeSet};
use smallvec;
use std::cell::RefCell;
use std::cmp::{self, Ordering};
use std::fmt;
@ -1348,7 +1347,7 @@ pub trait ToPredicate<'tcx> {
impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<TraitRef<'tcx>> {
fn to_predicate(&self) -> Predicate<'tcx> {
ty::Predicate::Trait(
ty::Binder::dummy(ty::TraitPredicate { trait_ref: self.value.clone() }),
ty::Binder::dummy(ty::TraitPredicate { trait_ref: self.value }),
self.constness,
)
}

1
src/librustc_builtin_macros/log_syntax.rs
View file

@ -1,6 +1,5 @@
use rustc_ast_pretty::pprust;
use rustc_expand::base;
use rustc_span;
use syntax::tokenstream::TokenStream;
pub fn expand_log_syntax<'cx>(

12
src/librustc_expand/expand.rs
View file

@ -363,7 +363,17 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
krate.attrs = vec![];
krate.module = ast::Mod { inner: orig_mod_span, items: vec![], inline: true };
}
_ => unreachable!(),
Some(ast::Item { span, kind, .. }) => {
krate.attrs = vec![];
krate.module = ast::Mod { inner: orig_mod_span, items: vec![], inline: true };
self.cx.span_err(
span,
&format!(
"expected crate top-level item to be a module after macro expansion, found a {}",
kind.descriptive_variant()
),
);
}
};
self.cx.trace_macros_diag();
krate

3
src/librustc_incremental/persist/file_format.rs
View file

@ -90,8 +90,7 @@ pub fn read_file(
let mut rustc_version_str_len = [0u8; 1];
file.read_exact(&mut rustc_version_str_len)?;
let rustc_version_str_len = rustc_version_str_len[0] as usize;
let mut buffer = Vec::with_capacity(rustc_version_str_len);
buffer.resize(rustc_version_str_len, 0);
let mut buffer = vec![0; rustc_version_str_len];
file.read_exact(&mut buffer)?;
if buffer != rustc_version().as_bytes() {

1
src/librustc_interface/callbacks.rs
View file

@ -11,7 +11,6 @@
use rustc::ty::tls;
use rustc_errors::{Diagnostic, TRACK_DIAGNOSTICS};
use rustc_span;
use std::fmt;
/// This is a callback from libsyntax as it cannot access the implicit state

4
src/librustc_interface/passes.rs
View file

@ -17,7 +17,6 @@ use rustc::traits;
use rustc::ty::steal::Steal;
use rustc::ty::{self, GlobalCtxt, ResolverOutputs, TyCtxt};
use rustc::util::common::ErrorReported;
use rustc_builtin_macros;
use rustc_codegen_ssa::back::link::emit_metadata;
use rustc_codegen_utils::codegen_backend::CodegenBackend;
use rustc_codegen_utils::link::filename_for_metadata;
@ -26,18 +25,15 @@ use rustc_data_structures::{box_region_allow_access, declare_box_region_type, pa
use rustc_errors::PResult;
use rustc_expand::base::ExtCtxt;
use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
use rustc_incremental;
use rustc_lint::LintStore;
use rustc_mir as mir;
use rustc_mir_build as mir_build;
use rustc_parse::{parse_crate_from_file, parse_crate_from_source_str};
use rustc_passes::{self, hir_stats, layout_test};
use rustc_plugin_impl as plugin;
use rustc_privacy;
use rustc_resolve::{Resolver, ResolverArenas};
use rustc_span::symbol::Symbol;
use rustc_span::FileName;
use rustc_traits;
use rustc_typeck as typeck;
use syntax::mut_visit::MutVisitor;
use syntax::{self, ast, visit};

2
src/librustc_macros/src/lift.rs
View file

@ -1,7 +1,5 @@
use proc_macro2;
use quote::quote;
use syn::{self, parse_quote};
use synstructure;
pub fn lift_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
s.add_bounds(synstructure::AddBounds::Generics);

1
src/librustc_macros/src/query.rs
View file

@ -2,7 +2,6 @@ use itertools::Itertools;
use proc_macro::TokenStream;
use proc_macro2::{Delimiter, TokenTree};
use quote::quote;
use syn;
use syn::parse::{Parse, ParseStream, Result};
use syn::punctuated::Punctuated;
use syn::spanned::Spanned;

1
src/librustc_macros/src/symbols.rs
View file

@ -1,7 +1,6 @@
use proc_macro::TokenStream;
use quote::quote;
use std::collections::HashSet;
use syn;
use syn::parse::{Parse, ParseStream, Result};
use syn::{braced, parse_macro_input, Ident, LitStr, Token};

2
src/librustc_macros/src/type_foldable.rs
View file

@ -1,6 +1,4 @@
use quote::quote;
use syn;
use synstructure;
pub fn type_foldable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
if let syn::Data::Union(_) = s.ast().data {

27
src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs
View file

@ -397,14 +397,20 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
(BorrowKind::Mut { .. }, BorrowKind::Mut { .. }) => {
first_borrow_desc = "first ";
self.cannot_mutably_borrow_multiply(
let mut err = self.cannot_mutably_borrow_multiply(
span,
&desc_place,
&msg_place,
issued_span,
&msg_borrow,
None,
)
);
self.suggest_split_at_mut_if_applicable(
&mut err,
&place,
&issued_borrow.borrowed_place,
);
err
}
(BorrowKind::Unique, BorrowKind::Unique) => {
@ -549,6 +555,23 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
err
}
fn suggest_split_at_mut_if_applicable(
&self,
err: &mut DiagnosticBuilder<'_>,
place: &Place<'tcx>,
borrowed_place: &Place<'tcx>,
) {
match (&place.projection[..], &borrowed_place.projection[..]) {
([ProjectionElem::Index(_)], [ProjectionElem::Index(_)]) => {
err.help(
"consider using `.split_at_mut(position)` or similar method to obtain \
two mutable non-overlapping sub-slices",
);
}
_ => {}
}
}
/// Returns the description of the root place for a conflicting borrow and the full
/// descriptions of the places that caused the conflict.
///

1
src/librustc_passes/dead.rs
View file

@ -15,7 +15,6 @@ use rustc_hir::itemlikevisit::ItemLikeVisitor;
use rustc_hir::{Node, PatKind, TyKind};
use rustc_session::lint;
use rustc_span;
use rustc_span::symbol::sym;
use syntax::{ast, attr};

4
src/librustc_session/config.rs
View file

@ -22,8 +22,6 @@ use rustc_span::symbol::{sym, Symbol};
use rustc_errors::emitter::HumanReadableErrorType;
use rustc_errors::{ColorConfig, FatalError, Handler, HandlerFlags};
use getopts;
use std::collections::btree_map::{
Iter as BTreeMapIter, Keys as BTreeMapKeysIter, Values as BTreeMapValuesIter,
};
@ -816,7 +814,6 @@ mod opt {
#![allow(dead_code)]
use super::RustcOptGroup;
use getopts;
pub type R = RustcOptGroup;
pub type S = &'static str;
@ -1862,7 +1859,6 @@ pub fn parse_crate_types_from_list(list_list: Vec<String>) -> Result<Vec<CrateTy
pub mod nightly_options {
use super::{ErrorOutputType, OptionStability, RustcOptGroup};
use crate::early_error;
use getopts;
use rustc_feature::UnstableFeatures;
pub fn is_unstable_enabled(matches: &getopts::Matches) -> bool {

2
src/librustc_session/options.rs
View file

@ -11,8 +11,6 @@ use rustc_target::spec::{LinkerFlavor, MergeFunctions, PanicStrategy, RelroLevel
use rustc_feature::UnstableFeatures;
use rustc_span::edition::Edition;
use getopts;
use std::collections::BTreeMap;
use std::collections::hash_map::DefaultHasher;

1
src/librustc_session/session.rs
View file

@ -33,7 +33,6 @@ use rustc_data_structures::jobserver::{self, Client};
use rustc_data_structures::profiling::{SelfProfiler, SelfProfilerRef};
use rustc_target::spec::{PanicStrategy, RelroLevel, Target, TargetTriple};
use std;
use std::cell::{self, RefCell};
use std::env;
use std::fmt;

6
src/librustc_typeck/astconv.rs
View file

@ -1438,10 +1438,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
// Expand trait aliases recursively and check that only one regular (non-auto) trait
// is used and no 'maybe' bounds are used.
let expanded_traits = traits::expand_trait_aliases(
tcx,
bounds.trait_bounds.iter().map(|&(a, b, _)| (a.clone(), b)),
);
let expanded_traits =
traits::expand_trait_aliases(tcx, bounds.trait_bounds.iter().map(|&(a, b, _)| (a, b)));
let (mut auto_traits, regular_traits): (Vec<_>, Vec<_>) =
expanded_traits.partition(|i| tcx.trait_is_auto(i.trait_ref().def_id()));
if regular_traits.len() > 1 {

1
src/librustc_typeck/variance/mod.rs
View file

@ -3,7 +3,6 @@
//!
//! [rustc guide]: https://rust-lang.github.io/rustc-guide/variance.html
use arena;
use hir::Node;
use rustc::ty::query::Providers;
use rustc::ty::{self, CrateVariancesMap, TyCtxt};

1
src/librustdoc/clean/utils.rs
View file

@ -16,7 +16,6 @@ use rustc_data_structures::fx::FxHashSet;
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::{DefId, LOCAL_CRATE};
use rustc_span;
use rustc_span::symbol::{kw, sym, Symbol};
use std::mem;

2
src/librustdoc/config.rs
View file

@ -3,7 +3,6 @@ use std::ffi::OsStr;
use std::fmt;
use std::path::PathBuf;
use getopts;
use rustc::lint::Level;
use rustc::session;
use rustc::session::config::{
@ -13,7 +12,6 @@ use rustc::session::config::{
use rustc::session::config::{parse_crate_types_from_list, parse_externs, CrateType};
use rustc::session::config::{CodegenOptions, DebuggingOptions, ErrorOutputType, Externs};
use rustc::session::search_paths::SearchPath;
use rustc_driver;
use rustc_span::edition::{Edition, DEFAULT_EDITION};
use rustc_target::spec::TargetTriple;

1
src/librustdoc/core.rs
View file

@ -11,7 +11,6 @@ use rustc_hir::def::Namespace::TypeNS;
use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE};
use rustc_hir::HirId;
use rustc_interface::interface;
use rustc_lint;
use rustc_resolve as resolve;
use rustc_session::lint;

11
src/librustdoc/html/render.rs
View file

@ -73,8 +73,6 @@ use crate::html::markdown::{self, ErrorCodes, IdMap, Markdown, MarkdownHtml, Mar
use crate::html::sources;
use crate::html::{highlight, layout, static_files};
use minifier;
#[cfg(test)]
mod tests;
@ -3629,14 +3627,7 @@ fn render_impl(
for it in &i.inner_impl().items {
if let clean::TypedefItem(ref tydef, _) = it.inner {
write!(w, "<span class=\"where fmt-newline\"> ");
assoc_type(
w,
it,
&vec![],
Some(&tydef.type_),
AssocItemLink::Anchor(None),
"",
);
assoc_type(w, it, &[], Some(&tydef.type_), AssocItemLink::Anchor(None), "");
write!(w, ";</span>");
}
}

1
src/librustdoc/markdown.rs
View file

@ -5,7 +5,6 @@ use std::path::PathBuf;
use rustc_feature::UnstableFeatures;
use rustc_span::edition::Edition;
use rustc_span::source_map::DUMMY_SP;
use testing;
use crate::config::{Options, RenderOptions};
use crate::externalfiles::{load_string, LoadStringError};

1
src/librustdoc/passes/collect_intra_doc_links.rs
View file

@ -13,7 +13,6 @@ use rustc_hir::def_id::DefId;
use rustc_resolve::ParentScope;
use rustc_span::symbol::Symbol;
use rustc_span::DUMMY_SP;
use syntax;
use syntax::ast::{self, Ident};
use std::ops::Range;

1
src/librustdoc/test.rs
View file

@ -20,7 +20,6 @@ use std::str;
use syntax::ast;
use syntax::with_globals;
use tempfile::Builder as TempFileBuilder;
use testing;
use crate::clean::Attributes;
use crate::config::Options;

1
src/libtest/cli.rs
View file

@ -1,6 +1,5 @@
//! Module converting command-line arguments into test configuration.
use getopts;
use std::env;
use std::path::PathBuf;

2
src/libtest/console.rs
View file

@ -4,8 +4,6 @@ use std::fs::File;
use std::io;
use std::io::prelude::Write;
use term;
use super::{
bench::fmt_bench_samples,
cli::TestOpts,

16
src/test/ui/proc-macro/auxiliary/issue-59191.rs Normal file
View file

@ -0,0 +1,16 @@
// edition:2018
// force-host
// no-prefer-dynamic
#![crate_type = "proc-macro"]
extern crate proc_macro;
use proc_macro::TokenStream;
#[proc_macro_attribute]
pub fn no_main(_attrs: TokenStream, _input: TokenStream) -> TokenStream {
let new_krate = r#"
fn main() {}
"#;
new_krate.parse().unwrap()
}

8
src/test/ui/proc-macro/issue-59191-replace-root-with-fn.rs Normal file
View file

@ -0,0 +1,8 @@
// edition:2018
// aux-crate:issue_59191=issue-59191.rs
// Test that using a macro to replace the entire crate tree with a non-'mod' item errors out nicely.
// `issue_59191::no_main` replaces whatever's passed in with `fn main() {}`.
#![feature(custom_inner_attributes)]
//~^ ERROR `main` function not found in crate `issue_59191_replace_root_with_fn` [E0601]
#![issue_59191::no_main]
//~^ ERROR expected crate top-level item to be a module after macro expansion, found a function

17
src/test/ui/proc-macro/issue-59191-replace-root-with-fn.stderr Normal file
View file

@ -0,0 +1,17 @@
error: expected crate top-level item to be a module after macro expansion, found a function
--> $DIR/issue-59191-replace-root-with-fn.rs:7:1
|
LL | #![issue_59191::no_main]
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0601]: `main` function not found in crate `issue_59191_replace_root_with_fn`
--> $DIR/issue-59191-replace-root-with-fn.rs:5:1
|
LL | / #![feature(custom_inner_attributes)]
LL | |
LL | | #![issue_59191::no_main]
| |________________________^ consider adding a `main` function to `$DIR/issue-59191-replace-root-with-fn.rs`
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0601`.

8
src/test/ui/suggestions/suggest-split-at-mut.rs Normal file
View file

@ -0,0 +1,8 @@
fn main() {
let mut foo = [1, 2, 3, 4];
let a = &mut foo[2];
let b = &mut foo[3]; //~ ERROR cannot borrow `foo[_]` as mutable more than once at a time
*a = 5;
*b = 6;
println!("{:?} {:?}", a, b);
}

15
src/test/ui/suggestions/suggest-split-at-mut.stderr Normal file
View file

@ -0,0 +1,15 @@
error[E0499]: cannot borrow `foo[_]` as mutable more than once at a time
--> $DIR/suggest-split-at-mut.rs:4:13
|
LL | let a = &mut foo[2];
| ----------- first mutable borrow occurs here
LL | let b = &mut foo[3];
| ^^^^^^^^^^^ second mutable borrow occurs here
LL | *a = 5;
| ------ first borrow later used here
|
= help: consider using `.split_at_mut(position)` or similar method to obtain two mutable non-overlapping sub-slices
error: aborting due to previous error
For more information about this error, try `rustc --explain E0499`.