Struct rustc_middle::middle::region::Scope[−][src]

pub struct Scope {
    pub id: ItemLocalId,
    pub data: ScopeData,
}

Represents a statically-describable scope that can be used to bound the lifetime/region for values.

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

DestructionScope(node_id) represents the scope 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 ScopeTree.

Remainder { block, statement_index } represents the scope 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 scopes 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.): Node scope of the whole `let a = ...;` statement.
 (M2.): Node scope of the `f()` expression.
 (M3.): Node scope of the `f().g(..)` expression.
 (M4.): Node scope of the block labeled `'b:`.
 (M5.): Node scope of the `let x = d();` statement
 (D6.): DestructionScope for temporaries created during M5.
 (R7.): Remainder scope for block `'b:`, stmt 0 (let x = ...).
 (M8.): Node scope of the `let y = d();` statement.
 (D9.): DestructionScope for temporaries created during M8.
(R10.): Remainder scope 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 node scopes, 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.