Merge branch 'dcreager/predicates' into dcreager/alist-for-live-bds

* dcreager/predicates:
  fix doc links
  Rename constraint to predicate

Author: dcreager

crates/red_knot_python_semantic/src/semantic_index.rs

@@ -25,10 +25,10 @@ use crate::Db;
 pub mod ast_ids;
 pub mod attribute_assignment;
 mod builder;
-pub(crate) mod constraint;
 pub mod definition;
 pub mod expression;
 mod narrowing_constraints;
+pub(crate) mod predicate;
 pub mod symbol;
 mod use_def;
 mod visibility_constraints;

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -1,77 +1,77 @@
 //! # Narrowing constraints
 //!
-//! When building a semantic index for a file, we associate each binding with _narrowing
-//! constraints_. The narrowing constraint is used to constrain the type of the binding's symbol.
-//! Note that a binding can be associated with a different narrowing constraint at different points
-//! in a file. See the [`use_def`][crate::semantic_index::use_def] module for more details.
+//! When building a semantic index for a file, we associate each binding with a _narrowing
+//! constraint_, which constrains the type of the binding's symbol. Note that a binding can be
+//! associated with a different narrowing constraint at different points in a file. See the
+//! [`use_def`][crate::semantic_index::use_def] module for more details.
 //!
 //! This module defines how narrowing constraints are stored internally.
 //!
-//! A _narrowing constraint_ consists of a list of _clauses_, each of which corresponds with an
-//! expression in the source file (represented by a [`Constraint`]). We need to support the
+//! A _narrowing constraint_ consists of a list of _predicates_, each of which corresponds with an
+//! expression in the source file (represented by a [`Predicate`]). We need to support the
 //! following operations on narrowing constraints:
 //!
-//! - Adding a new clause to an existing constraint
-//! - Merging two constraints together, which produces the _intersection_ of their clauses
-//! - Iterating through the clauses in a constraint
+//! - Adding a new predicate to an existing constraint
+//! - Merging two constraints together, which produces the _intersection_ of their predicates
+//! - Iterating through the predicates in a constraint
 //!
-//! In particular, note that we do not need random access to the clauses in a constraint. That
+//! In particular, note that we do not need random access to the predicates in a constraint. That
 //! means that we can use a simple [_sorted association list_][ruff_index::list] as our data
 //! structure. That lets us use a single 32-bit integer to store each narrowing constraint, no
-//! matter how many clauses it contains. It also makes merging two narrowing constraints fast,
+//! matter how many predicates it contains. It also makes merging two narrowing constraints fast,
 //! since alists support fast intersection.
 //!
 //! Because we visit the contents of each scope in source-file order, and assign scoped IDs in
 //! source-file order, that means that we will tend to visit narrowing constraints in order by
-//! their IDs. This is exactly how to get the best performance from our alist implementation.
+//! their predicate IDs. This is exactly how to get the best performance from our alist
+//! implementation.
 //!
-//! [`Constraint`]: crate::semantic_index::constraint::Constraint
+//! [`Predicate`]: crate::semantic_index::predicate::Predicate
 
 use ruff_index::list::{ListBuilder, ListSetReverseIterator, ListStorage};
 use ruff_index::newtype_index;
 
-use crate::semantic_index::constraint::ScopedConstraintId;
+use crate::semantic_index::predicate::ScopedPredicateId;
 
 /// A narrowing constraint associated with a live binding.
 ///
-/// A constraint is a list of clauses, each of which is a [`Constraint`] that constrains the type
-/// of the binding's symbol.
+/// A constraint is a list of [`Predicate`]s that each constrain the type of the binding's symbol.
 ///
 /// An instance of this type represents a _non-empty_ narrowing constraint. You will often wrap
 /// this in `Option` and use `None` to represent an empty narrowing constraint.
 ///
-/// [`Constraint`]: crate::semantic_index::constraint::Constraint
+/// [`Predicate`]: crate::semantic_index::predicate::Predicate
 #[newtype_index]
 pub(crate) struct ScopedNarrowingConstraintId;
 
-/// One of the clauses in a narrowing constraint, which is a [`Constraint`] that constrains the
-/// type of the binding's symbol.
+/// One of the [`Predicate`]s in a narrowing constraint, which constraints the type of the
+/// binding's symbol.
 ///
-/// Note that those [`Constraint`]s are stored in [their own per-scope
-/// arena][crate::semantic_index::constraint::Constraints], so internally we use a
-/// [`ScopedConstraintId`] to refer to the underlying constraint.
+/// Note that those [`Predicate`]s are stored in [their own per-scope
+/// arena][crate::semantic_index::predicate::Predicates], so internally we use a
+/// [`ScopedPredicateId`] to refer to the underlying predicate.
 ///
-/// [`Constraint`]: crate::semantic_index::constraint::Constraint
+/// [`Predicate`]: crate::semantic_index::predicate::Predicate
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
-pub(crate) struct ScopedNarrowingConstraintClause(ScopedConstraintId);
+pub(crate) struct ScopedNarrowingConstraintPredicate(ScopedPredicateId);
 
-impl ScopedNarrowingConstraintClause {
-    /// Returns (the ID of) the `Constraint` for this clause
-    pub(crate) fn constraint(self) -> ScopedConstraintId {
+impl ScopedNarrowingConstraintPredicate {
+    /// Returns (the ID of) the `Predicate`
+    pub(crate) fn predicate(self) -> ScopedPredicateId {
         self.0
     }
 }
 
-impl From<ScopedConstraintId> for ScopedNarrowingConstraintClause {
-    fn from(constraint: ScopedConstraintId) -> ScopedNarrowingConstraintClause {
-        ScopedNarrowingConstraintClause(constraint)
+impl From<ScopedPredicateId> for ScopedNarrowingConstraintPredicate {
+    fn from(predicate: ScopedPredicateId) -> ScopedNarrowingConstraintPredicate {
+        ScopedNarrowingConstraintPredicate(predicate)
     }
 }
 
 /// A collection of narrowing constraints for a given scope.
 #[derive(Debug, Eq, PartialEq)]
 pub(crate) struct NarrowingConstraints {
-    lists: ListStorage<ScopedNarrowingConstraintId, ScopedNarrowingConstraintClause>,
+    lists: ListStorage<ScopedNarrowingConstraintId, ScopedNarrowingConstraintPredicate>,
 }
 
 // Building constraints
@@ -80,7 +80,7 @@ pub(crate) struct NarrowingConstraints {
 /// A builder for creating narrowing constraints.
 #[derive(Debug, Default, Eq, PartialEq)]
 pub(crate) struct NarrowingConstraintsBuilder {
-    lists: ListBuilder<ScopedNarrowingConstraintId, ScopedNarrowingConstraintClause>,
+    lists: ListBuilder<ScopedNarrowingConstraintId, ScopedNarrowingConstraintPredicate>,
 }
 
 impl NarrowingConstraintsBuilder {
@@ -90,18 +90,18 @@ impl NarrowingConstraintsBuilder {
         }
     }
 
-    /// Adds a clause to an existing narrowing constraint.
-    pub(crate) fn add(
+    /// Adds a predicate to an existing narrowing constraint.
+    pub(crate) fn add_predicate_to_constraint(
         &mut self,
         constraint: Option<ScopedNarrowingConstraintId>,
-        clause: ScopedNarrowingConstraintClause,
+        predicate: ScopedNarrowingConstraintPredicate,
     ) -> Option<ScopedNarrowingConstraintId> {
-        self.lists.insert(constraint, clause)
+        self.lists.insert(constraint, predicate)
     }
 
-    /// Returns the intersection of two narrowing constraints. The result contains the clauses that
-    /// appear in both inputs.
-    pub(crate) fn intersect(
+    /// Returns the intersection of two narrowing constraints. The result contains the predicates
+    /// that appear in both inputs.
+    pub(crate) fn intersect_constraints(
         &mut self,
         a: Option<ScopedNarrowingConstraintId>,
         b: Option<ScopedNarrowingConstraintId>,
@@ -114,12 +114,12 @@ impl NarrowingConstraintsBuilder {
 // ---------
 
 pub(crate) type NarrowingConstraintsIterator<'a> = std::iter::Copied<
-    ListSetReverseIterator<'a, ScopedNarrowingConstraintId, ScopedNarrowingConstraintClause>,
+    ListSetReverseIterator<'a, ScopedNarrowingConstraintId, ScopedNarrowingConstraintPredicate>,
 >;
 
 impl NarrowingConstraints {
-    /// Iterates over the clauses in a narrowing constraint.
-    pub(crate) fn iter_clauses(
+    /// Iterates over the predicates in a narrowing constraint.
+    pub(crate) fn iter_predicates(
         &self,
         set: Option<ScopedNarrowingConstraintId>,
     ) -> NarrowingConstraintsIterator<'_> {
@@ -134,14 +134,14 @@ impl NarrowingConstraints {
 mod tests {
     use super::*;
 
-    impl ScopedNarrowingConstraintClause {
+    impl ScopedNarrowingConstraintPredicate {
         pub(crate) fn as_u32(self) -> u32 {
             self.0.as_u32()
         }
     }
 
     impl NarrowingConstraintsBuilder {
-        pub(crate) fn iter_constraints(
+        pub(crate) fn iter_predicates(
             &self,
             set: Option<ScopedNarrowingConstraintId>,
         ) -> NarrowingConstraintsIterator<'_> {

crates/red_knot_python_semantic/src/semantic_index/constraint.rs

@@ -0,0 +1,84 @@
+//! _Predicates_ are Python expressions whose runtime values can affect type inference.
+//!
+//! We currently use predicates in two places:
+//!
+//! - [_Narrowing constraints_][crate::semantic_index::narrowing_constraints] constrain the type of
+//!   a binding that is visible at a particular use.
+//! - [_Visibility constraints_][crate::semantic_index::visibility_constraints] determine the
+//!   static visibility of a binding, and the reachability of a statement.
+
+use ruff_db::files::File;
+use ruff_index::{newtype_index, IndexVec};
+use ruff_python_ast::Singleton;
+
+use crate::db::Db;
+use crate::semantic_index::expression::Expression;
+use crate::semantic_index::symbol::{FileScopeId, ScopeId};
+
+// A scoped identifier for each `Predicate` in a scope.
+#[newtype_index]
+#[derive(Ord, PartialOrd)]
+pub(crate) struct ScopedPredicateId;
+
+// A collection of predicates for a given scope.
+pub(crate) type Predicates<'db> = IndexVec<ScopedPredicateId, Predicate<'db>>;
+
+#[derive(Debug, Default)]
+pub(crate) struct PredicatesBuilder<'db> {
+    predicates: IndexVec<ScopedPredicateId, Predicate<'db>>,
+}
+
+impl<'db> PredicatesBuilder<'db> {
+    /// Adds a predicate. Note that we do not deduplicate predicates. If you add a `Predicate`
+    /// more than once, you will get distinct `ScopedPredicateId`s for each one. (This lets you
+    /// model predicates that might evaluate to different values at different points of execution.)
+    pub(crate) fn add_predicate(&mut self, predicate: Predicate<'db>) -> ScopedPredicateId {
+        self.predicates.push(predicate)
+    }
+
+    pub(crate) fn build(mut self) -> Predicates<'db> {
+        self.predicates.shrink_to_fit();
+        self.predicates
+    }
+}
+
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, salsa::Update)]
+pub(crate) struct Predicate<'db> {
+    pub(crate) node: PredicateNode<'db>,
+    pub(crate) is_positive: bool,
+}
+
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, salsa::Update)]
+pub(crate) enum PredicateNode<'db> {
+    Expression(Expression<'db>),
+    Pattern(PatternPredicate<'db>),
+}
+
+/// Pattern kinds for which we support type narrowing and/or static visibility analysis.
+#[derive(Debug, Clone, Hash, PartialEq, salsa::Update)]
+pub(crate) enum PatternPredicateKind<'db> {
+    Singleton(Singleton, Option<Expression<'db>>),
+    Value(Expression<'db>, Option<Expression<'db>>),
+    Class(Expression<'db>, Option<Expression<'db>>),
+    Unsupported,
+}
+
+#[salsa::tracked]
+pub(crate) struct PatternPredicate<'db> {
+    pub(crate) file: File,
+
+    pub(crate) file_scope: FileScopeId,
+
+    pub(crate) subject: Expression<'db>,
+
+    #[return_ref]
+    pub(crate) kind: PatternPredicateKind<'db>,
+
+    count: countme::Count<PatternPredicate<'static>>,
+}
+
+impl<'db> PatternPredicate<'db> {
+    pub(crate) fn scope(self, db: &'db dyn Db) -> ScopeId<'db> {
+        self.file_scope(db).to_scope_id(db, self.file(db))
+    }
+}