1use build_helper::exit;
17
18use super::compile::{run_cargo, rustc_cargo, std_cargo};
19use super::tool::{SourceType, prepare_tool_cargo};
20use crate::builder::{Builder, ShouldRun};
21use crate::core::build_steps::check::{CompilerForCheck, prepare_compiler_for_check};
22use crate::core::build_steps::compile::std_crates_for_run_make;
23use crate::core::builder;
24use crate::core::builder::{Alias, Kind, RunConfig, Step, StepMetadata, crate_description};
25use crate::utils::build_stamp::{self, BuildStamp};
26use crate::{Compiler, Mode, Subcommand, TargetSelection};
27
28const IGNORED_RULES_FOR_STD_AND_RUSTC: &[&str] = &[
30 "many_single_char_names", "collapsible_if",
32 "type_complexity",
33 "missing_safety_doc", "too_many_arguments",
35 "needless_lifetimes", "wrong_self_convention",
37 "approx_constant", ];
39
40fn lint_args(builder: &Builder<'_>, config: &LintConfig, ignored_rules: &[&str]) -> Vec<String> {
41 fn strings<'a>(arr: &'a [&str]) -> impl Iterator<Item = String> + 'a {
42 arr.iter().copied().map(String::from)
43 }
44
45 let Subcommand::Clippy { fix, allow_dirty, allow_staged, .. } = &builder.config.cmd else {
46 unreachable!("clippy::lint_args can only be called from `clippy` subcommands.");
47 };
48
49 let mut args = vec![];
50 if *fix {
51 #[rustfmt::skip]
52 args.extend(strings(&[
53 "--fix", "-Zunstable-options",
54 "--lib", "--bins", "--examples",
58 ]));
59
60 if *allow_dirty {
61 args.push("--allow-dirty".to_owned());
62 }
63
64 if *allow_staged {
65 args.push("--allow-staged".to_owned());
66 }
67 }
68
69 args.extend(strings(&["--"]));
70
71 if config.deny.is_empty() && config.forbid.is_empty() {
72 args.extend(strings(&["--cap-lints", "warn"]));
73 }
74
75 let all_args = std::env::args().collect::<Vec<_>>();
76 args.extend(get_clippy_rules_in_order(&all_args, config));
77
78 args.extend(ignored_rules.iter().map(|lint| format!("-Aclippy::{lint}")));
79 args.extend(builder.config.free_args.clone());
80 args
81}
82
83pub fn get_clippy_rules_in_order(all_args: &[String], config: &LintConfig) -> Vec<String> {
87 let mut result = vec![];
88
89 for (prefix, item) in
90 [("-A", &config.allow), ("-D", &config.deny), ("-W", &config.warn), ("-F", &config.forbid)]
91 {
92 item.iter().for_each(|v| {
93 let rule = format!("{prefix}{v}");
94 let position = all_args.iter().position(|t| t == &rule || t == v).unwrap_or(usize::MAX);
97 result.push((position, rule));
98 });
99 }
100
101 result.sort_by_key(|&(position, _)| position);
102 result.into_iter().map(|v| v.1).collect()
103}
104
105#[derive(Debug, Clone, PartialEq, Eq, Hash)]
106pub struct LintConfig {
107 pub allow: Vec<String>,
108 pub warn: Vec<String>,
109 pub deny: Vec<String>,
110 pub forbid: Vec<String>,
111}
112
113impl LintConfig {
114 fn new(builder: &Builder<'_>) -> Self {
115 match builder.config.cmd.clone() {
116 Subcommand::Clippy { allow, deny, warn, forbid, .. } => {
117 Self { allow, warn, deny, forbid }
118 }
119 _ => unreachable!("LintConfig can only be called from `clippy` subcommands."),
120 }
121 }
122
123 fn merge(&self, other: &Self) -> Self {
124 let merged = |self_attr: &[String], other_attr: &[String]| -> Vec<String> {
125 self_attr.iter().cloned().chain(other_attr.iter().cloned()).collect()
126 };
127 Self {
129 allow: merged(&self.allow, &other.allow),
130 warn: merged(&self.warn, &other.warn),
131 deny: merged(&self.deny, &other.deny),
132 forbid: merged(&self.forbid, &other.forbid),
133 }
134 }
135}
136
137#[derive(Debug, Clone, PartialEq, Eq, Hash)]
138pub struct Std {
139 build_compiler: Compiler,
140 target: TargetSelection,
141 config: LintConfig,
142 crates: Vec<String>,
144}
145
146impl Std {
147 fn new(
148 builder: &Builder<'_>,
149 target: TargetSelection,
150 config: LintConfig,
151 crates: Vec<String>,
152 ) -> Self {
153 Self {
154 build_compiler: builder.compiler(builder.top_stage, builder.host_target),
155 target,
156 config,
157 crates,
158 }
159 }
160
161 fn from_build_compiler(
162 build_compiler: Compiler,
163 target: TargetSelection,
164 config: LintConfig,
165 crates: Vec<String>,
166 ) -> Self {
167 Self { build_compiler, target, config, crates }
168 }
169}
170
171impl Step for Std {
172 type Output = ();
173 const DEFAULT: bool = true;
174
175 fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
176 run.crate_or_deps("sysroot").path("library")
177 }
178
179 fn make_run(run: RunConfig<'_>) {
180 let crates = std_crates_for_run_make(&run);
181 let config = LintConfig::new(run.builder);
182 run.builder.ensure(Std::new(run.builder, run.target, config, crates));
183 }
184
185 fn run(self, builder: &Builder<'_>) {
186 let target = self.target;
187 let build_compiler = self.build_compiler;
188
189 let mut cargo = builder::Cargo::new(
190 builder,
191 build_compiler,
192 Mode::Std,
193 SourceType::InTree,
194 target,
195 Kind::Clippy,
196 );
197
198 std_cargo(builder, target, &mut cargo);
199
200 for krate in &*self.crates {
201 cargo.arg("-p").arg(krate);
202 }
203
204 let _guard = builder.msg(
205 Kind::Clippy,
206 format_args!("library{}", crate_description(&self.crates)),
207 Mode::Std,
208 build_compiler,
209 target,
210 );
211
212 run_cargo(
213 builder,
214 cargo,
215 lint_args(builder, &self.config, IGNORED_RULES_FOR_STD_AND_RUSTC),
216 &build_stamp::libstd_stamp(builder, build_compiler, target),
217 vec![],
218 true,
219 false,
220 );
221 }
222
223 fn metadata(&self) -> Option<StepMetadata> {
224 Some(StepMetadata::clippy("std", self.target).built_by(self.build_compiler))
225 }
226}
227
228#[derive(Debug, Clone, PartialEq, Eq, Hash)]
233pub struct Rustc {
234 build_compiler: CompilerForCheck,
235 target: TargetSelection,
236 config: LintConfig,
237 crates: Vec<String>,
239}
240
241impl Rustc {
242 fn new(
243 builder: &Builder<'_>,
244 target: TargetSelection,
245 config: LintConfig,
246 crates: Vec<String>,
247 ) -> Self {
248 Self {
249 build_compiler: prepare_compiler_for_check(builder, target, Mode::Rustc),
250 target,
251 config,
252 crates,
253 }
254 }
255}
256
257impl Step for Rustc {
258 type Output = ();
259 const IS_HOST: bool = true;
260 const DEFAULT: bool = true;
261
262 fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
263 run.crate_or_deps("rustc-main").path("compiler")
264 }
265
266 fn make_run(run: RunConfig<'_>) {
267 let builder = run.builder;
268 let crates = run.make_run_crates(Alias::Compiler);
269 let config = LintConfig::new(run.builder);
270 run.builder.ensure(Rustc::new(builder, run.target, config, crates));
271 }
272
273 fn run(self, builder: &Builder<'_>) {
274 let build_compiler = self.build_compiler.build_compiler();
275 let target = self.target;
276
277 let mut cargo = builder::Cargo::new(
278 builder,
279 build_compiler,
280 Mode::Rustc,
281 SourceType::InTree,
282 target,
283 Kind::Clippy,
284 );
285
286 rustc_cargo(builder, &mut cargo, target, &build_compiler, &self.crates);
287 self.build_compiler.configure_cargo(&mut cargo);
288
289 for krate in &*self.crates {
293 cargo.arg("-p").arg(krate);
294 }
295
296 let _guard = builder.msg(
297 Kind::Clippy,
298 format_args!("compiler{}", crate_description(&self.crates)),
299 Mode::Rustc,
300 build_compiler,
301 target,
302 );
303
304 run_cargo(
305 builder,
306 cargo,
307 lint_args(builder, &self.config, IGNORED_RULES_FOR_STD_AND_RUSTC),
308 &build_stamp::librustc_stamp(builder, build_compiler, target),
309 vec![],
310 true,
311 false,
312 );
313 }
314
315 fn metadata(&self) -> Option<StepMetadata> {
316 Some(
317 StepMetadata::clippy("rustc", self.target)
318 .built_by(self.build_compiler.build_compiler()),
319 )
320 }
321}
322
323#[derive(Debug, Clone, Hash, PartialEq, Eq)]
324pub struct CodegenGcc {
325 build_compiler: CompilerForCheck,
326 target: TargetSelection,
327 config: LintConfig,
328}
329
330impl CodegenGcc {
331 fn new(builder: &Builder<'_>, target: TargetSelection, config: LintConfig) -> Self {
332 Self {
333 build_compiler: prepare_compiler_for_check(builder, target, Mode::Codegen),
334 target,
335 config,
336 }
337 }
338}
339
340impl Step for CodegenGcc {
341 type Output = ();
342
343 fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
344 run.alias("rustc_codegen_gcc")
345 }
346
347 fn make_run(run: RunConfig<'_>) {
348 let builder = run.builder;
349 let config = LintConfig::new(builder);
350 builder.ensure(CodegenGcc::new(builder, run.target, config));
351 }
352
353 fn run(self, builder: &Builder<'_>) -> Self::Output {
354 let build_compiler = self.build_compiler.build_compiler();
355 let target = self.target;
356
357 let mut cargo = prepare_tool_cargo(
358 builder,
359 build_compiler,
360 Mode::Codegen,
361 target,
362 Kind::Clippy,
363 "compiler/rustc_codegen_gcc",
364 SourceType::InTree,
365 &[],
366 );
367 self.build_compiler.configure_cargo(&mut cargo);
368
369 let _guard = builder.msg(
370 Kind::Clippy,
371 "rustc_codegen_gcc",
372 Mode::ToolRustcPrivate,
373 build_compiler,
374 target,
375 );
376
377 let stamp = BuildStamp::new(&builder.cargo_out(build_compiler, Mode::Codegen, target))
378 .with_prefix("rustc_codegen_gcc-check");
379
380 run_cargo(
381 builder,
382 cargo,
383 lint_args(builder, &self.config, &[]),
384 &stamp,
385 vec![],
386 true,
387 false,
388 );
389 }
390
391 fn metadata(&self) -> Option<StepMetadata> {
392 Some(
393 StepMetadata::clippy("rustc_codegen_gcc", self.target)
394 .built_by(self.build_compiler.build_compiler()),
395 )
396 }
397}
398
399macro_rules! lint_any {
400 ($(
401 $name:ident,
402 $path:expr,
403 $readable_name:expr,
404 $mode:expr
405 $(,lint_by_default = $lint_by_default:expr)*
406 ;
407 )+) => {
408 $(
409
410 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
411 pub struct $name {
412 build_compiler: CompilerForCheck,
413 target: TargetSelection,
414 config: LintConfig,
415 }
416
417 impl Step for $name {
418 type Output = ();
419 const DEFAULT: bool = if false $(|| $lint_by_default)* { true } else { false };
420
421 fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
422 run.path($path)
423 }
424
425 fn make_run(run: RunConfig<'_>) {
426 let config = LintConfig::new(run.builder);
427 run.builder.ensure($name {
428 build_compiler: prepare_compiler_for_check(run.builder, run.target, $mode),
429 target: run.target,
430 config,
431 });
432 }
433
434 fn run(self, builder: &Builder<'_>) -> Self::Output {
435 let build_compiler = self.build_compiler.build_compiler();
436 let target = self.target;
437 let mut cargo = prepare_tool_cargo(
438 builder,
439 build_compiler,
440 $mode,
441 target,
442 Kind::Clippy,
443 $path,
444 SourceType::InTree,
445 &[],
446 );
447 self.build_compiler.configure_cargo(&mut cargo);
448
449 let _guard = builder.msg(
450 Kind::Clippy,
451 $readable_name,
452 $mode,
453 build_compiler,
454 target,
455 );
456
457 let stringified_name = stringify!($name).to_lowercase();
458 let stamp = BuildStamp::new(&builder.cargo_out(build_compiler, $mode, target))
459 .with_prefix(&format!("{}-check", stringified_name));
460
461 run_cargo(
462 builder,
463 cargo,
464 lint_args(builder, &self.config, &[]),
465 &stamp,
466 vec![],
467 true,
468 false,
469 );
470 }
471
472 fn metadata(&self) -> Option<StepMetadata> {
473 Some(StepMetadata::clippy($readable_name, self.target).built_by(self.build_compiler.build_compiler()))
474 }
475 }
476 )+
477 }
478}
479
480lint_any!(
483 Bootstrap, "src/bootstrap", "bootstrap", Mode::ToolTarget;
484 BuildHelper, "src/build_helper", "build_helper", Mode::ToolTarget;
485 BuildManifest, "src/tools/build-manifest", "build-manifest", Mode::ToolTarget;
486 CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri", Mode::ToolRustcPrivate;
487 Clippy, "src/tools/clippy", "clippy", Mode::ToolRustcPrivate;
488 CollectLicenseMetadata, "src/tools/collect-license-metadata", "collect-license-metadata", Mode::ToolTarget;
489 Compiletest, "src/tools/compiletest", "compiletest", Mode::ToolTarget;
490 CoverageDump, "src/tools/coverage-dump", "coverage-dump", Mode::ToolTarget;
491 Jsondocck, "src/tools/jsondocck", "jsondocck", Mode::ToolTarget;
492 Jsondoclint, "src/tools/jsondoclint", "jsondoclint", Mode::ToolTarget;
493 LintDocs, "src/tools/lint-docs", "lint-docs", Mode::ToolTarget;
494 LlvmBitcodeLinker, "src/tools/llvm-bitcode-linker", "llvm-bitcode-linker", Mode::ToolTarget;
495 Miri, "src/tools/miri", "miri", Mode::ToolRustcPrivate;
496 MiroptTestTools, "src/tools/miropt-test-tools", "miropt-test-tools", Mode::ToolTarget;
497 OptDist, "src/tools/opt-dist", "opt-dist", Mode::ToolTarget;
498 RemoteTestClient, "src/tools/remote-test-client", "remote-test-client", Mode::ToolTarget;
499 RemoteTestServer, "src/tools/remote-test-server", "remote-test-server", Mode::ToolTarget;
500 RustAnalyzer, "src/tools/rust-analyzer", "rust-analyzer", Mode::ToolRustcPrivate;
501 Rustdoc, "src/librustdoc", "clippy", Mode::ToolRustcPrivate;
502 Rustfmt, "src/tools/rustfmt", "rustfmt", Mode::ToolRustcPrivate;
503 RustInstaller, "src/tools/rust-installer", "rust-installer", Mode::ToolTarget;
504 Tidy, "src/tools/tidy", "tidy", Mode::ToolTarget;
505 TestFloatParse, "src/tools/test-float-parse", "test-float-parse", Mode::ToolStd;
506);
507
508#[derive(Debug, Clone, PartialEq, Eq, Hash)]
510pub struct CI {
511 target: TargetSelection,
512 config: LintConfig,
513}
514
515impl Step for CI {
516 type Output = ();
517 const DEFAULT: bool = false;
518
519 fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
520 run.alias("ci")
521 }
522
523 fn make_run(run: RunConfig<'_>) {
524 let config = LintConfig::new(run.builder);
525 run.builder.ensure(CI { target: run.target, config });
526 }
527
528 fn run(self, builder: &Builder<'_>) -> Self::Output {
529 if builder.top_stage != 2 {
530 eprintln!("ERROR: `x clippy ci` should always be executed with --stage 2");
531 exit!(1);
532 }
533
534 builder.ensure(Bootstrap {
542 build_compiler: prepare_compiler_for_check(builder, self.target, Mode::ToolTarget),
544 target: self.target,
545 config: self.config.merge(&LintConfig {
546 allow: vec![],
547 warn: vec![],
548 deny: vec!["warnings".into()],
549 forbid: vec![],
550 }),
551 });
552
553 let library_clippy_cfg = LintConfig {
554 allow: vec!["clippy::all".into()],
555 warn: vec![],
556 deny: vec![
557 "clippy::correctness".into(),
558 "clippy::char_lit_as_u8".into(),
559 "clippy::four_forward_slashes".into(),
560 "clippy::needless_bool".into(),
561 "clippy::needless_bool_assign".into(),
562 "clippy::non_minimal_cfg".into(),
563 "clippy::print_literal".into(),
564 "clippy::same_item_push".into(),
565 "clippy::single_char_add_str".into(),
566 "clippy::to_string_in_format_args".into(),
567 ],
568 forbid: vec![],
569 };
570 builder.ensure(Std::from_build_compiler(
571 builder.compiler(1, self.target),
573 self.target,
574 self.config.merge(&library_clippy_cfg),
575 vec![],
576 ));
577
578 let compiler_clippy_cfg = LintConfig {
579 allow: vec!["clippy::all".into()],
580 warn: vec![],
581 deny: vec![
582 "clippy::correctness".into(),
583 "clippy::char_lit_as_u8".into(),
584 "clippy::clone_on_ref_ptr".into(),
585 "clippy::format_in_format_args".into(),
586 "clippy::four_forward_slashes".into(),
587 "clippy::needless_bool".into(),
588 "clippy::needless_bool_assign".into(),
589 "clippy::non_minimal_cfg".into(),
590 "clippy::print_literal".into(),
591 "clippy::same_item_push".into(),
592 "clippy::single_char_add_str".into(),
593 "clippy::to_string_in_format_args".into(),
594 ],
595 forbid: vec![],
596 };
597 builder.ensure(Rustc::new(
599 builder,
600 self.target,
601 self.config.merge(&compiler_clippy_cfg),
602 vec![],
603 ));
604
605 let rustc_codegen_gcc = LintConfig {
606 allow: vec![],
607 warn: vec![],
608 deny: vec!["warnings".into()],
609 forbid: vec![],
610 };
611 builder.ensure(CodegenGcc::new(
613 builder,
614 self.target,
615 self.config.merge(&rustc_codegen_gcc),
616 ));
617 }
618}