Struct SemanticIndex 

pub struct SemanticIndex<'db> { /* private fields */ }

The place tables and use-def maps for all scopes in a file.

Implementations

impl<'db> SemanticIndex<'db>

pub fn place_table(&self, scope_id: FileScopeId) -> &PlaceTable

Returns the place table for a specific scope.

Use the Salsa cached place_table() query if you only need the place table for a single scope.

pub fn narrowing_alias_predicate( &self, key: impl Into<ExpressionNodeKey>, ) -> Option<&NarrowingAliasPredicate<'db>>

Returns alias metadata for an alias Name node in a predicate, if one exists.

pub fn use_def_map(&self, scope_id: FileScopeId) -> &UseDefMap<'db>

Returns the use-def map for a specific scope.

Use the Salsa cached use_def_map() query if you only need the use-def map for a single scope.

pub fn imported_modules(&self) -> impl Iterator<Item = &ModuleName>

Returns the set of modules that are imported anywhere in this file.

This set only considers import statements, not from...import statements. See ModuleLiteralType::available_submodule_attributes for discussion of why this analysis is intentionally limited.

pub fn expression_scope_id<E>(&self, expression: &E) -> FileScopeId

where E: HasTrackedScope,

Returns the ID of the expression’s enclosing scope.

pub fn try_expression_scope_id<E>(&self, expression: &E) -> Option<FileScopeId>

where E: HasTrackedScope,

Returns the ID of the expression’s enclosing scope.

pub fn expression_scope(&self, expression: &impl HasTrackedScope) -> &Scope

Returns the Scope of the expression’s enclosing scope.

pub fn scope(&self, id: FileScopeId) -> &Scope

Returns the Scope with the given id.

pub fn scope_ids(&self) -> impl Iterator<Item = ScopeId<'db>> + '_

pub fn symbol_is_global_in_scope( &self, symbol: ScopedSymbolId, scope: FileScopeId, ) -> bool

pub fn symbol_resolves_to_global_scope( &self, symbol: ScopedSymbolId, scope: FileScopeId, ) -> bool

Returns true if the given symbol in the given scope resolves to the global scope, either because:

1. The given scope is the global scope.
2. The symbol is explicitly declared global in the given scope.
3. The symbol is a free variable in the given scope, and no enclosing function scope defines it.

The third case requires walking ancestor scopes until we encounter either a binding or a nonlocal declaration (those aren’t allowed to resolve to the global scope, so we don’t need to chase them).

pub fn parent_scope_id(&self, scope_id: FileScopeId) -> Option<FileScopeId>

Returns the id of the parent scope.

pub fn parent_scope(&self, scope_id: FileScopeId) -> Option<&Scope>

Returns the parent scope of scope_id.

pub fn class_definition_of_method( &self, function_body_scope: FileScopeId, ) -> Option<Definition<'db>>

Return the Definition of the class enclosing this method, given the method’s body scope, or None if it is not a method.

pub fn enclosing_lambda_statement( &self, lambda: ExpressionNodeKey, ) -> Option<Statement<'db>>

pub fn unannotated_collection_initializer( &self, collection_use: &Expr, ) -> Option<Definition<'db>>

If this is a potentially constraining use of an unannotated collection initializer, returns its definition.

pub fn constraining_collection_uses( &self, collection_def: Definition<'db>, ) -> impl Iterator<Item = (Statement<'db>, ExpressionNodeKey)>

Returns all potentially constraining uses of the given unannotated collection initializer.

pub fn is_in_type_checking_block( &self, scope_id: FileScopeId, range: TextRange, ) -> bool

pub fn child_scopes(&self, scope: FileScopeId) -> ChildrenIter<'_>

Returns an iterator over the direct child scopes of scope.

pub fn ancestor_scopes(&self, scope: FileScopeId) -> AncestorsIter<'_>

Returns an iterator over all ancestors of scope, starting with scope itself.

pub fn visible_ancestor_scopes( &self, scope: FileScopeId, ) -> VisibleAncestorsIter<'_>

Returns an iterator over ancestors of scope that are visible for name resolution, starting with scope itself. This follows Python’s lexical scoping rules where class scopes are skipped during name resolution (except for the starting scope if it happens to be a class scope).

For example, in this code:

x = 1
class A:
    x = 2
    def method(self):
        print(x)  # Refers to global x=1, not class x=2

The method function can see the global scope but not the class scope.

pub fn definitions( &self, definition_key: impl Into<DefinitionNodeKey>, ) -> &[Definition<'db>]

Returns the definition::Definition salsa ingredient(s) for definition_key.

There will only ever be >1 Definition associated with a definition_key if the definitions are created by a wildcard (*) import.

pub fn try_definitions( &self, definition_node: AnyNodeRef<'_>, ) -> Option<&[Definition<'db>]>

Returns the definition::Definition salsa ingredient(s) for definition_node, if any.

pub fn expect_single_definition( &self, definition_key: impl Into<DefinitionNodeKey> + Debug + Copy, ) -> Definition<'db>

Returns the definition::Definition salsa ingredient for definition_key.

Panics

If the number of definitions associated with the key is not exactly 1 and the debug_assertions feature is enabled, this method will panic.

It is generally safe to use this method for any AST node that does not correspond to a * (wildcard) import, since those are the only situations that can result in multiple definitions being associated with a single AST node.

pub fn try_definition( &self, definition_key: impl Into<DefinitionNodeKey>, ) -> Option<Definition<'db>>

pub fn expression( &self, expression_key: impl Into<ExpressionNodeKey>, ) -> Expression<'db>

Returns the Expression ingredient for an expression node. Panics if we have no expression ingredient for that node. We can only call this method for standalone-inferable expressions, which we call add_standalone_expression for in SemanticIndexBuilder.

pub fn try_expression( &self, expression_key: impl Into<ExpressionNodeKey>, ) -> Option<Expression<'db>>

pub fn try_unpack( &self, target: impl Into<ExpressionNodeKey>, ) -> Option<Unpack<'db>>

Returns the unpack::Unpack ingredient for an unpacking target, if any.

pub fn is_standalone_expression( &self, expression_key: impl Into<ExpressionNodeKey>, ) -> bool

pub fn try_statement( &self, statement_key: impl Into<StatementNodeKey>, ) -> Option<Statement<'db>>

pub fn node_scope(&self, node: NodeWithScopeRef<'_>) -> FileScopeId

Returns the id of the scope that node creates. This is different from definition::Definition::scope which returns the scope in which that definition is defined in.

pub fn try_node_scope(&self, node: NodeWithScopeRef<'_>) -> Option<FileScopeId>

Returns the id of the scope that node creates, if it exists.

pub fn node_scope_by_key(&self, key: NodeWithScopeKey) -> FileScopeId

Returns the id of the scope that the node identified by key creates.

This is useful when you have a NodeWithScopeKey constructed from an AstNodeRef and want to avoid loading the parsed module just to look up the scope.

pub fn has_future_annotations(&self) -> bool

Checks if there is an import of __future__.annotations in the global scope, which affects the logic for type inference.

pub fn enclosing_snapshot( &self, enclosing_scope: FileScopeId, expr: PlaceExprRef<'_>, nested_scope: FileScopeId, ) -> EnclosingSnapshotResult<'_, 'db>

Returns

• NoLongerInEagerContext if the nested scope is no longer in an eager context (that is, not every scope that will be traversed is eager) and no lazy snapshots were found.
• an iterator of bindings for a particular nested scope reference if the bindings exist.
• a narrowing constraint if there are no bindings, but there is a narrowing constraint for an enclosing scope place.
• NotFound if the narrowing constraint / bindings do not exist in the nested scope.

pub fn semantic_syntax_errors(&self) -> &[SemanticSyntaxError]

Trait Implementations

impl<'db> Debug for SemanticIndex<'db>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'db> GetSize for SemanticIndex<'db>

fn get_heap_size(&self) -> usize

Determines how many bytes this object occupies inside the heap.

fn get_heap_size_with_tracker<TRACKER: GetSizeTracker>( &self, tracker: TRACKER, ) -> (usize, TRACKER)

Determines how many bytes this object occupies inside the heap while using a tracker.

fn get_stack_size() -> usize

Determines how may bytes this object occupies inside the stack.

fn get_size(&self) -> usize

Determines the total size of the object.

fn get_size_with_tracker<T>(&self, tracker: T) -> (usize, T)

where T: GetSizeTracker,

Determines the total size of the object while using a tracker.

impl<'db> SalsaValue for SemanticIndex<'db>