display impl for constraint sets

Author: dcreager

crates/ty_python_semantic/src/types/constraints.rs

@@ -26,6 +26,8 @@
 //! constraint set implementation, and the `bool` impl of the trait (and possibly the trait itself)
 //! will go away.
 
+use std::fmt::Display;
+
 use smallvec::{SmallVec, smallvec};
 
 use crate::Db;
@@ -82,6 +84,9 @@ pub(crate) trait Constraints<'db>: Clone + Sized {
         }
         self
     }
+
+    #[allow(dead_code)]
+    fn display(&self, db: &'db dyn Db) -> impl Display;
 }
 
 /// An extension trait for building constraint sets from [`Option`] values.
@@ -214,6 +219,31 @@ impl<'db> ConstraintSet<'db> {
             }
         }
     }
+
+    #[allow(dead_code)]
+    pub(crate) fn display(&self, db: &'db dyn Db) -> impl Display {
+        struct DisplayConstraintSet<'a, 'db> {
+            set: &'a ConstraintSet<'db>,
+            db: &'db dyn Db,
+        }
+
+        impl Display for DisplayConstraintSet<'_, '_> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                if self.set.clauses.is_empty() {
+                    return f.write_str("0");
+                }
+                for (i, clause) in self.set.clauses.iter().enumerate() {
+                    if i > 0 {
+                        f.write_str(" ∨ ")?;
+                    }
+                    clause.display(self.db).fmt(f)?;
+                }
+                Ok(())
+            }
+        }
+
+        DisplayConstraintSet { set: self, db }
+    }
 }
 
 impl<'db> Constraints<'db> for ConstraintSet<'db> {
@@ -250,6 +280,10 @@ impl<'db> Constraints<'db> for ConstraintSet<'db> {
         }
         result
     }
+
+    fn display(&self, db: &'db dyn Db) -> impl Display {
+        self.display(db)
+    }
 }
 
 /// The intersection of a list of atomic constraints.
@@ -381,6 +415,37 @@ impl<'db> ConstraintClause<'db> {
         }
         result
     }
+
+    fn display(&self, db: &'db dyn Db) -> impl Display {
+        struct DisplayConstraintClause<'a, 'db> {
+            clause: &'a ConstraintClause<'db>,
+            db: &'db dyn Db,
+        }
+
+        impl Display for DisplayConstraintClause<'_, '_> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                if self.clause.constraints.is_empty() {
+                    return f.write_str("1");
+                }
+
+                if self.clause.constraints.len() > 1 {
+                    f.write_str("(")?;
+                }
+                for (i, constraint) in self.clause.constraints.iter().enumerate() {
+                    if i > 0 {
+                        f.write_str(" ∧ ")?;
+                    }
+                    constraint.display(self.db).fmt(f)?;
+                }
+                if self.clause.constraints.len() > 1 {
+                    f.write_str(")")?;
+                }
+                Ok(())
+            }
+        }
+
+        DisplayConstraintClause { clause: self, db }
+    }
 }
 
 /// A constraint on a single typevar.
@@ -597,6 +662,35 @@ impl<'db> AtomicConstraint<'db> {
             ),
         }
     }
+
+    fn display(self, db: &'db dyn Db) -> impl Display {
+        struct DisplayAtomicConstraint<'db> {
+            constraint: AtomicConstraint<'db>,
+            db: &'db dyn Db,
+        }
+
+        impl Display for DisplayAtomicConstraint<'_> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                if self.constraint.sign == ConstraintSign::Negative {
+                    f.write_str("¬")?;
+                }
+                f.write_str("(")?;
+                if !self.constraint.lower.is_never() {
+                    write!(f, "{} ≤ ", self.constraint.lower.display(self.db))?;
+                }
+                self.constraint.typevar.display(self.db).fmt(f)?;
+                if !self.constraint.upper.is_object(self.db) {
+                    write!(f, " ≤ {}", self.constraint.lower.display(self.db))?;
+                }
+                f.write_str(")")
+            }
+        }
+
+        DisplayAtomicConstraint {
+            constraint: self,
+            db,
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug)]

crates/ty_python_semantic/src/types/display.rs

@@ -14,8 +14,8 @@ use crate::types::generics::{GenericContext, Specialization};
 use crate::types::signatures::{CallableSignature, Parameter, Parameters, Signature};
 use crate::types::tuple::TupleSpec;
 use crate::types::{
-    CallableType, IntersectionType, KnownClass, MethodWrapperKind, Protocol, StringLiteralType,
-    SubclassOfInner, Type, UnionType, WrapperDescriptorKind,
+    BoundTypeVarInstance, CallableType, IntersectionType, KnownClass, MethodWrapperKind, Protocol,
+    StringLiteralType, SubclassOfInner, Type, UnionType, WrapperDescriptorKind,
 };
 
 /// Settings for displaying types and signatures
@@ -279,12 +279,7 @@ impl Display for DisplayRepresentation<'_> {
                 )
             }
             Type::NonInferableTypeVar(bound_typevar) | Type::TypeVar(bound_typevar) => {
-                f.write_str(bound_typevar.typevar(self.db).name(self.db))?;
-                if let Some(binding_context) = bound_typevar.binding_context(self.db).name(self.db)
-                {
-                    write!(f, "@{binding_context}")?;
-                }
-                Ok(())
+                bound_typevar.display(self.db).fmt(f)
             }
             Type::AlwaysTruthy => f.write_str("AlwaysTruthy"),
             Type::AlwaysFalsy => f.write_str("AlwaysFalsy"),
@@ -318,6 +313,31 @@ impl Display for DisplayRepresentation<'_> {
     }
 }
 
+impl<'db> BoundTypeVarInstance<'db> {
+    #[allow(dead_code)]
+    pub(crate) fn display(self, db: &'db dyn Db) -> impl Display {
+        DisplayBoundTypeVarInstance {
+            bound_typevar: self,
+            db,
+        }
+    }
+}
+
+struct DisplayBoundTypeVarInstance<'db> {
+    bound_typevar: BoundTypeVarInstance<'db>,
+    db: &'db dyn Db,
+}
+
+impl Display for DisplayBoundTypeVarInstance<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_str(self.bound_typevar.typevar(self.db).name(self.db))?;
+        if let Some(binding_context) = self.bound_typevar.binding_context(self.db).name(self.db) {
+            write!(f, "@{binding_context}")?;
+        }
+        Ok(())
+    }
+}
+
 impl<'db> TupleSpec<'db> {
     pub(crate) fn display_with(
         &'db self,