Enum rustc::middle::region::CodeExtentData

pub enum CodeExtentData {
    Misc(NodeId),
    CallSiteScope {
        fn_id: NodeId,
        body_id: NodeId,
    },
    ParameterScope {
        fn_id: NodeId,
        body_id: NodeId,
    },
    DestructionScope(NodeId),
    Remainder(BlockRemainder),
}

Unstable (rustc_private)

CodeExtent represents a statically-describable extent that can be used to bound the lifetime/region for values.

Misc(node_id): Any AST node that has any extent at all has the Misc(node_id) extent. Other variants represent special cases not immediately derivable from the abstract syntax tree structure.

DestructionScope(node_id) represents the extent of destructors implicitly-attached to node_id that run immediately after the expression for node_id itself. Not every AST node carries a DestructionScope, but those that are terminating_scopes do; see discussion with RegionMaps.

Remainder(BlockRemainder { block, statement_index }) represents the extent of user code running immediately after the initializer expression for the indexed statement, until the end of the block.

So: the following code can be broken down into the extents beneath: let a = f().g( 'b: { let x = d(); let y = d(); x.h(y) } ) ;

                                                         +-+ (D12.)
                                                   +-+       (D11.)
                                         +---------+         (R10.)
                                         +-+                  (D9.)
                              +----------+                    (M8.)
                            +----------------------+          (R7.)
                            +-+                               (D6.)
                 +----------+                                 (M5.)
               +-----------------------------------+          (M4.)
    +--------------------------------------------------+      (M3.)
    +--+                                                      (M2.)

+-----------------------------------------------------------+ (M1.)

(M1.): Misc extent of the whole let a = ...; statement. (M2.): Misc extent of the f() expression. (M3.): Misc extent of the f().g(..) expression. (M4.): Misc extent of the block labelled 'b:. (M5.): Misc extent of the let x = d(); statement (D6.): DestructionScope for temporaries created during M5. (R7.): Remainder extent for block 'b:, stmt 0 (let x = ...). (M8.): Misc Extent of the let y = d(); statement. (D9.): DestructionScope for temporaries created during M8. (R10.): Remainder extent for block 'b:, stmt 1 (let y = ...). (D11.): DestructionScope for temporaries and bindings from block 'b:. (D12.): DestructionScope for temporaries created during M1 (e.g. f()).

Note that while the above picture shows the destruction scopes as following their corresponding misc extents, in the internal data structures of the compiler the destruction scopes are represented as enclosing parents. This is sound because we use the enclosing parent relationship just to ensure that referenced values live long enough; phrased another way, the starting point of each range is not really the important thing in the above picture, but rather the ending point.

FIXME (pnkfelix): This currently derives PartialOrd and Ord to placate the same deriving in ty::FreeRegion, but we may want to actually attach a more meaningful ordering to scopes than the one generated via deriving here.

Variants

Misc(NodeId)

Unstable (rustc_private)

CallSiteScope

Unstable (rustc_private)

Fields

fn_id: NodeId	Unstable (rustc_private)
body_id: NodeId	Unstable (rustc_private)

ParameterScope

Unstable (rustc_private)

Fields

fn_id: NodeId	Unstable (rustc_private)
body_id: NodeId	Unstable (rustc_private)

DestructionScope(NodeId)

Unstable (rustc_private)

Remainder(BlockRemainder)

Unstable (rustc_private)

Methods

impl CodeExtentData

fn node_id(&self) -> NodeId

Unstable (rustc_private)

Returns a node id associated with this scope.

NB: likely to be replaced as API is refined; e.g. pnkfelix anticipates fn entry_node_id and fn each_exit_node_id.

Trait Implementations

Derived Implementations

impl Copy for CodeExtentData

impl Debug for CodeExtentData

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Hash for CodeExtentData

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl Ord for CodeExtentData

fn cmp(&self, __arg_0: &CodeExtentData) -> Ordering

This method returns an Ordering between self and other.

impl Eq for CodeExtentData

impl PartialOrd for CodeExtentData

fn partial_cmp(&self, __arg_0: &CodeExtentData) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, __arg_0: &CodeExtentData) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, __arg_0: &CodeExtentData) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, __arg_0: &CodeExtentData) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, __arg_0: &CodeExtentData) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialEq for CodeExtentData

fn eq(&self, __arg_0: &CodeExtentData) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &CodeExtentData) -> bool

This method tests for !=.

impl Clone for CodeExtentData

fn clone(&self) -> CodeExtentData

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.