fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
30.9 KiB971 linesraw
1error: unescaped backtick
2  --> $DIR/unescaped_backticks.rs:187:70
3   |
4LL | /// if you want your MIR to be modified by the full MIR pipeline, or `#![custom_mir(dialect =
5   |                                                                      ^
6   |
7note: the lint level is defined here
8  --> $DIR/unescaped_backticks.rs:1:9
9   |
10LL | #![deny(rustdoc::unescaped_backticks)]
11   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12help: the closing backtick of an inline code may be missing
13   |
14LL | /// "runtime", phase = "optimized")]` if you don't.
15   |                                     +
16help: if you meant to use a literal backtick, escape it
17   |
18LL | /// if you want your MIR to be modified by the full MIR pipeline, or \`#![custom_mir(dialect =
19   |                                                                      +
20
21error: unescaped backtick
22  --> $DIR/unescaped_backticks.rs:232:13
23   |
24LL |         //! `#![rustc_expected_cgu_reuse(module="spike", cfg="rpass2", kind="post-lto")]
25   |             ^
26   |
27help: the closing backtick of an inline code may be missing
28   |
29LL |         //! `#![rustc_expected_cgu_reuse(module="spike", cfg="rpass2", kind="post-lto")]`
30   |                                                                                         +
31help: if you meant to use a literal backtick, escape it
32   |
33LL |         //! \`#![rustc_expected_cgu_reuse(module="spike", cfg="rpass2", kind="post-lto")]
34   |             +
35
36error: unescaped backtick
37  --> $DIR/unescaped_backticks.rs:237:13
38   |
39LL |         /// `cfg=...
40   |             ^
41   |
42help: the closing backtick of an inline code may be missing
43   |
44LL |         /// `cfg=...`
45   |                     +
46help: if you meant to use a literal backtick, escape it
47   |
48LL |         /// \`cfg=...
49   |             +
50
51error: unescaped backtick
52  --> $DIR/unescaped_backticks.rs:241:42
53   |
54LL |         /// `cfg=... and not `#[cfg_attr]`
55   |                                          ^
56   |
57help: a previous inline code might be longer than expected
58   |
59LL |         /// `cfg=...` and not `#[cfg_attr]`
60   |                     +
61help: if you meant to use a literal backtick, escape it
62   |
63LL |         /// `cfg=... and not `#[cfg_attr]\`
64   |                                          +
65
66error: unescaped backtick
67  --> $DIR/unescaped_backticks.rs:193:91
68   |
69LL |     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` with the given `msg to
70   |                                                                                           ^
71   |
72help: the closing backtick of an inline code may be missing
73   |
74LL |     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` with the given `msg` to
75   |                                                                                               +
76help: if you meant to use a literal backtick, escape it
77   |
78LL |     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` with the given \`msg to
79   |                                                                                           +
80
81error: unescaped backtick
82  --> $DIR/unescaped_backticks.rs:202:34
83   |
84LL |         /// in `nt_to_tokenstream`
85   |                                  ^
86   |
87help: a previous inline code might be longer than expected
88   |
89LL |         /// if we parsed no predicates (e.g. `struct` Foo where {}
90   |                                                     +
91help: if you meant to use a literal backtick, escape it
92   |
93LL |         /// in `nt_to_tokenstream\`
94   |                                  +
95
96error: unescaped backtick
97  --> $DIR/unescaped_backticks.rs:208:62
98   |
99LL |     /// that `Option<Symbol>` only takes up 4 bytes, because `newtype_index! reserves
100   |                                                              ^
101   |
102help: the closing backtick of an inline code may be missing
103   |
104LL |     /// that `Option<Symbol>` only takes up 4 bytes, because `newtype_index!` reserves
105   |                                                                             +
106help: if you meant to use a literal backtick, escape it
107   |
108LL |     /// that `Option<Symbol>` only takes up 4 bytes, because \`newtype_index! reserves
109   |                                                              +
110
111error: unescaped backtick
112  --> $DIR/unescaped_backticks.rs:216:52
113   |
114LL |     /// also avoids the need to import `OpenOptions`.
115   |                                                    ^
116   |
117help: a previous inline code might be longer than expected
118   |
119LL |     /// you can write `File::with_options().read(true).open("foo.txt")`. This
120   |                                                                       +
121help: if you meant to use a literal backtick, escape it
122   |
123LL |     /// also avoids the need to import `OpenOptions\`.
124   |                                                    +
125
126error: unescaped backtick
127  --> $DIR/unescaped_backticks.rs:221:46
128   |
129LL |     /// `HybridBitSet`. Has no effect if `row` does not exist.
130   |                                              ^
131   |
132help: a previous inline code might be longer than expected
133   |
134LL |     /// Subtracts `set` from `row`. `set` can be either `BitSet` or
135   |                       +
136help: if you meant to use a literal backtick, escape it
137   |
138LL |     /// `HybridBitSet`. Has no effect if `row\` does not exist.
139   |                                              +
140
141error: unescaped backtick
142  --> $DIR/unescaped_backticks.rs:247:12
143   |
144LL |     /// RWU`s can get very large, so it uses a more compact representation.
145   |            ^
146   |
147help: the opening backtick of an inline code may be missing
148   |
149LL |     /// `RWU`s can get very large, so it uses a more compact representation.
150   |         +
151help: if you meant to use a literal backtick, escape it
152   |
153LL |     /// RWU\`s can get very large, so it uses a more compact representation.
154   |            +
155
156error: unescaped backtick
157  --> $DIR/unescaped_backticks.rs:254:15
158   |
159LL |     /// in `U2`.
160   |               ^
161   |
162help: the opening backtick of a previous inline code may be missing
163   |
164LL |     /// `'?1` is in `U3` would be canonicalized to have `?0` in `U1` and `'?1`
165   |                                                         +
166help: if you meant to use a literal backtick, escape it
167   |
168LL |     /// in `U2\`.
169   |               +
170
171error: unescaped backtick
172  --> $DIR/unescaped_backticks.rs:271:42
173   |
174LL |     /// because it contains `[type error]`. Yuck! (See issue #29857 for
175   |                                          ^
176   |
177help: a previous inline code might be longer than expected
178   |
179LL |     /// as Trait>::Foo == $0`. Here, normalizing `<MyType<$0>` as
180   |                                                              +
181help: if you meant to use a literal backtick, escape it
182   |
183LL |     /// because it contains `[type error]\`. Yuck! (See issue #29857 for
184   |                                          +
185
186error: unescaped backtick
187  --> $DIR/unescaped_backticks.rs:281:53
188   |
189LL |     /// well as the second instance of `A: AutoTrait`) to suppress
190   |                                                     ^
191   |
192help: a previous inline code might be longer than expected
193   |
194LL |     /// encountered a problem (later on) with `A:` AutoTrait. So we
195   |                                                  +
196help: if you meant to use a literal backtick, escape it
197   |
198LL |     /// well as the second instance of `A: AutoTrait\`) to suppress
199   |                                                     +
200
201error: unescaped backtick
202  --> $DIR/unescaped_backticks.rs:291:40
203   |
204LL |     /// `'a` with `'b` and not `'static`. But it will have to do for
205   |                                        ^
206   |
207   = help: the opening or closing backtick of an inline code may be missing
208help: if you meant to use a literal backtick, escape it
209   |
210LL |     /// `'a` with `'b` and not `'static\`. But it will have to do for
211   |                                        +
212
213error: unescaped backtick
214  --> $DIR/unescaped_backticks.rs:300:54
215   |
216LL | /// `None`. Otherwise, it will return `Some(Dispatch)`.
217   |                                                      ^
218   |
219help: the opening backtick of a previous inline code may be missing
220   |
221LL | /// The `Subscriber` may be accessed by calling [`WeakDispatch::upgrade`],
222   |         +
223help: if you meant to use a literal backtick, escape it
224   |
225LL | /// `None`. Otherwise, it will return `Some(Dispatch)\`.
226   |                                                      +
227
228error: unescaped backtick
229  --> $DIR/unescaped_backticks.rs:304:13
230   |
231LL | /// or `None` if it isn't.
232   |             ^
233   |
234   = help: the opening or closing backtick of an inline code may be missing
235help: if you meant to use a literal backtick, escape it
236   |
237LL | /// or `None\` if it isn't.
238   |             +
239
240error: unescaped backtick
241  --> $DIR/unescaped_backticks.rs:308:14
242   |
243LL | /// `on_event` should be called.
244   |              ^
245   |
246help: a previous inline code might be longer than expected
247   |
248LL | /// Called before the filtered [`Layer`]'s [`on_event`], to determine if
249   |                                       +
250help: if you meant to use a literal backtick, escape it
251   |
252LL | /// `on_event\` should be called.
253   |              +
254
255error: unescaped backtick
256  --> $DIR/unescaped_backticks.rs:313:29
257   |
258LL | /// [`rebuild_interest_cache`][rebuild] is called after the value of the max
259   |                             ^
260   |
261help: a previous inline code might be longer than expected
262   |
263LL | /// Therefore, if the `Filter` will change the value returned by this
264   |                              +
265help: if you meant to use a literal backtick, escape it
266   |
267LL | /// [`rebuild_interest_cache\`][rebuild] is called after the value of the max
268   |                             +
269
270error: unescaped backtick
271  --> $DIR/unescaped_backticks.rs:323:5
272   |
273LL | /     /// The Subscriber` may be accessed by calling [`WeakDispatch::upgrade`],
274LL | |
275LL | |
276LL | |
277...  |
278LL | |     /// [`rebuild_interest_cache`][rebuild] is called after the value of the max
279LL | |     /// level changes.
280   | |______________________^
281   |
282   = help: the opening backtick of a previous inline code may be missing
283            change: The Subscriber` may be accessed by calling [`WeakDispatch::upgrade`],
284           to this: The `Subscriber` may be accessed by calling [`WeakDispatch::upgrade`],
285   = help: if you meant to use a literal backtick, escape it
286            change: `None`. Otherwise, it will return `Some(Dispatch)`.
287           to this: `None`. Otherwise, it will return `Some(Dispatch)\`.
288
289error: unescaped backtick
290  --> $DIR/unescaped_backticks.rs:323:5
291   |
292LL | /     /// The Subscriber` may be accessed by calling [`WeakDispatch::upgrade`],
293LL | |
294LL | |
295LL | |
296...  |
297LL | |     /// [`rebuild_interest_cache`][rebuild] is called after the value of the max
298LL | |     /// level changes.
299   | |______________________^
300   |
301   = help: the opening or closing backtick of an inline code may be missing
302   = help: if you meant to use a literal backtick, escape it
303            change: or `None` if it isn't.
304           to this: or `None\` if it isn't.
305
306error: unescaped backtick
307  --> $DIR/unescaped_backticks.rs:323:5
308   |
309LL | /     /// The Subscriber` may be accessed by calling [`WeakDispatch::upgrade`],
310LL | |
311LL | |
312LL | |
313...  |
314LL | |     /// [`rebuild_interest_cache`][rebuild] is called after the value of the max
315LL | |     /// level changes.
316   | |______________________^
317   |
318   = help: a previous inline code might be longer than expected
319            change: Called before the filtered [`Layer]'s [`on_event`], to determine if
320           to this: Called before the filtered [`Layer`]'s [`on_event`], to determine if
321   = help: if you meant to use a literal backtick, escape it
322            change: `on_event` should be called.
323           to this: `on_event\` should be called.
324
325error: unescaped backtick
326  --> $DIR/unescaped_backticks.rs:323:5
327   |
328LL | /     /// The Subscriber` may be accessed by calling [`WeakDispatch::upgrade`],
329LL | |
330LL | |
331LL | |
332...  |
333LL | |     /// [`rebuild_interest_cache`][rebuild] is called after the value of the max
334LL | |     /// level changes.
335   | |______________________^
336   |
337   = help: a previous inline code might be longer than expected
338            change: Therefore, if the `Filter will change the value returned by this
339           to this: Therefore, if the `Filter` will change the value returned by this
340   = help: if you meant to use a literal backtick, escape it
341            change: [`rebuild_interest_cache`][rebuild] is called after the value of the max
342           to this: [`rebuild_interest_cache\`][rebuild] is called after the value of the max
343
344error: unescaped backtick
345  --> $DIR/unescaped_backticks.rs:349:56
346   |
347LL |     /// instead and use [`CloneCounterObserver::counter`] to increment.
348   |                                                        ^
349   |
350   = help: the opening or closing backtick of an inline code may be missing
351help: if you meant to use a literal backtick, escape it
352   |
353LL |     /// instead and use [`CloneCounterObserver::counter\`] to increment.
354   |                                                        +
355
356error: unescaped backtick
357  --> $DIR/unescaped_backticks.rs:12:5
358   |
359LL | /// `
360   |     ^
361   |
362   = help: the opening or closing backtick of an inline code may be missing
363help: if you meant to use a literal backtick, escape it
364   |
365LL | /// \`
366   |     +
367
368error: unescaped backtick
369  --> $DIR/unescaped_backticks.rs:19:7
370   |
371LL | /// \`
372   |       ^
373   |
374help: the opening backtick of an inline code may be missing
375   |
376LL | /// `\`
377   |     +
378help: if you meant to use a literal backtick, escape it
379   |
380LL | /// \\`
381   |       +
382
383error: unescaped backtick
384  --> $DIR/unescaped_backticks.rs:26:6
385   |
386LL | /// [`link1]
387   |      ^
388   |
389help: the closing backtick of an inline code may be missing
390   |
391LL | /// [`link1`]
392   |            +
393help: if you meant to use a literal backtick, escape it
394   |
395LL | /// [\`link1]
396   |      +
397
398error: unescaped backtick
399  --> $DIR/unescaped_backticks.rs:30:11
400   |
401LL | /// [link2`]
402   |           ^
403   |
404help: the opening backtick of an inline code may be missing
405   |
406LL | /// [`link2`]
407   |      +
408help: if you meant to use a literal backtick, escape it
409   |
410LL | /// [link2\`]
411   |           +
412
413error: unescaped backtick
414  --> $DIR/unescaped_backticks.rs:34:6
415   |
416LL | /// [`link_long](link_long)
417   |      ^
418   |
419help: the closing backtick of an inline code may be missing
420   |
421LL | /// [`link_long`](link_long)
422   |                +
423help: if you meant to use a literal backtick, escape it
424   |
425LL | /// [\`link_long](link_long)
426   |      +
427
428error: unescaped backtick
429  --> $DIR/unescaped_backticks.rs:38:6
430   |
431LL | /// [`broken-link]
432   |      ^
433   |
434help: the closing backtick of an inline code may be missing
435   |
436LL | /// [`broken-link`]
437   |                  +
438help: if you meant to use a literal backtick, escape it
439   |
440LL | /// [\`broken-link]
441   |      +
442
443error: unescaped backtick
444  --> $DIR/unescaped_backticks.rs:45:8
445   |
446LL | /// <x:`>
447   |        ^
448   |
449help: the opening backtick of an inline code may be missing
450   |
451LL | /// `<x:`>
452   |     +
453help: if you meant to use a literal backtick, escape it
454   |
455LL | /// <x:\`>
456   |        +
457
458error: unescaped backtick
459  --> $DIR/unescaped_backticks.rs:55:6
460   |
461LL | /// 🦀`🦀
462   |       ^
463   |
464help: the opening backtick of an inline code may be missing
465   |
466LL | /// `🦀`🦀
467   |     +
468help: the closing backtick of an inline code may be missing
469   |
470LL | /// 🦀`🦀`
471   |          +
472help: if you meant to use a literal backtick, escape it
473   |
474LL | /// 🦀\`🦀
475   |       +
476
477error: unescaped backtick
478  --> $DIR/unescaped_backticks.rs:59:5
479   |
480LL | /// `foo(
481   |     ^
482   |
483help: the closing backtick of an inline code may be missing
484   |
485LL | /// `foo(`
486   |          +
487help: if you meant to use a literal backtick, escape it
488   |
489LL | /// \`foo(
490   |     +
491
492error: unescaped backtick
493  --> $DIR/unescaped_backticks.rs:65:14
494   |
495LL | /// `foo `bar`
496   |              ^
497   |
498help: a previous inline code might be longer than expected
499   |
500LL | /// `foo` `bar`
501   |         +
502help: if you meant to use a literal backtick, escape it
503   |
504LL | /// `foo `bar\`
505   |              +
506
507error: unescaped backtick
508  --> $DIR/unescaped_backticks.rs:71:5
509   |
510LL | /// `foo(
511   |     ^
512   |
513help: the closing backtick of an inline code may be missing
514   |
515LL | /// not paragraph`
516   |                  +
517help: if you meant to use a literal backtick, escape it
518   |
519LL | /// \`foo(
520   |     +
521
522error: unescaped backtick
523  --> $DIR/unescaped_backticks.rs:76:83
524   |
525LL | /// Addition is commutative, which means that add(a, b)` is the same as `add(b, a)`.
526   |                                                                                   ^
527   |
528help: the opening backtick of a previous inline code may be missing
529   |
530LL | /// Addition is commutative, which means that `add(a, b)` is the same as `add(b, a)`.
531   |                                               +
532help: if you meant to use a literal backtick, escape it
533   |
534LL | /// Addition is commutative, which means that add(a, b)` is the same as `add(b, a)\`.
535   |                                                                                   +
536
537error: unescaped backtick
538  --> $DIR/unescaped_backticks.rs:80:51
539   |
540LL | /// or even to add a number `n` to 42 (`add(42, b)`)!
541   |                                                   ^
542   |
543help: the opening backtick of a previous inline code may be missing
544   |
545LL | /// You could use this function to add 42 to a number `n` (`add(n, 42)`),
546   |                                                            +
547help: if you meant to use a literal backtick, escape it
548   |
549LL | /// or even to add a number `n` to 42 (`add(42, b)\`)!
550   |                                                   +
551
552error: unescaped backtick
553  --> $DIR/unescaped_backticks.rs:84:83
554   |
555LL | /// Addition is commutative, which means that `add(a, b) is the same as `add(b, a)`.
556   |                                                                                   ^
557   |
558help: a previous inline code might be longer than expected
559   |
560LL | /// Addition is commutative, which means that `add(a, b)` is the same as `add(b, a)`.
561   |                                                         +
562help: if you meant to use a literal backtick, escape it
563   |
564LL | /// Addition is commutative, which means that `add(a, b) is the same as `add(b, a)\`.
565   |                                                                                   +
566
567error: unescaped backtick
568  --> $DIR/unescaped_backticks.rs:88:51
569   |
570LL | /// or even to add a number `n` to 42 (`add(42, n)`)!
571   |                                                   ^
572   |
573help: a previous inline code might be longer than expected
574   |
575LL | /// You could use this function to add 42 to a number `n` (`add(n, 42)`),
576   |                                                                       +
577help: if you meant to use a literal backtick, escape it
578   |
579LL | /// or even to add a number `n` to 42 (`add(42, n)\`)!
580   |                                                   +
581
582error: unescaped backtick
583  --> $DIR/unescaped_backticks.rs:92:83
584   |
585LL | /// Addition is commutative, which means that `add(a, b)` is the same as add(b, a)`.
586   |                                                                                   ^
587   |
588help: the opening backtick of an inline code may be missing
589   |
590LL | /// Addition is commutative, which means that `add(a, b)` is the same as `add(b, a)`.
591   |                                                                          +
592help: if you meant to use a literal backtick, escape it
593   |
594LL | /// Addition is commutative, which means that `add(a, b)` is the same as add(b, a)\`.
595   |                                                                                   +
596
597error: unescaped backtick
598  --> $DIR/unescaped_backticks.rs:96:50
599   |
600LL | /// or even to add a number `n` to 42 (add(42, n)`)!
601   |                                                  ^
602   |
603help: the opening backtick of an inline code may be missing
604   |
605LL | /// or even to add a number `n` to 42 (`add(42, n)`)!
606   |                                        +
607help: if you meant to use a literal backtick, escape it
608   |
609LL | /// or even to add a number `n` to 42 (add(42, n)\`)!
610   |                                                  +
611
612error: unescaped backtick
613  --> $DIR/unescaped_backticks.rs:100:74
614   |
615LL | /// Addition is commutative, which means that `add(a, b)` is the same as `add(b, a).
616   |                                                                          ^
617   |
618help: the closing backtick of an inline code may be missing
619   |
620LL | /// Addition is commutative, which means that `add(a, b)` is the same as `add(b, a)`.
621   |                                                                                    +
622help: if you meant to use a literal backtick, escape it
623   |
624LL | /// Addition is commutative, which means that `add(a, b)` is the same as \`add(b, a).
625   |                                                                          +
626
627error: unescaped backtick
628  --> $DIR/unescaped_backticks.rs:104:51
629   |
630LL | /// or even to add a number `n` to 42 (`add(42, n)`)!
631   |                                                   ^
632   |
633help: a previous inline code might be longer than expected
634   |
635LL | /// You could use this function to add 42 to a number `n` (`add(n, 42)`),
636   |                                                                       +
637help: if you meant to use a literal backtick, escape it
638   |
639LL | /// or even to add a number `n` to 42 (`add(42, n)\`)!
640   |                                                   +
641
642error: unescaped backtick
643  --> $DIR/unescaped_backticks.rs:108:1
644   |
645LL | #[doc = "`"]
646   | ^^^^^^^^^^^^
647   |
648   = help: the opening or closing backtick of an inline code may be missing
649   = help: if you meant to use a literal backtick, escape it
650            change: `
651           to this: \`
652
653error: unescaped backtick
654  --> $DIR/unescaped_backticks.rs:115:1
655   |
656LL | #[doc = concat!("\\", "`")]
657   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
658   |
659   = help: the opening backtick of an inline code may be missing
660            change: \`
661           to this: `\`
662   = help: if you meant to use a literal backtick, escape it
663            change: \`
664           to this: \\`
665
666error: unescaped backtick
667  --> $DIR/unescaped_backticks.rs:119:1
668   |
669LL | #[doc = "Addition is commutative, which means that add(a, b)` is the same as `add(b, a)`."]
670   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
671   |
672   = help: the opening backtick of a previous inline code may be missing
673            change: Addition is commutative, which means that add(a, b)` is the same as `add(b, a)`.
674           to this: Addition is commutative, which means that `add(a, b)` is the same as `add(b, a)`.
675   = help: if you meant to use a literal backtick, escape it
676            change: Addition is commutative, which means that add(a, b)` is the same as `add(b, a)`.
677           to this: Addition is commutative, which means that add(a, b)` is the same as `add(b, a)\`.
678
679error: unescaped backtick
680  --> $DIR/unescaped_backticks.rs:123:1
681   |
682LL | #[doc = "Addition is commutative, which means that `add(a, b) is the same as `add(b, a)`."]
683   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
684   |
685   = help: a previous inline code might be longer than expected
686            change: Addition is commutative, which means that `add(a, b) is the same as `add(b, a)`.
687           to this: Addition is commutative, which means that `add(a, b)` is the same as `add(b, a)`.
688   = help: if you meant to use a literal backtick, escape it
689            change: Addition is commutative, which means that `add(a, b) is the same as `add(b, a)`.
690           to this: Addition is commutative, which means that `add(a, b) is the same as `add(b, a)\`.
691
692error: unescaped backtick
693  --> $DIR/unescaped_backticks.rs:127:1
694   |
695LL | #[doc = "Addition is commutative, which means that `add(a, b)` is the same as add(b, a)`."]
696   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
697   |
698   = help: the opening backtick of an inline code may be missing
699            change: Addition is commutative, which means that `add(a, b)` is the same as add(b, a)`.
700           to this: Addition is commutative, which means that `add(a, b)` is the same as `add(b, a)`.
701   = help: if you meant to use a literal backtick, escape it
702            change: Addition is commutative, which means that `add(a, b)` is the same as add(b, a)`.
703           to this: Addition is commutative, which means that `add(a, b)` is the same as add(b, a)\`.
704
705error: unescaped backtick
706  --> $DIR/unescaped_backticks.rs:131:1
707   |
708LL | #[doc = "Addition is commutative, which means that `add(a, b)` is the same as `add(b, a)."]
709   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
710   |
711   = help: the closing backtick of an inline code may be missing
712            change: Addition is commutative, which means that `add(a, b)` is the same as `add(b, a).
713           to this: Addition is commutative, which means that `add(a, b)` is the same as `add(b, a)`.
714   = help: if you meant to use a literal backtick, escape it
715            change: Addition is commutative, which means that `add(a, b)` is the same as `add(b, a).
716           to this: Addition is commutative, which means that `add(a, b)` is the same as \`add(b, a).
717
718error: unescaped backtick
719  --> $DIR/unescaped_backticks.rs:136:5
720   |
721LL | /// `foo
722   |     ^
723   |
724help: the closing backtick of an inline code may be missing
725   |
726LL | /// `foo`
727   |         +
728help: if you meant to use a literal backtick, escape it
729   |
730LL | /// \`foo
731   |     +
732
733error: unescaped backtick
734  --> $DIR/unescaped_backticks.rs:140:7
735   |
736LL | /// # `(heading
737   |       ^
738   |
739help: the closing backtick of an inline code may be missing
740   |
741LL | /// # `(heading`
742   |                +
743help: if you meant to use a literal backtick, escape it
744   |
745LL | /// # \`(heading
746   |       +
747
748error: unescaped backtick
749  --> $DIR/unescaped_backticks.rs:142:17
750   |
751LL | /// ## heading2)`
752   |                 ^
753   |
754help: the opening backtick of an inline code may be missing
755   |
756LL | /// ## `heading2)`
757   |        +
758help: if you meant to use a literal backtick, escape it
759   |
760LL | /// ## heading2)\`
761   |                 +
762
763error: unescaped backtick
764  --> $DIR/unescaped_backticks.rs:145:11
765   |
766LL | /// multi `(
767   |           ^
768   |
769help: the closing backtick of an inline code may be missing
770   |
771LL | /// )` heading
772   |      +
773help: if you meant to use a literal backtick, escape it
774   |
775LL | /// multi \`(
776   |           +
777
778error: unescaped backtick
779  --> $DIR/unescaped_backticks.rs:151:10
780   |
781LL | /// para)`(graph
782   |          ^
783   |
784help: the opening backtick of an inline code may be missing
785   |
786LL | /// `para)`(graph
787   |     +
788help: the closing backtick of an inline code may be missing
789   |
790LL | /// para)`(graph`
791   |                 +
792help: if you meant to use a literal backtick, escape it
793   |
794LL | /// para)\`(graph
795   |          +
796
797error: unescaped backtick
798  --> $DIR/unescaped_backticks.rs:154:10
799   |
800LL | /// para)`(graph2
801   |          ^
802   |
803help: the opening backtick of an inline code may be missing
804   |
805LL | /// `para)`(graph2
806   |     +
807help: the closing backtick of an inline code may be missing
808   |
809LL | /// para)`(graph2`
810   |                  +
811help: if you meant to use a literal backtick, escape it
812   |
813LL | /// para)\`(graph2
814   |          +
815
816error: unescaped backtick
817  --> $DIR/unescaped_backticks.rs:157:12
818   |
819LL | /// 1. foo)`
820   |            ^
821   |
822help: the opening backtick of an inline code may be missing
823   |
824LL | /// 1. `foo)`
825   |        +
826help: if you meant to use a literal backtick, escape it
827   |
828LL | /// 1. foo)\`
829   |            +
830
831error: unescaped backtick
832  --> $DIR/unescaped_backticks.rs:159:8
833   |
834LL | /// 2. `(bar
835   |        ^
836   |
837help: the closing backtick of an inline code may be missing
838   |
839LL | /// 2. `(bar`
840   |             +
841help: if you meant to use a literal backtick, escape it
842   |
843LL | /// 2. \`(bar
844   |        +
845
846error: unescaped backtick
847  --> $DIR/unescaped_backticks.rs:161:11
848   |
849LL | /// * baz)`
850   |           ^
851   |
852help: the opening backtick of an inline code may be missing
853   |
854LL | /// * `baz)`
855   |       +
856help: if you meant to use a literal backtick, escape it
857   |
858LL | /// * baz)\`
859   |           +
860
861error: unescaped backtick
862  --> $DIR/unescaped_backticks.rs:163:7
863   |
864LL | /// * `(quux
865   |       ^
866   |
867help: the closing backtick of an inline code may be missing
868   |
869LL | /// * `(quux`
870   |             +
871help: if you meant to use a literal backtick, escape it
872   |
873LL | /// * \`(quux
874   |       +
875
876error: unescaped backtick
877  --> $DIR/unescaped_backticks.rs:166:5
878   |
879LL | /// `#![this_is_actually_an_image(and(not), an = "attribute")]
880   |     ^
881   |
882help: the closing backtick of an inline code may be missing
883   |
884LL | /// `#`![this_is_actually_an_image(and(not), an = "attribute")]
885   |       +
886help: if you meant to use a literal backtick, escape it
887   |
888LL | /// \`#![this_is_actually_an_image(and(not), an = "attribute")]
889   |     +
890
891error: unescaped backtick
892  --> $DIR/unescaped_backticks.rs:169:62
893   |
894LL | /// #![this_is_actually_an_image(and(not), an = "attribute")]`
895   |                                                              ^
896   |
897help: the opening backtick of an inline code may be missing
898   |
899LL | /// `#![this_is_actually_an_image(and(not), an = "attribute")]`
900   |     +
901help: if you meant to use a literal backtick, escape it
902   |
903LL | /// #![this_is_actually_an_image(and(not), an = "attribute")]\`
904   |                                                              +
905
906error: unescaped backtick
907  --> $DIR/unescaped_backticks.rs:174:7
908   |
909LL | /// | `table( | )head` |
910   |       ^
911   |
912help: the closing backtick of an inline code may be missing
913   |
914LL | /// | `table(` | )head` |
915   |              +
916help: if you meant to use a literal backtick, escape it
917   |
918LL | /// | \`table( | )head` |
919   |       +
920
921error: unescaped backtick
922  --> $DIR/unescaped_backticks.rs:174:22
923   |
924LL | /// | `table( | )head` |
925   |                      ^
926   |
927help: the opening backtick of an inline code may be missing
928   |
929LL | /// | `table( | `)head` |
930   |                 +
931help: if you meant to use a literal backtick, escape it
932   |
933LL | /// | `table( | )head\` |
934   |                      +
935
936error: unescaped backtick
937  --> $DIR/unescaped_backticks.rs:178:12
938   |
939LL | /// | table`( | )`body |
940   |            ^
941   |
942help: the opening backtick of an inline code may be missing
943   |
944LL | /// | `table`( | )`body |
945   |       +
946help: if you meant to use a literal backtick, escape it
947   |
948LL | /// | table\`( | )`body |
949   |            +
950
951error: unescaped backtick
952  --> $DIR/unescaped_backticks.rs:178:18
953   |
954LL | /// | table`( | )`body |
955   |                  ^
956   |
957help: the opening backtick of an inline code may be missing
958   |
959LL | /// | table`( | `)`body |
960   |                 +
961help: the closing backtick of an inline code may be missing
962   |
963LL | /// | table`( | )`body` |
964   |                       +
965help: if you meant to use a literal backtick, escape it
966   |
967LL | /// | table`( | )\`body |
968   |                  +
969
970error: aborting due to 64 previous errors
971