Method detect_deadlock

src/detector/lock/mod.rs:589–662

First detect doublelock on each relation(a, b), use non-doublelock relations to build `ConflictLockGraph`. Then find the cycles in `ConflictLockGraph` as conflictlock.

(
        &self,
        lockguards: &LockGuardMap<'tcx>,
        callgraph: &'a CallGraph<'tcx>,
        alias_analysis: &mut AliasAnalysis<'a, 'tcx>,
    )

                }
            } else {
                // if is terminator
                for succ_bb in body[loc.block].terminator().successors() {
                    let succ = Location {
                        block: succ_bb,
                        statement_index: 0,
                    };
                    // union and reprocess if changed
                    let changed = states.get_mut(&succ).unwrap().union_in_place(after.clone());
                    if changed {
                        worklist.push_back(succ);
                    }
                }
            }
        }
        states
    }

    /// First detect doublelock on each relation(a, b),
    /// use non-doublelock relations to build `ConflictLockGraph`.
    /// Then find the cycles in `ConflictLockGraph` as conflictlock.
    fn detect_deadlock<'a>(
        &self,
        lockguards: &LockGuardMap<'tcx>,
        callgraph: &'a CallGraph<'tcx>,
        alias_analysis: &mut AliasAnalysis<'a, 'tcx>,
    ) -> Vec<Report> {
        let mut reports = Vec::new();
        let mut conflictlock_graph = ConflictLockGraph::new();
        let mut relation_to_nodes = FxHashMap::default();
        // Detect doublelock:
        // forall relation(a, b): deadlock(a, b) => doublelock(a, b)
        for (a, b) in &self.lockguard_relations {
            let (possibility, reason) = deadlock_possibility(a, b, lockguards, alias_analysis);
            match possibility {
                DeadlockPossibility::Probably | DeadlockPossibility::Possibly => {
                    let diagnosis = diagnose_doublelock(a, b, lockguards, callgraph, self.tcx);
                    let report = Report::DoubleLock(ReportContent::new(
                        "DoubleLock".to_owned(),
                        format!("{:?}", possibility),
                        diagnosis,
                        "The first lock is not released when acquiring the second lock".to_owned(),
                    ));
                    reports.push(report);
                }
                _ if NotDeadlockReason::RecursiveRead != reason
                    && NotDeadlockReason::SameSpan != reason =>
                {
                    // if unlikely doublelock, add the pair into graph to check conflictlock
                    // when the lockguards are gen by call rather than move
                    if !lockguards[a].is_gen_only_by_move() && !lockguards[b].is_gen_only_by_move()
                    {
                        let node = conflictlock_graph.add_node((*a, *b));
                        relation_to_nodes.insert((*a, *b), node);
                    }
                }
                _ => {}
            }
        }