nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-27 01:04:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

rustdoc: Respect diagnostic debugging options

Browse Source
This commit is contained in:
Vadim Petrochenkov 2019-12-29 23:07:23 +03:00
parent 4feeceecd1
commit 1370bbcf0d
5 changed files with 26 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/librustc_session/config.rs
View File

@ -20,7 +20,7 @@ use rustc_span::source_map::{FileName, FilePathMapping};
use rustc_span::symbol::{sym, Symbol};
use rustc_errors::emitter::HumanReadableErrorType;
use rustc_errors::{ColorConfig, FatalError, Handler};
use rustc_errors::{ColorConfig, FatalError, Handler, HandlerFlags};
use getopts;
@ -597,6 +597,17 @@ impl DebuggingOptions {
pub fn ui_testing(&self) -> bool {
self.ui_testing.unwrap_or(false)
}
pub fn diagnostic_handler_flags(&self, can_emit_warnings: bool) -> HandlerFlags {
HandlerFlags {
can_emit_warnings,
treat_err_as_bug: self.treat_err_as_bug,
dont_buffer_diagnostics: self.dont_buffer_diagnostics,
report_delayed_bugs: self.report_delayed_bugs,
external_macro_backtrace: self.external_macro_backtrace,
deduplicate_diagnostics: self.deduplicate_diagnostics.unwrap_or(true),
}
}
}
// The type of entry function, so users can have their own entry functions

15
src/librustc_session/session.rs
View File

@ -941,13 +941,7 @@ pub fn build_session_with_source_map(
.last()
.unwrap_or(false);
let cap_lints_allow = sopts.lint_cap.map_or(false, |cap| cap == lint::Allow);
let can_emit_warnings = !(warnings_allow || cap_lints_allow);
let treat_err_as_bug = sopts.debugging_opts.treat_err_as_bug;
let dont_buffer_diagnostics = sopts.debugging_opts.dont_buffer_diagnostics;
let report_delayed_bugs = sopts.debugging_opts.report_delayed_bugs;
let external_macro_backtrace = sopts.debugging_opts.external_macro_backtrace;
let deduplicate_diagnostics = sopts.debugging_opts.deduplicate_diagnostics.unwrap_or(true);
let write_dest = match diagnostics_output {
DiagnosticOutput::Default => None,
@ -957,14 +951,7 @@ pub fn build_session_with_source_map(
let diagnostic_handler = rustc_errors::Handler::with_emitter_and_flags(
emitter,
rustc_errors::HandlerFlags {
can_emit_warnings,
treat_err_as_bug,
report_delayed_bugs,
dont_buffer_diagnostics,
external_macro_backtrace,
deduplicate_diagnostics,
},
sopts.debugging_opts.diagnostic_handler_flags(can_emit_warnings),
);
build_session_(sopts, local_crate_source_file, diagnostic_handler, source_map, lint_caps)

7
src/librustdoc/config.rs
View File

@ -269,12 +269,7 @@ impl Options {
let codegen_options = build_codegen_options(matches, error_format);
let debugging_options = build_debugging_options(matches, error_format);
let diag = new_handler(
error_format,
None,
debugging_options.treat_err_as_bug,
debugging_options.ui_testing(),
);
let diag = new_handler(error_format, None, &debugging_options);
// check for deprecated options
check_deprecated_options(&matches, &diag);

29
src/librustdoc/core.rs
View File

@ -35,7 +35,7 @@ use crate::html::render::RenderInfo;
use crate::passes;
pub use rustc::session::config::{CodegenOptions, Input, Options};
pub use rustc::session::config::{CodegenOptions, DebuggingOptions, Input, Options};
pub use rustc::session::search_paths::SearchPath;
pub type ExternalPaths = FxHashMap<DefId, (Vec<String>, clean::TypeKind)>;
@ -170,12 +170,8 @@ impl<'tcx> DocContext<'tcx> {
pub fn new_handler(
error_format: ErrorOutputType,
source_map: Option<Lrc<source_map::SourceMap>>,
treat_err_as_bug: Option<usize>,
ui_testing: bool,
debugging_opts: &DebuggingOptions,
) -> errors::Handler {
// rustdoc doesn't override (or allow to override) anything from this that is relevant here, so
// stick to the defaults
let sessopts = Options::default();
let emitter: Box<dyn Emitter + sync::Send> = match error_format {
ErrorOutputType::HumanReadable(kind) => {
let (short, color_config) = kind.unzip();
@ -184,34 +180,25 @@ pub fn new_handler(
color_config,
source_map.map(|cm| cm as _),
short,
sessopts.debugging_opts.teach,
sessopts.debugging_opts.terminal_width,
debugging_opts.teach,
debugging_opts.terminal_width,
false,
)
.ui_testing(ui_testing),
.ui_testing(debugging_opts.ui_testing),
)
}
ErrorOutputType::Json { pretty, json_rendered } => {
let source_map = source_map.unwrap_or_else(|| {
Lrc::new(source_map::SourceMap::new(sessopts.file_path_mapping()))
Lrc::new(source_map::SourceMap::new(source_map::FilePathMapping::empty()))
});
Box::new(
JsonEmitter::stderr(None, source_map, pretty, json_rendered, false)
.ui_testing(ui_testing),
.ui_testing(debugging_opts.ui_testing),
)
}
};
errors::Handler::with_emitter_and_flags(
emitter,
errors::HandlerFlags {
can_emit_warnings: true,
treat_err_as_bug,
report_delayed_bugs: false,
external_macro_backtrace: false,
..Default::default()
},
)
errors::Handler::with_emitter_and_flags(emitter, debugging_opts.diagnostic_handler_flags(true))
}
pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOptions) {

18
src/librustdoc/lib.rs
View File

@ -445,12 +445,7 @@ fn main_args(args: &[String]) -> i32 {
}
fn main_options(options: config::Options) -> i32 {
let diag = core::new_handler(
options.error_format,
None,
options.debugging_options.treat_err_as_bug,
options.debugging_options.ui_testing(),
);
let diag = core::new_handler(options.error_format, None, &options.debugging_options);
match (options.should_test, options.markdown_input()) {
(true, true) => return markdown::test(options, &diag),
@ -463,12 +458,7 @@ fn main_options(options: config::Options) -> i32 {
// need to move these items separately because we lose them by the time the closure is called,
// but we can't crates the Handler ahead of time because it's not Send
let diag_opts = (
options.error_format,
options.debugging_options.treat_err_as_bug,
options.debugging_options.ui_testing(),
options.edition,
);
let diag_opts = (options.error_format, options.edition, options.debugging_options.clone());
let show_coverage = options.show_coverage;
rust_input(options, move |out| {
if show_coverage {
@ -479,8 +469,8 @@ fn main_options(options: config::Options) -> i32 {
let Output { krate, renderinfo, renderopts } = out;
info!("going to format");
let (error_format, treat_err_as_bug, ui_testing, edition) = diag_opts;
let diag = core::new_handler(error_format, None, treat_err_as_bug, ui_testing);
let (error_format, edition, debugging_options) = diag_opts;
let diag = core::new_handler(error_format, None, &debugging_options);
match html::render::run(krate, renderopts, renderinfo, &diag, edition) {
Ok(_) => rustc_driver::EXIT_SUCCESS,
Err(e) => {