1 use std::time::Instant;
3 use expect_test::{expect_file, ExpectFile};
4 use ide_db::SymbolKind;
5 use test_utils::{bench, bench_fixture, skip_slow_tests, AssertLinear};
7 use crate::{fixture, FileRange, HlTag, TextRange};
10 fn test_highlighting() {
13 //- proc_macros: identity, mirror
14 //- /main.rs crate:main deps:foo
15 use inner::{self as inner_mod};
18 #[rustc_builtin_macro]
21 // Needed for function consuming vs normal
27 #[proc_macros::identity]
30 pub trait FnOnce<Args> {}
33 pub trait FnMut<Args>: FnOnce<Args> {}
36 pub trait Fn<Args>: FnMut<Args> {}
39 proc_macros::mirror! {
46 trait Bar where Self: {
50 impl Bar for Foo where Self: {
51 fn bar(&self) -> i32 {
57 fn baz(mut self, f: Foo) -> i32 {
65 fn quop(&self) -> i32 {
76 fn baz(self, f: FooCopy) -> u32 {
84 fn quop(&self) -> u32 {
93 fn foo<'a, T>() -> T {
101 fn const_param<const FOO: usize>() -> usize {
106 fn baz<F: Fn() -> ()>(f: F) {
110 fn foobar() -> impl Copy {}
116 macro_rules! def_fn {
117 ($($tt:tt)*) => {$($tt)*}
126 macro_rules! dont_color_me_braces {
136 macro_rules! keyword_frag {
137 ($type:ty) => ($type)
140 macro with_args($i:ident) {
152 println!("Hello, {}!", 92);
153 dont_color_me_braces!();
155 let mut vec = Vec::new();
158 vec.push(Foo { x, y: 1 });
172 let Foo { x: z, y } = Foo { x: z, y };
176 let mut foo = Foo { x, y: x };
177 let foo2 = Foo { x, y: x };
182 let mut copy = FooCopy { x };
208 fn and<U>(self, other: Option<U>) -> Option<(T, U)> {
210 None => unimplemented!(),
216 async fn learn_and_sing() {
217 let song = learn_song().await;
218 sing_song(song).await;
221 async fn async_main() {
222 let f1 = learn_and_sing();
224 futures::join!(f1, f2);
228 let bob = foo::Person {
230 age: foo::consts::NUMBER,
233 let control_flow = foo::identity(foo::ControlFlow::Continue);
235 if control_flow.should_die() {
240 pub enum Bool { True, False }
243 pub const fn to_primitive(self) -> bool {
244 matches!(self, Self::True)
247 const USAGE_OF_BOOL:bool = Bool::True.to_primitive();
249 //- /foo.rs crate:foo
251 pub name: &'static str,
255 pub enum ControlFlow {
261 pub fn should_die(self) -> bool {
262 matches!(self, ControlFlow::Die)
266 pub fn identity<T>(x: T) -> T { x }
269 pub const NUMBER: i64 = 92;
279 expect_file!["./test_data/highlighting.html"],
285 fn test_rainbow_highlighting() {
290 let x = hello.to_string();
291 let y = hello.to_string();
293 let x = "other color please!";
294 let y = x.to_string();
298 let mut hello = "hello";
302 expect_file!["./test_data/rainbow_highlighting.html"],
308 fn benchmark_syntax_highlighting_long_struct() {
309 if skip_slow_tests() {
313 let fixture = bench_fixture::big_struct();
314 let (analysis, file_id) = fixture::file(&fixture);
317 let _pt = bench("syntax highlighting long struct");
322 .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Struct))
325 assert_eq!(hash, 2001);
329 fn syntax_highlighting_not_quadratic() {
330 if skip_slow_tests() {
334 let mut al = AssertLinear::default();
335 while al.next_round() {
339 let fixture = bench_fixture::big_struct_n(n);
340 let (analysis, file_id) = fixture::file(&fixture);
342 let time = Instant::now();
348 .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Struct))
350 assert!(hash > n as usize);
352 let elapsed = time.elapsed();
353 al.sample(n as f64, elapsed.as_millis() as f64);
359 fn benchmark_syntax_highlighting_parser() {
360 if skip_slow_tests() {
364 let fixture = bench_fixture::glorious_old_parser();
365 let (analysis, file_id) = fixture::file(&fixture);
368 let _pt = bench("syntax highlighting parser");
373 .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Function))
376 assert_eq!(hash, 1616);
381 let (analysis, file_id) = fixture::file(
383 #[derive(Clone, Debug)]
392 let highlights = &analysis
393 .highlight_range(FileRange { file_id, range: TextRange::at(45.into(), 1.into()) })
396 assert_eq!(&highlights[0].highlight.to_string(), "field.declaration.public");
400 fn test_flattening() {
403 fn fixture(ra_fixture: &str) {}
409 println!("2 + 2 = {}", 4);
415 expect_file!["./test_data/highlight_injection.html"],
422 let (analysis, file_id) = fixture::file(
429 let _ = analysis.highlight(file_id).unwrap();
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`
438 macro_rules! println {
440 $crate::io::_print($crate::format_args_nl!($($arg)*));
443 #[rustc_builtin_macro]
444 macro_rules! format_args_nl {
445 ($fmt:expr) => {{ /* compiler built-in */ }};
446 ($fmt:expr, $($args:tt)*) => {{ /* compiler built-in */ }};
450 // from https://doc.rust-lang.org/std/fmt/index.html
451 println!("Hello"); // => "Hello"
452 println!("Hello, {}!", "world"); // => "Hello, world!"
453 println!("The number is {}", 1); // => "The number is 1"
454 println!("{:?}", (3, 4)); // => "(3, 4)"
455 println!("{value}", value=4); // => "4"
456 println!("{} {}", 1, 2); // => "1 2"
457 println!("{:04}", 42); // => "0042" with leading zerosV
458 println!("{1} {} {0} {}", 1, 2); // => "2 1 1 2"
459 println!("{argument}", argument = "test"); // => "test"
460 println!("{name} {}", 1, name = 2); // => "2 1"
461 println!("{a} {c} {b}", a="a", b='b', c=3); // => "a 3 b"
462 println!("{{{}}}", 2); // => "{2}"
463 println!("Hello {:5}!", "x");
464 println!("Hello {:1$}!", "x", 5);
465 println!("Hello {1:0$}!", 5, "x");
466 println!("Hello {:width$}!", "x", width = 5);
467 println!("Hello {:<5}!", "x");
468 println!("Hello {:-<5}!", "x");
469 println!("Hello {:^5}!", "x");
470 println!("Hello {:>5}!", "x");
471 println!("Hello {:+}!", 5);
472 println!("{:#x}!", 27);
473 println!("Hello {:05}!", 5);
474 println!("Hello {:05}!", -5);
475 println!("{:#010x}!", 27);
476 println!("Hello {0} is {1:.5}", "x", 0.01);
477 println!("Hello {1} is {2:.0$}", 5, "x", 0.01);
478 println!("Hello {0} is {2:.1$}", "x", 5, 0.01);
479 println!("Hello {} is {:.*}", "x", 5, 0.01);
480 println!("Hello {} is {2:.*}", "x", 5, 0.01);
481 println!("Hello {} is {number:.prec$}", "x", prec = 5, number = 0.01);
482 println!("{}, `{name:.*}` has 3 fractional digits", "Hello", 3, name=1234.56);
483 println!("{}, `{name:.*}` has 3 characters", "Hello", 3, name="1234.56");
484 println!("{}, `{name:>8.*}` has 3 right-aligned characters", "Hello", 3, name="1234.56");
485 println!("Hello {{}}");
486 println!("{{ Hello");
488 println!(r"Hello, {}!", "world");
491 println!("Hello\nWorld");
492 println!("\u{48}\x65\x6C\x6C\x6F World");
494 println!("{\x41}", A = 92);
495 println!("{ничоси}", ничоси = 92);
497 println!("{:x?} {} ", thingy, n2);
500 expect_file!["./test_data/highlight_strings.html"],
506 fn test_unsafe_highlighting() {
509 static mut MUT_GLOBAL: Struct = Struct { field: 0 };
510 static GLOBAL: Struct = Struct { field: 0 };
511 unsafe fn unsafe_fn() {}
518 struct Struct { field: i32 }
520 unsafe fn unsafe_method(&self) {}
528 unsafe trait UnsafeTrait {}
529 unsafe impl UnsafeTrait for Packed {}
530 impl !UnsafeTrait for () {}
532 fn unsafe_trait_bound<T: UnsafeTrait>(_: T) {}
535 fn calls_autoref(&self);
538 impl DoTheAutoref for u16 {
539 fn calls_autoref(&self) {}
543 let x = &5 as *const _ as *const usize;
544 let u = Union { b: 0 };
546 // unsafe fn and method calls
550 Union { b: 0 } => (),
553 Struct { field: 0 }.unsafe_method();
558 // unsafe access to a static mut
562 // unsafe ref of packed fields
563 let packed = Packed { a: 0 };
565 let ref a = packed.a;
566 let Packed { ref a } = packed;
567 let Packed { a: ref _a } = packed;
569 // unsafe auto ref of packed field
570 packed.a.calls_autoref();
575 expect_file!["./test_data/highlight_unsafe.html"],
581 fn test_highlight_doc_comment() {
584 //! This is a module to test doc injection.
590 /// let _ = "early doctests should not go boom";
596 /// This is an impl with a code block.
609 pub const bar: bool = true;
611 /// Constructs a new `Foo`.
616 /// # #![allow(unused_mut)]
617 /// let mut foo: Foo = Foo::new();
619 pub const fn new() -> Foo {
623 /// `bar` method on `Foo`.
630 /// let foo = Foo::new();
632 /// // calls bar on foo
633 /// assert!(foo.bar());
635 /// let bar = foo.bar || Foo::bar;
640 /// let multi_line_string = "Foo
647 /// let foobar = Foo::new().bar();
653 pub fn foo(&self) -> bool {
658 /// [`Foo`](Foo) is a struct
659 /// This function is > [`all_the_links`](all_the_links) <
660 /// [`noop`](noop) is a macro below
661 /// [`Item`] is a struct in the module [`module`]
663 /// [`Item`]: module::Item
664 /// [mix_and_match]: ThisShouldntResolve
665 pub fn all_the_links() {}
681 /// let _ = example(&[1, 2, 3]);
686 #[cfg_attr(not(feature = "false"), doc = "loop {}")]
690 #[cfg_attr(feature = "alloc", doc = "```rust")]
691 #[cfg_attr(not(feature = "alloc"), doc = "```ignore")]
692 /// let _ = example(&alloc::vec![1, 2, 3]);
694 pub fn mix_and_match() {}
697 It is beyond me why you'd use these when you got ///
699 let _ = example(&[1, 2, 3]);
701 [`block_comments2`] tests these with indentation
703 pub fn block_comments() {}
706 Really, I don't get it
708 let _ = example(&[1, 2, 3]);
710 [`block_comments`] tests these without indentation
712 pub fn block_comments2() {}
715 expect_file!["./test_data/highlight_doctest.html"],
721 fn test_extern_crate() {
724 //- /main.rs crate:main deps:std,alloc
726 extern crate alloc as abc;
727 //- /std/lib.rs crate:std
729 //- /alloc/lib.rs crate:alloc
732 expect_file!["./test_data/highlight_extern_crate.html"],
738 fn test_default_library() {
741 //- minicore: option, iterators
746 let nums = iter::repeat(foo.unwrap());
749 expect_file!["./test_data/highlight_default_library.html"],
755 fn test_associated_function() {
763 pub fn is_static() {}
764 pub fn is_not_static(&self) {}
769 fn t_is_not_static(&self) {}
773 pub fn is_static() {}
774 pub fn is_not_static(&self) {}
777 expect_file!["./test_data/highlight_assoc_functions.html"],
783 fn test_injection() {
786 fn f(ra_fixture: &str) {}
796 expect_file!["./test_data/injection.html"],
801 /// Highlights the code given by the `ra_fixture` argument, renders the
802 /// result as HTML, and compares it with the HTML file given as `snapshot`.
803 /// Note that the `snapshot` file is overwritten by the rendered HTML.
804 fn check_highlighting(ra_fixture: &str, expect: ExpectFile, rainbow: bool) {
805 let (analysis, file_id) = fixture::file(ra_fixture);
806 let actual_html = &analysis.highlight_as_html(file_id, rainbow).unwrap();
807 expect.assert_eq(actual_html)