crates/ide/src/syntax_highlighting/tests.rs

   1 use std::time::Instant;
   2
   3 use expect_test::{expect_file, ExpectFile};
   4 use ide_db::SymbolKind;
   5 use test_utils::{bench, bench_fixture, skip_slow_tests, AssertLinear};
   6
   7 use crate::{fixture, FileRange, HlTag, TextRange};
   8
   9 #[test]
  10 fn test_highlighting() {
  11     check_highlighting(
  12         r#"
  13 //- proc_macros: identity, mirror
  14 //- /main.rs crate:main deps:foo
  15 use inner::{self as inner_mod};
  16 mod inner {}
  17
  18 #[rustc_builtin_macro]
  19 macro Copy {}
  20
  21 // Needed for function consuming vs normal
  22 pub mod marker {
  23     #[lang = "copy"]
  24     pub trait Copy {}
  25 }
  26
  27 #[proc_macros::identity]
  28 pub mod ops {
  29     #[lang = "fn_once"]
  30     pub trait FnOnce<Args> {}
  31
  32     #[lang = "fn_mut"]
  33     pub trait FnMut<Args>: FnOnce<Args> {}
  34
  35     #[lang = "fn"]
  36     pub trait Fn<Args>: FnMut<Args> {}
  37 }
  38
  39 proc_macros::mirror! {
  40     {
  41         ,i32 :x pub
  42         ,i32 :y pub
  43     } Foo struct
  44 }
  45
  46 trait Bar where Self: {
  47     fn bar(&self) -> i32;
  48 }
  49
  50 impl Bar for Foo where Self: {
  51     fn bar(&self) -> i32 {
  52         self.x
  53     }
  54 }
  55
  56 impl Foo {
  57     fn baz(mut self, f: Foo) -> i32 {
  58         f.baz(self)
  59     }
  60
  61     fn qux(&mut self) {
  62         self.x = 0;
  63     }
  64
  65     fn quop(&self) -> i32 {
  66         self.x
  67     }
  68 }
  69
  70 #[derive(Copy)]
  71 struct FooCopy {
  72     x: u32,
  73 }
  74
  75 impl FooCopy {
  76     fn baz(self, f: FooCopy) -> u32 {
  77         f.baz(self)
  78     }
  79
  80     fn qux(&mut self) {
  81         self.x = 0;
  82     }
  83
  84     fn quop(&self) -> u32 {
  85         self.x
  86     }
  87 }
  88
  89 fn str() {
  90     str();
  91 }
  92
  93 fn foo<'a, T>() -> T {
  94     foo::<'a, i32>()
  95 }
  96
  97 fn never() -> ! {
  98     loop {}
  99 }
 100
 101 fn const_param<const FOO: usize>() -> usize {
 102     FOO
 103 }
 104
 105 use ops::Fn;
 106 fn baz<F: Fn() -> ()>(f: F) {
 107     f()
 108 }
 109
 110 fn foobar() -> impl Copy {}
 111
 112 fn foo() {
 113     let bar = foobar();
 114 }
 115
 116 macro_rules! def_fn {
 117     ($($tt:tt)*) => {$($tt)*}
 118 }
 119
 120 def_fn! {
 121     fn bar() -> u32 {
 122         100
 123     }
 124 }
 125
 126 macro_rules! dont_color_me_braces {
 127     () => {0}
 128 }
 129
 130 macro_rules! noop {
 131     ($expr:expr) => {
 132         $expr
 133     }
 134 }
 135
 136 macro_rules! keyword_frag {
 137     ($type:ty) => ($type)
 138 }
 139
 140 macro with_args($i:ident) {
 141     $i
 142 }
 143
 144 macro without_args {
 145     ($i:ident) => {
 146         $i
 147     }
 148 }
 149
 150 // comment
 151 fn main() {
 152     println!("Hello, {}!", 92);
 153     dont_color_me_braces!();
 154
 155     let mut vec = Vec::new();
 156     if true {
 157         let x = 92;
 158         vec.push(Foo { x, y: 1 });
 159     }
 160
 161     for e in vec {
 162         // Do nothing
 163     }
 164
 165     noop!(noop!(1));
 166
 167     let mut x = 42;
 168     x += 1;
 169     let y = &mut x;
 170     let z = &y;
 171
 172     let Foo { x: z, y } = Foo { x: z, y };
 173
 174     y;
 175
 176     let mut foo = Foo { x, y: x };
 177     let foo2 = Foo { x, y: x };
 178     foo.quop();
 179     foo.qux();
 180     foo.baz(foo2);
 181
 182     let mut copy = FooCopy { x };
 183     copy.quop();
 184     copy.qux();
 185     copy.baz(copy);
 186
 187     let a = |x| x;
 188     let bar = Foo::baz;
 189
 190     let baz = (-42,);
 191     let baz = -baz.0;
 192
 193     let _ = !true;
 194
 195     'foo: loop {
 196         break 'foo;
 197         continue 'foo;
 198     }
 199 }
 200
 201 enum Option<T> {
 202     Some(T),
 203     None,
 204 }
 205 use Option::*;
 206
 207 impl<T> Option<T> {
 208     fn and<U>(self, other: Option<U>) -> Option<(T, U)> {
 209         match other {
 210             None => unimplemented!(),
 211             Nope => Nope,
 212         }
 213     }
 214 }
 215
 216 async fn learn_and_sing() {
 217     let song = learn_song().await;
 218     sing_song(song).await;
 219 }
 220
 221 async fn async_main() {
 222     let f1 = learn_and_sing();
 223     let f2 = dance();
 224     futures::join!(f1, f2);
 225 }
 226
 227 fn use_foo_items() {
 228     let bob = foo::Person {
 229         name: "Bob",
 230         age: foo::consts::NUMBER,
 231     };
 232
 233     let control_flow = foo::identity(foo::ControlFlow::Continue);
 234
 235     if control_flow.should_die() {
 236         foo::die!();
 237     }
 238 }
 239
 240 pub enum Bool { True, False }
 241
 242 impl Bool {
 243     pub const fn to_primitive(self) -> bool {
 244         matches!(self, Self::True)
 245     }
 246 }
 247 const USAGE_OF_BOOL:bool = Bool::True.to_primitive();
 248
 249 //- /foo.rs crate:foo
 250 pub struct Person {
 251     pub name: &'static str,
 252     pub age: u8,
 253 }
 254
 255 pub enum ControlFlow {
 256     Continue,
 257     Die,
 258 }
 259
 260 impl ControlFlow {
 261     pub fn should_die(self) -> bool {
 262         matches!(self, ControlFlow::Die)
 263     }
 264 }
 265
 266 pub fn identity<T>(x: T) -> T { x }
 267
 268 pub mod consts {
 269     pub const NUMBER: i64 = 92;
 270 }
 271
 272 macro_rules! die {
 273     () => {
 274         panic!();
 275     };
 276 }
 277 "#
 278         .trim(),
 279         expect_file!["./test_data/highlighting.html"],
 280         false,
 281     );
 282 }
 283
 284 #[test]
 285 fn test_rainbow_highlighting() {
 286     check_highlighting(
 287         r#"
 288 fn main() {
 289     let hello = "hello";
 290     let x = hello.to_string();
 291     let y = hello.to_string();
 292
 293     let x = "other color please!";
 294     let y = x.to_string();
 295 }
 296
 297 fn bar() {
 298     let mut hello = "hello";
 299 }
 300 "#
 301         .trim(),
 302         expect_file!["./test_data/rainbow_highlighting.html"],
 303         true,
 304     );
 305 }
 306
 307 #[test]
 308 fn benchmark_syntax_highlighting_long_struct() {
 309     if skip_slow_tests() {
 310         return;
 311     }
 312
 313     let fixture = bench_fixture::big_struct();
 314     let (analysis, file_id) = fixture::file(&fixture);
 315
 316     let hash = {
 317         let _pt = bench("syntax highlighting long struct");
 318         analysis
 319             .highlight(file_id)
 320             .unwrap()
 321             .iter()
 322             .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Struct))
 323             .count()
 324     };
 325     assert_eq!(hash, 2001);
 326 }
 327
 328 #[test]
 329 fn syntax_highlighting_not_quadratic() {
 330     if skip_slow_tests() {
 331         return;
 332     }
 333
 334     let mut al = AssertLinear::default();
 335     while al.next_round() {
 336         for i in 6..=10 {
 337             let n = 1 << i;
 338
 339             let fixture = bench_fixture::big_struct_n(n);
 340             let (analysis, file_id) = fixture::file(&fixture);
 341
 342             let time = Instant::now();
 343
 344             let hash = analysis
 345                 .highlight(file_id)
 346                 .unwrap()
 347                 .iter()
 348                 .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Struct))
 349                 .count();
 350             assert!(hash > n as usize);
 351
 352             let elapsed = time.elapsed();
 353             al.sample(n as f64, elapsed.as_millis() as f64);
 354         }
 355     }
 356 }
 357
 358 #[test]
 359 fn benchmark_syntax_highlighting_parser() {
 360     if skip_slow_tests() {
 361         return;
 362     }
 363
 364     let fixture = bench_fixture::glorious_old_parser();
 365     let (analysis, file_id) = fixture::file(&fixture);
 366
 367     let hash = {
 368         let _pt = bench("syntax highlighting parser");
 369         analysis
 370             .highlight(file_id)
 371             .unwrap()
 372             .iter()
 373             .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Function))
 374             .count()
 375     };
 376     assert_eq!(hash, 1616);
 377 }
 378
 379 #[test]
 380 fn test_ranges() {
 381     let (analysis, file_id) = fixture::file(
 382         r#"
 383 #[derive(Clone, Debug)]
 384 struct Foo {
 385     pub x: i32,
 386     pub y: i32,
 387 }
 388 "#,
 389     );
 390
 391     // The "x"
 392     let highlights = &analysis
 393         .highlight_range(FileRange { file_id, range: TextRange::at(45.into(), 1.into()) })
 394         .unwrap();
 395
 396     assert_eq!(&highlights[0].highlight.to_string(), "field.declaration.public");
 397 }
 398
 399 #[test]
 400 fn test_flattening() {
 401     check_highlighting(
 402         r##"
 403 fn fixture(ra_fixture: &str) {}
 404
 405 fn main() {
 406     fixture(r#"
 407         trait Foo {
 408             fn foo() {
 409                 println!("2 + 2 = {}", 4);
 410             }
 411         }"#
 412     );
 413 }"##
 414         .trim(),
 415         expect_file!["./test_data/highlight_injection.html"],
 416         false,
 417     );
 418 }
 419
 420 #[test]
 421 fn ranges_sorted() {
 422     let (analysis, file_id) = fixture::file(
 423         r#"
 424 #[foo(bar = "bar")]
 425 macro_rules! test {}
 426 }"#
 427         .trim(),
 428     );
 429     let _ = analysis.highlight(file_id).unwrap();
 430 }
 431
 432 #[test]
 433 fn test_string_highlighting() {
 434     // The format string detection is based on macro-expansion,
 435     // thus, we have to copy the macro definition from `std`
 436     check_highlighting(
 437         r#"
 438 macro_rules! println {
 439     ($($arg:tt)*) => ({
 440         $crate::io::_print($crate::format_args_nl!($($arg)*));
 441     })
 442 }
 443 #[rustc_builtin_macro]
 444 #[macro_export]
 445 macro_rules! format_args {}
 446 #[rustc_builtin_macro]
 447 #[macro_export]
 448 macro_rules! const_format_args {}
 449 #[rustc_builtin_macro]
 450 #[macro_export]
 451 macro_rules! format_args_nl {}
 452
 453 mod panic {
 454     pub macro panic_2015 {
 455         () => (
 456             $crate::panicking::panic("explicit panic")
 457         ),
 458         ($msg:literal $(,)?) => (
 459             $crate::panicking::panic($msg)
 460         ),
 461         // Use `panic_str` instead of `panic_display::<&str>` for non_fmt_panic lint.
 462         ($msg:expr $(,)?) => (
 463             $crate::panicking::panic_str($msg)
 464         ),
 465         // Special-case the single-argument case for const_panic.
 466         ("{}", $arg:expr $(,)?) => (
 467             $crate::panicking::panic_display(&$arg)
 468         ),
 469         ($fmt:expr, $($arg:tt)+) => (
 470             $crate::panicking::panic_fmt($crate::const_format_args!($fmt, $($arg)+))
 471         ),
 472     }
 473 }
 474
 475 #[rustc_builtin_macro(std_panic)]
 476 #[macro_export]
 477 macro_rules! panic {}
 478 #[rustc_builtin_macro]
 479 macro_rules! assert {}
 480 #[rustc_builtin_macro]
 481 macro_rules! asm {}
 482
 483 macro_rules! toho {
 484     () => ($crate::panic!("not yet implemented"));
 485     ($($arg:tt)+) => ($crate::panic!("not yet implemented: {}", $crate::format_args!($($arg)+)));
 486 }
 487
 488 fn main() {
 489     // from https://doc.rust-lang.org/std/fmt/index.html
 490     println!("Hello");                 // => "Hello"
 491     println!("Hello, {}!", "world");   // => "Hello, world!"
 492     println!("The number is {}", 1);   // => "The number is 1"
 493     println!("{:?}", (3, 4));          // => "(3, 4)"
 494     println!("{value}", value=4);      // => "4"
 495     println!("{} {}", 1, 2);           // => "1 2"
 496     println!("{:04}", 42);             // => "0042" with leading zerosV
 497     println!("{1} {} {0} {}", 1, 2);   // => "2 1 1 2"
 498     println!("{argument}", argument = "test");   // => "test"
 499     println!("{name} {}", 1, name = 2);          // => "2 1"
 500     println!("{a} {c} {b}", a="a", b='b', c=3);  // => "a 3 b"
 501     println!("{{{}}}", 2);                       // => "{2}"
 502     println!("Hello {:5}!", "x");
 503     println!("Hello {:1$}!", "x", 5);
 504     println!("Hello {1:0$}!", 5, "x");
 505     println!("Hello {:width$}!", "x", width = 5);
 506     println!("Hello {:<5}!", "x");
 507     println!("Hello {:-<5}!", "x");
 508     println!("Hello {:^5}!", "x");
 509     println!("Hello {:>5}!", "x");
 510     println!("Hello {:+}!", 5);
 511     println!("{:#x}!", 27);
 512     println!("Hello {:05}!", 5);
 513     println!("Hello {:05}!", -5);
 514     println!("{:#010x}!", 27);
 515     println!("Hello {0} is {1:.5}", "x", 0.01);
 516     println!("Hello {1} is {2:.0$}", 5, "x", 0.01);
 517     println!("Hello {0} is {2:.1$}", "x", 5, 0.01);
 518     println!("Hello {} is {:.*}",    "x", 5, 0.01);
 519     println!("Hello {} is {2:.*}",   "x", 5, 0.01);
 520     println!("Hello {} is {number:.prec$}", "x", prec = 5, number = 0.01);
 521     println!("{}, `{name:.*}` has 3 fractional digits", "Hello", 3, name=1234.56);
 522     println!("{}, `{name:.*}` has 3 characters", "Hello", 3, name="1234.56");
 523     println!("{}, `{name:>8.*}` has 3 right-aligned characters", "Hello", 3, name="1234.56");
 524     println!("Hello {{}}");
 525     println!("{{ Hello");
 526
 527     println!(r"Hello, {}!", "world");
 528
 529     // escape sequences
 530     println!("Hello\nWorld");
 531     println!("\u{48}\x65\x6C\x6C\x6F World");
 532
 533     println!("{\x41}", A = 92);
 534     println!("{ничоси}", ничоси = 92);
 535
 536     println!("{:x?} {} ", thingy, n2);
 537     panic!("{}", 0);
 538     panic!("more {}", 1);
 539     assert!(true, "{}", 1);
 540     assert!(true, "{} asdasd", 1);
 541     toho!("{}fmt", 0);
 542     asm!("mov eax, {0}");
 543     format_args!(concat!("{}"), "{}");
 544 }"#
 545         .trim(),
 546         expect_file!["./test_data/highlight_strings.html"],
 547         false,
 548     );
 549 }
 550
 551 #[test]
 552 fn test_unsafe_highlighting() {
 553     check_highlighting(
 554         r#"
 555 static mut MUT_GLOBAL: Struct = Struct { field: 0 };
 556 static GLOBAL: Struct = Struct { field: 0 };
 557 unsafe fn unsafe_fn() {}
 558
 559 union Union {
 560     a: u32,
 561     b: f32,
 562 }
 563
 564 struct Struct { field: i32 }
 565 impl Struct {
 566     unsafe fn unsafe_method(&self) {}
 567 }
 568
 569 #[repr(packed)]
 570 struct Packed {
 571     a: u16,
 572 }
 573
 574 unsafe trait UnsafeTrait {}
 575 unsafe impl UnsafeTrait for Packed {}
 576 impl !UnsafeTrait for () {}
 577
 578 fn unsafe_trait_bound<T: UnsafeTrait>(_: T) {}
 579
 580 trait DoTheAutoref {
 581     fn calls_autoref(&self);
 582 }
 583
 584 impl DoTheAutoref for u16 {
 585     fn calls_autoref(&self) {}
 586 }
 587
 588 fn main() {
 589     let x = &5 as *const _ as *const usize;
 590     let u = Union { b: 0 };
 591     unsafe {
 592         // unsafe fn and method calls
 593         unsafe_fn();
 594         let b = u.b;
 595         match u {
 596             Union { b: 0 } => (),
 597             Union { a } => (),
 598         }
 599         Struct { field: 0 }.unsafe_method();
 600
 601         // unsafe deref
 602         *x;
 603
 604         // unsafe access to a static mut
 605         MUT_GLOBAL.field;
 606         GLOBAL.field;
 607
 608         // unsafe ref of packed fields
 609         let packed = Packed { a: 0 };
 610         let a = &packed.a;
 611         let ref a = packed.a;
 612         let Packed { ref a } = packed;
 613         let Packed { a: ref _a } = packed;
 614
 615         // unsafe auto ref of packed field
 616         packed.a.calls_autoref();
 617     }
 618 }
 619 "#
 620         .trim(),
 621         expect_file!["./test_data/highlight_unsafe.html"],
 622         false,
 623     );
 624 }
 625
 626 #[test]
 627 fn test_highlight_doc_comment() {
 628     check_highlighting(
 629         r#"
 630 //! This is a module to test doc injection.
 631 //! ```
 632 //! fn test() {}
 633 //! ```
 634
 635 /// ```
 636 /// let _ = "early doctests should not go boom";
 637 /// ```
 638 struct Foo {
 639     bar: bool,
 640 }
 641
 642 /// This is an impl with a code block.
 643 ///
 644 /// ```
 645 /// fn foo() {
 646 ///
 647 /// }
 648 /// ```
 649 impl Foo {
 650     /// ```
 651     /// let _ = "Call me
 652     //    KILLER WHALE
 653     ///     Ishmael.";
 654     /// ```
 655     pub const bar: bool = true;
 656
 657     /// Constructs a new `Foo`.
 658     ///
 659     /// # Examples
 660     ///
 661     /// ```
 662     /// # #![allow(unused_mut)]
 663     /// let mut foo: Foo = Foo::new();
 664     /// ```
 665     pub const fn new() -> Foo {
 666         Foo { bar: true }
 667     }
 668
 669     /// `bar` method on `Foo`.
 670     ///
 671     /// # Examples
 672     ///
 673     /// ```
 674     /// use x::y;
 675     ///
 676     /// let foo = Foo::new();
 677     ///
 678     /// // calls bar on foo
 679     /// assert!(foo.bar());
 680     ///
 681     /// let bar = foo.bar || Foo::bar;
 682     ///
 683     /// /* multi-line
 684     ///        comment */
 685     ///
 686     /// let multi_line_string = "Foo
 687     ///   bar\n
 688     ///          ";
 689     ///
 690     /// ```
 691     ///
 692     /// ```rust,no_run
 693     /// let foobar = Foo::new().bar();
 694     /// ```
 695     ///
 696     /// ```sh
 697     /// echo 1
 698     /// ```
 699     pub fn foo(&self) -> bool {
 700         true
 701     }
 702 }
 703
 704 /// [`Foo`](Foo) is a struct
 705 /// This function is > [`all_the_links`](all_the_links) <
 706 /// [`noop`](noop) is a macro below
 707 /// [`Item`] is a struct in the module [`module`]
 708 ///
 709 /// [`Item`]: module::Item
 710 /// [mix_and_match]: ThisShouldntResolve
 711 pub fn all_the_links() {}
 712
 713 pub mod module {
 714     pub struct Item;
 715 }
 716
 717 /// ```
 718 /// noop!(1);
 719 /// ```
 720 macro_rules! noop {
 721     ($expr:expr) => {
 722         $expr
 723     }
 724 }
 725
 726 /// ```rust
 727 /// let _ = example(&[1, 2, 3]);
 728 /// ```
 729 ///
 730 /// ```
 731 /// loop {}
 732 #[cfg_attr(not(feature = "false"), doc = "loop {}")]
 733 #[doc = "loop {}"]
 734 /// ```
 735 ///
 736 #[cfg_attr(feature = "alloc", doc = "```rust")]
 737 #[cfg_attr(not(feature = "alloc"), doc = "```ignore")]
 738 /// let _ = example(&alloc::vec![1, 2, 3]);
 739 /// ```
 740 pub fn mix_and_match() {}
 741
 742 /**
 743 It is beyond me why you'd use these when you got ///
 744 ```rust
 745 let _ = example(&[1, 2, 3]);
 746 ```
 747 [`block_comments2`] tests these with indentation
 748  */
 749 pub fn block_comments() {}
 750
 751 /**
 752     Really, I don't get it
 753     ```rust
 754     let _ = example(&[1, 2, 3]);
 755     ```
 756     [`block_comments`] tests these without indentation
 757 */
 758 pub fn block_comments2() {}
 759 "#
 760         .trim(),
 761         expect_file!["./test_data/highlight_doctest.html"],
 762         false,
 763     );
 764 }
 765
 766 #[test]
 767 fn test_extern_crate() {
 768     check_highlighting(
 769         r#"
 770         //- /main.rs crate:main deps:std,alloc
 771         extern crate std;
 772         extern crate alloc as abc;
 773         //- /std/lib.rs crate:std
 774         pub struct S;
 775         //- /alloc/lib.rs crate:alloc
 776         pub struct A
 777         "#,
 778         expect_file!["./test_data/highlight_extern_crate.html"],
 779         false,
 780     );
 781 }
 782
 783 #[test]
 784 fn test_crate_root() {
 785     check_highlighting(
 786         r#"
 787         //- minicore: iterators
 788         //- /main.rs crate:main deps:foo
 789         extern crate foo;
 790         use core::iter;
 791
 792         pub const NINETY_TWO: u8 = 92;
 793
 794         use foo as foooo;
 795
 796         pub(crate) fn main() {
 797             let baz = iter::repeat(92);
 798         }
 799
 800         mod bar {
 801             pub(in super) const FORTY_TWO: u8 = 42;
 802
 803             mod baz {
 804                 use super::super::NINETY_TWO;
 805                 use crate::foooo::Point;
 806
 807                 pub(in super::super) const TWENTY_NINE: u8 = 29;
 808             }
 809         }
 810         //- /foo.rs crate:foo
 811         struct Point {
 812             x: u8,
 813             y: u8,
 814         }
 815
 816         mod inner {
 817             pub(super) fn swap(p: crate::Point) -> crate::Point {
 818                 crate::Point { x: p.y, y: p.x }
 819             }
 820         }
 821         "#,
 822         expect_file!["./test_data/highlight_crate_root.html"],
 823         false,
 824     );
 825 }
 826
 827 #[test]
 828 fn test_default_library() {
 829     check_highlighting(
 830         r#"
 831         //- minicore: option, iterators
 832         use core::iter;
 833
 834         fn main() {
 835             let foo = Some(92);
 836             let nums = iter::repeat(foo.unwrap());
 837         }
 838         "#,
 839         expect_file!["./test_data/highlight_default_library.html"],
 840         false,
 841     );
 842 }
 843
 844 #[test]
 845 fn test_associated_function() {
 846     check_highlighting(
 847         r#"
 848 fn not_static() {}
 849
 850 struct foo {}
 851
 852 impl foo {
 853     pub fn is_static() {}
 854     pub fn is_not_static(&self) {}
 855 }
 856
 857 trait t {
 858     fn t_is_static() {}
 859     fn t_is_not_static(&self) {}
 860 }
 861
 862 impl t for foo {
 863     pub fn is_static() {}
 864     pub fn is_not_static(&self) {}
 865 }
 866         "#,
 867         expect_file!["./test_data/highlight_assoc_functions.html"],
 868         false,
 869     )
 870 }
 871
 872 #[test]
 873 fn test_injection() {
 874     check_highlighting(
 875         r##"
 876 fn f(ra_fixture: &str) {}
 877 fn main() {
 878     f(r"
 879 fn foo() {
 880     foo(\$0{
 881         92
 882     }\$0)
 883 }");
 884 }
 885     "##,
 886         expect_file!["./test_data/injection.html"],
 887         false,
 888     );
 889 }
 890
 891 /// Highlights the code given by the `ra_fixture` argument, renders the
 892 /// result as HTML, and compares it with the HTML file given as `snapshot`.
 893 /// Note that the `snapshot` file is overwritten by the rendered HTML.
 894 fn check_highlighting(ra_fixture: &str, expect: ExpectFile, rainbow: bool) {
 895     let (analysis, file_id) = fixture::file(ra_fixture);
 896     let actual_html = &analysis.highlight_as_html(file_id, rainbow).unwrap();
 897     expect.assert_eq(actual_html)
 898 }