From b49aba8b46850c85cd0dcbafc35e8a5bcbd5382b Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Fri, 19 May 2023 08:59:49 +0000 Subject: [PATCH] Prevent rustdoc from finding links. --- compiler/rustc_borrowck/src/places_conflict.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/compiler/rustc_borrowck/src/places_conflict.rs b/compiler/rustc_borrowck/src/places_conflict.rs index 3a2a11d43323b..8784999f3a9a1 100644 --- a/compiler/rustc_borrowck/src/places_conflict.rs +++ b/compiler/rustc_borrowck/src/places_conflict.rs @@ -7,33 +7,43 @@ //! have the same type, and that they only overlap if they are the identical. //! //! For example, if we are comparing these: +//! ```text //! BORROW: (*x1[2].y).z.a //! ACCESS: (*x1[i].y).w.b +//! ``` //! //! Then our steps are: +//! ```text //! x1 | x1 -- places are the same //! x1[2] | x1[i] -- equal or disjoint (disjoint if indexes differ) //! x1[2].y | x1[i].y -- equal or disjoint //! *x1[2].y | *x1[i].y -- equal or disjoint //! (*x1[2].y).z | (*x1[i].y).w -- we are disjoint and don't need to check more! +//! ``` //! //! Because `zip` does potentially bad things to the iterator inside, this loop //! also handles the case where the access might be a *prefix* of the borrow, e.g. //! +//! ```text //! BORROW: (*x1[2].y).z.a //! ACCESS: x1[i].y +//! ``` //! //! Then our steps are: +//! ```text //! x1 | x1 -- places are the same //! x1[2] | x1[i] -- equal or disjoint (disjoint if indexes differ) //! x1[2].y | x1[i].y -- equal or disjoint +//! ``` //! //! -- here we run out of access - the borrow can access a part of it. If this //! is a full deep access, then we *know* the borrow conflicts with it. However, //! if the access is shallow, then we can proceed: //! +//! ```text //! x1[2].y | (*x1[i].y) -- a deref! the access can't get past this, so we //! are disjoint +//! ``` //! //! Our invariant is, that at each step of the iteration: //! - If we didn't run out of access to match, our borrow and access are comparable