mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #73297 - ehuss:tool-warnings, r=Mark-Simulacrum

Browse Source 
Support configurable deny-warnings for all in-tree crates.

This removes the hard-coded `deny(warnings)` on all in-tree tools, and allows it to be configured from the config.  This is just a personal preference, as I find `deny(warnings)` frustrating during development or doing small tests.

This also fixes some regressions in terms of warning handling.  Warnings used to be dependent on `SourceType`, but in #64316 it was changed to be based on `Mode`. This means tools like rustdoc no longer used the same settings as the rest of the tree. It also made `SourceType` useless since the only thing it was used for was warnings. I think it would be better for everything in the tree to use the same settings.

Fixes #64523
This commit is contained in:
Manish Goregaokar 2020-06-26 00:39:01 -07:00 committed by GitHub
commit 10d655bb47
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 102 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/bootstrap/builder.rs
View File

@ -23,7 +23,7 @@
use crate::native;
use crate::run;
use crate::test;
use crate::tool;
use crate::tool::{self, SourceType};
use crate::util::{self, add_dylib_path, add_link_lib_path, exe, libdir};
use crate::{Build, DocTests, GitRepo, Mode};
@ -759,6 +759,7 @@ pub fn cargo(
&self,
compiler: Compiler,
mode: Mode,
source_type: SourceType,
target: Interned<String>,
cmd: &str,
) -> Cargo {
@ -1125,7 +1126,7 @@ pub fn cargo(
cargo.env("RUSTC_VERBOSE", self.verbosity.to_string());
if !mode.is_tool() {
if source_type == SourceType::InTree {
// When extending this list, add the new lints to the RUSTFLAGS of the
// build_bootstrap function of src/bootstrap/bootstrap.py as well as
// some code doesn't go through this `rustc` wrapper.

29
src/bootstrap/check.rs
View File

@ -44,7 +44,13 @@ fn run(self, builder: &Builder<'_>) {
let target = self.target;
let compiler = builder.compiler(0, builder.config.build);
let mut cargo = builder.cargo(compiler, Mode::Std, target, cargo_subcommand(builder.kind));
let mut cargo = builder.cargo(
compiler,
Mode::Std,
SourceType::InTree,
target,
cargo_subcommand(builder.kind),
);
std_cargo(builder, target, compiler.stage, &mut cargo);
builder.info(&format!("Checking std artifacts ({} -> {})", &compiler.host, target));
@ -92,8 +98,13 @@ fn run(self, builder: &Builder<'_>) {
builder.ensure(Std { target });
let mut cargo =
builder.cargo(compiler, Mode::Rustc, target, cargo_subcommand(builder.kind));
let mut cargo = builder.cargo(
compiler,
Mode::Rustc,
SourceType::InTree,
target,
cargo_subcommand(builder.kind),
);
rustc_cargo(builder, &mut cargo, target);
builder.info(&format!("Checking compiler artifacts ({} -> {})", &compiler.host, target));
@ -113,7 +124,7 @@ fn run(self, builder: &Builder<'_>) {
}
macro_rules! tool_check_step {
($name:ident, $path:expr) => {
($name:ident, $path:expr, $source_type:expr) => {
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct $name {
pub target: Interned<String>,
@ -145,7 +156,7 @@ fn run(self, builder: &Builder<'_>) {
target,
cargo_subcommand(builder.kind),
$path,
SourceType::InTree,
$source_type,
&[],
);
@ -184,8 +195,12 @@ fn stamp(
};
}
tool_check_step!(Rustdoc, "src/tools/rustdoc");
tool_check_step!(Clippy, "src/tools/clippy");
tool_check_step!(Rustdoc, "src/tools/rustdoc", SourceType::InTree);
// Clippy is a hybrid. It is an external tool, but uses a git subtree instead
// of a submodule. Since the SourceType only drives the deny-warnings
// behavior, treat it as in-tree so that any new warnings in clippy will be
// rejected.
tool_check_step!(Clippy, "src/tools/clippy", SourceType::InTree);
/// Cargo's output path for the standard library in a given stage, compiled
/// by a particular compiler for the specified target.

14
src/bootstrap/compile.rs
View File

@ -20,13 +20,13 @@
use serde::Deserialize;
use crate::builder::Cargo;
use crate::dist;
use crate::native;
use crate::util::{exe, is_dylib, symlink_dir};
use crate::{Compiler, DependencyType, GitRepo, Mode};
use crate::builder::{Builder, Kind, RunConfig, ShouldRun, Step};
use crate::cache::{Interned, INTERNER};
use crate::dist;
use crate::native;
use crate::tool::SourceType;
use crate::util::{exe, is_dylib, symlink_dir};
use crate::{Compiler, DependencyType, GitRepo, Mode};
#[derive(Debug, PartialOrd, Ord, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Std {
@ -87,7 +87,7 @@ fn run(self, builder: &Builder<'_>) {
target_deps.extend(copy_third_party_objects(builder, &compiler, target));
target_deps.extend(copy_self_contained_objects(builder, &compiler, target));
let mut cargo = builder.cargo(compiler, Mode::Std, target, "build");
let mut cargo = builder.cargo(compiler, Mode::Std, SourceType::InTree, target, "build");
std_cargo(builder, target, compiler.stage, &mut cargo);
builder.info(&format!(
@ -513,7 +513,7 @@ fn run(self, builder: &Builder<'_>) {
target: builder.config.build,
});
let mut cargo = builder.cargo(compiler, Mode::Rustc, target, "build");
let mut cargo = builder.cargo(compiler, Mode::Rustc, SourceType::InTree, target, "build");
rustc_cargo(builder, &mut cargo, target);
builder.info(&format!(

5
src/bootstrap/doc.rs
View File

@ -435,7 +435,8 @@ fn run(self, builder: &Builder<'_>) {
t!(fs::copy(builder.src.join("src/doc/rust.css"), out.join("rust.css")));
let run_cargo_rustdoc_for = |package: &str| {
let mut cargo = builder.cargo(compiler, Mode::Std, target, "rustdoc");
let mut cargo =
builder.cargo(compiler, Mode::Std, SourceType::InTree, target, "rustdoc");
compile::std_cargo(builder, target, compiler.stage, &mut cargo);
// Keep a whitelist so we do not build internal stdlib crates, these will be
@ -534,7 +535,7 @@ fn run(self, builder: &Builder<'_>) {
t!(symlink_dir_force(&builder.config, &out, &out_dir));
// Build cargo command.
let mut cargo = builder.cargo(compiler, Mode::Rustc, target, "doc");
let mut cargo = builder.cargo(compiler, Mode::Rustc, SourceType::InTree, target, "doc");
cargo.env(
"RUSTDOCFLAGS",
"--document-private-items \

19
src/bootstrap/lib.rs
View File

@ -301,16 +301,21 @@ pub enum Mode {
/// Build codegen libraries, placing output in the "stageN-codegen" directory
Codegen,
/// Build some tools, placing output in the "stageN-tools" directory. The
/// "other" here is for miscellaneous sets of tools that are built using the
/// bootstrap compiler in its entirety (target libraries and all).
/// Typically these tools compile with stable Rust.
/// Build a tool, placing output in the "stage0-bootstrap-tools"
/// directory. This is for miscellaneous sets of tools that are built
/// using the bootstrap stage0 compiler in its entirety (target libraries
/// and all). Typically these tools compile with stable Rust.
ToolBootstrap,
/// Compile a tool which uses all libraries we compile (up to rustc).
/// Doesn't use the stage0 compiler libraries like "other", and includes
/// tools like rustdoc, cargo, rls, etc.
/// Build a tool which uses the locally built std, placing output in the
/// "stageN-tools" directory. Its usage is quite rare, mainly used by
/// compiletest which needs libtest.
ToolStd,
/// Build a tool which uses the locally built rustc and the target std,
/// placing the output in the "stageN-tools" directory. This is used for
/// anything that needs a fully functional rustc, such as rustdoc, clippy,
/// cargo, rls, rustfmt, miri, etc.
ToolRustc,
}

6
src/bootstrap/test.rs
View File

@ -367,7 +367,8 @@ fn run(self, builder: &Builder<'_>) {
extra_features: Vec::new(),
});
if let (Some(miri), Some(_cargo_miri)) = (miri, cargo_miri) {
let mut cargo = builder.cargo(compiler, Mode::ToolRustc, host, "install");
let mut cargo =
builder.cargo(compiler, Mode::ToolRustc, SourceType::Submodule, host, "install");
cargo.arg("xargo");
// Configure `cargo install` path. cargo adds a `bin/`.
cargo.env("CARGO_INSTALL_ROOT", &builder.out);
@ -1696,7 +1697,8 @@ fn run(self, builder: &Builder<'_>) {
// we're working with automatically.
let compiler = builder.compiler_for(compiler.stage, compiler.host, target);
let mut cargo = builder.cargo(compiler, mode, target, test_kind.subcommand());
let mut cargo =
builder.cargo(compiler, mode, SourceType::InTree, target, test_kind.subcommand());
match mode {
Mode::Std => {
compile::std_cargo(builder, target, compiler.stage, &mut cargo);

19
src/bootstrap/tool.rs
View File

@ -16,7 +16,7 @@
use crate::Compiler;
use crate::Mode;
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum SourceType {
InTree,
Submodule,
@ -226,14 +226,10 @@ pub fn prepare_tool_cargo(
source_type: SourceType,
extra_features: &[String],
) -> CargoCommand {
let mut cargo = builder.cargo(compiler, mode, target, command);
let mut cargo = builder.cargo(compiler, mode, source_type, target, command);
let dir = builder.src.join(path);
cargo.arg("--manifest-path").arg(dir.join("Cargo.toml"));
if source_type == SourceType::Submodule {
cargo.env("RUSTC_EXTERNAL_TOOL", "1");
}
let mut features = extra_features.to_vec();
if builder.build.config.cargo_native_static {
if path.ends_with("cargo")
@ -596,6 +592,7 @@ macro_rules! tool_extended {
$path:expr,
$tool_name:expr,
stable = $stable:expr,
$(in_tree = $in_tree:expr,)*
$extra_deps:block;)+) => {
$(
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
@ -647,7 +644,11 @@ fn run(mut $sel, $builder: &Builder<'_>) -> Option<PathBuf> {
path: $path,
extra_features: $sel.extra_features,
is_optional_tool: true,
source_type: SourceType::Submodule,
source_type: if false $(|| $in_tree)* {
SourceType::InTree
} else {
SourceType::Submodule
},
})
}
}
@ -659,8 +660,8 @@ fn run(mut $sel, $builder: &Builder<'_>) -> Option<PathBuf> {
// to make `./x.py build <tool>` work.
tool_extended!((self, builder),
Cargofmt, rustfmt, "src/tools/rustfmt", "cargo-fmt", stable=true, {};
CargoClippy, clippy, "src/tools/clippy", "cargo-clippy", stable=true, {};
Clippy, clippy, "src/tools/clippy", "clippy-driver", stable=true, {};
CargoClippy, clippy, "src/tools/clippy", "cargo-clippy", stable=true, in_tree=true, {};
Clippy, clippy, "src/tools/clippy", "clippy-driver", stable=true, in_tree=true, {};
Miri, miri, "src/tools/miri", "miri", stable=false, {};
CargoMiri, miri, "src/tools/miri/cargo-miri", "cargo-miri", stable=false, {};
Rls, rls, "src/tools/rls", "rls", stable=true, {

2
src/librustdoc/clean/inline.rs
View File

@ -278,7 +278,7 @@ fn build_type_alias_type(cx: &DocContext<'_>, did: DefId) -> Option<clean::Type>
type_.def_id().and_then(|did| build_ty(cx, did))
}
pub fn build_ty(cx: &DocContext, did: DefId) -> Option<clean::Type> {
pub fn build_ty(cx: &DocContext<'_>, did: DefId) -> Option<clean::Type> {
match cx.tcx.def_kind(did) {
DefKind::Struct | DefKind::Union | DefKind::Enum | DefKind::Const | DefKind::Static => {
Some(cx.tcx.type_of(did).clean(cx))

4
src/librustdoc/clean/utils.rs
View File

@ -328,7 +328,7 @@ pub fn strip_path(path: &Path) -> Path {
Path { global: path.global, res: path.res, segments }
}
pub fn qpath_to_string(p: &hir::QPath) -> String {
pub fn qpath_to_string(p: &hir::QPath<'_>) -> String {
let segments = match *p {
hir::QPath::Resolved(_, ref path) => &path.segments,
hir::QPath::TypeRelative(_, ref segment) => return segment.ident.to_string(),
@ -417,7 +417,7 @@ fn to_src(&self, cx: &DocContext<'_>) -> String {
}
}
pub fn name_from_pat(p: &hir::Pat) -> String {
pub fn name_from_pat(p: &hir::Pat<'_>) -> String {
use rustc_hir::*;
debug!("trying to get a name from pattern: {:?}", p);

2
src/librustdoc/doctree.rs
View File

@ -262,7 +262,7 @@ pub struct ProcMacro<'hir> {
pub whence: Span,
}
pub fn struct_type_from_def(vdata: &hir::VariantData) -> StructType {
pub fn struct_type_from_def(vdata: &hir::VariantData<'_>) -> StructType {
match *vdata {
hir::VariantData::Struct(..) => Plain,
hir::VariantData::Tuple(..) => Tuple,

18
src/librustdoc/test.rs
View File

@ -166,7 +166,7 @@ pub fn run(options: Options) -> Result<(), String> {
}
// Look for `#![doc(test(no_crate_inject))]`, used by crates in the std facade.
fn scrape_test_config(krate: &::rustc_hir::Crate) -> TestOptions {
fn scrape_test_config(krate: &::rustc_hir::Crate<'_>) -> TestOptions {
use rustc_ast_pretty::pprust;
let mut opts =
@ -973,7 +973,7 @@ fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
intravisit::NestedVisitorMap::All(self.map)
}
fn visit_item(&mut self, item: &'hir hir::Item) {
fn visit_item(&mut self, item: &'hir hir::Item<'_>) {
let name = if let hir::ItemKind::Impl { ref self_ty, .. } = item.kind {
rustc_hir_pretty::id_to_string(&self.map, self_ty.hir_id)
} else {
@ -985,19 +985,19 @@ fn visit_item(&mut self, item: &'hir hir::Item) {
});
}
fn visit_trait_item(&mut self, item: &'hir hir::TraitItem) {
fn visit_trait_item(&mut self, item: &'hir hir::TraitItem<'_>) {
self.visit_testable(item.ident.to_string(), &item.attrs, item.hir_id, item.span, |this| {
intravisit::walk_trait_item(this, item);
});
}
fn visit_impl_item(&mut self, item: &'hir hir::ImplItem) {
fn visit_impl_item(&mut self, item: &'hir hir::ImplItem<'_>) {
self.visit_testable(item.ident.to_string(), &item.attrs, item.hir_id, item.span, |this| {
intravisit::walk_impl_item(this, item);
});
}
fn visit_foreign_item(&mut self, item: &'hir hir::ForeignItem) {
fn visit_foreign_item(&mut self, item: &'hir hir::ForeignItem<'_>) {
self.visit_testable(item.ident.to_string(), &item.attrs, item.hir_id, item.span, |this| {
intravisit::walk_foreign_item(this, item);
});
@ -1005,8 +1005,8 @@ fn visit_foreign_item(&mut self, item: &'hir hir::ForeignItem) {
fn visit_variant(
&mut self,
v: &'hir hir::Variant,
g: &'hir hir::Generics,
v: &'hir hir::Variant<'_>,
g: &'hir hir::Generics<'_>,
item_id: hir::HirId,
) {
self.visit_testable(v.ident.to_string(), &v.attrs, v.id, v.span, |this| {
@ -1014,13 +1014,13 @@ fn visit_variant(
});
}
fn visit_struct_field(&mut self, f: &'hir hir::StructField) {
fn visit_struct_field(&mut self, f: &'hir hir::StructField<'_>) {
self.visit_testable(f.ident.to_string(), &f.attrs, f.hir_id, f.span, |this| {
intravisit::walk_struct_field(this, f);
});
}
fn visit_macro_def(&mut self, macro_def: &'hir hir::MacroDef) {
fn visit_macro_def(&mut self, macro_def: &'hir hir::MacroDef<'_>) {
self.visit_testable(
macro_def.ident.to_string(),
&macro_def.attrs,

43
src/librustdoc/visit_ast.rs
View File

@ -62,7 +62,7 @@ fn store_path(&mut self, did: DefId) {
self.exact_paths.entry(did).or_insert_with(|| def_id_to_path(tcx, did));
}
pub fn visit(mut self, krate: &'tcx hir::Crate) -> Module<'tcx> {
pub fn visit(mut self, krate: &'tcx hir::Crate<'_>) -> Module<'tcx> {
let mut module = self.visit_mod_contents(
krate.item.span,
krate.item.attrs,
@ -84,10 +84,10 @@ pub fn visit(mut self, krate: &'tcx hir::Crate) -> Module<'tcx> {
fn visit_variant_data(
&mut self,
item: &'tcx hir::Item,
item: &'tcx hir::Item<'_>,
name: Symbol,
sd: &'tcx hir::VariantData,
generics: &'tcx hir::Generics,
sd: &'tcx hir::VariantData<'_>,
generics: &'tcx hir::Generics<'_>,
) -> Struct<'tcx> {
debug!("visiting struct");
let struct_type = struct_type_from_def(&*sd);
@ -105,10 +105,10 @@ fn visit_variant_data(
fn visit_union_data(
&mut self,
item: &'tcx hir::Item,
item: &'tcx hir::Item<'_>,
name: Symbol,
sd: &'tcx hir::VariantData,
generics: &'tcx hir::Generics,
sd: &'tcx hir::VariantData<'_>,
generics: &'tcx hir::Generics<'_>,
) -> Union<'tcx> {
debug!("visiting union");
let struct_type = struct_type_from_def(&*sd);
@ -126,10 +126,10 @@ fn visit_union_data(
fn visit_enum_def(
&mut self,
it: &'tcx hir::Item,
it: &'tcx hir::Item<'_>,
name: Symbol,
def: &'tcx hir::EnumDef,
generics: &'tcx hir::Generics,
def: &'tcx hir::EnumDef<'_>,
generics: &'tcx hir::Generics<'_>,
) -> Enum<'tcx> {
debug!("visiting enum");
Enum {
@ -156,11 +156,11 @@ fn visit_enum_def(
fn visit_fn(
&mut self,
om: &mut Module<'tcx>,
item: &'tcx hir::Item,
item: &'tcx hir::Item<'_>,
name: Symbol,
decl: &'tcx hir::FnDecl,
decl: &'tcx hir::FnDecl<'_>,
header: hir::FnHeader,
generics: &'tcx hir::Generics,
generics: &'tcx hir::Generics<'_>,
body: hir::BodyId,
) {
debug!("visiting fn");
@ -231,7 +231,7 @@ fn visit_mod_contents(
&mut self,
span: Span,
attrs: &'tcx [ast::Attribute],
vis: &'tcx hir::Visibility,
vis: &'tcx hir::Visibility<'_>,
id: hir::HirId,
m: &'tcx hir::Mod<'tcx>,
name: Option<Symbol>,
@ -375,7 +375,12 @@ fn inherits_doc_hidden(cx: &core::DocContext<'_>, mut node: hir::HirId) -> bool
ret
}
fn visit_item(&mut self, item: &'tcx hir::Item, renamed: Option<Ident>, om: &mut Module<'tcx>) {
fn visit_item(
&mut self,
item: &'tcx hir::Item<'_>,
renamed: Option<Ident>,
om: &mut Module<'tcx>,
) {
debug!("visiting item {:?}", item);
let ident = renamed.unwrap_or(item.ident);
@ -587,7 +592,7 @@ fn visit_item(&mut self, item: &'tcx hir::Item, renamed: Option<Ident>, om: &mut
fn visit_foreign_item(
&mut self,
item: &'tcx hir::ForeignItem,
item: &'tcx hir::ForeignItem<'_>,
renamed: Option<Ident>,
om: &mut Module<'tcx>,
) {
@ -607,7 +612,11 @@ fn visit_foreign_item(
}
// Convert each `exported_macro` into a doc item.
fn visit_local_macro(&self, def: &'tcx hir::MacroDef, renamed: Option<Symbol>) -> Macro<'tcx> {
fn visit_local_macro(
&self,
def: &'tcx hir::MacroDef<'_>,
renamed: Option<Symbol>,
) -> Macro<'tcx> {
debug!("visit_local_macro: {}", def.ident);
let tts = def.ast.body.inner_tokens().trees().collect::<Vec<_>>();
// Extract the spans of all matchers. They represent the "interface" of the macro.

2
src/tools/build-manifest/src/main.rs
View File

@ -4,8 +4,6 @@
//! via `x.py dist hash-and-sign`; the cmdline arguments are set up
//! by rustbuild (in `src/bootstrap/dist.rs`).
#![deny(warnings)]
use serde::Serialize;
use std::collections::BTreeMap;

2
src/tools/cargotest/main.rs
View File

@ -1,5 +1,3 @@
#![deny(warnings)]
use std::env;
use std::fs;
use std::path::{Path, PathBuf};

1
src/tools/compiletest/src/main.rs
View File

@ -1,5 +1,4 @@
#![crate_name = "compiletest"]
#![deny(warnings)]
// The `test` crate is the only unstable feature
// allowed here, just to share similar code.
#![feature(test)]

1
src/tools/error_index_generator/main.rs
View File

@ -1,5 +1,4 @@
#![feature(rustc_private)]
#![deny(warnings)]
extern crate env_logger;
extern crate rustc_ast;

4
src/tools/expand-yaml-anchors/src/main.rs
View File

@ -165,7 +165,7 @@ fn main() {
impl Error for StrError {}
impl std::fmt::Display for StrError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Display::fmt(&self.0, f)
}
}
@ -177,7 +177,7 @@ struct WithContext {
}
impl std::fmt::Display for WithContext {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.context)
}
}

2
src/tools/linkchecker/main.rs
View File

@ -14,8 +14,6 @@
//! A few whitelisted exceptions are allowed as there's known bugs in rustdoc,
//! but this should catch the majority of "broken link" cases.
#![deny(warnings)]
use std::collections::hash_map::Entry;
use std::collections::{HashMap, HashSet};
use std::env;

2
src/tools/remote-test-client/src/main.rs
View File

@ -5,8 +5,6 @@
//! Here is also where we bake in the support to spawn the QEMU emulator as
//! well.
#![deny(warnings)]
use std::env;
use std::fs::{self, File};
use std::io::prelude::*;

2
src/tools/remote-test-server/src/main.rs
View File

@ -10,8 +10,6 @@
//! themselves having support libraries. All data over the TCP sockets is in a
//! basically custom format suiting our needs.
#![deny(warnings)]
#[cfg(not(windows))]
use std::fs::Permissions;
#[cfg(not(windows))]

2
src/tools/tidy/src/main.rs
View File

@ -4,8 +4,6 @@
//! etc. This is run by default on `./x.py test` and as part of the auto
//! builders. The tidy checks can be executed with `./x.py test tidy`.
#![deny(warnings)]
use tidy::*;
use std::env;

2
src/tools/unstable-book-gen/src/main.rs
View File

@ -1,7 +1,5 @@
//! Auto-generate stub docs for the unstable book
#![deny(warnings)]
use std::collections::BTreeSet;
use std::env;
use std::fs::{self, File};