Add DisplayType trait

.github/workflows/build-docker.yml

@@ -72,7 +72,7 @@ jobs:
       - name: Normalize Platform Pair (replace / with -)
         run: |
           platform=${{ matrix.platform }}
-          echo "PLATFORM_TUPLE=${platform//\//-}" >> "$GITHUB_ENV"
+          echo "PLATFORM_TUPLE=${platform//\//-}" >> $GITHUB_ENV
 
       # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
       - name: Build and push by digest
@@ -144,7 +144,7 @@ jobs:
         run: |
           docker buildx imagetools create \
             $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf "${RUFF_BASE_IMG}@sha256:%s " *)
+            $(printf '${RUFF_BASE_IMG}@sha256:%s ' *)
 
   docker-publish-extra:
     name: Publish additional Docker image based on ${{ matrix.image-mapping }}
@@ -203,14 +203,14 @@ jobs:
           TAG_PATTERNS="${TAG_PATTERNS%\\n}"
 
           # Export image cache name
-          echo "IMAGE_REF=${BASE_IMAGE//:/-}" >> "$GITHUB_ENV"
+          echo "IMAGE_REF=${BASE_IMAGE//:/-}" >> $GITHUB_ENV
 
           # Export tag patterns using the multiline env var syntax
           {
             echo "TAG_PATTERNS<<EOF"
             echo -e "${TAG_PATTERNS}"
             echo EOF
-          } >> "$GITHUB_ENV"
+          } >> $GITHUB_ENV
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
@@ -289,4 +289,4 @@ jobs:
           docker buildx imagetools create \
             "${annotations[@]}" \
             $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf "${RUFF_BASE_IMG}@sha256:%s " *)
+            $(printf '${RUFF_BASE_IMG}@sha256:%s ' *)

CHANGELOG.md

@@ -1,40 +1,5 @@
 # Changelog
 
-## 0.8.3
-
-### Preview features
-
-- Fix fstring formatting removing overlong implicit concatenated string in expression part ([#14811](https://github.com/astral-sh/ruff/pull/14811))
-- \[`airflow`\] Add fix to remove deprecated keyword arguments (`AIR302`) ([#14887](https://github.com/astral-sh/ruff/pull/14887))
-- \[`airflow`\]: Extend rule to include deprecated names for Airflow 3.0 (`AIR302`) ([#14765](https://github.com/astral-sh/ruff/pull/14765) and [#14804](https://github.com/astral-sh/ruff/pull/14804))
-- \[`flake8-bugbear`\] Improve error messages for `except*` (`B025`, `B029`, `B030`, `B904`) ([#14815](https://github.com/astral-sh/ruff/pull/14815))
-- \[`flake8-bugbear`\] `itertools.batched()` without explicit `strict` (`B911`) ([#14408](https://github.com/astral-sh/ruff/pull/14408))
-- \[`flake8-use-pathlib`\] Dotless suffix passed to `Path.with_suffix()` (`PTH210`) ([#14779](https://github.com/astral-sh/ruff/pull/14779))
-- \[`pylint`\] Include parentheses and multiple comparators in check for `boolean-chained-comparison` (`PLR1716`) ([#14781](https://github.com/astral-sh/ruff/pull/14781))
-- \[`ruff`\] Do not simplify `round()` calls (`RUF046`) ([#14832](https://github.com/astral-sh/ruff/pull/14832))
-- \[`ruff`\] Don't emit `used-dummy-variable` on function parameters (`RUF052`) ([#14818](https://github.com/astral-sh/ruff/pull/14818))
-- \[`ruff`\] Implement `if-key-in-dict-del` (`RUF051`) ([#14553](https://github.com/astral-sh/ruff/pull/14553))
-- \[`ruff`\] Mark autofix for `RUF052` as always unsafe ([#14824](https://github.com/astral-sh/ruff/pull/14824))
-- \[`ruff`\] Teach autofix for `used-dummy-variable` about TypeVars etc. (`RUF052`) ([#14819](https://github.com/astral-sh/ruff/pull/14819))
-
-### Rule changes
-
-- \[`flake8-bugbear`\] Offer unsafe autofix for `no-explicit-stacklevel` (`B028`) ([#14829](https://github.com/astral-sh/ruff/pull/14829))
-- \[`flake8-pyi`\] Skip all type definitions in `string-or-bytes-too-long` (`PYI053`) ([#14797](https://github.com/astral-sh/ruff/pull/14797))
-- \[`pyupgrade`\] Do not report when a UTF-8 comment is followed by a non-UTF-8 one (`UP009`) ([#14728](https://github.com/astral-sh/ruff/pull/14728))
-- \[`pyupgrade`\] Mark fixes for `convert-typed-dict-functional-to-class` and `convert-named-tuple-functional-to-class` as unsafe if they will remove comments (`UP013`, `UP014`) ([#14842](https://github.com/astral-sh/ruff/pull/14842))
-
-### Bug fixes
-
-- Raise syntax error for mixing `except` and `except*` ([#14895](https://github.com/astral-sh/ruff/pull/14895))
-- \[`flake8-bugbear`\] Fix `B028` to allow `stacklevel` to be explicitly assigned as a positional argument ([#14868](https://github.com/astral-sh/ruff/pull/14868))
-- \[`flake8-bugbear`\] Skip `B028` if `warnings.warn` is called with `*args` or `**kwargs` ([#14870](https://github.com/astral-sh/ruff/pull/14870))
-- \[`flake8-comprehensions`\] Skip iterables with named expressions in `unnecessary-map` (`C417`) ([#14827](https://github.com/astral-sh/ruff/pull/14827))
-- \[`flake8-pyi`\] Also remove `self` and `cls`'s annotation (`PYI034`) ([#14801](https://github.com/astral-sh/ruff/pull/14801))
-- \[`flake8-pytest-style`\] Fix `pytest-parametrize-names-wrong-type` (`PT006`) to edit both `argnames` and `argvalues` if both of them are single-element tuples/lists ([#14699](https://github.com/astral-sh/ruff/pull/14699))
-- \[`perflint`\] Improve autofix for `PERF401` ([#14369](https://github.com/astral-sh/ruff/pull/14369))
-- \[`pylint`\] Fix `PLW1508` false positive for default string created via a mult operation ([#14841](https://github.com/astral-sh/ruff/pull/14841))
-
 ## 0.8.2
 
 ### Preview features

Cargo.lock

@@ -2517,7 +2517,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.8.3"
+version = "0.8.2"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2736,7 +2736,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.8.3"
+version = "0.8.2"
 dependencies = [
  "aho-corasick",
  "annotate-snippets 0.9.2",
@@ -3051,7 +3051,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.8.3"
+version = "0.8.2"
 dependencies = [
  "console_error_panic_hook",
  "console_log",

README.md

@@ -140,8 +140,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.8.3/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.8.3/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.8.2/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.8.2/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -174,7 +174,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.8.3
+  rev: v0.8.2
   hooks:
     # Run the linter.
     - id: ruff

crates/red_knot_python_semantic/src/types.rs

@@ -9,7 +9,6 @@ use ruff_python_ast as ast;
 pub(crate) use self::builder::{IntersectionBuilder, UnionBuilder};
 pub(crate) use self::diagnostic::register_lints;
 pub use self::diagnostic::{TypeCheckDiagnostic, TypeCheckDiagnostics};
-pub(crate) use self::display::TypeArrayDisplay;
 pub(crate) use self::infer::{
     infer_deferred_types, infer_definition_types, infer_expression_types, infer_scope_types,
 };

crates/red_knot_python_semantic/src/types/call.rs

@@ -1,5 +1,5 @@
 use super::diagnostic::{TypeCheckDiagnosticsBuilder, CALL_NON_CALLABLE};
-use super::{Severity, Type, TypeArrayDisplay, UnionBuilder};
+use super::{Severity, Type, UnionBuilder};
 use crate::Db;
 use ruff_db::diagnostic::DiagnosticId;
 use ruff_python_ast as ast;
@@ -135,7 +135,7 @@ impl<'db> CallOutcome<'db> {
                     format_args!(
                         "Object of type `{}` is not callable (due to union elements {})",
                         called_ty.display(db),
-                        not_callable_tys.display(db),
+                        Type::display_slice(db, &not_callable_tys),
                     ),
                 );
                 return_ty

crates/red_knot_python_semantic/src/types/display.rs

@@ -1,10 +1,8 @@
 //! Display implementations for types.
 
-use std::fmt::{self, Display, Formatter, Write};
-
-use ruff_db::display::FormatterJoinExtension;
 use ruff_python_ast::str::Quote;
 use ruff_python_literal::escape::AsciiEscape;
+use std::fmt::{self, Arguments, Formatter, Write};
 
 use crate::types::mro::ClassBase;
 use crate::types::{
@@ -15,25 +13,33 @@ use crate::Db;
 use rustc_hash::FxHashMap;
 
 impl<'db> Type<'db> {
-    pub fn display(&self, db: &'db dyn Db) -> DisplayType {
-        DisplayType { ty: self, db }
+    fn representation(self) -> Representation<'db> {
+        Representation { ty: self }
     }
-    fn representation(self, db: &'db dyn Db) -> DisplayRepresentation<'db> {
-        DisplayRepresentation { db, ty: self }
+
+    pub fn display(self, db: &'db dyn Db) -> DisplayWrapper<'db, Type<'db>> {
+        DisplayWrapper::new(db, self)
+    }
+
+    pub fn display_slice<'types>(
+        db: &'db dyn Db,
+        types: &'types [Type<'db>],
+    ) -> DisplayWrapper<'db, &'types [Type<'db>]> {
+        DisplayWrapper::new(db, types)
     }
 }
 
-#[derive(Copy, Clone)]
-pub struct DisplayType<'db> {
-    ty: &'db Type<'db>,
-    db: &'db dyn Db,
-}
+impl<'db> DisplayType<'db> for Type<'db> {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
+        if f.visited.contains(self) {
+            return f.write_str("<recursion>");
+        }
+        f.visited.push(*self);
+
+        let representation = self.representation();
 
-impl Display for DisplayType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let representation = self.ty.representation(self.db);
         if matches!(
-            self.ty,
+            self,
             Type::IntLiteral(_)
                 | Type::BooleanLiteral(_)
                 | Type::StringLiteral(_)
@@ -41,38 +47,38 @@ impl Display for DisplayType<'_> {
                 | Type::ClassLiteral(_)
                 | Type::FunctionLiteral(_)
         ) {
-            write!(f, "Literal[{representation}]")
+            f.write_str("Literal[")?;
+            representation.fmt(f)?;
+            f.write_str("]")?;
         } else {
-            representation.fmt(f)
+            representation.fmt(f)?;
         }
-    }
-}
 
-impl fmt::Debug for DisplayType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        Display::fmt(self, f)
+        let removed = f.visited.pop();
+        debug_assert_eq!(removed, Some(*self));
+
+        Ok(())
     }
 }
 
 /// Writes the string representation of a type, which is the value displayed either as
 /// `Literal[<repr>]` or `Literal[<repr1>, <repr2>]` for literal types or as `<repr>` for
 /// non literals
-struct DisplayRepresentation<'db> {
+struct Representation<'db> {
     ty: Type<'db>,
-    db: &'db dyn Db,
 }
 
-impl Display for DisplayRepresentation<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+impl<'db> DisplayType<'db> for Representation<'db> {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
         match self.ty {
             Type::Any => f.write_str("Any"),
             Type::Never => f.write_str("Never"),
             Type::Unknown => f.write_str("Unknown"),
             Type::Instance(InstanceType { class }) => {
-                let representation = match class.known(self.db) {
+                let representation = match class.known(f.db()) {
                     Some(KnownClass::NoneType) => "None",
                     Some(KnownClass::NoDefaultType) => "NoDefault",
-                    _ => class.name(self.db),
+                    _ => class.name(f.db()),
                 };
                 f.write_str(representation)
             }
@@ -80,37 +86,37 @@ impl Display for DisplayRepresentation<'_> {
             // any other type
             Type::Todo(todo) => write!(f, "@Todo{todo}"),
             Type::ModuleLiteral(file) => {
-                write!(f, "<module '{:?}'>", file.path(self.db))
+                write!(f, "<module '{:?}'>", file.path(f.db()))
             }
             // TODO functions and classes should display using a fully qualified name
-            Type::ClassLiteral(ClassLiteralType { class }) => f.write_str(class.name(self.db)),
+            Type::ClassLiteral(ClassLiteralType { class }) => f.write_str(class.name(f.db())),
             Type::SubclassOf(SubclassOfType {
                 base: ClassBase::Class(class),
             }) => {
                 // Only show the bare class name here; ClassBase::display would render this as
                 // type[<class 'Foo'>] instead of type[Foo].
-                write!(f, "type[{}]", class.name(self.db))
+                write!(f, "type[{}]", class.name(f.db()))
             }
             Type::SubclassOf(SubclassOfType { base }) => {
-                write!(f, "type[{}]", base.display(self.db))
+                write!(f, "type[{}]", base.display(f.db()))
             }
-            Type::KnownInstance(known_instance) => f.write_str(known_instance.repr(self.db)),
-            Type::FunctionLiteral(function) => f.write_str(function.name(self.db)),
-            Type::Union(union) => union.display(self.db).fmt(f),
-            Type::Intersection(intersection) => intersection.display(self.db).fmt(f),
-            Type::IntLiteral(n) => n.fmt(f),
+            Type::KnownInstance(known_instance) => f.write_str(known_instance.repr(f.db())),
+            Type::FunctionLiteral(function) => f.write_str(function.name(f.db())),
+            Type::Union(union) => union.fmt(f),
+            Type::Intersection(intersection) => intersection.fmt(f),
+            Type::IntLiteral(n) => write!(f, "{n}"),
             Type::BooleanLiteral(boolean) => f.write_str(if boolean { "True" } else { "False" }),
-            Type::StringLiteral(string) => string.display(self.db).fmt(f),
+            Type::StringLiteral(string) => string.fmt(f),
             Type::LiteralString => f.write_str("LiteralString"),
             Type::BytesLiteral(bytes) => {
                 let escape =
-                    AsciiEscape::with_preferred_quote(bytes.value(self.db).as_ref(), Quote::Double);
+                    AsciiEscape::with_preferred_quote(bytes.value(f.db()).as_ref(), Quote::Double);
 
                 escape.bytes_repr().write(f)
             }
             Type::SliceLiteral(slice) => {
                 f.write_str("slice[")?;
-                if let Some(start) = slice.start(self.db) {
+                if let Some(start) = slice.start(f.db()) {
                     write!(f, "Literal[{start}]")?;
                 } else {
                     f.write_str("None")?;
@@ -118,13 +124,13 @@ impl Display for DisplayRepresentation<'_> {
 
                 f.write_str(", ")?;
 
-                if let Some(stop) = slice.stop(self.db) {
+                if let Some(stop) = slice.stop(f.db()) {
                     write!(f, "Literal[{stop}]")?;
                 } else {
                     f.write_str("None")?;
                 }
 
-                if let Some(step) = slice.step(self.db) {
+                if let Some(step) = slice.step(f.db()) {
                     write!(f, ", Literal[{step}]")?;
                 }
 
@@ -132,11 +138,11 @@ impl Display for DisplayRepresentation<'_> {
             }
             Type::Tuple(tuple) => {
                 f.write_str("tuple[")?;
-                let elements = tuple.elements(self.db);
+                let elements = tuple.elements(f.db());
                 if elements.is_empty() {
                     f.write_str("()")?;
                 } else {
-                    elements.display(self.db).fmt(f)?;
+                    elements.fmt(f)?;
                 }
                 f.write_str("]")
             }
@@ -144,20 +150,9 @@ impl Display for DisplayRepresentation<'_> {
     }
 }
 
-impl<'db> UnionType<'db> {
-    fn display(&'db self, db: &'db dyn Db) -> DisplayUnionType<'db> {
-        DisplayUnionType { db, ty: self }
-    }
-}
-
-struct DisplayUnionType<'db> {
-    ty: &'db UnionType<'db>,
-    db: &'db dyn Db,
-}
-
-impl Display for DisplayUnionType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let elements = self.ty.elements(self.db);
+impl<'db> DisplayType<'db> for UnionType<'db> {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
+        let elements = self.elements(f.db());
 
         // Group condensed-display types by kind.
         let mut grouped_condensed_kinds = FxHashMap::default();
@@ -181,12 +176,11 @@ impl Display for DisplayUnionType<'_> {
                 if kind == CondensedDisplayTypeKind::Int {
                     condensed_kind.sort_unstable_by_key(|ty| ty.expect_int_literal());
                 }
-                join.entry(&DisplayLiteralGroup {
+                join.entry(&LiteralGroup {
                     literals: condensed_kind,
-                    db: self.db,
                 });
             } else {
-                join.entry(&element.display(self.db));
+                join.entry(element);
             }
         }
 
@@ -198,22 +192,15 @@ impl Display for DisplayUnionType<'_> {
     }
 }
 
-impl fmt::Debug for DisplayUnionType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        Display::fmt(self, f)
-    }
-}
-
-struct DisplayLiteralGroup<'db> {
+struct LiteralGroup<'db> {
     literals: Vec<Type<'db>>,
-    db: &'db dyn Db,
 }
 
-impl Display for DisplayLiteralGroup<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+impl<'db> DisplayType<'db> for LiteralGroup<'db> {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
         f.write_str("Literal[")?;
         f.join(", ")
-            .entries(self.literals.iter().map(|ty| ty.representation(self.db)))
+            .entries(self.literals.iter().map(|ty| ty.representation()))
             .finish()?;
         f.write_str("]")
     }
@@ -249,106 +236,63 @@ impl TryFrom<Type<'_>> for CondensedDisplayTypeKind {
     }
 }
 
-impl<'db> IntersectionType<'db> {
-    fn display(&'db self, db: &'db dyn Db) -> DisplayIntersectionType<'db> {
-        DisplayIntersectionType { db, ty: self }
-    }
-}
-
-struct DisplayIntersectionType<'db> {
-    ty: &'db IntersectionType<'db>,
-    db: &'db dyn Db,
-}
-
-impl Display for DisplayIntersectionType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+impl<'db> DisplayType<'db> for IntersectionType<'db> {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
         let tys = self
-            .ty
-            .positive(self.db)
+            .positive(f.db())
             .iter()
-            .map(|&ty| DisplayMaybeNegatedType {
-                ty,
-                db: self.db,
-                negated: false,
-            })
+            .map(|&ty| MaybeNegatedType { ty, negated: false })
             .chain(
-                self.ty
-                    .negative(self.db)
+                self.negative(f.db())
                     .iter()
-                    .map(|&ty| DisplayMaybeNegatedType {
-                        ty,
-                        db: self.db,
-                        negated: true,
-                    }),
+                    .map(|&ty| MaybeNegatedType { ty, negated: true }),
             );
         f.join(" & ").entries(tys).finish()
     }
 }
 
-impl fmt::Debug for DisplayIntersectionType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        Display::fmt(self, f)
-    }
-}
-
-struct DisplayMaybeNegatedType<'db> {
+struct MaybeNegatedType<'db> {
     ty: Type<'db>,
-    db: &'db dyn Db,
     negated: bool,
 }
 
-impl Display for DisplayMaybeNegatedType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+impl<'db> DisplayType<'db> for MaybeNegatedType<'db> {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
         if self.negated {
             f.write_str("~")?;
         }
-        self.ty.display(self.db).fmt(f)
+
+        self.ty.fmt(f)
     }
 }
 
-pub(crate) trait TypeArrayDisplay<'db> {
-    fn display(&self, db: &'db dyn Db) -> DisplayTypeArray;
-}
-
-impl<'db> TypeArrayDisplay<'db> for Box<[Type<'db>]> {
-    fn display(&self, db: &'db dyn Db) -> DisplayTypeArray {
-        DisplayTypeArray { types: self, db }
+impl<'db> DisplayType<'db> for [Type<'db>] {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
+        f.join(", ").entries(self.iter().copied()).finish()
     }
 }
 
-impl<'db> TypeArrayDisplay<'db> for Vec<Type<'db>> {
-    fn display(&self, db: &'db dyn Db) -> DisplayTypeArray {
-        DisplayTypeArray { types: self, db }
+impl<'db> DisplayType<'db> for &[Type<'db>] {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
+        (**self).fmt(f)
     }
 }
 
-pub(crate) struct DisplayTypeArray<'b, 'db> {
-    types: &'b [Type<'db>],
-    db: &'db dyn Db,
-}
-
-impl Display for DisplayTypeArray<'_, '_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.join(", ")
-            .entries(self.types.iter().map(|ty| ty.display(self.db)))
-            .finish()
+impl<'db> DisplayType<'db> for Box<[Type<'db>]> {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
+        (**self).fmt(f)
     }
 }
 
-impl<'db> StringLiteralType<'db> {
-    fn display(&'db self, db: &'db dyn Db) -> DisplayStringLiteralType<'db> {
-        DisplayStringLiteralType { db, ty: self }
+impl<'db> DisplayType<'db> for Vec<Type<'db>> {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
+        (**self).fmt(f)
     }
 }
 
-struct DisplayStringLiteralType<'db> {
-    ty: &'db StringLiteralType<'db>,
-    db: &'db dyn Db,
-}
-
-impl Display for DisplayStringLiteralType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let value = self.ty.value(self.db);
+impl<'db> DisplayType<'db> for StringLiteralType<'db> {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
+        let value = self.value(f.db());
         f.write_char('"')?;
         for ch in value.chars() {
             match ch {
@@ -362,6 +306,119 @@ impl Display for DisplayStringLiteralType<'_> {
     }
 }
 
+struct TypeFormatter<'db, 'write> {
+    db: &'db dyn Db,
+    write: &'write mut dyn Write,
+    visited: Vec<Type<'db>>,
+}
+
+impl<'db, 'write> TypeFormatter<'db, 'write> {
+    pub(crate) fn new(db: &'db dyn Db, write: &'write mut dyn Write) -> Self {
+        Self {
+            db,
+            write,
+            visited: Vec::default(),
+        }
+    }
+
+    pub(crate) fn join<'f>(&'f mut self, separator: &'static str) -> Join<'db, 'f, 'write> {
+        Join {
+            fmt: self,
+            separator,
+            result: Ok(()),
+            seen_first: false,
+        }
+    }
+
+    pub(crate) fn db(&self) -> &'db dyn Db {
+        self.db
+    }
+}
+
+impl Write for TypeFormatter<'_, '_> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.write.write_str(s)
+    }
+
+    fn write_char(&mut self, c: char) -> fmt::Result {
+        self.write.write_char(c)
+    }
+
+    fn write_fmt(&mut self, args: Arguments<'_>) -> fmt::Result {
+        self.write.write_fmt(args)
+    }
+}
+
+trait DisplayType<'db> {
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result;
+}
+
+pub struct DisplayWrapper<'db, T> {
+    db: &'db dyn Db,
+    inner: T,
+}
+
+impl<'db, T> DisplayWrapper<'db, T> {
+    fn new(db: &'db dyn Db, inner: T) -> Self {
+        Self { db, inner }
+    }
+}
+
+impl<'db, T> DisplayType<'db> for DisplayWrapper<'db, T>
+where
+    T: DisplayType<'db>,
+{
+    fn fmt(&self, f: &mut TypeFormatter<'db, '_>) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+impl<'db, T> fmt::Display for DisplayWrapper<'db, T>
+where
+    T: DisplayType<'db>,
+{
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let mut f = TypeFormatter::new(self.db, f);
+        DisplayType::fmt(self, &mut f)
+    }
+}
+
+struct Join<'db, 'f, 'write> {
+    fmt: &'f mut TypeFormatter<'db, 'write>,
+    separator: &'static str,
+    result: fmt::Result,
+    seen_first: bool,
+}
+
+impl<'db> Join<'db, '_, '_> {
+    fn entry(&mut self, item: &dyn DisplayType<'db>) -> &mut Self {
+        if self.seen_first {
+            self.result = self
+                .result
+                .and_then(|()| self.fmt.write_str(self.separator));
+        } else {
+            self.seen_first = true;
+        }
+        self.result = self.result.and_then(|()| item.fmt(self.fmt));
+        self
+    }
+
+    fn entries<I, F>(&mut self, items: I) -> &mut Self
+    where
+        I: IntoIterator<Item = F>,
+        F: DisplayType<'db>,
+    {
+        for item in items {
+            self.entry(&item);
+        }
+        self
+    }
+
+    fn finish(&mut self) -> fmt::Result {
+        self.result
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use ruff_db::files::system_path_to_file;
@@ -406,7 +463,7 @@ mod tests {
             Type::none(&db),
         ];
         let union = UnionType::from_elements(&db, union_elements).expect_union();
-        let display = format!("{}", union.display(&db));
+        let display = format!("{}", Type::Union(union).display(&db));
         assert_eq!(
             display,
             concat!(

crates/red_knot_python_semantic/src/types/infer.rs

@@ -64,8 +64,8 @@ use crate::types::{
     typing_extensions_symbol, Boundness, Class, ClassLiteralType, FunctionType, InstanceType,
     IntersectionBuilder, IntersectionType, IterationOutcome, KnownClass, KnownFunction,
     KnownInstanceType, MetaclassCandidate, MetaclassErrorKind, SliceLiteralType, Symbol,
-    Truthiness, TupleType, Type, TypeAliasType, TypeArrayDisplay, TypeVarBoundOrConstraints,
-    TypeVarInstance, UnionBuilder, UnionType,
+    Truthiness, TupleType, Type, TypeAliasType, TypeVarBoundOrConstraints, TypeVarInstance,
+    UnionBuilder, UnionType,
 };
 use crate::unpack::Unpack;
 use crate::util::subscript::{PyIndex, PySlice};
@@ -799,7 +799,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     node,
                     format_args!(
                         "Conflicting declared types for `{symbol_name}`: {}",
-                        conflicting.display(self.db)
+                        Type::display_slice(self.db, &conflicting)
                     ),
                 );
                 ty

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.8.3"
+version = "0.8.2"
 publish = true
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_linter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.8.3"
+version = "0.8.2"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_wasm"
-version = "0.8.3"
+version = "0.8.2"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

docs/integrations.md

@@ -80,7 +80,7 @@ You can add the following configuration to `.gitlab-ci.yml` to run a `ruff forma
   stage: build
   interruptible: true
   image:
-    name: ghcr.io/astral-sh/ruff:0.8.3-alpine
+    name: ghcr.io/astral-sh/ruff:0.8.2-alpine
   before_script:
     - cd $CI_PROJECT_DIR
     - ruff --version
@@ -106,7 +106,7 @@ Ruff can be used as a [pre-commit](https://pre-commit.com) hook via [`ruff-pre-c
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.8.3
+  rev: v0.8.2
   hooks:
     # Run the linter.
     - id: ruff
@@ -119,7 +119,7 @@ To enable lint fixes, add the `--fix` argument to the lint hook:
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.8.3
+  rev: v0.8.2
   hooks:
     # Run the linter.
     - id: ruff
@@ -133,7 +133,7 @@ To run the hooks over Jupyter Notebooks too, add `jupyter` to the list of allowe
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.8.3
+  rev: v0.8.2
   hooks:
     # Run the linter.
     - id: ruff

docs/tutorial.md

@@ -349,7 +349,7 @@ This tutorial has focused on Ruff's command-line interface, but Ruff can also be
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.8.3
+  rev: v0.8.2
   hooks:
     # Run the linter.
     - id: ruff

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ruff"
-version = "0.8.3"
+version = "0.8.2"
 description = "An extremely fast Python linter and code formatter, written in Rust."
 authors = [{ name = "Astral Software Inc.", email = "hey@astral.sh" }]
 readme = "README.md"

scripts/benchmarks/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "scripts"
-version = "0.8.3"
+version = "0.8.2"
 description = ""
 authors = ["Charles Marsh <charlie.r.marsh@gmail.com>"]