Add various Update implementations

Author: MichaReiser

Cargo.lock

@@ -12,9 +12,9 @@ license = { workspace = true }
 
 [dependencies]
 ruff_db = { workspace = true }
-ruff_index = { workspace = true }
+ruff_index = { workspace = true, features = ["salsa"] }
 ruff_macros = { workspace = true }
-ruff_python_ast = { workspace = true }
+ruff_python_ast = { workspace = true, features = ["salsa"] }
 ruff_python_parser = { workspace = true }
 ruff_python_stdlib = { workspace = true }
 ruff_source_file = { workspace = true }
@@ -31,7 +31,7 @@ drop_bomb = { workspace = true }
 indexmap = { workspace = true }
 itertools = { workspace = true }
 ordermap = { workspace = true }
-salsa = { workspace = true }
+salsa = { workspace = true, features = ["compact_str"] }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 rustc-hash = { workspace = true }

crates/red_knot_python_semantic/Cargo.toml

@@ -86,6 +86,20 @@ unsafe impl<T> Send for AstNodeRef<T> where T: Send {}
 #[allow(unsafe_code)]
 unsafe impl<T> Sync for AstNodeRef<T> where T: Sync {}
 
+#[allow(unsafe_code)]
+unsafe impl<T> salsa::Update for AstNodeRef<T> {
+    unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {
+        let old_node: &mut AstNodeRef<T> = unsafe { &mut *old_pointer };
+
+        if old_node._parsed == new_value._parsed {
+            false
+        } else {
+            *old_node = new_value;
+            true
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::ast_node_ref::AstNodeRef;

crates/red_knot_python_semantic/src/ast_node_ref.rs

@@ -1,13 +1,14 @@
 use std::iter::FusedIterator;
 use std::sync::Arc;
 
-use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
-use salsa::plumbing::AsId;
-
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
 use ruff_index::{IndexSlice, IndexVec};
 
+use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
+use salsa::plumbing::AsId;
+use salsa::Update;
+
 use crate::module_name::ModuleName;
 use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey;
 use crate::semantic_index::ast_ids::AstIds;
@@ -123,7 +124,7 @@ pub(crate) fn global_scope(db: &dyn Db, file: File) -> ScopeId<'_> {
 }
 
 /// The symbol tables and use-def maps for all scopes in a file.
-#[derive(Debug)]
+#[derive(Debug, Update)]
 pub(crate) struct SemanticIndex<'db> {
     /// List of all symbol tables in this file, indexed by scope.
     symbol_tables: IndexVec<FileScopeId, Arc<SymbolTable>>,

crates/red_knot_python_semantic/src/semantic_index.rs

@@ -49,6 +49,15 @@ 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))
 }
 
+// Always consider AstIds as changed.
+#[allow(unsafe_code)]
+unsafe impl salsa::Update for AstIds {
+    unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {
+        *old_pointer = new_value;
+        true
+    }
+}
+
 /// Uniquely identifies a use of a name in a [`crate::semantic_index::symbol::FileScopeId`].
 #[newtype_index]
 pub struct ScopedUseId;

crates/red_knot_python_semantic/src/semantic_index/ast_ids.rs

@@ -9,7 +9,7 @@ use rustc_hash::FxHashMap;
 
 /// Describes an (annotated) attribute assignment that we discovered in a method
 /// body, typically of the form `self.x: int`, `self.x: int = …` or `self.x = …`.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, salsa::Update)]
 pub(crate) enum AttributeAssignment<'db> {
     /// An attribute assignment with an explicit type annotation, either
     /// `self.x: <annotation>` or `self.x: <annotation> = …`.

crates/red_knot_python_semantic/src/semantic_index/attribute_assignment.rs

@@ -5,13 +5,13 @@ use crate::db::Db;
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{FileScopeId, ScopeId};
 
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, salsa::Update)]
 pub(crate) struct Constraint<'db> {
     pub(crate) node: ConstraintNode<'db>,
     pub(crate) is_positive: bool,
 }
 
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, salsa::Update)]
 pub(crate) enum ConstraintNode<'db> {
     Expression(Expression<'db>),
     Pattern(PatternConstraint<'db>),

crates/red_knot_python_semantic/src/semantic_index/constraint.rs

@@ -175,7 +175,7 @@ impl FileScopeId {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, salsa::Update)]
 pub struct Scope {
     pub(super) parent: Option<FileScopeId>,
     pub(super) node: NodeWithScopeKind,
@@ -214,7 +214,7 @@ impl ScopeKind {
 }
 
 /// Symbol table for a specific [`Scope`].
-#[derive(Debug, Default)]
+#[derive(Debug, Default, salsa::Update)]
 pub struct SymbolTable {
     /// The symbols in this scope.
     symbols: IndexVec<ScopedSymbolId, Symbol>,
@@ -422,7 +422,7 @@ impl NodeWithScopeRef<'_> {
 }
 
 /// Node that introduces a new scope.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, salsa::Update)]
 pub enum NodeWithScopeKind {
     Module,
     Class(AstNodeRef<ast::StmtClassDef>),

crates/red_knot_python_semantic/src/semantic_index/symbol.rs

@@ -278,7 +278,7 @@ mod symbol_state;
 type AllConstraints<'db> = IndexVec<ScopedConstraintId, Constraint<'db>>;
 
 /// Applicable definitions and constraints for every use of a name.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, salsa::Update)]
 pub(crate) struct UseDefMap<'db> {
     /// Array of [`Definition`] in this scope. Only the first entry should be `None`;
     /// this represents the implicit "unbound"/"undeclared" definition of every symbol.
@@ -384,7 +384,7 @@ impl<'db> UseDefMap<'db> {
 }
 
 /// Either live bindings or live declarations for a symbol.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, salsa::Update)]
 enum SymbolDefinitions {
     Bindings(SymbolBindings),
     Declarations(SymbolDeclarations),

crates/red_knot_python_semantic/src/semantic_index/use_def.rs

@@ -26,7 +26,7 @@ pub(crate) enum Boundness {
 /// possibly_unbound:  Symbol::Type(Type::IntLiteral(2), Boundness::PossiblyUnbound),
 /// non_existent:      Symbol::Unbound,
 /// ```
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, salsa::Update)]
 pub(crate) enum Symbol<'db> {
     Type(Type<'db>, Boundness),
     Unbound,