src/librustdoc/passes/check_code_block_syntax.rs

   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};
   6
   7 use crate::clean;
   8 use crate::core::DocContext;
   9 use crate::fold::DocFolder;
  10 use crate::html::markdown::{self, RustCodeBlock};
  11 use crate::passes::Pass;
  12
  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",
  17 };
  18
  19 pub fn check_code_block_syntax(krate: clean::Crate, cx: &DocContext<'_>) -> clean::Crate {
  20     SyntaxChecker { cx }.fold_crate(krate)
  21 }
  22
  23 struct SyntaxChecker<'a, 'tcx> {
  24     cx: &'a DocContext<'tcx>,
  25 }
  26
  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(),
  33         );
  34
  35         let errors = {
  36             let mut lexer = Lexer::new(&sess, source_file, None);
  37             while let Ok(token::Token { kind, .. }) = lexer.try_next_token() {
  38                 if kind == token::Eof {
  39                     break;
  40                 }
  41             }
  42
  43             let errors = lexer.buffer_fatal_errors();
  44
  45             if !errors.is_empty() {
  46                 Err(errors)
  47             } else {
  48                 Ok(())
  49             }
  50         };
  51
  52         if let Err(errors) = errors {
  53             let mut diag = if let Some(sp) =
  54                 super::source_span_for_markdown_range(self.cx, &dox, &code_block.range, &item.attrs)
  55             {
  56                 let mut diag = self
  57                     .cx
  58                     .sess()
  59                     .struct_span_warn(sp, "could not parse code block as Rust code");
  60
  61                 for mut err in errors {
  62                     diag.note(&format!("error from rustc: {}", err.message()));
  63                     err.cancel();
  64                 }
  65
  66                 if code_block.syntax.is_none() && code_block.is_fenced {
  67                     let sp = sp.from_inner(InnerSpan::new(0, 3));
  68                     diag.span_suggestion(
  69                         sp,
  70                         "mark blocks that do not contain Rust code as text",
  71                         String::from("```text"),
  72                         Applicability::MachineApplicable,
  73                     );
  74                 }
  75
  76                 diag
  77             } else {
  78                 // We couldn't calculate the span of the markdown block that had the error, so our
  79                 // diagnostics are going to be a bit lacking.
  80                 let mut diag = self.cx.sess().struct_span_warn(
  81                     super::span_of_attrs(&item.attrs),
  82                     "doc comment contains an invalid Rust code block",
  83                 );
  84
  85                 for mut err in errors {
  86                     // Don't bother reporting the error, because we can't show where it happened.
  87                     err.cancel();
  88                 }
  89
  90                 if code_block.syntax.is_none() && code_block.is_fenced {
  91                     diag.help("mark blocks that do not contain Rust code as text: ```text");
  92                 }
  93
  94                 diag
  95             };
  96
  97             diag.emit();
  98         }
  99     }
 100 }
 101
 102 impl<'a, 'tcx> DocFolder for SyntaxChecker<'a, 'tcx> {
 103     fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
 104         if let Some(dox) = &item.attrs.collapsed_doc_value() {
 105             for code_block in markdown::rust_code_blocks(&dox) {
 106                 self.check_rust_syntax(&item, &dox, code_block);
 107             }
 108         }
 109
 110         self.fold_item_recur(item)
 111     }
 112 }