checkpoint.rs 92.3%

181 of 196 lines run, 21 of 34 functions · run #417 on main · run missed

//! Checkpoints (spec §11): a serialized state kept per bookmark so loading
//! a state costs the changes since the checkpoint rather than all of them.
//!
//! The newest checkpoint of each bookmark is pointed at by
//! `.oxy/checkpoints/<bookmark>`; older ones become unreachable and are
//! garbage collected. A checkpoint applies to a requested head set when all
//! of its heads lie in that set's closure, which the loader establishes while
//! walking from the requested heads and stopping at checkpoint members.

use super::*;
use crate::objects::Checkpoint;

impl Repo {
    fn checkpoint_pointer(&self, bookmark: &str) -> PathBuf {
        self.oxy.join("checkpoints").join(name_file(bookmark))
    }

    /// The newest checkpoint recorded for a bookmark.
    pub fn latest_checkpoint(&self, bookmark: &str) -> Result<Option<(ObjectRef, Checkpoint)>> {
        match fs::read_to_string(self.checkpoint_pointer(bookmark)) {
            Ok(h) => {
                let r = ObjectRef::from_hex(h.trim())
                    .ok_or_else(|| RepoError::Msg("corrupt checkpoint pointer".into()))?;
                match self.store.get_typed(&r, ObjectType::Checkpoint) {
                    Ok(bytes) => Ok(Some((r, Checkpoint::decode(&bytes)?))),
                    Err(StoreError::NotFound(_)) => Ok(None),
                    Err(e) => Err(e.into()),
                }
            }
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
            Err(e) => Err(e.into()),
        }
    }

    /// Every checkpoint pointer, for garbage collection roots.
    pub(crate) fn checkpoint_refs(&self) -> Result<Vec<ObjectRef>> {
        let dir = self.oxy.join("checkpoints");
        let mut out = Vec::new();
        if let Ok(rd) = fs::read_dir(&dir) {
            for e in rd.flatten() {
                if let Ok(h) = fs::read_to_string(e.path()) {
                    if let Some(r) = ObjectRef::from_hex(h.trim()) {
                        out.push(r);
                    }
                }
            }
        }
        Ok(out)
    }

    /// Write a checkpoint of `state` (whose heads are `heads`) for `bookmark`.
    pub(crate) fn write_checkpoint(
        &self,
        bookmark: &str,
        state: &State,
        heads: &[ChangeHash],
    ) -> Result<(ObjectRef, usize)> {
        let batch = self.store.begin_batch()?;
        let (blob, payload_len) = self.store_checkpoint_payload(state)?;
        let cp = Checkpoint {
            heads: StateObject::new(heads.to_vec()).heads,
            count: state.len() as u64,
            payload: blob,
        };
        let r = self.store.put(ObjectType::Checkpoint, &cp.encode())?;
        batch.finish()?;
        fs::create_dir_all(self.oxy.join("checkpoints"))?;
        write_atomic(&self.checkpoint_pointer(bookmark), r.to_hex().as_bytes())?;
        Ok((r, payload_len))
    }

    /// Store `state` as a version 2 payload (spec §11): the graphs of large
    /// files as blobs of their own, shared with earlier checkpoints when
    /// unchanged, and the index naming them. Returns the index blob and its size.
    pub(crate) fn store_checkpoint_payload(&self, state: &State) -> Result<(ObjectRef, usize)> {
        let graphs = state.checkpoint_file_graphs();
        for (_, enc) in &graphs {
            if enc.len() >= crate::state::INLINE_GRAPH_LIMIT {
                self.store_blob(enc)?;
            }
        }
        let index = state.checkpoint_index(&graphs, Repo::blob_ref);
        Ok((self.store_blob(&index)?, index.len()))
    }

    /// The graph blobs a checkpoint's payload names (none for version 1).
    pub(crate) fn checkpoint_graph_blobs(&self, cp: &Checkpoint) -> Result<Vec<ObjectRef>> {
        let payload = self.read_blob(&cp.payload)?;
        Ok(State::checkpoint_graph_refs(&payload)?)
    }

    /// Decode a checkpoint's payload, reading its graph blobs from the store.
    pub(crate) fn state_from_checkpoint(&self, payload: &[u8]) -> Result<State> {
        Ok(State::from_checkpoint(payload, |refs| {
            self.read_blobs(refs).map_err(|e| {
                crate::objects::ObjectError::Schema(format!("checkpoint graph blobs: {e}"))
            })
        })?)
    }

    /// Checkpoint the current bookmark's state now.
    pub fn checkpoint(&self) -> Result<(ObjectRef, usize, usize)> {
        let heads = self.bookmark_heads()?;
        let state = self.load_state_full(&heads)?;
        let (r, bytes) = self.write_checkpoint(&self.config.bookmark, &state, &heads)?;
        Ok((r, state.len(), bytes))
    }

    /// Point `bookmark` at an already stored checkpoint (a shallow clone's base).
    pub(crate) fn install_checkpoint(&self, bookmark: &str, r: &ObjectRef) -> Result<()> {
        Checkpoint::decode(&self.store.get_typed(r, ObjectType::Checkpoint)?)?;
        fs::create_dir_all(self.oxy.join("checkpoints"))?;
        write_atomic(&self.checkpoint_pointer(bookmark), r.to_hex().as_bytes())
    }

    /// The checkpoint of exactly `heads`: the bookmark's latest when it
    /// is that state, else one made now (kept as the bookmark's when the
    /// bookmark is at `heads`).
    fn checkpoint_ref_for(&self, heads: &[ChangeHash]) -> Result<ObjectRef> {
        let _t = crate::timing::phase("checkpoint: find or make");
        let wanted = StateObject::new(heads.to_vec()).heads;
        let bookmark = self.config.bookmark.clone();
        let current = self.bookmark_heads()?;
        Ok(match self.latest_checkpoint(&bookmark)? {
            Some((r, cp)) if cp.heads == wanted => r,
            _ => {
                let state = self.load_state(&wanted)?;
                if current == wanted {
                    self.write_checkpoint(&bookmark, &state, &wanted)?.0
                } else {
                    let (blob, _) = self.store_checkpoint_payload(&state)?;
                    let cp = Checkpoint {
                        heads: wanted.clone(),
                        count: state.len() as u64,
                        payload: blob,
                    };
                    self.store.put(ObjectType::Checkpoint, &cp.encode())?
                }
            }
        })
    }

    /// A checkpoint of exactly `heads` without its graph blobs (spec
    /// §16.1 `checkpoint-index`, oxygen#137): the checkpoint object, its
    /// payload blob and the blob's chunks. The client asks for the graph
    /// blobs the payload names in parts, with `objects`, so neither side
    /// holds a big state's whole answer at once.
    pub fn checkpoint_index_for(&self, heads: &[ChangeHash]) -> Result<Bundle> {
        let r = self.checkpoint_ref_for(heads)?;
        let cp = Checkpoint::decode(&self.store.get_typed(&r, ObjectType::Checkpoint)?)?;
        let mut bundle = Bundle::default();
        let chunks = Blob::decode(&self.store.get_typed(&cp.payload, ObjectType::Blob)?)?.chunks;
        for got in self.store.get_many(&chunks) {
            bundle.objects.push(got?);
        }
        bundle.objects.push(self.store.get(&cp.payload)?);
        bundle.objects.push((ObjectType::Checkpoint, cp.encode()));
        Ok(bundle)
    }

    /// A checkpoint of exactly `heads` with its graph blobs and their
    /// chunks, in one answer (spec §16.1 `checkpoint`): what a client
    /// older than `checkpoint-index` asks for.
    pub fn checkpoint_bundle_for(&self, heads: &[ChangeHash]) -> Result<Bundle> {
        let mut bundle = self.checkpoint_index_for(heads)?;
        let _t = crate::timing::phase("checkpoint: gather its objects");
        let cp = match bundle.objects.last() {
            Some((ObjectType::Checkpoint, body)) => Checkpoint::decode(body)?,
            _ => return fail("a checkpoint index without its checkpoint"),
        };
        // The graph blobs and their chunks in two parallel reads (#137): a
        // big state's are tens of thousands, and one by one they took six
        // minutes for VS Code.
        let graphs = self.checkpoint_graph_blobs(&cp)?;
        let mut blobs = Vec::with_capacity(graphs.len());
        for got in self.store.get_many(&graphs) {
            blobs.push(got?);
        }
        let mut chunks = Vec::new();
        for (ty, body) in &blobs {
            if *ty != ObjectType::Blob {
                return fail("a checkpoint graph is not a blob");
            }
            chunks.extend(Blob::decode(body)?.chunks);
        }
        let last = bundle.objects.pop();
        for got in self.store.get_many(&chunks) {
            bundle.objects.push(got?);
        }
        bundle.objects.extend(blobs);
        bundle.objects.extend(last);
        Ok(bundle)
    }

    /// Load the state of `heads` using a checkpoint when one applies.
    pub(crate) fn load_state_checkpointed(&self, heads: &[ChangeHash]) -> Result<Option<State>> {
        self.load_state_checkpointed_as(heads, false)
    }

    /// As [`Repo::load_state_checkpointed`]; `history` builds no file graph.
    pub(crate) fn load_state_checkpointed_as(
        &self,
        heads: &[ChangeHash],
        history: bool,
    ) -> Result<Option<State>> {
        let mut bookmarks: Vec<String> = vec![self.config.bookmark.clone()];
        if let Ok(rd) = fs::read_dir(self.oxy.join("checkpoints")) {
            for e in rd.flatten() {
                let name = file_name_to_name(&e.file_name().to_string_lossy());
                if !bookmarks.contains(&name) {
                    bookmarks.push(name);
                }
            }
        }
        for b in bookmarks {
            let Some((_, cp)) = self.latest_checkpoint(&b)? else {
                continue;
            };
            let payload = {
                let _t = crate::timing::phase("load: read checkpoint");
                self.read_blob(&cp.payload)?
            };
            let base = {
                let _t = crate::timing::phase("load: decode checkpoint");
                if history {
                    State::from_checkpoint_history(&payload)?
                } else {
                    self.state_from_checkpoint(&payload)?
                }
            };
            let cp_heads: BTreeSet<ChangeHash> = cp.heads.iter().copied().collect();
            let mut found: BTreeSet<ChangeHash> = BTreeSet::new();
            let mut delta: Vec<(ChangeHash, Change, Vec<crate::objects::TextRef>)> = Vec::new();
            let mut seen: BTreeSet<ChangeHash> = BTreeSet::new();
            let mut stack: Vec<ChangeHash> = heads.to_vec();
            while let Some(h) = stack.pop() {
                if !seen.insert(h) {
                    continue;
                }
                if base.contains(&h) {
                    if cp_heads.contains(&h) {
                        found.insert(h);
                    }
                    continue;
                }
                // For history, the skeleton: text is read only for the
                // graphs built later, and a state holding none can be
                // indexed (oxygen#93).
                let (c, texts) = if history {
                    self.store.get_change_lazy(&h)?
                } else {
                    (self.store.get_change(&h)?, Vec::new())
                };
                stack.extend(c.deps.iter().copied());
                delta.push((h, c, texts));
            }
            if found.len() != cp_heads.len() {
                continue;
            }
            let _t = crate::timing::phase("load: apply delta and validate");
            let mut state = base;
            for (h, c, texts) in delta {
                if history {
                    state.add_known(h, c, texts);
                } else {
                    state.add_unchecked(c);
                }
            }
            state.validate()?;
            return Ok(Some(state));
        }
        Ok(None)
    }
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! Checkpoints (spec §11): a serialized state kept per bookmark so loading
2		//! a state costs the changes since the checkpoint rather than all of them.
3		//!
4		//! The newest checkpoint of each bookmark is pointed at by
5		//! `.oxy/checkpoints/<bookmark>`; older ones become unreachable and are
6		//! garbage collected. A checkpoint applies to a requested head set when all
7		//! of its heads lie in that set's closure, which the loader establishes while
8		//! walking from the requested heads and stopping at checkpoint members.
9
10		use super::*;
11		use crate::objects::Checkpoint;
12
13		impl Repo {
14	3172×	fn checkpoint_pointer(&self, bookmark: &str) -> PathBuf {
15	3172×	self.oxy.join("checkpoints").join(name_file(bookmark))
16	3172×	}
17
18		/// The newest checkpoint recorded for a bookmark.
19	3158×	pub fn latest_checkpoint(&self, bookmark: &str) -> Result<Option<(ObjectRef, Checkpoint)>> {
20	3158×	match fs::read_to_string(self.checkpoint_pointer(bookmark)) {
21	77×	Ok(h) => {
22	77×	let r = ObjectRef::from_hex(h.trim())
23	77×	.ok_or_else(\|\| RepoError::Msg("corrupt checkpoint pointer".into()))?;
24	77×	match self.store.get_typed(&r, ObjectType::Checkpoint) {
25	77×	Ok(bytes) => Ok(Some((r, Checkpoint::decode(&bytes)?))),
26	0×	Err(StoreError::NotFound(_)) => Ok(None),
27	0×	Err(e) => Err(e.into()),
28		}
29		}
30	3081×	Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
31	0×	Err(e) => Err(e.into()),
32		}
33	3158×	}
34
35		/// Every checkpoint pointer, for garbage collection roots.
36	105×	pub(crate) fn checkpoint_refs(&self) -> Result<Vec<ObjectRef>> {
37	105×	let dir = self.oxy.join("checkpoints");
38	105×	let mut out = Vec::new();
39	105×	if let Ok(rd) = fs::read_dir(&dir) {
40	11×	for e in rd.flatten() {
41	11×	if let Ok(h) = fs::read_to_string(e.path()) {
42	11×	if let Some(r) = ObjectRef::from_hex(h.trim()) {
43	11×	out.push(r);
44	11×	}
45	0×	}
46		}
47	94×	}
48	105×	Ok(out)
49	105×	}
50
51		/// Write a checkpoint of `state` (whose heads are `heads`) for `bookmark`.
52	10×	pub(crate) fn write_checkpoint(
53	10×	&self,
54	10×	bookmark: &str,
55	10×	state: &State,
56	10×	heads: &[ChangeHash],
57	10×	) -> Result<(ObjectRef, usize)> {
58	10×	let batch = self.store.begin_batch()?;
59	10×	let (blob, payload_len) = self.store_checkpoint_payload(state)?;
60	10×	let cp = Checkpoint {
61	10×	heads: StateObject::new(heads.to_vec()).heads,
62	10×	count: state.len() as u64,
63	10×	payload: blob,
64	10×	};
65	10×	let r = self.store.put(ObjectType::Checkpoint, &cp.encode())?;
66	10×	batch.finish()?;
67	10×	fs::create_dir_all(self.oxy.join("checkpoints"))?;
68	10×	write_atomic(&self.checkpoint_pointer(bookmark), r.to_hex().as_bytes())?;
69	10×	Ok((r, payload_len))
70	10×	}
71
72		/// Store `state` as a version 2 payload (spec §11): the graphs of large
73		/// files as blobs of their own, shared with earlier checkpoints when
74		/// unchanged, and the index naming them. Returns the index blob and its size.
75	10×	pub(crate) fn store_checkpoint_payload(&self, state: &State) -> Result<(ObjectRef, usize)> {
76	10×	let graphs = state.checkpoint_file_graphs();
77	40×	for (_, enc) in &graphs {
78	40×	if enc.len() >= crate::state::INLINE_GRAPH_LIMIT {
79	3×	self.store_blob(enc)?;
80	37×	}
81		}
82	10×	let index = state.checkpoint_index(&graphs, Repo::blob_ref);
83	10×	Ok((self.store_blob(&index)?, index.len()))
84	10×	}
85
86		/// The graph blobs a checkpoint's payload names (none for version 1).
87	9×	pub(crate) fn checkpoint_graph_blobs(&self, cp: &Checkpoint) -> Result<Vec<ObjectRef>> {
88	9×	let payload = self.read_blob(&cp.payload)?;
89	9×	Ok(State::checkpoint_graph_refs(&payload)?)
90	9×	}
91
92		/// Decode a checkpoint's payload, reading its graph blobs from the store.
93	19×	pub(crate) fn state_from_checkpoint(&self, payload: &[u8]) -> Result<State> {
94	19×	Ok(State::from_checkpoint(payload, \|refs\| {
95	4×	self.read_blobs(refs).map_err(\|e\| {
96	2×	crate::objects::ObjectError::Schema(format!("checkpoint graph blobs: {e}"))
97	2×	})
98	4×	})?)
99	19×	}
100
101		/// Checkpoint the current bookmark's state now.
102	6×	pub fn checkpoint(&self) -> Result<(ObjectRef, usize, usize)> {
103	6×	let heads = self.bookmark_heads()?;
104	6×	let state = self.load_state_full(&heads)?;
105	6×	let (r, bytes) = self.write_checkpoint(&self.config.bookmark, &state, &heads)?;
106	6×	Ok((r, state.len(), bytes))
107	6×	}
108
109		/// Point `bookmark` at an already stored checkpoint (a shallow clone's base).
110	4×	pub(crate) fn install_checkpoint(&self, bookmark: &str, r: &ObjectRef) -> Result<()> {
111	4×	Checkpoint::decode(&self.store.get_typed(r, ObjectType::Checkpoint)?)?;
112	4×	fs::create_dir_all(self.oxy.join("checkpoints"))?;
113	4×	write_atomic(&self.checkpoint_pointer(bookmark), r.to_hex().as_bytes())
114	4×	}
115
116		/// The checkpoint of exactly `heads`: the bookmark's latest when it
117		/// is that state, else one made now (kept as the bookmark's when the
118		/// bookmark is at `heads`).
119	4×	fn checkpoint_ref_for(&self, heads: &[ChangeHash]) -> Result<ObjectRef> {
120	4×	let _t = crate::timing::phase("checkpoint: find or make");
121	4×	let wanted = StateObject::new(heads.to_vec()).heads;
122	4×	let bookmark = self.config.bookmark.clone();
123	4×	let current = self.bookmark_heads()?;
124	4×	Ok(match self.latest_checkpoint(&bookmark)? {
125	2×	Some((r, cp)) if cp.heads == wanted => r,
126		_ => {
127	2×	let state = self.load_state(&wanted)?;
128	2×	if current == wanted {
129	2×	self.write_checkpoint(&bookmark, &state, &wanted)?.0
130		} else {
131	0×	let (blob, _) = self.store_checkpoint_payload(&state)?;
132	0×	let cp = Checkpoint {
133	0×	heads: wanted.clone(),
134	0×	count: state.len() as u64,
135	0×	payload: blob,
136	0×	};
137	0×	self.store.put(ObjectType::Checkpoint, &cp.encode())?
138		}
139		}
140		})
141	4×	}
142
143		/// A checkpoint of exactly `heads` without its graph blobs (spec
144		/// §16.1 `checkpoint-index`, oxygen#137): the checkpoint object, its
145		/// payload blob and the blob's chunks. The client asks for the graph
146		/// blobs the payload names in parts, with `objects`, so neither side
147		/// holds a big state's whole answer at once.
148	4×	pub fn checkpoint_index_for(&self, heads: &[ChangeHash]) -> Result<Bundle> {
149	4×	let r = self.checkpoint_ref_for(heads)?;
150	4×	let cp = Checkpoint::decode(&self.store.get_typed(&r, ObjectType::Checkpoint)?)?;
151	4×	let mut bundle = Bundle::default();
152	4×	let chunks = Blob::decode(&self.store.get_typed(&cp.payload, ObjectType::Blob)?)?.chunks;
153	4×	for got in self.store.get_many(&chunks) {
154	4×	bundle.objects.push(got?);
155		}
156	4×	bundle.objects.push(self.store.get(&cp.payload)?);
157	4×	bundle.objects.push((ObjectType::Checkpoint, cp.encode()));
158	4×	Ok(bundle)
159	4×	}
160
161		/// A checkpoint of exactly `heads` with its graph blobs and their
162		/// chunks, in one answer (spec §16.1 `checkpoint`): what a client
163		/// older than `checkpoint-index` asks for.
164	1×	pub fn checkpoint_bundle_for(&self, heads: &[ChangeHash]) -> Result<Bundle> {
165	1×	let mut bundle = self.checkpoint_index_for(heads)?;
166	1×	let _t = crate::timing::phase("checkpoint: gather its objects");
167	1×	let cp = match bundle.objects.last() {
168	1×	Some((ObjectType::Checkpoint, body)) => Checkpoint::decode(body)?,
169	0×	_ => return fail("a checkpoint index without its checkpoint"),
170		};
171		// The graph blobs and their chunks in two parallel reads (#137): a
172		// big state's are tens of thousands, and one by one they took six
173		// minutes for VS Code.
174	1×	let graphs = self.checkpoint_graph_blobs(&cp)?;
175	1×	let mut blobs = Vec::with_capacity(graphs.len());
176	1×	for got in self.store.get_many(&graphs) {
177	1×	blobs.push(got?);
178		}
179	1×	let mut chunks = Vec::new();
180	1×	for (ty, body) in &blobs {
181	1×	if *ty != ObjectType::Blob {
182	0×	return fail("a checkpoint graph is not a blob");
183	1×	}
184	1×	chunks.extend(Blob::decode(body)?.chunks);
185		}
186	1×	let last = bundle.objects.pop();
187	1×	for got in self.store.get_many(&chunks) {
188	1×	bundle.objects.push(got?);
189		}
190	1×	bundle.objects.extend(blobs);
191	1×	bundle.objects.extend(last);
192	1×	Ok(bundle)
193	1×	}
194
195		/// Load the state of `heads` using a checkpoint when one applies.
196	228×	pub(crate) fn load_state_checkpointed(&self, heads: &[ChangeHash]) -> Result<Option<State>> {
197	228×	self.load_state_checkpointed_as(heads, false)
198	228×	}
199
200		/// As [`Repo::load_state_checkpointed`]; `history` builds no file graph.
201	2372×	pub(crate) fn load_state_checkpointed_as(
202	2372×	&self,
203	2372×	heads: &[ChangeHash],
204	2372×	history: bool,
205	2372×	) -> Result<Option<State>> {
206	2372×	let mut bookmarks: Vec<String> = vec![self.config.bookmark.clone()];
207	2372×	if let Ok(rd) = fs::read_dir(self.oxy.join("checkpoints")) {
208	58×	for e in rd.flatten() {
209	58×	let name = file_name_to_name(&e.file_name().to_string_lossy());
210	58×	if !bookmarks.contains(&name) {
211	0×	bookmarks.push(name);
212	58×	}
213		}
214	2314×	}
215	2372×	for b in bookmarks {
216	2372×	let Some((_, cp)) = self.latest_checkpoint(&b)? else {
217	2314×	continue;
218		};
219	58×	let payload = {
220	58×	let _t = crate::timing::phase("load: read checkpoint");
221	58×	self.read_blob(&cp.payload)?
222		};
223	57×	let base = {
224	58×	let _t = crate::timing::phase("load: decode checkpoint");
225	58×	if history {
226	48×	State::from_checkpoint_history(&payload)?
227		} else {
228	10×	self.state_from_checkpoint(&payload)?
229		}
230		};
231	57×	let cp_heads: BTreeSet<ChangeHash> = cp.heads.iter().copied().collect();
232	57×	let mut found: BTreeSet<ChangeHash> = BTreeSet::new();
233	57×	let mut delta: Vec<(ChangeHash, Change, Vec<crate::objects::TextRef>)> = Vec::new();
234	57×	let mut seen: BTreeSet<ChangeHash> = BTreeSet::new();
235	57×	let mut stack: Vec<ChangeHash> = heads.to_vec();
236	240×	while let Some(h) = stack.pop() {
237	183×	if !seen.insert(h) {
238	28×	continue;
239	155×	}
240	155×	if base.contains(&h) {
241	101×	if cp_heads.contains(&h) {
242	52×	found.insert(h);
243	52×	}
244	101×	continue;
245	54×	}
246		// For history, the skeleton: text is read only for the
247		// graphs built later, and a state holding none can be
248		// indexed (oxygen#93).
249	54×	let (c, texts) = if history {
250	47×	self.store.get_change_lazy(&h)?
251		} else {
252	7×	(self.store.get_change(&h)?, Vec::new())
253		};
254	54×	stack.extend(c.deps.iter().copied());
255	54×	delta.push((h, c, texts));
256		}
257	57×	if found.len() != cp_heads.len() {
258	6×	continue;
259	51×	}
260	51×	let _t = crate::timing::phase("load: apply delta and validate");
261	51×	let mut state = base;
262	51×	for (h, c, texts) in delta {
263	45×	if history {
264	38×	state.add_known(h, c, texts);
265	38×	} else {
266	7×	state.add_unchecked(c);
267	7×	}
268		}
269	51×	state.validate()?;
270	51×	return Ok(Some(state));
271		}
272	2320×	Ok(None)
273	2372×	}
274		}

Coverage / crates/oxy-core/src/repo/checkpoint.rs 92.3%

Keyboard