From d6b1081898a175bf7fce9da3f19c1c8dc775fd83 Mon Sep 17 00:00:00 2001 From: Micha Reiser Date: Fri, 11 Jul 2025 20:26:12 +0200 Subject: [PATCH] [ty] Move `ScopedUseId` to `UseDefMap` --- crates/ty_python_semantic/src/node_key.rs | 30 +++- .../ty_python_semantic/src/semantic_index.rs | 22 +-- .../src/semantic_index/ast_ids.rs | 144 ------------------ .../src/semantic_index/builder.rs | 29 +--- .../semantic_index/narrowing_constraints.rs | 2 +- .../src/semantic_index/use_def.rs | 79 ++++++++-- .../ty_python_semantic/src/semantic_model.rs | 2 +- .../ty_python_semantic/src/types/function.rs | 3 +- crates/ty_python_semantic/src/types/infer.rs | 8 +- .../ty_python_semantic/src/types/unpacker.rs | 2 +- 10 files changed, 115 insertions(+), 206 deletions(-) delete mode 100644 crates/ty_python_semantic/src/semantic_index/ast_ids.rs diff --git a/crates/ty_python_semantic/src/node_key.rs b/crates/ty_python_semantic/src/node_key.rs index 18edfe1a04..d0c13d818e 100644 --- a/crates/ty_python_semantic/src/node_key.rs +++ b/crates/ty_python_semantic/src/node_key.rs @@ -1,4 +1,4 @@ -use ruff_python_ast::{HasNodeIndex, NodeIndex}; +use ruff_python_ast::{self as ast, HasNodeIndex, NodeIndex}; /// Compact key for a node for use in a hash map. #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, get_size2::GetSize)] @@ -12,3 +12,31 @@ impl NodeKey { NodeKey(node.node_index().load()) } } + +#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, salsa::Update, get_size2::GetSize)] +pub(crate) struct ExpressionNodeKey(NodeKey); + +// TODO: Delete after merging https://github.com/astral-sh/ruff/pull/19025 +impl From<&ast::Identifier> for ExpressionNodeKey { + fn from(value: &ast::Identifier) -> Self { + Self(NodeKey::from_node(value)) + } +} + +impl From> for ExpressionNodeKey { + fn from(value: ast::ExprRef<'_>) -> Self { + Self(NodeKey::from_node(value)) + } +} + +impl From<&ast::Expr> for ExpressionNodeKey { + fn from(value: &ast::Expr) -> Self { + Self(NodeKey::from_node(value)) + } +} + +impl From<&ast::ExprCall> for ExpressionNodeKey { + fn from(value: &ast::ExprCall) -> Self { + Self(NodeKey::from_node(value)) + } +} diff --git a/crates/ty_python_semantic/src/semantic_index.rs b/crates/ty_python_semantic/src/semantic_index.rs index 5cb8b00238..01c04fca7a 100644 --- a/crates/ty_python_semantic/src/semantic_index.rs +++ b/crates/ty_python_semantic/src/semantic_index.rs @@ -12,9 +12,7 @@ use salsa::plumbing::AsId; use crate::Db; use crate::module_name::ModuleName; -use crate::node_key::NodeKey; -use crate::semantic_index::ast_ids::AstIds; -use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey; +use crate::node_key::{ExpressionNodeKey, NodeKey}; use crate::semantic_index::builder::SemanticIndexBuilder; use crate::semantic_index::definition::{Definition, DefinitionNodeKey, Definitions}; use crate::semantic_index::expression::Expression; @@ -24,9 +22,9 @@ use crate::semantic_index::place::{ ScopeKind, ScopedPlaceId, }; use crate::semantic_index::use_def::{EagerSnapshotKey, ScopedEagerSnapshotId, UseDefMap}; +pub(crate) use crate::semantic_index::use_def::{HasScopedUseId, ScopedUseId}; use crate::util::get_size::untracked_arc_size; -pub mod ast_ids; mod builder; pub mod definition; pub mod expression; @@ -220,12 +218,6 @@ pub(crate) struct SemanticIndex<'db> { /// Use-def map for each scope in this file. use_def_maps: IndexVec>, - /// Lookup table to map between node ids and ast nodes. - /// - /// Note: We should not depend on this map when analysing other files or - /// changing a file invalidates all dependents. - ast_ids: IndexVec, - /// The set of modules that are imported anywhere within this file. imported_modules: Arc>, @@ -261,11 +253,6 @@ impl<'db> SemanticIndex<'db> { self.use_def_maps[scope_id].clone() } - #[track_caller] - pub(crate) fn ast_ids(&self, scope_id: FileScopeId) -> &AstIds { - &self.ast_ids[scope_id] - } - /// Returns the ID of the `expression`'s enclosing scope. #[track_caller] pub(crate) fn expression_scope_id( @@ -623,11 +610,12 @@ mod tests { use crate::Db; use crate::db::tests::{TestDb, TestDbBuilder}; - use crate::semantic_index::ast_ids::{HasScopedUseId, ScopedUseId}; use crate::semantic_index::definition::{Definition, DefinitionKind}; use crate::semantic_index::place::{FileScopeId, PlaceTable, Scope, ScopeKind, ScopedPlaceId}; use crate::semantic_index::use_def::UseDefMap; - use crate::semantic_index::{global_scope, place_table, semantic_index, use_def_map}; + use crate::semantic_index::{ + HasScopedUseId, ScopedUseId, global_scope, place_table, semantic_index, use_def_map, + }; impl UseDefMap<'_> { fn first_public_binding(&self, symbol: ScopedPlaceId) -> Option> { diff --git a/crates/ty_python_semantic/src/semantic_index/ast_ids.rs b/crates/ty_python_semantic/src/semantic_index/ast_ids.rs deleted file mode 100644 index 6d12d22916..0000000000 --- a/crates/ty_python_semantic/src/semantic_index/ast_ids.rs +++ /dev/null @@ -1,144 +0,0 @@ -use rustc_hash::FxHashMap; - -use ruff_index::newtype_index; -use ruff_python_ast as ast; -use ruff_python_ast::ExprRef; - -use crate::Db; -use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey; -use crate::semantic_index::place::ScopeId; -use crate::semantic_index::semantic_index; - -/// AST ids for a single scope. -/// -/// The motivation for building the AST ids per scope isn't about reducing invalidation because -/// the struct changes whenever the parsed AST changes. Instead, it's mainly that we can -/// build the AST ids struct when building the place table and also keep the property that -/// IDs of outer scopes are unaffected by changes in inner scopes. -/// -/// For example, we don't want that adding new statements to `foo` changes the statement id of `x = foo()` in: -/// -/// ```python -/// def foo(): -/// return 5 -/// -/// x = foo() -/// ``` -#[derive(Debug, salsa::Update, get_size2::GetSize)] -pub(crate) struct AstIds { - /// Maps expressions which "use" a place (that is, [`ast::ExprName`], [`ast::ExprAttribute`] or [`ast::ExprSubscript`]) to a use id. - uses_map: FxHashMap, -} - -impl AstIds { - fn use_id(&self, key: impl Into) -> ScopedUseId { - self.uses_map[&key.into()] - } -} - -fn ast_ids<'db>(db: &'db dyn Db, scope: ScopeId) -> &'db AstIds { - semantic_index(db, scope.file(db)).ast_ids(scope.file_scope_id(db)) -} - -/// Uniquely identifies a use of a name in a [`crate::semantic_index::place::FileScopeId`]. -#[newtype_index] -#[derive(get_size2::GetSize)] -pub struct ScopedUseId; - -pub trait HasScopedUseId { - /// Returns the ID that uniquely identifies the use in `scope`. - fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId; -} - -impl HasScopedUseId for ast::Identifier { - fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId { - let ast_ids = ast_ids(db, scope); - ast_ids.use_id(self) - } -} - -impl HasScopedUseId for ast::ExprName { - fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId { - let expression_ref = ExprRef::from(self); - expression_ref.scoped_use_id(db, scope) - } -} - -impl HasScopedUseId for ast::ExprAttribute { - fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId { - let expression_ref = ExprRef::from(self); - expression_ref.scoped_use_id(db, scope) - } -} - -impl HasScopedUseId for ast::ExprSubscript { - fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId { - let expression_ref = ExprRef::from(self); - expression_ref.scoped_use_id(db, scope) - } -} - -impl HasScopedUseId for ast::ExprRef<'_> { - fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId { - let ast_ids = ast_ids(db, scope); - ast_ids.use_id(*self) - } -} - -#[derive(Debug, Default)] -pub(super) struct AstIdsBuilder { - uses_map: FxHashMap, -} - -impl AstIdsBuilder { - /// Adds `expr` to the use ids map and returns its id. - pub(super) fn record_use(&mut self, expr: impl Into) -> ScopedUseId { - let use_id = self.uses_map.len().into(); - - self.uses_map.insert(expr.into(), use_id); - - use_id - } - - pub(super) fn finish(mut self) -> AstIds { - self.uses_map.shrink_to_fit(); - - AstIds { - uses_map: self.uses_map, - } - } -} - -/// Node key that can only be constructed for expressions. -pub(crate) mod node_key { - use ruff_python_ast as ast; - - use crate::node_key::NodeKey; - - #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, salsa::Update, get_size2::GetSize)] - pub(crate) struct ExpressionNodeKey(NodeKey); - - impl From> for ExpressionNodeKey { - fn from(value: ast::ExprRef<'_>) -> Self { - Self(NodeKey::from_node(value)) - } - } - - impl From<&ast::Expr> for ExpressionNodeKey { - fn from(value: &ast::Expr) -> Self { - Self(NodeKey::from_node(value)) - } - } - - impl From<&ast::ExprCall> for ExpressionNodeKey { - fn from(value: &ast::ExprCall) -> Self { - Self(NodeKey::from_node(value)) - } - } - - impl From<&ast::Identifier> for ExpressionNodeKey { - fn from(value: &ast::Identifier) -> Self { - Self(NodeKey::from_node(value)) - } - } -} diff --git a/crates/ty_python_semantic/src/semantic_index/builder.rs b/crates/ty_python_semantic/src/semantic_index/builder.rs index 5d862bfa0f..4b5e424e74 100644 --- a/crates/ty_python_semantic/src/semantic_index/builder.rs +++ b/crates/ty_python_semantic/src/semantic_index/builder.rs @@ -19,9 +19,8 @@ use ruff_text_size::TextRange; use crate::ast_node_ref::AstNodeRef; use crate::module_name::ModuleName; use crate::module_resolver::resolve_module; -use crate::node_key::NodeKey; -use crate::semantic_index::ast_ids::AstIdsBuilder; -use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey; +use crate::node_key::{ExpressionNodeKey, NodeKey}; + use crate::semantic_index::definition::{ AnnotatedAssignmentDefinitionNodeRef, AssignmentDefinitionNodeRef, ComprehensionDefinitionNodeRef, Definition, DefinitionCategory, DefinitionNodeKey, @@ -99,7 +98,6 @@ pub(super) struct SemanticIndexBuilder<'db, 'ast> { scopes: IndexVec, scope_ids_by_scope: IndexVec>, place_tables: IndexVec, - ast_ids: IndexVec, use_def_maps: IndexVec>, scopes_by_node: FxHashMap, scopes_by_expression: FxHashMap, @@ -132,7 +130,6 @@ impl<'db, 'ast> SemanticIndexBuilder<'db, 'ast> { scopes: IndexVec::new(), place_tables: IndexVec::new(), - ast_ids: IndexVec::new(), scope_ids_by_scope: IndexVec::new(), use_def_maps: IndexVec::new(), @@ -255,7 +252,6 @@ impl<'db, 'ast> SemanticIndexBuilder<'db, 'ast> { self.place_tables.push(PlaceTableBuilder::default()); self.use_def_maps .push(UseDefMapBuilder::new(is_class_scope)); - let ast_id_scope = self.ast_ids.push(AstIdsBuilder::default()); let scope_id = ScopeId::new(self.db, self.file, file_scope_id); @@ -263,8 +259,6 @@ impl<'db, 'ast> SemanticIndexBuilder<'db, 'ast> { let previous = self.scopes_by_node.insert(node.node_key(), file_scope_id); debug_assert_eq!(previous, None); - debug_assert_eq!(ast_id_scope, file_scope_id); - self.scope_stack.push(ScopeInfo { file_scope_id, current_loop: None, @@ -372,11 +366,6 @@ impl<'db, 'ast> SemanticIndexBuilder<'db, 'ast> { &mut self.use_def_maps[scope_id].reachability_constraints } - fn current_ast_ids(&mut self) -> &mut AstIdsBuilder { - let scope_id = self.current_scope(); - &mut self.ast_ids[scope_id] - } - fn flow_snapshot(&self) -> FlowSnapshot { self.current_use_def_map().snapshot() } @@ -1028,16 +1017,9 @@ impl<'db, 'ast> SemanticIndexBuilder<'db, 'ast> { .map(|builder| ArcUseDefMap::new(builder.finish())) .collect(); - let mut ast_ids: IndexVec<_, _> = self - .ast_ids - .into_iter() - .map(super::ast_ids::AstIdsBuilder::finish) - .collect(); - self.scopes.shrink_to_fit(); place_tables.shrink_to_fit(); use_def_maps.shrink_to_fit(); - ast_ids.shrink_to_fit(); self.scopes_by_expression.shrink_to_fit(); self.definitions_by_node.shrink_to_fit(); @@ -1052,7 +1034,6 @@ impl<'db, 'ast> SemanticIndexBuilder<'db, 'ast> { definitions_by_node: self.definitions_by_node, expressions_by_node: self.expressions_by_node, scope_ids_by_scope: self.scope_ids_by_scope, - ast_ids, scopes_by_expression: self.scopes_by_expression, scopes_by_node: self.scopes_by_node, use_def_maps, @@ -1144,9 +1125,8 @@ impl<'ast> Visitor<'ast> for SemanticIndexBuilder<'_, 'ast> { // done on the `Identifier` node as opposed to `ExprName` because that's what the // AST uses. self.mark_place_used(symbol); - let use_id = self.current_ast_ids().record_use(name); self.current_use_def_map_mut() - .record_use(symbol, use_id, NodeKey::from_node(name)); + .record_use(symbol, NodeKey::from_node(name)); self.add_definition(symbol, function_def); } @@ -2054,9 +2034,8 @@ impl<'ast> Visitor<'ast> for SemanticIndexBuilder<'_, 'ast> { if is_use { self.mark_place_used(place_id); - let use_id = self.current_ast_ids().record_use(expr); self.current_use_def_map_mut() - .record_use(place_id, use_id, node_key); + .record_use(place_id, node_key); } if is_definition { diff --git a/crates/ty_python_semantic/src/semantic_index/narrowing_constraints.rs b/crates/ty_python_semantic/src/semantic_index/narrowing_constraints.rs index 54155a6ff3..59547b0f5c 100644 --- a/crates/ty_python_semantic/src/semantic_index/narrowing_constraints.rs +++ b/crates/ty_python_semantic/src/semantic_index/narrowing_constraints.rs @@ -29,9 +29,9 @@ //! [`Predicate`]: crate::semantic_index::predicate::Predicate use crate::list::{List, ListBuilder, ListSetReverseIterator, ListStorage}; -use crate::semantic_index::ast_ids::ScopedUseId; use crate::semantic_index::place::FileScopeId; use crate::semantic_index::predicate::ScopedPredicateId; +use crate::semantic_index::use_def::ScopedUseId; /// A narrowing constraint associated with a live binding. /// diff --git a/crates/ty_python_semantic/src/semantic_index/use_def.rs b/crates/ty_python_semantic/src/semantic_index/use_def.rs index 33dc7d8989..9989777bea 100644 --- a/crates/ty_python_semantic/src/semantic_index/use_def.rs +++ b/crates/ty_python_semantic/src/semantic_index/use_def.rs @@ -241,21 +241,22 @@ //! visits a `StmtIf` node. use ruff_index::{IndexVec, newtype_index}; +use ruff_python_ast as ast; use rustc_hash::FxHashMap; use self::place_state::{ Bindings, Declarations, EagerSnapshot, LiveBindingsIterator, LiveDeclaration, LiveDeclarationsIterator, PlaceState, ScopedDefinitionId, }; +use crate::Db; use crate::node_key::NodeKey; use crate::place::BoundnessAnalysis; -use crate::semantic_index::ast_ids::ScopedUseId; use crate::semantic_index::definition::{Definition, DefinitionState}; use crate::semantic_index::narrowing_constraints::{ ConstraintKey, NarrowingConstraints, NarrowingConstraintsBuilder, NarrowingConstraintsIterator, }; use crate::semantic_index::place::{ - FileScopeId, PlaceExpr, PlaceExprWithFlags, ScopeKind, ScopedPlaceId, + FileScopeId, PlaceExpr, PlaceExprWithFlags, ScopeId, ScopeKind, ScopedPlaceId, }; use crate::semantic_index::predicate::{ Predicate, PredicateOrLiteral, Predicates, PredicatesBuilder, ScopedPredicateId, @@ -264,7 +265,7 @@ use crate::semantic_index::reachability_constraints::{ ReachabilityConstraints, ReachabilityConstraintsBuilder, ScopedReachabilityConstraintId, }; use crate::semantic_index::use_def::place_state::PreviousDefinitions; -use crate::semantic_index::{EagerSnapshotResult, SemanticIndex}; +use crate::semantic_index::{EagerSnapshotResult, SemanticIndex, use_def_map}; use crate::types::{IntersectionBuilder, Truthiness, Type, infer_narrowing_constraint}; mod place_state; @@ -285,6 +286,10 @@ pub(crate) struct UseDefMap<'db> { /// Array of reachability constraints in this scope. reachability_constraints: ReachabilityConstraints, + /// Map from node to their use id. + /// Only contains entries for nodes implementing [`HasScopedUseId`]. + uses_by_node: FxHashMap, + /// [`Bindings`] reaching a [`ScopedUseId`]. bindings_by_use: IndexVec, @@ -347,6 +352,11 @@ pub(crate) enum ApplicableConstraints<'map, 'db> { } impl<'db> UseDefMap<'db> { + #[track_caller] + pub(crate) fn use_id(&self, node: NodeKey) -> ScopedUseId { + self.uses_by_node[&node] + } + pub(crate) fn bindings_at_use( &self, use_id: ScopedUseId, @@ -734,6 +744,10 @@ pub(super) struct UseDefMapBuilder<'db> { /// Builder of reachability constraints. pub(super) reachability_constraints: ReachabilityConstraintsBuilder, + /// Map from node to their use id. + /// Only contains entries for nodes implementing [`HasScopedUseId`]. + uses_by_node: FxHashMap, + /// Live bindings at each so-far-recorded use. bindings_by_use: IndexVec, @@ -772,6 +786,7 @@ impl<'db> UseDefMapBuilder<'db> { narrowing_constraints: NarrowingConstraintsBuilder::default(), reachability_constraints: ReachabilityConstraintsBuilder::default(), bindings_by_use: IndexVec::new(), + uses_by_node: FxHashMap::default(), reachability: ScopedReachabilityConstraintId::ALWAYS_TRUE, node_reachability: FxHashMap::default(), declarations_by_binding: FxHashMap::default(), @@ -1000,18 +1015,15 @@ impl<'db> UseDefMapBuilder<'db> { ); } - pub(super) fn record_use( - &mut self, - place: ScopedPlaceId, - use_id: ScopedUseId, - node_key: NodeKey, - ) { + pub(super) fn record_use(&mut self, place: ScopedPlaceId, node_key: NodeKey) { // We have a use of a place; clone the current bindings for that place, and record them // as the live bindings for this use. let new_use = self .bindings_by_use .push(self.place_states[place].bindings().clone()); - debug_assert_eq!(use_id, new_use); + + self.uses_by_node.insert(node_key, new_use); + debug_assert_eq!(self.bindings_by_use.len(), self.uses_by_node.len()); // Track reachability of all uses of places to silence `unresolved-reference` // diagnostics in unreachable code. @@ -1122,6 +1134,7 @@ impl<'db> UseDefMapBuilder<'db> { self.all_definitions.shrink_to_fit(); self.place_states.shrink_to_fit(); self.reachable_definitions.shrink_to_fit(); + self.uses_by_node.shrink_to_fit(); self.bindings_by_use.shrink_to_fit(); self.node_reachability.shrink_to_fit(); self.declarations_by_binding.shrink_to_fit(); @@ -1133,6 +1146,7 @@ impl<'db> UseDefMapBuilder<'db> { predicates: self.predicates.build(), narrowing_constraints: self.narrowing_constraints.build(), reachability_constraints: self.reachability_constraints.build(), + uses_by_node: self.uses_by_node, bindings_by_use: self.bindings_by_use, node_reachability: self.node_reachability, end_of_scope_places: self.place_states, @@ -1144,3 +1158,48 @@ impl<'db> UseDefMapBuilder<'db> { } } } + +/// Uniquely identifies a use of a name in a [`crate::semantic_index::place::FileScopeId`]. +#[newtype_index] +#[derive(get_size2::GetSize)] +pub struct ScopedUseId; + +pub(crate) trait HasScopedUseId { + /// Returns the ID that uniquely identifies the use in `scope`. + fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId; +} + +impl HasScopedUseId for ast::Identifier { + fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId { + let use_def_map = use_def_map(db, scope); + use_def_map.use_id(NodeKey::from_node(self)) + } +} + +impl HasScopedUseId for ast::ExprName { + fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId { + let expression_ref = ast::ExprRef::from(self); + expression_ref.scoped_use_id(db, scope) + } +} + +impl HasScopedUseId for ast::ExprAttribute { + fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId { + let expression_ref = ast::ExprRef::from(self); + expression_ref.scoped_use_id(db, scope) + } +} + +impl HasScopedUseId for ast::ExprSubscript { + fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId { + let expression_ref = ast::ExprRef::from(self); + expression_ref.scoped_use_id(db, scope) + } +} + +impl HasScopedUseId for ast::ExprRef<'_> { + fn scoped_use_id(&self, db: &dyn Db, scope: ScopeId) -> ScopedUseId { + let use_def_map = use_def_map(db, scope); + use_def_map.use_id(NodeKey::from_node(self)) + } +} diff --git a/crates/ty_python_semantic/src/semantic_model.rs b/crates/ty_python_semantic/src/semantic_model.rs index 3f2ef429e3..a5d8f72746 100644 --- a/crates/ty_python_semantic/src/semantic_model.rs +++ b/crates/ty_python_semantic/src/semantic_model.rs @@ -1,6 +1,6 @@ use ruff_db::files::{File, FilePath}; use ruff_db::source::line_index; -use ruff_python_ast as ast; +use ruff_python_ast::{self as ast}; use ruff_python_ast::{Expr, ExprRef, name::Name}; use ruff_source_file::LineIndex; diff --git a/crates/ty_python_semantic/src/types/function.rs b/crates/ty_python_semantic/src/types/function.rs index 189ea9dd12..97531281d5 100644 --- a/crates/ty_python_semantic/src/types/function.rs +++ b/crates/ty_python_semantic/src/types/function.rs @@ -60,10 +60,9 @@ use ruff_text_size::Ranged; use crate::module_resolver::{KnownModule, file_to_module}; use crate::place::{Boundness, Place, place_from_bindings}; -use crate::semantic_index::ast_ids::HasScopedUseId; use crate::semantic_index::definition::Definition; use crate::semantic_index::place::ScopeId; -use crate::semantic_index::semantic_index; +use crate::semantic_index::{HasScopedUseId, semantic_index}; use crate::types::context::InferContext; use crate::types::diagnostic::{ REDUNDANT_CAST, STATIC_ASSERT_ERROR, TYPE_ASSERTION_FAILURE, diff --git a/crates/ty_python_semantic/src/types/infer.rs b/crates/ty_python_semantic/src/types/infer.rs index 62077774ec..6d520956b0 100644 --- a/crates/ty_python_semantic/src/types/infer.rs +++ b/crates/ty_python_semantic/src/types/infer.rs @@ -63,15 +63,14 @@ use super::subclass_of::SubclassOfInner; use super::{ClassBase, NominalInstanceType, add_inferred_python_version_hint_to_diagnostic}; use crate::module_name::{ModuleName, ModuleNameResolutionError}; use crate::module_resolver::resolve_module; -use crate::node_key::NodeKey; +use crate::node_key::{ExpressionNodeKey, NodeKey}; use crate::place::{ Boundness, ConsideredDefinitions, LookupError, Place, PlaceAndQualifiers, builtins_module_scope, builtins_symbol, explicit_global_symbol, global_symbol, module_type_implicit_global_declaration, module_type_implicit_global_symbol, place, place_from_bindings, place_from_declarations, typing_extensions_symbol, }; -use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey; -use crate::semantic_index::ast_ids::{HasScopedUseId, ScopedUseId}; + use crate::semantic_index::definition::{ AnnotatedAssignmentDefinitionKind, AssignmentDefinitionKind, ComprehensionDefinitionKind, Definition, DefinitionKind, DefinitionNodeKey, DefinitionState, ExceptHandlerDefinitionKind, @@ -83,7 +82,8 @@ use crate::semantic_index::place::{ FileScopeId, NodeWithScopeKind, NodeWithScopeRef, PlaceExpr, ScopeId, ScopeKind, ScopedPlaceId, }; use crate::semantic_index::{ - ApplicableConstraints, EagerSnapshotResult, SemanticIndex, place_table, semantic_index, + ApplicableConstraints, EagerSnapshotResult, HasScopedUseId, ScopedUseId, SemanticIndex, + place_table, semantic_index, }; use crate::types::call::{Binding, Bindings, CallArgumentTypes, CallArguments, CallError}; use crate::types::class::{CodeGeneratorKind, MetaclassErrorKind, SliceLiteral}; diff --git a/crates/ty_python_semantic/src/types/unpacker.rs b/crates/ty_python_semantic/src/types/unpacker.rs index e3c74dd25a..cd22205aa2 100644 --- a/crates/ty_python_semantic/src/types/unpacker.rs +++ b/crates/ty_python_semantic/src/types/unpacker.rs @@ -6,7 +6,7 @@ use rustc_hash::FxHashMap; use ruff_python_ast::{self as ast, AnyNodeRef}; use crate::Db; -use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey; +use crate::node_key::ExpressionNodeKey; use crate::semantic_index::place::ScopeId; use crate::types::tuple::{ResizeTupleError, Tuple, TupleLength, TupleUnpacker}; use crate::types::{Type, TypeCheckDiagnostics, infer_expression_types};