self, parse_crate_types_from_list, parse_externs, parse_target_triple, CrateType,
};
use rustc_session::config::{get_cmd_lint_options, nightly_options};
-use rustc_session::config::{CodegenOptions, DebuggingOptions, ErrorOutputType, Externs};
+use rustc_session::config::{
+ CodegenOptions, DebuggingOptions, ErrorOutputType, Externs, JsonUnusedExterns,
+};
use rustc_session::getopts;
use rustc_session::lint::Level;
use rustc_session::search_paths::SearchPath;
use crate::html::render::StylePath;
use crate::html::static_files;
use crate::opts;
-use crate::passes::{self, Condition, DefaultPassOption};
+use crate::passes::{self, Condition};
+use crate::scrape_examples::{AllCallLocations, ScrapeExamplesOptions};
use crate::theme;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
crate extern_strs: Vec<String>,
/// List of `cfg` flags to hand to the compiler. Always includes `rustdoc`.
crate cfgs: Vec<String>,
+ /// List of check cfg flags to hand to the compiler.
+ crate check_cfgs: Vec<String>,
/// Codegen options to hand to the compiler.
crate codegen_options: CodegenOptions,
/// Codegen options strings to hand to the compiler.
crate test_builder: Option<PathBuf>,
// Options that affect the documentation process
- /// The selected default set of passes to use.
- ///
- /// Be aware: This option can come both from the CLI and from crate attributes!
- crate default_passes: DefaultPassOption,
- /// Any passes manually selected by the user.
- ///
- /// Be aware: This option can come both from the CLI and from crate attributes!
- crate manual_passes: Vec<String>,
- /// Whether to display warnings during doc generation or while gathering doctests. By default,
- /// all non-rustdoc-specific lints are allowed when generating docs.
- crate display_doctest_warnings: bool,
/// Whether to run the `calculate-doc-coverage` pass, which counts the number of public items
/// with and without documentation.
crate show_coverage: bool,
/// documentation.
crate run_check: bool,
/// Whether doctests should emit unused externs
- crate json_unused_externs: bool,
+ crate json_unused_externs: JsonUnusedExterns,
/// Whether to skip capturing stdout and stderr of tests.
crate nocapture: bool,
+
+ /// Configuration for scraping examples from the current crate. If this option is Some(..) then
+ /// the compiler will scrape examples and not generate documentation.
+ crate scrape_examples_options: Option<ScrapeExamplesOptions>,
}
impl fmt::Debug for Options {
.field("libs", &self.libs)
.field("externs", &FmtExterns(&self.externs))
.field("cfgs", &self.cfgs)
+ .field("check-cfgs", &self.check_cfgs)
.field("codegen_options", &"...")
.field("debugging_options", &"...")
.field("target", &self.target)
.field("test_args", &self.test_args)
.field("test_run_directory", &self.test_run_directory)
.field("persist_doctests", &self.persist_doctests)
- .field("default_passes", &self.default_passes)
- .field("manual_passes", &self.manual_passes)
- .field("display_doctest_warnings", &self.display_doctest_warnings)
.field("show_coverage", &self.show_coverage)
.field("crate_version", &self.crate_version)
.field("render_options", &self.render_options)
.field("run_check", &self.run_check)
.field("no_run", &self.no_run)
.field("nocapture", &self.nocapture)
+ .field("scrape_examples_options", &self.scrape_examples_options)
.finish()
}
}
/// If present, playground URL to use in the "Run" button added to code samples generated from
/// standalone Markdown files. If not present, `playground_url` is used.
crate markdown_playground_url: Option<String>,
- /// If false, the `select` element to have search filtering by crates on rendered docs
- /// won't be generated.
- crate generate_search_filter: bool,
/// Document items that have lower than `pub` visibility.
crate document_private: bool,
/// Document items that have `doc(hidden)`.
crate emit: Vec<EmitType>,
/// If `true`, HTML source pages will generate links for items to their definition.
crate generate_link_to_definition: bool,
+ /// Set of function-call locations to include as examples
+ crate call_locations: AllCallLocations,
+ /// If `true`, Context::init will not emit shared files.
+ crate no_emit_shared: bool,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
/// been printed, returns `Err` with the exit code.
crate fn from_matches(matches: &getopts::Matches) -> Result<Options, i32> {
// Check for unstable options.
- nightly_options::check_nightly_options(&matches, &opts());
+ nightly_options::check_nightly_options(matches, &opts());
if matches.opt_present("h") || matches.opt_present("help") {
crate::usage("rustdoc");
return Err(0);
} else if matches.opt_present("version") {
- rustc_driver::version("rustdoc", &matches);
+ rustc_driver::version("rustdoc", matches);
return Err(0);
}
+ let color = config::parse_color(matches);
+ let config::JsonConfig { json_rendered, json_unused_externs, .. } =
+ config::parse_json(matches);
+ let error_format = config::parse_error_format(matches, color, json_rendered);
+
+ let codegen_options = CodegenOptions::build(matches, error_format);
+ let debugging_opts = DebuggingOptions::build(matches, error_format);
+
+ let diag = new_handler(error_format, None, &debugging_opts);
+
+ // check for deprecated options
+ check_deprecated_options(matches, &diag);
+
if matches.opt_strs("passes") == ["list"] {
println!("Available passes for running rustdoc:");
for pass in passes::PASSES {
return Err(0);
}
- let color = config::parse_color(&matches);
- let config::JsonConfig { json_rendered, json_unused_externs, .. } =
- config::parse_json(&matches);
- let error_format = config::parse_error_format(&matches, color, json_rendered);
-
- let codegen_options = CodegenOptions::build(matches, error_format);
- let debugging_opts = DebuggingOptions::build(matches, error_format);
-
- let diag = new_handler(error_format, None, &debugging_opts);
-
- // check for deprecated options
- check_deprecated_options(&matches, &diag);
-
let mut emit = Vec::new();
for list in matches.opt_strs("emit") {
for kind in list.split(',') {
.iter()
.map(|s| SearchPath::from_cli_opt(s, error_format))
.collect();
- let externs = parse_externs(&matches, &debugging_opts, error_format);
- let extern_html_root_urls = match parse_extern_html_roots(&matches) {
+ let externs = parse_externs(matches, &debugging_opts, error_format);
+ let extern_html_root_urls = match parse_extern_html_roots(matches) {
Ok(ex) => ex,
Err(err) => {
diag.struct_err(err).emit();
matches
.opt_str("default-theme")
.iter()
- .map(|theme| {
+ .flat_map(|theme| {
vec![
("use-system-theme".to_string(), "false".to_string()),
("theme".to_string(), theme.to_string()),
]
})
- .flatten()
.collect(),
matches
.opt_strs("default-setting")
return Err(1);
}
- let output =
- matches.opt_str("o").map(|s| PathBuf::from(&s)).unwrap_or_else(|| PathBuf::from("doc"));
+ let out_dir = matches.opt_str("out-dir").map(|s| PathBuf::from(&s));
+ let output = matches.opt_str("output").map(|s| PathBuf::from(&s));
+ let output = match (out_dir, output) {
+ (Some(_), Some(_)) => {
+ diag.struct_err("cannot use both 'out-dir' and 'output' at once").emit();
+ return Err(1);
+ }
+ (Some(out_dir), None) => out_dir,
+ (None, Some(output)) => output,
+ (None, None) => PathBuf::from("doc"),
+ };
+
let cfgs = matches.opt_strs("cfg");
+ let check_cfgs = matches.opt_strs("check-cfg");
let extension_css = matches.opt_str("e").map(|s| PathBuf::from(&s));
))
.emit();
}
- themes.push(StylePath { path: theme_file, disabled: true });
+ themes.push(StylePath { path: theme_file });
}
}
- let edition = config::parse_crate_edition(&matches);
+ let edition = config::parse_crate_edition(matches);
let mut id_map = html::markdown::IdMap::new();
- let external_html = match ExternalHtml::load(
+ let Some(external_html) = ExternalHtml::load(
&matches.opt_strs("html-in-header"),
&matches.opt_strs("html-before-content"),
&matches.opt_strs("html-after-content"),
&matches.opt_strs("markdown-before-content"),
&matches.opt_strs("markdown-after-content"),
- nightly_options::match_is_nightly_build(&matches),
+ nightly_options::match_is_nightly_build(matches),
&diag,
&mut id_map,
edition,
&None,
- ) {
- Some(eh) => eh,
- None => return Err(3),
+ ) else {
+ return Err(3);
};
match matches.opt_str("r").as_deref() {
let show_coverage = matches.opt_present("show-coverage");
- let default_passes = if matches.opt_present("no-defaults") {
- passes::DefaultPassOption::None
- } else if show_coverage {
- passes::DefaultPassOption::Coverage
- } else {
- passes::DefaultPassOption::Default
- };
- let manual_passes = matches.opt_strs("passes");
-
let crate_types = match parse_crate_types_from_list(matches.opt_strs("crate-type")) {
Ok(types) => types,
Err(e) => {
let proc_macro_crate = crate_types.contains(&CrateType::ProcMacro);
let playground_url = matches.opt_str("playground-url");
let maybe_sysroot = matches.opt_str("sysroot").map(PathBuf::from);
- let display_doctest_warnings = matches.opt_present("display-doctest-warnings");
let sort_modules_alphabetically = !matches.opt_present("sort-modules-by-appearance");
let resource_suffix = matches.opt_str("resource-suffix").unwrap_or_default();
let enable_minification = !matches.opt_present("disable-minification");
let crate_version = matches.opt_str("crate-version");
let enable_index_page = matches.opt_present("enable-index-page") || index_page.is_some();
let static_root_path = matches.opt_str("static-root-path");
- let generate_search_filter = !matches.opt_present("disable-per-crate-search");
let test_run_directory = matches.opt_str("test-run-directory").map(PathBuf::from);
let persist_doctests = matches.opt_str("persist-doctests").map(PathBuf::from);
let test_builder = matches.opt_str("test-builder").map(PathBuf::from);
return Err(1);
}
+ let scrape_examples_options = ScrapeExamplesOptions::new(&matches, &diag)?;
+ let with_examples = matches.opt_strs("with-examples");
+ let call_locations = crate::scrape_examples::load_call_locations(with_examples, &diag)?;
+
let (lint_opts, describe_lints, lint_cap) = get_cmd_lint_options(matches, error_format);
Ok(Options {
externs,
extern_strs,
cfgs,
+ check_cfgs,
codegen_options,
codegen_options_strs,
debugging_opts,
lint_cap,
should_test,
test_args,
- default_passes,
- manual_passes,
- display_doctest_warnings,
show_coverage,
crate_version,
test_run_directory,
markdown_no_toc,
markdown_css,
markdown_playground_url,
- generate_search_filter,
document_private,
document_hidden,
generate_redirect_map,
),
emit,
generate_link_to_definition,
+ call_locations,
+ no_emit_shared: false,
},
crate_name,
output_format,
json_unused_externs,
+ scrape_examples_options,
})
}
/// Prints deprecation warnings for deprecated options
fn check_deprecated_options(matches: &getopts::Matches, diag: &rustc_errors::Handler) {
- let deprecated_flags = ["input-format", "no-defaults", "passes"];
+ let deprecated_flags = [];
- for flag in deprecated_flags.iter() {
+ for &flag in deprecated_flags.iter() {
if matches.opt_present(flag) {
- let mut err = diag.struct_warn(&format!("the `{}` flag is deprecated", flag));
+ diag.struct_warn(&format!("the `{}` flag is deprecated", flag))
+ .note(
+ "see issue #44136 <https://github.com/rust-lang/rust/issues/44136> \
+ for more information",
+ )
+ .emit();
+ }
+ }
+
+ let removed_flags = ["plugins", "plugin-path", "no-defaults", "passes", "input-format"];
+
+ for &flag in removed_flags.iter() {
+ if matches.opt_present(flag) {
+ let mut err = diag.struct_warn(&format!("the `{}` flag no longer functions", flag));
err.note(
"see issue #44136 <https://github.com/rust-lang/rust/issues/44136> \
- for more information",
+ for more information",
);
- if *flag == "no-defaults" {
+ if flag == "no-defaults" || flag == "passes" {
err.help("you may want to use --document-private-items");
+ } else if flag == "plugins" || flag == "plugin-path" {
+ err.warn("see CVE-2018-1000622");
}
err.emit();
}
}
-
- let removed_flags = ["plugins", "plugin-path"];
-
- for &flag in removed_flags.iter() {
- if matches.opt_present(flag) {
- diag.struct_warn(&format!("the '{}' flag no longer functions", flag))
- .warn("see CVE-2018-1000622")
- .emit();
- }
- }
}
/// Extracts `--extern-html-root-url` arguments from `matches` and returns a map of crate names to
projects / rustc.git / blobdiff