Function deadlock_possibility

src/detector/lock/mod.rs:676–714

Check deadlock possibility. for two lockguards, first check if their types may deadlock; if so, then check if they may alias.

(
    a: &LockGuardId,
    b: &LockGuardId,
    lockguards: &LockGuardMap<'_>,
    alias_analysis: &mut AliasAnalysis,
)

                "ConflictLock".to_owned(),
                "Possibly".to_owned(),
                diagnosis,
                "Locks mutually wait for each other to form a cycle".to_owned(),
            ));
            reports.push(report);
        }
        reports
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum NotDeadlockReason {
    TrueDeadlock,
    RecursiveRead,
    SameSpan,
    // TODO,
}

/// Check deadlock possibility.
/// for two lockguards, first check if their types may deadlock;
/// if so, then check if they may alias.
fn deadlock_possibility(
    a: &LockGuardId,
    b: &LockGuardId,
    lockguards: &LockGuardMap<'_>,
    alias_analysis: &mut AliasAnalysis,
) -> (DeadlockPossibility, NotDeadlockReason) {
    let a_ty = &lockguards[a].lockguard_ty;
    let b_ty = &lockguards[b].lockguard_ty;
    if let (LockGuardTy::ParkingLotRead(_), LockGuardTy::ParkingLotRead(_)) = (a_ty, b_ty) {
        if lockguards[b].is_gen_only_by_recursive() {
            return (
                DeadlockPossibility::Unlikely,
                NotDeadlockReason::RecursiveRead,
            );
        }
    }
    // Assume that a lock in a loop or recursive functions will not deadlock with itself,
    // in which case the lock spans of the two locks are the same.
    // This may miss some bugs but can reduce many FPs.
    if lockguards[a].span == lockguards[b].span {
        return (DeadlockPossibility::Unlikely, NotDeadlockReason::SameSpan);
    }