format_code_in_doc_comments = true

Summary: D52632085

Reviewed By: zertosh

Differential Revision: D52640376

fbshipit-source-id: da918401a991b1f15dd84e1e9066cca1457afd28

common/test-allocator/src/lib.rs

@@ -269,7 +269,10 @@ const DEFAULT_SIZE: usize = 0x20000000000; // 128 GiB, try to avoid any rlimits
 /// # use test_allocator::GLOBAL_SLAB_TOP;
 /// # unsafe {
 /// GLOBAL.skip_to_offset(0x100000).unwrap();
-/// assert_eq!(GLOBAL.allocate(4, 4) as usize, GLOBAL_SLAB_TOP - 0x100000 - 4);
+/// assert_eq!(
+///     GLOBAL.allocate(4, 4) as usize,
+///     GLOBAL_SLAB_TOP - 0x100000 - 4
+/// );
 /// # }
 /// ```
 pub const GLOBAL_SLAB_TOP: usize = DEFAULT_PAGE_ADDRESS + DEFAULT_SIZE;

detcore-model/src/schedule.rs

@@ -232,7 +232,6 @@ impl From<Signal> for SigWrapper {
 ///   change this design by going to either extreme. (1) removing implicit O's and changing the
 ///   count mechanism to allow repetition of entire sequences "(O*B)^3" instead of "B^3".  Or (2),
 ///   including implicit O's in all event types, and not recording them explicitly.
-///
 #[derive(PartialEq, Debug, Eq, Copy, Clone, Hash, Serialize, Deserialize)]
 pub enum Op {
     /// A single retired conditional branch, corresponding to one increment of the RCB counter.

detcore-model/src/time.rs

@@ -287,7 +287,6 @@ pub type Microseconds = u64;
 /// without a tick occurring. For example, retired branches are a safe bet (any
 /// non-trivial amount of work will execute a branch), but system calls are not: a
 /// spinning thread can burn cycles forever without executing a syscall.
-///
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DetTime {
     /// The syscalls issued by this thread.

detcore/src/ivar.rs

@@ -153,7 +153,6 @@ impl<T: Debug + Clone> Ivar<T> {
     ///
     /// This is, in general, nondeterministic, because it may be racing with a put operation.
     /// Use with care.
-    ///
     pub fn try_read(&self) -> Option<T> {
         let shared = self.inner.lock().expect("Ivar try_read could not lock.");
         shared.contents.clone()
@@ -163,7 +162,6 @@ impl<T: Debug + Clone> Ivar<T> {
     ///
     ///   (1) symmetry with put,
     ///   (2) taking self by reference instead of consuming it
-    ///
     pub async fn get(&self) -> T {
         let v: Ivar<T> = self.clone();
         v.await

detcore/src/lib.rs

@@ -121,7 +121,6 @@ impl<T: RecordOrReplay> Detcore<T> {
     /// # Arguments
     ///
     /// * `precise_branch`: if true, there were no non-branch instructions since the last recorded branch instruction.
-    ///
     async fn update_logical_time_rcbs<G: Guest<Self>>(
         &self,
         guest: &mut G,
@@ -393,7 +392,6 @@ impl<T: RecordOrReplay> Detcore<T> {
     /// Effects
     ///  - ends timeslice (mutating thread stats, end_of_timeslice)
     ///  - priority change / yield RPC
-    ///
     async fn end_timeslice<G: Guest<Self>>(&self, guest: &mut G) {
         let thread_state = guest.thread_state();
         let dettid = thread_state.dettid;

detcore/src/tool_global.rs

@@ -1477,7 +1477,6 @@ pub struct TraceSchedEventResponse {
 /// Arguments:
 /// - tag_end_rip: read the current guest registers to fill in the `end_rip` on the event with the
 ///   current instruction pointer.
-///
 pub async fn trace_schedevent<G, T>(guest: &mut G, ev: SchedEvent, tag_end_rip: bool)
 where
     G: Guest<Detcore<T>>,

detcore/src/tool_local.rs

@@ -462,7 +462,6 @@ impl<T> ThreadState<T> {
     /// * `ty` - fd type (regular file, socket, pipe, etc..)
     ///
     /// * `stat` - stat returned from fstat
-    ///
     pub fn add_fd(
         &self,
         fd: RawFd,

hermit-cli/src/bin/hermit/analyze/types.rs

@@ -41,7 +41,6 @@ use tracing::metadata::LevelFilter;
 ///
 /// The critical events are identified to the user by printing their stack traces, optionally into a
 /// separate report file.
-///
 #[derive(Debug, Parser, Clone)]
 pub struct AnalyzeOpts {
     /// Target: Analyze runs that have collected stdout output matching this regular expression.

hermit-cli/src/bin/hermit/schedule_search.rs

@@ -406,7 +406,6 @@ where
 /// critical branch in thread B which will (fortunately) be `j`. We will return the critical
 /// schedule in the form that passes and coordinates into the schedule to indicate where a single
 /// flipped pair of branches can cause the test to fail
-///
 #[allow(unused)]
 fn sub_event_search<F>(
     tester: &mut F,
@@ -555,7 +554,6 @@ fn sched_event_with_new_count(original: &SchedEvent, new_count: u32) -> SchedEve
 /// Original Branches  => AAAAAAAABBBBBBBBB
 /// Synthetic Branches => AAAABBBBBBBAAAABB
 ///                       <A4><- B7-><A4>B2
-///
 fn create_schedule_with_critical_pair(
     prefix: &[SchedEvent],
     postfix: &[SchedEvent],