1 use errors::Applicability;
2 use syntax::parse::lexer::{StringReader as Lexer};
3 use syntax::parse::{ParseSess, token};
4 use syntax::source_map::FilePathMapping;
5 use syntax_pos::{InnerSpan, FileName};
8 use crate::core::DocContext;
9 use crate::fold::DocFolder;
10 use crate::html::markdown::{self, RustCodeBlock};
11 use crate::passes::Pass;
13 pub const CHECK_CODE_BLOCK_SYNTAX: Pass = Pass {
14 name: "check-code-block-syntax",
15 pass: check_code_block_syntax,
16 description: "validates syntax inside Rust code blocks",
19 pub fn check_code_block_syntax(krate: clean::Crate, cx: &DocContext<'_>) -> clean::Crate {
20 SyntaxChecker { cx }.fold_crate(krate)
23 struct SyntaxChecker<'a, 'tcx: 'a> {
24 cx: &'a DocContext<'tcx>,
27 impl<'a, 'tcx> SyntaxChecker<'a, 'tcx> {
28 fn check_rust_syntax(&self, item: &clean::Item, dox: &str, code_block: RustCodeBlock) {
29 let sess = ParseSess::new(FilePathMapping::empty());
30 let source_file = sess.source_map().new_source_file(
31 FileName::Custom(String::from("doctest")),
32 dox[code_block.code].to_owned(),
35 let errors = Lexer::new_or_buffered_errs(&sess, source_file, None).and_then(|mut lexer| {
36 while let Ok(token::Token { kind, .. }) = lexer.try_next_token() {
37 if kind == token::Eof {
42 let errors = lexer.buffer_fatal_errors();
44 if !errors.is_empty() {
51 if let Err(errors) = errors {
52 let mut diag = if let Some(sp) =
53 super::source_span_for_markdown_range(self.cx, &dox, &code_block.range, &item.attrs)
58 .struct_span_warn(sp, "could not parse code block as Rust code");
60 for mut err in errors {
61 diag.note(&format!("error from rustc: {}", err.message()));
65 if code_block.syntax.is_none() && code_block.is_fenced {
66 let sp = sp.from_inner(InnerSpan::new(0, 3));
69 "mark blocks that do not contain Rust code as text",
70 String::from("```text"),
71 Applicability::MachineApplicable,
77 // We couldn't calculate the span of the markdown block that had the error, so our
78 // diagnostics are going to be a bit lacking.
79 let mut diag = self.cx.sess().struct_span_warn(
80 super::span_of_attrs(&item.attrs),
81 "doc comment contains an invalid Rust code block",
84 for mut err in errors {
85 // Don't bother reporting the error, because we can't show where it happened.
89 if code_block.syntax.is_none() && code_block.is_fenced {
90 diag.help("mark blocks that do not contain Rust code as text: ```text");
101 impl<'a, 'tcx> DocFolder for SyntaxChecker<'a, 'tcx> {
102 fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
103 if let Some(dox) = &item.attrs.collapsed_doc_value() {
104 for code_block in markdown::rust_code_blocks(&dox) {
105 self.check_rust_syntax(&item, &dox, code_block);
109 self.fold_item_recur(item)