crates/ide/src/syntax_highlighting/inject.rs

   1 //! "Recursive" Syntax highlighting for code in doctests and fixtures.
   2
   3 use std::{mem, ops::Range};
   4
   5 use either::Either;
   6 use hir::{HasAttrs, InFile, Semantics};
   7 use ide_db::{call_info::ActiveParameter, defs::Definition, SymbolKind};
   8 use syntax::{
   9     ast::{self, AstNode},
  10     match_ast, AstToken, NodeOrToken, SyntaxNode, SyntaxToken, TextRange, TextSize,
  11 };
  12
  13 use crate::{
  14     doc_links::{extract_definitions_from_markdown, resolve_doc_path_for_def},
  15     Analysis, HlMod, HlRange, HlTag, RootDatabase,
  16 };
  17
  18 use super::{highlights::Highlights, injector::Injector};
  19
  20 pub(super) fn ra_fixture(
  21     hl: &mut Highlights,
  22     sema: &Semantics<RootDatabase>,
  23     literal: ast::String,
  24     expanded: SyntaxToken,
  25 ) -> Option<()> {
  26     let active_parameter = ActiveParameter::at_token(&sema, expanded)?;
  27     if !active_parameter.ident().map_or(false, |name| name.text().starts_with("ra_fixture")) {
  28         return None;
  29     }
  30     let value = literal.value()?;
  31
  32     if let Some(range) = literal.open_quote_text_range() {
  33         hl.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
  34     }
  35
  36     let mut inj = Injector::default();
  37
  38     let mut text = &*value;
  39     let mut offset: TextSize = 0.into();
  40
  41     while !text.is_empty() {
  42         let marker = "$0";
  43         let idx = text.find(marker).unwrap_or(text.len());
  44         let (chunk, next) = text.split_at(idx);
  45         inj.add(chunk, TextRange::at(offset, TextSize::of(chunk)));
  46
  47         text = next;
  48         offset += TextSize::of(chunk);
  49
  50         if let Some(next) = text.strip_prefix(marker) {
  51             if let Some(range) = literal.map_range_up(TextRange::at(offset, TextSize::of(marker))) {
  52                 hl.add(HlRange { range, highlight: HlTag::Keyword.into(), binding_hash: None });
  53             }
  54
  55             text = next;
  56
  57             let marker_len = TextSize::of(marker);
  58             offset += marker_len;
  59         }
  60     }
  61
  62     let (analysis, tmp_file_id) = Analysis::from_single_file(inj.text().to_string());
  63
  64     for mut hl_range in analysis.highlight(tmp_file_id).unwrap() {
  65         for range in inj.map_range_up(hl_range.range) {
  66             if let Some(range) = literal.map_range_up(range) {
  67                 hl_range.range = range;
  68                 hl.add(hl_range);
  69             }
  70         }
  71     }
  72
  73     if let Some(range) = literal.close_quote_text_range() {
  74         hl.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
  75     }
  76
  77     Some(())
  78 }
  79
  80 const RUSTDOC_FENCE: &'static str = "```";
  81 const RUSTDOC_FENCE_TOKENS: &[&'static str] = &[
  82     "",
  83     "rust",
  84     "should_panic",
  85     "ignore",
  86     "no_run",
  87     "compile_fail",
  88     "edition2015",
  89     "edition2018",
  90     "edition2021",
  91 ];
  92
  93 fn doc_attributes<'node>(
  94     sema: &Semantics<RootDatabase>,
  95     node: &'node SyntaxNode,
  96 ) -> Option<(hir::AttrsWithOwner, Definition)> {
  97     match_ast! {
  98         match node {
  99             ast::SourceFile(it)  => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Module(def)))),
 100             ast::Module(it)      => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Module(def)))),
 101             ast::Fn(it)          => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Function(def)))),
 102             ast::Struct(it)      => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Struct(def))))),
 103             ast::Union(it)       => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Union(def))))),
 104             ast::Enum(it)        => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Enum(def))))),
 105             ast::Variant(it)     => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Variant(def)))),
 106             ast::Trait(it)       => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Trait(def)))),
 107             ast::Static(it)      => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Static(def)))),
 108             ast::Const(it)       => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Const(def)))),
 109             ast::TypeAlias(it)   => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::TypeAlias(def)))),
 110             ast::Impl(it)        => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::SelfType(def))),
 111             ast::RecordField(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Field(def))),
 112             ast::TupleField(it)  => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Field(def))),
 113             ast::Macro(it)       => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Macro(def))),
 114             // ast::Use(it) => sema.to_def(&it).map(|def| (Box::new(it) as _, def.attrs(sema.db))),
 115             _ => return None
 116         }
 117     }
 118 }
 119
 120 /// Injection of syntax highlighting of doctests.
 121 pub(super) fn doc_comment(
 122     hl: &mut Highlights,
 123     sema: &Semantics<RootDatabase>,
 124     node: InFile<&SyntaxNode>,
 125 ) {
 126     let (attributes, def) = match doc_attributes(sema, node.value) {
 127         Some(it) => it,
 128         None => return,
 129     };
 130
 131     let mut inj = Injector::default();
 132     inj.add_unmapped("fn doctest() {\n");
 133
 134     let attrs_source_map = attributes.source_map(sema.db);
 135
 136     let mut is_codeblock = false;
 137     let mut is_doctest = false;
 138
 139     // Replace the original, line-spanning comment ranges by new, only comment-prefix
 140     // spanning comment ranges.
 141     let mut new_comments = Vec::new();
 142     let mut intra_doc_links = Vec::new();
 143     let mut string;
 144     for attr in attributes.by_key("doc").attrs() {
 145         let InFile { file_id, value: src } = attrs_source_map.source_of(&attr);
 146         if file_id != node.file_id {
 147             continue;
 148         }
 149         let (line, range, prefix) = match &src {
 150             Either::Left(it) => {
 151                 string = match find_doc_string_in_attr(attr, it) {
 152                     Some(it) => it,
 153                     None => continue,
 154                 };
 155                 let text_range = string.syntax().text_range();
 156                 let text_range = TextRange::new(
 157                     text_range.start() + TextSize::from(1),
 158                     text_range.end() - TextSize::from(1),
 159                 );
 160                 let text = string.text();
 161                 (&text[1..text.len() - 1], text_range, "")
 162             }
 163             Either::Right(comment) => {
 164                 (comment.text(), comment.syntax().text_range(), comment.prefix())
 165             }
 166         };
 167
 168         let mut pos = TextSize::from(prefix.len() as u32);
 169         let mut range_start = range.start();
 170         for line in line.split('\n') {
 171             let line_len = TextSize::from(line.len() as u32);
 172             let prev_range_start = {
 173                 let next_range_start = range_start + line_len + TextSize::from(1);
 174                 mem::replace(&mut range_start, next_range_start)
 175             };
 176             // only first line has the prefix so take it away for future iterations
 177             let mut pos = mem::take(&mut pos);
 178
 179             match line.find(RUSTDOC_FENCE) {
 180                 Some(idx) => {
 181                     is_codeblock = !is_codeblock;
 182                     // Check whether code is rust by inspecting fence guards
 183                     let guards = &line[idx + RUSTDOC_FENCE.len()..];
 184                     let is_rust =
 185                         guards.split(',').all(|sub| RUSTDOC_FENCE_TOKENS.contains(&sub.trim()));
 186                     is_doctest = is_codeblock && is_rust;
 187                     continue;
 188                 }
 189                 None if !is_doctest => {
 190                     intra_doc_links.extend(
 191                         extract_definitions_from_markdown(line)
 192                             .into_iter()
 193                             .filter_map(|(range, link, ns)| {
 194                                 Some(range).zip(resolve_doc_path_for_def(sema.db, def, &link, ns))
 195                             })
 196                             .map(|(Range { start, end }, def)| {
 197                                 (
 198                                     def,
 199                                     TextRange::at(
 200                                         prev_range_start + TextSize::from(start as u32),
 201                                         TextSize::from((end - start) as u32),
 202                                     ),
 203                                 )
 204                             }),
 205                     );
 206                     continue;
 207                 }
 208                 None => (),
 209             }
 210
 211             // whitespace after comment is ignored
 212             if let Some(ws) = line[pos.into()..].chars().next().filter(|c| c.is_whitespace()) {
 213                 pos += TextSize::of(ws);
 214             }
 215             // lines marked with `#` should be ignored in output, we skip the `#` char
 216             if line[pos.into()..].starts_with('#') {
 217                 pos += TextSize::of('#');
 218             }
 219
 220             new_comments.push(TextRange::at(prev_range_start, pos));
 221             inj.add(&line[pos.into()..], TextRange::new(pos, line_len) + prev_range_start);
 222             inj.add_unmapped("\n");
 223         }
 224     }
 225
 226     for (def, range) in intra_doc_links {
 227         hl.add(HlRange {
 228             range,
 229             highlight: module_def_to_hl_tag(def)
 230                 | HlMod::Documentation
 231                 | HlMod::Injected
 232                 | HlMod::IntraDocLink,
 233             binding_hash: None,
 234         });
 235     }
 236
 237     if new_comments.is_empty() {
 238         return; // no need to run an analysis on an empty file
 239     }
 240
 241     inj.add_unmapped("\n}");
 242
 243     let (analysis, tmp_file_id) = Analysis::from_single_file(inj.text().to_string());
 244
 245     for HlRange { range, highlight, binding_hash } in
 246         analysis.with_db(|db| super::highlight(db, tmp_file_id, None, true)).unwrap()
 247     {
 248         for range in inj.map_range_up(range) {
 249             hl.add(HlRange { range, highlight: highlight | HlMod::Injected, binding_hash });
 250         }
 251     }
 252
 253     for range in new_comments {
 254         hl.add(HlRange {
 255             range,
 256             highlight: HlTag::Comment | HlMod::Documentation,
 257             binding_hash: None,
 258         });
 259     }
 260 }
 261
 262 fn find_doc_string_in_attr(attr: &hir::Attr, it: &ast::Attr) -> Option<ast::String> {
 263     match it.expr() {
 264         // #[doc = lit]
 265         Some(ast::Expr::Literal(lit)) => match lit.kind() {
 266             ast::LiteralKind::String(it) => Some(it),
 267             _ => None,
 268         },
 269         // #[cfg_attr(..., doc = "", ...)]
 270         None => {
 271             // We gotta hunt the string token manually here
 272             let text = attr.string_value()?;
 273             // FIXME: We just pick the first string literal that has the same text as the doc attribute
 274             // This means technically we might highlight the wrong one
 275             it.syntax()
 276                 .descendants_with_tokens()
 277                 .filter_map(NodeOrToken::into_token)
 278                 .filter_map(ast::String::cast)
 279                 .find(|string| {
 280                     string.text().get(1..string.text().len() - 1).map_or(false, |it| it == text)
 281                 })
 282         }
 283         _ => return None,
 284     }
 285 }
 286
 287 fn module_def_to_hl_tag(def: hir::ModuleDef) -> HlTag {
 288     let symbol = match def {
 289         hir::ModuleDef::Module(_) => SymbolKind::Module,
 290         hir::ModuleDef::Function(_) => SymbolKind::Function,
 291         hir::ModuleDef::Adt(hir::Adt::Struct(_)) => SymbolKind::Struct,
 292         hir::ModuleDef::Adt(hir::Adt::Enum(_)) => SymbolKind::Enum,
 293         hir::ModuleDef::Adt(hir::Adt::Union(_)) => SymbolKind::Union,
 294         hir::ModuleDef::Variant(_) => SymbolKind::Variant,
 295         hir::ModuleDef::Const(_) => SymbolKind::Const,
 296         hir::ModuleDef::Static(_) => SymbolKind::Static,
 297         hir::ModuleDef::Trait(_) => SymbolKind::Trait,
 298         hir::ModuleDef::TypeAlias(_) => SymbolKind::TypeAlias,
 299         hir::ModuleDef::BuiltinType(_) => return HlTag::BuiltinType,
 300     };
 301     HlTag::Symbol(symbol)
 302 }