fn init_free_and_bound_regions(&mut self) {
        // Update the names (if any)
        for (external_name, variable) in self.universal_regions.named_universal_regions() {
            debug!(
                "init_universal_regions: region {:?} has external name {:?}",
                variable, external_name
            );
            self.definitions[variable].external_name = Some(external_name);
        }

        for variable in self.definitions.indices() {
            let scc = self.constraint_sccs.scc(variable);

            match self.definitions[variable].origin {
                NLLRegionVariableOrigin::FreeRegion => {
                    // For each free, universally quantified region X:

                    // Add all nodes in the CFG to liveness constraints
                    self.liveness_constraints.add_all_points(variable);
                    self.scc_values.add_all_points(scc);

                    // Add `end(X)` into the set for X.
                    self.scc_values.add_element(scc, variable);
                }

                NLLRegionVariableOrigin::Placeholder(placeholder) => {
                    // Each placeholder region is only visible from
                    // its universe `ui` and its extensions. So we
                    // can't just add it into `scc` unless the
                    // universe of the scc can name this region.
                    let scc_universe = self.scc_universes[scc];
                    if scc_universe.can_name(placeholder.universe) {
                        self.scc_values.add_element(scc, placeholder);
                    } else {
                        debug!(
                            "init_free_and_bound_regions: placeholder {:?} is \
                             not compatible with universe {:?} of its SCC {:?}",
                            placeholder, scc_universe, scc,
                        );
                        self.add_incompatible_universe(scc);
                    }
                }

                NLLRegionVariableOrigin::Existential { .. } => {
                    // For existential, regions, nothing to do.
                }
            }
        }
    }
/// Initializes the region variables for each universally
/// quantified region (lifetime parameter). The first N variables
/// always correspond to the regions appearing in the function
/// signature (both named and anonymous) and where-clauses. This
/// function iterates over those regions and initializes them with
/// minimum values.
///
/// For example:
///
///     fn foo<'a, 'b>(..) where 'a: 'b
///
/// would initialize two variables like so:
///
///     R0 = { CFG, R0 } // 'a
///     R1 = { CFG, R0, R1 } // 'b
///
/// Here, R0 represents `'a`, and it contains (a) the entire CFG
/// and (b) any universally quantified regions that it outlives,
/// which in this case is just itself. R1 (`'b`) in contrast also
/// outlives `'a` and hence contains R0 and R1.
Initializes the region variables for each universally
quantified region (lifetime parameter). The first N variables
always correspond to the regions appearing in the function
signature (both named and anonymous) and where-clauses. This
function iterates over those regions and initializes them with
minimum values.

For example.



would initialize two variables like so.



Here, R0 represents `'a`, and it contains (a) the entire CFG
and (b) any universally quantified regions that it outlives,
which in this case is just itself. R1 (`'b`) in contrast also
outlives `'a` and hence contains R0 and R1.
Initializes the region variables for each universally quantified region ( lifetime parameter ) . The first N variables always correspond to the regions appearing in the function signature ( both named and anonymous ) and where - clauses . This function iterates over those regions and initializes them with minimum values . For example . would initialize two variables like so . Here R0 represents ` ' a ` and it contains ( a ) the entire CFG and ( b ) any universally quantified regions that it outlives which in this case is just itself . R1 ( ` ' b ` ) in contrast also outlives ` ' a ` and hence contains R0 and R1 .
fn init_free_and_bound_regions(&mut self) {
        // Update the names (if any)
        for (external_name, variable) in self.universal_regions.named_universal_regions() {
            debug!(
                "init_universal_regions: region {:?} has external name {:?}",
                variable, external_name
            );
            self.definitions[variable].external_name = Some(external_name);
        }
        for variable in self.definitions.indices() {
            let scc = self.constraint_sccs.scc(variable);
            match self.definitions[variable].origin {
                NLLRegionVariableOrigin::FreeRegion => {
                    // For each free, universally quantified region X:
                    // Add all nodes in the CFG to liveness constraints
                    self.liveness_constraints.add_all_points(variable);
                    self.scc_values.add_all_points(scc);
                    // Add `end(X)` into the set for X.
                    self.scc_values.add_element(scc, variable);
                }
                NLLRegionVariableOrigin::Placeholder(placeholder) => {
                    // Each placeholder region is only visible from
                    // its universe `ui` and its extensions. So we
                    // can't just add it into `scc` unless the
                    // universe of the scc can name this region.
                    let scc_universe = self.scc_universes[scc];
                    if scc_universe.can_name(placeholder.universe) {
                        self.scc_values.add_element(scc, placeholder);
                    } else {
                        debug!(
                            "init_free_and_bound_regions: placeholder {:?} is \
                             not compatible with universe {:?} of its SCC {:?}",
                            placeholder, scc_universe, scc,
                        );
                        self.add_incompatible_universe(scc);
                    }
                }
                NLLRegionVariableOrigin::Existential { .. } => {
                    // For existential, regions, nothing to do.
                }
            }
        }
    }
fn init_free_and_bound_regions ( & mut self ) { // Update the names (if any) for ( external_name , variable ) in self . universal_regions . named_universal_regions ( ) { debug ! ( " " variable external_name ) ; self . definitions [ variable ] . external_name = Some ( external_name ) ; } for variable in self . definitions . indices ( ) { let scc = self . constraint_sccs . scc ( variable ) ; match self . definitions [ variable ] . origin { NLLRegionVariableOrigin :: FreeRegion => { // For each free, universally quantified region X: // Add all nodes in the CFG to liveness constraints self . liveness_constraints . add_all_points ( variable ) ; self . scc_values . add_all_points ( scc ) ; // Add `end(X)` into the set for X. self . scc_values . add_element ( scc , variable ) ; } NLLRegionVariableOrigin :: Placeholder ( placeholder ) => { // Each placeholder region is only visible from // its universe `ui` and its extensions. So we // can't just add it into `scc` unless the // universe of the scc can name this region. let scc_universe = self . scc_universes [ scc ] ; if scc_universe . can_name ( placeholder . universe ) { self . scc_values . add_element ( scc , placeholder ) ; } else { debug ! ( " \
 " placeholder scc_universe scc ) ; self . add_incompatible_universe ( scc ) ; } } NLLRegionVariableOrigin :: Existential { .. } => { // For existential, regions, nothing to do. } } } }
Initializes the region variables for each universally
quantified region (lifetime parameter).
Initializes the region variables for each universally quantified region ( lifetime parameter ) .
&mut self