1use std::collections::BTreeMap;
2use std::ffi::OsStr;
3use std::io::Read;
4use std::path::{Path, PathBuf};
5use std::str::FromStr;
6use std::{fmt, io};
7
8use rustc_data_structures::fx::FxIndexMap;
9use rustc_errors::DiagCtxtHandle;
10use rustc_session::config::{
11 self, CodegenOptions, CrateType, ErrorOutputType, Externs, Input, JsonUnusedExterns,
12 OptionsTargetModifiers, Sysroot, UnstableOptions, get_cmd_lint_options, nightly_options,
13 parse_crate_types_from_list, parse_externs, parse_target_triple,
14};
15use rustc_session::lint::Level;
16use rustc_session::search_paths::SearchPath;
17use rustc_session::{EarlyDiagCtxt, getopts};
18use rustc_span::FileName;
19use rustc_span::edition::Edition;
20use rustc_target::spec::TargetTuple;
21
22use crate::core::new_dcx;
23use crate::externalfiles::ExternalHtml;
24use crate::html::markdown::IdMap;
25use crate::html::render::StylePath;
26use crate::html::static_files;
27use crate::passes::{self, Condition};
28use crate::scrape_examples::{AllCallLocations, ScrapeExamplesOptions};
29use crate::{html, opts, theme};
30
31#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
32pub(crate) enum OutputFormat {
33 Json,
34 #[default]
35 Html,
36 Doctest,
37}
38
39impl OutputFormat {
40 pub(crate) fn is_json(&self) -> bool {
41 matches!(self, OutputFormat::Json)
42 }
43}
44
45impl TryFrom<&str> for OutputFormat {
46 type Error = String;
47
48 fn try_from(value: &str) -> Result<Self, Self::Error> {
49 match value {
50 "json" => Ok(OutputFormat::Json),
51 "html" => Ok(OutputFormat::Html),
52 "doctest" => Ok(OutputFormat::Doctest),
53 _ => Err(format!("unknown output format `{value}`")),
54 }
55 }
56}
57
58pub(crate) enum InputMode {
60 NoInputMergeFinalize,
62 HasFile(Input),
64}
65
66#[derive(Clone)]
68pub(crate) struct Options {
69 pub(crate) crate_name: Option<String>,
72 pub(crate) bin_crate: bool,
74 pub(crate) proc_macro_crate: bool,
76 pub(crate) error_format: ErrorOutputType,
78 pub(crate) diagnostic_width: Option<usize>,
80 pub(crate) libs: Vec<SearchPath>,
82 pub(crate) lib_strs: Vec<String>,
84 pub(crate) externs: Externs,
86 pub(crate) extern_strs: Vec<String>,
88 pub(crate) cfgs: Vec<String>,
90 pub(crate) check_cfgs: Vec<String>,
92 pub(crate) codegen_options: CodegenOptions,
94 pub(crate) codegen_options_strs: Vec<String>,
96 pub(crate) unstable_opts: UnstableOptions,
98 pub(crate) unstable_opts_strs: Vec<String>,
100 pub(crate) target: TargetTuple,
102 pub(crate) edition: Edition,
105 pub(crate) sysroot: Sysroot,
107 pub(crate) lint_opts: Vec<(String, Level)>,
109 pub(crate) describe_lints: bool,
111 pub(crate) lint_cap: Option<Level>,
113
114 pub(crate) should_test: bool,
117 pub(crate) test_args: Vec<String>,
119 pub(crate) test_run_directory: Option<PathBuf>,
121 pub(crate) persist_doctests: Option<PathBuf>,
124 pub(crate) test_runtool: Option<String>,
126 pub(crate) test_runtool_args: Vec<String>,
128 pub(crate) no_run: bool,
130 pub(crate) remap_path_prefix: Vec<(PathBuf, PathBuf)>,
132
133 pub(crate) test_builder: Option<PathBuf>,
136
137 pub(crate) test_builder_wrappers: Vec<PathBuf>,
139
140 pub(crate) show_coverage: bool,
144
145 pub(crate) crate_version: Option<String>,
148 pub(crate) output_format: OutputFormat,
152 pub(crate) run_check: bool,
155 pub(crate) json_unused_externs: JsonUnusedExterns,
157 pub(crate) nocapture: bool,
159
160 pub(crate) scrape_examples_options: Option<ScrapeExamplesOptions>,
163
164 pub(crate) unstable_features: rustc_feature::UnstableFeatures,
167
168 pub(crate) expanded_args: Vec<String>,
173
174 pub(crate) doctest_build_args: Vec<String>,
176
177 pub(crate) target_modifiers: BTreeMap<OptionsTargetModifiers, String>,
179}
180
181impl fmt::Debug for Options {
182 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
183 struct FmtExterns<'a>(&'a Externs);
184
185 impl fmt::Debug for FmtExterns<'_> {
186 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
187 f.debug_map().entries(self.0.iter()).finish()
188 }
189 }
190
191 f.debug_struct("Options")
192 .field("crate_name", &self.crate_name)
193 .field("bin_crate", &self.bin_crate)
194 .field("proc_macro_crate", &self.proc_macro_crate)
195 .field("error_format", &self.error_format)
196 .field("libs", &self.libs)
197 .field("externs", &FmtExterns(&self.externs))
198 .field("cfgs", &self.cfgs)
199 .field("check-cfgs", &self.check_cfgs)
200 .field("codegen_options", &"...")
201 .field("unstable_options", &"...")
202 .field("target", &self.target)
203 .field("edition", &self.edition)
204 .field("sysroot", &self.sysroot)
205 .field("lint_opts", &self.lint_opts)
206 .field("describe_lints", &self.describe_lints)
207 .field("lint_cap", &self.lint_cap)
208 .field("should_test", &self.should_test)
209 .field("test_args", &self.test_args)
210 .field("test_run_directory", &self.test_run_directory)
211 .field("persist_doctests", &self.persist_doctests)
212 .field("show_coverage", &self.show_coverage)
213 .field("crate_version", &self.crate_version)
214 .field("test_runtool", &self.test_runtool)
215 .field("test_runtool_args", &self.test_runtool_args)
216 .field("run_check", &self.run_check)
217 .field("no_run", &self.no_run)
218 .field("test_builder_wrappers", &self.test_builder_wrappers)
219 .field("remap-file-prefix", &self.remap_path_prefix)
220 .field("nocapture", &self.nocapture)
221 .field("scrape_examples_options", &self.scrape_examples_options)
222 .field("unstable_features", &self.unstable_features)
223 .finish()
224 }
225}
226
227#[derive(Clone, Debug)]
229pub(crate) struct RenderOptions {
230 pub(crate) output: PathBuf,
232 pub(crate) external_html: ExternalHtml,
234 pub(crate) id_map: IdMap,
237 pub(crate) playground_url: Option<String>,
241 pub(crate) module_sorting: ModuleSorting,
244 pub(crate) themes: Vec<StylePath>,
247 pub(crate) extension_css: Option<PathBuf>,
249 pub(crate) extern_html_root_urls: BTreeMap<String, String>,
251 pub(crate) extern_html_root_takes_precedence: bool,
253 pub(crate) default_settings: FxIndexMap<String, String>,
256 pub(crate) resource_suffix: String,
258 pub(crate) enable_index_page: bool,
261 pub(crate) index_page: Option<PathBuf>,
264 pub(crate) static_root_path: Option<String>,
267
268 pub(crate) markdown_no_toc: bool,
272 pub(crate) markdown_css: Vec<String>,
274 pub(crate) markdown_playground_url: Option<String>,
277 pub(crate) document_private: bool,
279 pub(crate) document_hidden: bool,
281 pub(crate) generate_redirect_map: bool,
283 pub(crate) show_type_layout: bool,
285 pub(crate) unstable_features: rustc_feature::UnstableFeatures,
288 pub(crate) emit: Vec<EmitType>,
289 pub(crate) generate_link_to_definition: bool,
291 pub(crate) call_locations: AllCallLocations,
293 pub(crate) no_emit_shared: bool,
295 pub(crate) html_no_source: bool,
297 pub(crate) output_to_stdout: bool,
300 pub(crate) should_merge: ShouldMerge,
302 pub(crate) include_parts_dir: Vec<PathToParts>,
304 pub(crate) parts_out_dir: Option<PathToParts>,
306 pub(crate) disable_minification: bool,
308}
309
310#[derive(Copy, Clone, Debug, PartialEq, Eq)]
311pub(crate) enum ModuleSorting {
312 DeclarationOrder,
313 Alphabetical,
314}
315
316#[derive(Clone, Debug, PartialEq, Eq)]
317pub(crate) enum EmitType {
318 Unversioned,
319 Toolchain,
320 InvocationSpecific,
321 DepInfo(Option<PathBuf>),
322}
323
324impl FromStr for EmitType {
325 type Err = ();
326
327 fn from_str(s: &str) -> Result<Self, Self::Err> {
328 match s {
329 "unversioned-shared-resources" => Ok(Self::Unversioned),
330 "toolchain-shared-resources" => Ok(Self::Toolchain),
331 "invocation-specific" => Ok(Self::InvocationSpecific),
332 "dep-info" => Ok(Self::DepInfo(None)),
333 option => {
334 if let Some(file) = option.strip_prefix("dep-info=") {
335 Ok(Self::DepInfo(Some(Path::new(file).into())))
336 } else {
337 Err(())
338 }
339 }
340 }
341 }
342}
343
344impl RenderOptions {
345 pub(crate) fn should_emit_crate(&self) -> bool {
346 self.emit.is_empty() || self.emit.contains(&EmitType::InvocationSpecific)
347 }
348
349 pub(crate) fn dep_info(&self) -> Option<Option<&Path>> {
350 for emit in &self.emit {
351 if let EmitType::DepInfo(file) = emit {
352 return Some(file.as_deref());
353 }
354 }
355 None
356 }
357}
358
359fn make_input(early_dcx: &EarlyDiagCtxt, input: &str) -> Input {
363 if input == "-" {
364 let mut src = String::new();
365 if io::stdin().read_to_string(&mut src).is_err() {
366 early_dcx.early_fatal("couldn't read from stdin, as it did not contain valid UTF-8");
369 }
370 Input::Str { name: FileName::anon_source_code(&src), input: src }
371 } else {
372 Input::File(PathBuf::from(input))
373 }
374}
375
376impl Options {
377 pub(crate) fn from_matches(
380 early_dcx: &mut EarlyDiagCtxt,
381 matches: &getopts::Matches,
382 args: Vec<String>,
383 ) -> Option<(InputMode, Options, RenderOptions, Vec<PathBuf>)> {
384 nightly_options::check_nightly_options(early_dcx, matches, &opts());
386
387 if args.is_empty() || matches.opt_present("h") || matches.opt_present("help") {
388 crate::usage("rustdoc");
389 return None;
390 } else if matches.opt_present("version") {
391 rustc_driver::version!(&early_dcx, "rustdoc", matches);
392 return None;
393 }
394
395 if rustc_driver::describe_flag_categories(early_dcx, matches) {
396 return None;
397 }
398
399 let color = config::parse_color(early_dcx, matches);
400 let config::JsonConfig { json_rendered, json_unused_externs, json_color, .. } =
401 config::parse_json(early_dcx, matches);
402 let error_format =
403 config::parse_error_format(early_dcx, matches, color, json_color, json_rendered);
404 let diagnostic_width = matches.opt_get("diagnostic-width").unwrap_or_default();
405
406 let mut target_modifiers = BTreeMap::<OptionsTargetModifiers, String>::new();
407 let codegen_options = CodegenOptions::build(early_dcx, matches, &mut target_modifiers);
408 let unstable_opts = UnstableOptions::build(early_dcx, matches, &mut target_modifiers);
409
410 let remap_path_prefix = match parse_remap_path_prefix(matches) {
411 Ok(prefix_mappings) => prefix_mappings,
412 Err(err) => {
413 early_dcx.early_fatal(err);
414 }
415 };
416
417 let dcx = new_dcx(error_format, None, diagnostic_width, &unstable_opts);
418 let dcx = dcx.handle();
419
420 check_deprecated_options(matches, dcx);
422
423 if matches.opt_strs("passes") == ["list"] {
424 println!("Available passes for running rustdoc:");
425 for pass in passes::PASSES {
426 println!("{:>20} - {}", pass.name, pass.description);
427 }
428 println!("\nDefault passes for rustdoc:");
429 for p in passes::DEFAULT_PASSES {
430 print!("{:>20}", p.pass.name);
431 println_condition(p.condition);
432 }
433
434 if nightly_options::match_is_nightly_build(matches) {
435 println!("\nPasses run with `--show-coverage`:");
436 for p in passes::COVERAGE_PASSES {
437 print!("{:>20}", p.pass.name);
438 println_condition(p.condition);
439 }
440 }
441
442 fn println_condition(condition: Condition) {
443 use Condition::*;
444 match condition {
445 Always => println!(),
446 WhenDocumentPrivate => println!(" (when --document-private-items)"),
447 WhenNotDocumentPrivate => println!(" (when not --document-private-items)"),
448 WhenNotDocumentHidden => println!(" (when not --document-hidden-items)"),
449 }
450 }
451
452 return None;
453 }
454
455 let mut emit = Vec::new();
456 for list in matches.opt_strs("emit") {
457 for kind in list.split(',') {
458 match kind.parse() {
459 Ok(kind) => emit.push(kind),
460 Err(()) => dcx.fatal(format!("unrecognized emission type: {kind}")),
461 }
462 }
463 }
464
465 let show_coverage = matches.opt_present("show-coverage");
466 let output_format_s = matches.opt_str("output-format");
467 let output_format = match output_format_s {
468 Some(ref s) => match OutputFormat::try_from(s.as_str()) {
469 Ok(out_fmt) => out_fmt,
470 Err(e) => dcx.fatal(e),
471 },
472 None => OutputFormat::default(),
473 };
474
475 match (
477 output_format_s.as_ref().map(|_| output_format),
478 show_coverage,
479 nightly_options::is_unstable_enabled(matches),
480 ) {
481 (None | Some(OutputFormat::Json), true, _) => {}
482 (_, true, _) => {
483 dcx.fatal(format!(
484 "`--output-format={}` is not supported for the `--show-coverage` option",
485 output_format_s.unwrap_or_default(),
486 ));
487 }
488 (_, false, true) => {}
490 (None | Some(OutputFormat::Html), false, _) => {}
491 (Some(OutputFormat::Json), false, false) => {
492 dcx.fatal(
493 "the -Z unstable-options flag must be passed to enable --output-format for documentation generation (see https://github.com/rust-lang/rust/issues/76578)",
494 );
495 }
496 (Some(OutputFormat::Doctest), false, false) => {
497 dcx.fatal(
498 "the -Z unstable-options flag must be passed to enable --output-format for documentation generation (see https://github.com/rust-lang/rust/issues/134529)",
499 );
500 }
501 }
502
503 let to_check = matches.opt_strs("check-theme");
504 if !to_check.is_empty() {
505 let mut content =
506 std::str::from_utf8(static_files::STATIC_FILES.rustdoc_css.src_bytes).unwrap();
507 if let Some((_, inside)) = content.split_once("/* Begin theme: light */") {
508 content = inside;
509 }
510 if let Some((inside, _)) = content.split_once("/* End theme: light */") {
511 content = inside;
512 }
513 let paths = match theme::load_css_paths(content) {
514 Ok(p) => p,
515 Err(e) => dcx.fatal(e),
516 };
517 let mut errors = 0;
518
519 println!("rustdoc: [check-theme] Starting tests! (Ignoring all other arguments)");
520 for theme_file in to_check.iter() {
521 print!(" - Checking \"{theme_file}\"...");
522 let (success, differences) = theme::test_theme_against(theme_file, &paths, dcx);
523 if !differences.is_empty() || !success {
524 println!(" FAILED");
525 errors += 1;
526 if !differences.is_empty() {
527 println!("{}", differences.join("\n"));
528 }
529 } else {
530 println!(" OK");
531 }
532 }
533 if errors != 0 {
534 dcx.fatal("[check-theme] one or more tests failed");
535 }
536 return None;
537 }
538
539 let (lint_opts, describe_lints, lint_cap) = get_cmd_lint_options(early_dcx, matches);
540
541 let input = if describe_lints {
542 InputMode::HasFile(make_input(early_dcx, ""))
543 } else {
544 match matches.free.as_slice() {
545 [] if matches.opt_str("merge").as_deref() == Some("finalize") => {
546 InputMode::NoInputMergeFinalize
547 }
548 [] => dcx.fatal("missing file operand"),
549 [input] => InputMode::HasFile(make_input(early_dcx, input)),
550 _ => dcx.fatal("too many file operands"),
551 }
552 };
553
554 let externs = parse_externs(early_dcx, matches, &unstable_opts);
555 let extern_html_root_urls = match parse_extern_html_roots(matches) {
556 Ok(ex) => ex,
557 Err(err) => dcx.fatal(err),
558 };
559
560 let parts_out_dir =
561 match matches.opt_str("parts-out-dir").map(PathToParts::from_flag).transpose() {
562 Ok(parts_out_dir) => parts_out_dir,
563 Err(e) => dcx.fatal(e),
564 };
565 let include_parts_dir = match parse_include_parts_dir(matches) {
566 Ok(include_parts_dir) => include_parts_dir,
567 Err(e) => dcx.fatal(e),
568 };
569
570 let default_settings: Vec<Vec<(String, String)>> = vec![
571 matches
572 .opt_str("default-theme")
573 .iter()
574 .flat_map(|theme| {
575 vec![
576 ("use-system-theme".to_string(), "false".to_string()),
577 ("theme".to_string(), theme.to_string()),
578 ]
579 })
580 .collect(),
581 matches
582 .opt_strs("default-setting")
583 .iter()
584 .map(|s| match s.split_once('=') {
585 None => (s.clone(), "true".to_string()),
586 Some((k, v)) => (k.to_string(), v.to_string()),
587 })
588 .collect(),
589 ];
590 let default_settings = default_settings
591 .into_iter()
592 .flatten()
593 .map(
594 |(k, v)| (k.replace('-', "_"), v),
613 )
614 .collect();
615
616 let test_args = matches.opt_strs("test-args");
617 let test_args: Vec<String> =
618 test_args.iter().flat_map(|s| s.split_whitespace()).map(|s| s.to_string()).collect();
619
620 let should_test = matches.opt_present("test");
621 let no_run = matches.opt_present("no-run");
622
623 if !should_test && no_run {
624 dcx.fatal("the `--test` flag must be passed to enable `--no-run`");
625 }
626
627 let mut output_to_stdout = false;
628 let test_builder_wrappers =
629 matches.opt_strs("test-builder-wrapper").iter().map(PathBuf::from).collect();
630 let output = match (matches.opt_str("out-dir"), matches.opt_str("output")) {
631 (Some(_), Some(_)) => {
632 dcx.fatal("cannot use both 'out-dir' and 'output' at once");
633 }
634 (Some(out_dir), None) | (None, Some(out_dir)) => {
635 output_to_stdout = out_dir == "-";
636 PathBuf::from(out_dir)
637 }
638 (None, None) => PathBuf::from("doc"),
639 };
640
641 let cfgs = matches.opt_strs("cfg");
642 let check_cfgs = matches.opt_strs("check-cfg");
643
644 let extension_css = matches.opt_str("e").map(|s| PathBuf::from(&s));
645
646 let mut loaded_paths = Vec::new();
647
648 if let Some(ref p) = extension_css {
649 loaded_paths.push(p.clone());
650 if !p.is_file() {
651 dcx.fatal("option --extend-css argument must be a file");
652 }
653 }
654
655 let mut themes = Vec::new();
656 if matches.opt_present("theme") {
657 let mut content =
658 std::str::from_utf8(static_files::STATIC_FILES.rustdoc_css.src_bytes).unwrap();
659 if let Some((_, inside)) = content.split_once("/* Begin theme: light */") {
660 content = inside;
661 }
662 if let Some((inside, _)) = content.split_once("/* End theme: light */") {
663 content = inside;
664 }
665 let paths = match theme::load_css_paths(content) {
666 Ok(p) => p,
667 Err(e) => dcx.fatal(e),
668 };
669
670 for (theme_file, theme_s) in
671 matches.opt_strs("theme").iter().map(|s| (PathBuf::from(&s), s.to_owned()))
672 {
673 if !theme_file.is_file() {
674 dcx.struct_fatal(format!("invalid argument: \"{theme_s}\""))
675 .with_help("arguments to --theme must be files")
676 .emit();
677 }
678 if theme_file.extension() != Some(OsStr::new("css")) {
679 dcx.struct_fatal(format!("invalid argument: \"{theme_s}\""))
680 .with_help("arguments to --theme must have a .css extension")
681 .emit();
682 }
683 let (success, ret) = theme::test_theme_against(&theme_file, &paths, dcx);
684 if !success {
685 dcx.fatal(format!("error loading theme file: \"{theme_s}\""));
686 } else if !ret.is_empty() {
687 dcx.struct_warn(format!(
688 "theme file \"{theme_s}\" is missing CSS rules from the default theme",
689 ))
690 .with_warn("the theme may appear incorrect when loaded")
691 .with_help(format!(
692 "to see what rules are missing, call `rustdoc --check-theme \"{theme_s}\"`",
693 ))
694 .emit();
695 }
696 loaded_paths.push(theme_file.clone());
697 themes.push(StylePath { path: theme_file });
698 }
699 }
700
701 let edition = config::parse_crate_edition(early_dcx, matches);
702
703 let mut id_map = html::markdown::IdMap::new();
704 let Some(external_html) = ExternalHtml::load(
705 &matches.opt_strs("html-in-header"),
706 &matches.opt_strs("html-before-content"),
707 &matches.opt_strs("html-after-content"),
708 &matches.opt_strs("markdown-before-content"),
709 &matches.opt_strs("markdown-after-content"),
710 nightly_options::match_is_nightly_build(matches),
711 dcx,
712 &mut id_map,
713 edition,
714 &None,
715 &mut loaded_paths,
716 ) else {
717 dcx.fatal("`ExternalHtml::load` failed");
718 };
719
720 match matches.opt_str("r").as_deref() {
721 Some("rust") | None => {}
722 Some(s) => dcx.fatal(format!("unknown input format: {s}")),
723 }
724
725 let index_page = matches.opt_str("index-page").map(|s| PathBuf::from(&s));
726 if let Some(ref index_page) = index_page
727 && !index_page.is_file()
728 {
729 dcx.fatal("option `--index-page` argument must be a file");
730 }
731
732 let target = parse_target_triple(early_dcx, matches);
733 let sysroot = Sysroot::new(matches.opt_str("sysroot").map(PathBuf::from));
734
735 let libs = matches
736 .opt_strs("L")
737 .iter()
738 .map(|s| {
739 SearchPath::from_cli_opt(
740 sysroot.path(),
741 &target,
742 early_dcx,
743 s,
744 #[allow(rustc::bad_opt_access)] unstable_opts.unstable_options,
746 )
747 })
748 .collect();
749
750 let crate_types = match parse_crate_types_from_list(matches.opt_strs("crate-type")) {
751 Ok(types) => types,
752 Err(e) => {
753 dcx.fatal(format!("unknown crate type: {e}"));
754 }
755 };
756
757 let crate_name = matches.opt_str("crate-name");
758 let bin_crate = crate_types.contains(&CrateType::Executable);
759 let proc_macro_crate = crate_types.contains(&CrateType::ProcMacro);
760 let playground_url = matches.opt_str("playground-url");
761 let module_sorting = if matches.opt_present("sort-modules-by-appearance") {
762 ModuleSorting::DeclarationOrder
763 } else {
764 ModuleSorting::Alphabetical
765 };
766 let resource_suffix = matches.opt_str("resource-suffix").unwrap_or_default();
767 let markdown_no_toc = matches.opt_present("markdown-no-toc");
768 let markdown_css = matches.opt_strs("markdown-css");
769 let markdown_playground_url = matches.opt_str("markdown-playground-url");
770 let crate_version = matches.opt_str("crate-version");
771 let enable_index_page = matches.opt_present("enable-index-page") || index_page.is_some();
772 let static_root_path = matches.opt_str("static-root-path");
773 let test_run_directory = matches.opt_str("test-run-directory").map(PathBuf::from);
774 let persist_doctests = matches.opt_str("persist-doctests").map(PathBuf::from);
775 let test_builder = matches.opt_str("test-builder").map(PathBuf::from);
776 let codegen_options_strs = matches.opt_strs("C");
777 let unstable_opts_strs = matches.opt_strs("Z");
778 let lib_strs = matches.opt_strs("L");
779 let extern_strs = matches.opt_strs("extern");
780 let test_runtool = matches.opt_str("test-runtool");
781 let test_runtool_args = matches.opt_strs("test-runtool-arg");
782 let document_private = matches.opt_present("document-private-items");
783 let document_hidden = matches.opt_present("document-hidden-items");
784 let run_check = matches.opt_present("check");
785 let generate_redirect_map = matches.opt_present("generate-redirect-map");
786 let show_type_layout = matches.opt_present("show-type-layout");
787 let nocapture = matches.opt_present("nocapture");
788 let generate_link_to_definition = matches.opt_present("generate-link-to-definition");
789 let extern_html_root_takes_precedence =
790 matches.opt_present("extern-html-root-takes-precedence");
791 let html_no_source = matches.opt_present("html-no-source");
792 let should_merge = match parse_merge(matches) {
793 Ok(result) => result,
794 Err(e) => dcx.fatal(format!("--merge option error: {e}")),
795 };
796
797 if generate_link_to_definition && (show_coverage || output_format != OutputFormat::Html) {
798 dcx.struct_warn(
799 "`--generate-link-to-definition` option can only be used with HTML output format",
800 )
801 .with_note("`--generate-link-to-definition` option will be ignored")
802 .emit();
803 }
804
805 let scrape_examples_options = ScrapeExamplesOptions::new(matches, dcx);
806 let with_examples = matches.opt_strs("with-examples");
807 let call_locations =
808 crate::scrape_examples::load_call_locations(with_examples, dcx, &mut loaded_paths);
809 let doctest_build_args = matches.opt_strs("doctest-build-arg");
810
811 let unstable_features =
812 rustc_feature::UnstableFeatures::from_environment(crate_name.as_deref());
813
814 let disable_minification = matches.opt_present("disable-minification");
815
816 let options = Options {
817 bin_crate,
818 proc_macro_crate,
819 error_format,
820 diagnostic_width,
821 libs,
822 lib_strs,
823 externs,
824 extern_strs,
825 cfgs,
826 check_cfgs,
827 codegen_options,
828 codegen_options_strs,
829 unstable_opts,
830 unstable_opts_strs,
831 target,
832 edition,
833 sysroot,
834 lint_opts,
835 describe_lints,
836 lint_cap,
837 should_test,
838 test_args,
839 show_coverage,
840 crate_version,
841 test_run_directory,
842 persist_doctests,
843 test_runtool,
844 test_runtool_args,
845 test_builder,
846 run_check,
847 no_run,
848 test_builder_wrappers,
849 remap_path_prefix,
850 nocapture,
851 crate_name,
852 output_format,
853 json_unused_externs,
854 scrape_examples_options,
855 unstable_features,
856 expanded_args: args,
857 doctest_build_args,
858 target_modifiers,
859 };
860 let render_options = RenderOptions {
861 output,
862 external_html,
863 id_map,
864 playground_url,
865 module_sorting,
866 themes,
867 extension_css,
868 extern_html_root_urls,
869 extern_html_root_takes_precedence,
870 default_settings,
871 resource_suffix,
872 enable_index_page,
873 index_page,
874 static_root_path,
875 markdown_no_toc,
876 markdown_css,
877 markdown_playground_url,
878 document_private,
879 document_hidden,
880 generate_redirect_map,
881 show_type_layout,
882 unstable_features,
883 emit,
884 generate_link_to_definition,
885 call_locations,
886 no_emit_shared: false,
887 html_no_source,
888 output_to_stdout,
889 should_merge,
890 include_parts_dir,
891 parts_out_dir,
892 disable_minification,
893 };
894 Some((input, options, render_options, loaded_paths))
895 }
896}
897
898pub(crate) fn markdown_input(input: &Input) -> Option<&Path> {
900 input.opt_path().filter(|p| matches!(p.extension(), Some(e) if e == "md" || e == "markdown"))
901}
902
903fn parse_remap_path_prefix(
904 matches: &getopts::Matches,
905) -> Result<Vec<(PathBuf, PathBuf)>, &'static str> {
906 matches
907 .opt_strs("remap-path-prefix")
908 .into_iter()
909 .map(|remap| {
910 remap
911 .rsplit_once('=')
912 .ok_or("--remap-path-prefix must contain '=' between FROM and TO")
913 .map(|(from, to)| (PathBuf::from(from), PathBuf::from(to)))
914 })
915 .collect()
916}
917
918fn check_deprecated_options(matches: &getopts::Matches, dcx: DiagCtxtHandle<'_>) {
920 let deprecated_flags = [];
921
922 for &flag in deprecated_flags.iter() {
923 if matches.opt_present(flag) {
924 dcx.struct_warn(format!("the `{flag}` flag is deprecated"))
925 .with_note(
926 "see issue #44136 <https://github.com/rust-lang/rust/issues/44136> \
927 for more information",
928 )
929 .emit();
930 }
931 }
932
933 let removed_flags = ["plugins", "plugin-path", "no-defaults", "passes", "input-format"];
934
935 for &flag in removed_flags.iter() {
936 if matches.opt_present(flag) {
937 let mut err = dcx.struct_warn(format!("the `{flag}` flag no longer functions"));
938 err.note(
939 "see issue #44136 <https://github.com/rust-lang/rust/issues/44136> \
940 for more information",
941 );
942
943 if flag == "no-defaults" || flag == "passes" {
944 err.help("you may want to use --document-private-items");
945 } else if flag == "plugins" || flag == "plugin-path" {
946 err.warn("see CVE-2018-1000622");
947 }
948
949 err.emit();
950 }
951 }
952}
953
954fn parse_extern_html_roots(
958 matches: &getopts::Matches,
959) -> Result<BTreeMap<String, String>, &'static str> {
960 let mut externs = BTreeMap::new();
961 for arg in &matches.opt_strs("extern-html-root-url") {
962 let (name, url) =
963 arg.split_once('=').ok_or("--extern-html-root-url must be of the form name=url")?;
964 externs.insert(name.to_string(), url.to_string());
965 }
966 Ok(externs)
967}
968
969#[derive(Clone, Debug)]
973pub(crate) struct PathToParts(pub(crate) PathBuf);
974
975impl PathToParts {
976 fn from_flag(path: String) -> Result<PathToParts, String> {
977 let mut path = PathBuf::from(path);
978 if path.exists() && !path.is_dir() {
980 Err(format!(
981 "--parts-out-dir and --include-parts-dir expect directories, found: {}",
982 path.display(),
983 ))
984 } else {
985 path.push("crate-info");
987 Ok(PathToParts(path))
988 }
989 }
990}
991
992fn parse_include_parts_dir(m: &getopts::Matches) -> Result<Vec<PathToParts>, String> {
994 let mut ret = Vec::new();
995 for p in m.opt_strs("include-parts-dir") {
996 let p = PathToParts::from_flag(p)?;
997 if !p.0.is_file() {
999 return Err(format!("--include-parts-dir expected {} to be a file", p.0.display()));
1000 }
1001 ret.push(p);
1002 }
1003 Ok(ret)
1004}
1005
1006#[derive(Debug, Clone)]
1008pub(crate) struct ShouldMerge {
1009 pub(crate) read_rendered_cci: bool,
1011 pub(crate) write_rendered_cci: bool,
1013}
1014
1015fn parse_merge(m: &getopts::Matches) -> Result<ShouldMerge, &'static str> {
1018 match m.opt_str("merge").as_deref() {
1019 None => Ok(ShouldMerge { read_rendered_cci: true, write_rendered_cci: true }),
1021 Some("none") if m.opt_present("include-parts-dir") => {
1022 Err("--include-parts-dir not allowed if --merge=none")
1023 }
1024 Some("none") => Ok(ShouldMerge { read_rendered_cci: false, write_rendered_cci: false }),
1025 Some("shared") if m.opt_present("parts-out-dir") || m.opt_present("include-parts-dir") => {
1026 Err("--parts-out-dir and --include-parts-dir not allowed if --merge=shared")
1027 }
1028 Some("shared") => Ok(ShouldMerge { read_rendered_cci: true, write_rendered_cci: true }),
1029 Some("finalize") if m.opt_present("parts-out-dir") => {
1030 Err("--parts-out-dir not allowed if --merge=finalize")
1031 }
1032 Some("finalize") => Ok(ShouldMerge { read_rendered_cci: false, write_rendered_cci: true }),
1033 Some(_) => Err("argument to --merge must be `none`, `shared`, or `finalize`"),
1034 }
1035}