fn propagate_constraint_sccs_new(
        &mut self,
        scc_a: ConstraintSccIndex,
        visited: &mut BitSet<ConstraintSccIndex>,
    ) {
        let constraint_sccs = self.constraint_sccs.clone();

        // Walk each SCC `B` such that `A: B`...
        for &scc_b in constraint_sccs.successors(scc_a) {
            debug!("propagate_constraint_sccs: scc_a = {:?} scc_b = {:?}", scc_a, scc_b);

            // ...compute the value of `B`...
            self.propagate_constraint_sccs_if_new(scc_b, visited);

            // ...and add elements from `B` into `A`. One complication
            // arises because of universes: If `B` contains something
            // that `A` cannot name, then `A` can only contain `B` if
            // it outlives static.
            if self.universe_compatible(scc_b, scc_a) {
                // `A` can name everything that is in `B`, so just
                // merge the bits.
                self.scc_values.add_region(scc_a, scc_b);
            } else {
                self.add_incompatible_universe(scc_a);
            }
        }

        // Now take member constraints into account.
        let member_constraints = self.member_constraints.clone();
        for m_c_i in member_constraints.indices(scc_a) {
            self.apply_member_constraint(
                scc_a,
                m_c_i,
                member_constraints.choice_regions(m_c_i),
            );
        }

        debug!(
            "propagate_constraint_sccs: scc_a = {:?} has value {:?}",
            scc_a,
            self.scc_values.region_value_str(scc_a),
        );
    }
/// Computes the value of the SCC `scc_a`, which has not yet been
/// computed. This works by first computing all successors of the
/// SCC (if they haven't been computed already) and then unioning
/// together their elements.
Computes the value of the SCC `scc_a`, which has not yet been
computed. This works by first computing all successors of the
SCC (if they haven't been computed already) and then unioning
together their elements.
Computes the value of the SCC ` scc_a ` which has not yet been computed . This works by first computing all successors of the SCC ( if they haven ' t been computed already ) and then unioning together their elements .
fn propagate_constraint_sccs_new(
        &mut self,
        scc_a: ConstraintSccIndex,
        visited: &mut BitSet<ConstraintSccIndex>,
    ) {
        let constraint_sccs = self.constraint_sccs.clone();
        // Walk each SCC `B` such that `A: B`...
        for &scc_b in constraint_sccs.successors(scc_a) {
            debug!("propagate_constraint_sccs: scc_a = {:?} scc_b = {:?}", scc_a, scc_b);
            // ...compute the value of `B`...
            self.propagate_constraint_sccs_if_new(scc_b, visited);
            // ...and add elements from `B` into `A`. One complication
            // arises because of universes: If `B` contains something
            // that `A` cannot name, then `A` can only contain `B` if
            // it outlives static.
            if self.universe_compatible(scc_b, scc_a) {
                // `A` can name everything that is in `B`, so just
                // merge the bits.
                self.scc_values.add_region(scc_a, scc_b);
            } else {
                self.add_incompatible_universe(scc_a);
            }
        }
        // Now take member constraints into account.
        let member_constraints = self.member_constraints.clone();
        for m_c_i in member_constraints.indices(scc_a) {
            self.apply_member_constraint(
                scc_a,
                m_c_i,
                member_constraints.choice_regions(m_c_i),
            );
        }
        debug!(
            "propagate_constraint_sccs: scc_a = {:?} has value {:?}",
            scc_a,
            self.scc_values.region_value_str(scc_a),
        );
    }
fn propagate_constraint_sccs_new ( & mut self , scc_a : ConstraintSccIndex , visited : & mut BitSet < ConstraintSccIndex > , ) { let constraint_sccs = self . constraint_sccs . clone ( ) ; // Walk each SCC `B` such that `A: B`... for & scc_b in constraint_sccs . successors ( scc_a ) { debug ! ( " " scc_a scc_b ) ; // ...compute the value of `B`... self . propagate_constraint_sccs_if_new ( scc_b , visited ) ; // ...and add elements from `B` into `A`. One complication // arises because of universes: If `B` contains something // that `A` cannot name, then `A` can only contain `B` if // it outlives static. if self . universe_compatible ( scc_b , scc_a ) { // `A` can name everything that is in `B`, so just // merge the bits. self . scc_values . add_region ( scc_a , scc_b ) ; } else { self . add_incompatible_universe ( scc_a ) ; } } // Now take member constraints into account. let member_constraints = self . member_constraints . clone ( ) ; for m_c_i in member_constraints . indices ( scc_a ) { self . apply_member_constraint ( scc_a , m_c_i , member_constraints . choice_regions ( m_c_i ) , ) ; } debug ! ( " " scc_a self scc_values region_value_str ( scc_a ) ) ; }
Computes the value of the SCC `scc_a`, which has not yet been
computed.
Computes the value of the SCC ` scc_a ` which has not yet been computed .
&mut self
scc_a
ConstraintSccIndex
visited
&mut BitSet<ConstraintSccIndex>