[ty] remove any_over_type

.github/workflows/ci.yaml

@@ -321,30 +321,14 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - name: Setup Dev Drive
-        run: ${{ github.workspace }}/.github/workflows/setup-dev-drive.ps1
-
-      # actions/checkout does not let us clone into anywhere outside `github.workspace`, so we have to copy the clone
-      - name: Copy Git Repo to Dev Drive
-        env:
-          RUFF_WORKSPACE: ${{ env.RUFF_WORKSPACE }}
-        run: |
-          Copy-Item -Path "${{ github.workspace }}" -Destination "${env:RUFF_WORKSPACE}" -Recurse
-
       - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
-        with:
-          workspaces: ${{ env.RUFF_WORKSPACE }}
-
       - name: "Install Rust toolchain"
-        working-directory: ${{ env.RUFF_WORKSPACE }}
         run: rustup show
-
       - name: "Install cargo nextest"
         uses: taiki-e/install-action@d12e869b89167df346dd0ff65da342d1fb1202fb # v2.53.2
         with:
           tool: cargo-nextest
       - name: "Run tests"
-        working-directory: ${{ env.RUFF_WORKSPACE }}
         shell: bash
         env:
           NEXTEST_PROFILE: "ci"

.github/workflows/setup-dev-drive.ps1

@@ -1,93 +0,0 @@
-# Configures a drive for testing in CI.
-#
-# When using standard GitHub Actions runners, a `D:` drive is present and has
-# similar or better performance characteristics than a ReFS dev drive. Sometimes
-# using a larger runner is still more performant (e.g., when running the test
-# suite) and we need to create a dev drive. This script automatically configures
-# the appropriate drive.
-#
-# When using GitHub Actions' "larger runners", the `D:` drive is not present and
-# we create a DevDrive mount on `C:`. This is purported to be more performant
-# than an ReFS drive, though we did not see a change when we switched over.
-#
-# When using Depot runners, the underling infrastructure is EC2, which does not
-# support Hyper-V. The `New-VHD` commandlet only works with Hyper-V, but we can
-# create a ReFS drive using `diskpart` and `format` directory. We cannot use a
-# DevDrive, as that also requires Hyper-V. The Depot runners use `D:` already,
-# so we must check if it's a Depot runner first, and we use `V:` as the target
-# instead.
-
-
-if ($env:DEPOT_RUNNER -eq "1") {
-    Write-Output "DEPOT_RUNNER detected, setting up custom dev drive..."
-
-    # Create VHD and configure drive using diskpart
-    $vhdPath = "C:\ruff_dev_drive.vhdx"
-    @"
-create vdisk file="$vhdPath" maximum=20480 type=expandable
-attach vdisk
-create partition primary
-active
-assign letter=V
-"@ | diskpart
-
-    # Format the drive as ReFS
-    format V: /fs:ReFS /q /y
-    $Drive = "V:"
-
-    Write-Output "Custom dev drive created at $Drive"
-} elseif (Test-Path "D:\") {
-	# Note `Get-PSDrive` is not sufficient because the drive letter is assigned.
-    Write-Output "Using existing drive at D:"
-    $Drive = "D:"
-} else {
-	# The size (20 GB) is chosen empirically to be large enough for our
-	# workflows; larger drives can take longer to set up.
-	$Volume = New-VHD -Path C:/ruff_dev_drive.vhdx -SizeBytes 20GB |
-						Mount-VHD -Passthru |
-						Initialize-Disk -Passthru |
-						New-Partition -AssignDriveLetter -UseMaximumSize |
-						Format-Volume -DevDrive -Confirm:$false -Force
-
-	$Drive = "$($Volume.DriveLetter):"
-
-	# Set the drive as trusted
-	# See https://learn.microsoft.com/en-us/windows/dev-drive/#how-do-i-designate-a-dev-drive-as-trusted
-	fsutil devdrv trust $Drive
-
-	# Disable antivirus filtering on dev drives
-	# See https://learn.microsoft.com/en-us/windows/dev-drive/#how-do-i-configure-additional-filters-on-dev-drive
-	fsutil devdrv enable /disallowAv
-
-	# Remount so the changes take effect
-	Dismount-VHD -Path C:/ruff_dev_drive.vhdx
-	Mount-VHD -Path C:/ruff_dev_drive.vhdx
-
-	# Show some debug information
-	Write-Output $Volume
-	fsutil devdrv query $Drive
-
-    Write-Output "Using Dev Drive at $Volume"
-}
-
-$Tmp = "$($Drive)\ruff-tmp"
-
-# Create the directory ahead of time in an attempt to avoid race-conditions
-New-Item $Tmp -ItemType Directory
-
-# Move Cargo to the dev drive
-New-Item -Path "$($Drive)/.cargo/bin" -ItemType Directory -Force
-if (Test-Path "C:/Users/runneradmin/.cargo") {
-    Copy-Item -Path "C:/Users/runneradmin/.cargo/*" -Destination "$($Drive)/.cargo/" -Recurse -Force
-}
-
-Write-Output `
-	"DEV_DRIVE=$($Drive)" `
-	"TMP=$($Tmp)" `
-	"TEMP=$($Tmp)" `
-	"UV_INTERNAL__TEST_DIR=$($Tmp)" `
-	"RUSTUP_HOME=$($Drive)/.rustup" `
-	"CARGO_HOME=$($Drive)/.cargo" `
-	"RUFF_WORKSPACE=$($Drive)/ruff" `
-	"PATH=$($Drive)/.cargo/bin;$env:PATH" `
-	>> $env:GITHUB_ENV

crates/ruff_linter/src/rules/flake8_pyi/rules/simple_defaults.rs

@@ -75,7 +75,7 @@ impl AlwaysFixableViolation for TypedArgumentDefaultInStub {
 /// ## Example
 ///
 /// ```pyi
-/// def foo(arg=bar()) -> None: ...
+/// def foo(arg=[]) -> None: ...
 /// ```
 ///
 /// Use instead:
@@ -120,7 +120,7 @@ impl AlwaysFixableViolation for ArgumentDefaultInStub {
 ///
 /// ## Example
 /// ```pyi
-/// foo: str = bar()
+/// foo: str = "..."
 /// ```
 ///
 /// Use instead:

crates/ruff_linter/src/rules/flake8_pyi/rules/type_alias_naming.rs

@@ -14,15 +14,11 @@ use crate::checkers::ast::Checker;
 ///
 /// ## Example
 /// ```pyi
-/// from typing import TypeAlias
-///
 /// type_alias_name: TypeAlias = int
 /// ```
 ///
 /// Use instead:
 /// ```pyi
-/// from typing import TypeAlias
-///
 /// TypeAliasName: TypeAlias = int
 /// ```
 #[derive(ViolationMetadata)]

crates/ruff_linter/src/rules/pyflakes/rules/starred_expressions.rs

@@ -11,8 +11,8 @@ use crate::{Violation, checkers::ast::Checker};
 /// ## Why is this bad?
 /// In assignment statements, starred expressions can be used to unpack iterables.
 ///
-/// In Python 3, no more than `1 << 8` assignments are allowed before a starred
-/// expression, and no more than `1 << 24` expressions are allowed after a starred
+/// In Python 3, no more than 1 << 8 assignments are allowed before a starred
+/// expression, and no more than 1 << 24 expressions are allowed after a starred
 /// expression.
 ///
 /// ## References

crates/ty/tests/file_watching.rs

@@ -919,9 +919,6 @@ fn directory_renamed() -> anyhow::Result<()> {
 
 #[test]
 fn directory_deleted() -> anyhow::Result<()> {
-    use ruff_db::testing::setup_logging;
-    let _logging = setup_logging();
-
     let mut case = setup([
         ("bar.py", "import sub.a"),
         ("sub/__init__.py", ""),

crates/ty_ide/src/hover.rs

@@ -118,7 +118,7 @@ impl fmt::Display for DisplayHoverContent<'_, '_> {
         match self.content {
             HoverContent::Type(ty) => self
                 .kind
-                .fenced_code_block(ty.display(self.db), "python")
+                .fenced_code_block(ty.display(self.db), "text")
                 .fmt(f),
         }
     }
@@ -148,7 +148,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         Literal[10]
         ---------------------------------------------
-        ```python
+        ```text
         Literal[10]
         ```
         ---------------------------------------------
@@ -184,7 +184,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         int
         ---------------------------------------------
-        ```python
+        ```text
         int
         ```
         ---------------------------------------------
@@ -214,7 +214,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         def foo(a, b) -> Unknown
         ---------------------------------------------
-        ```python
+        ```text
         def foo(a, b) -> Unknown
         ```
         ---------------------------------------------
@@ -243,7 +243,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         bool
         ---------------------------------------------
-        ```python
+        ```text
         bool
         ```
         ---------------------------------------------
@@ -274,7 +274,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         Literal[123]
         ---------------------------------------------
-        ```python
+        ```text
         Literal[123]
         ```
         ---------------------------------------------
@@ -312,7 +312,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         (def foo(a, b) -> Unknown) | (def bar(a, b) -> Unknown)
         ---------------------------------------------
-        ```python
+        ```text
         (def foo(a, b) -> Unknown) | (def bar(a, b) -> Unknown)
         ```
         ---------------------------------------------
@@ -344,7 +344,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         <module 'lib'>
         ---------------------------------------------
-        ```python
+        ```text
         <module 'lib'>
         ```
         ---------------------------------------------
@@ -373,7 +373,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         T
         ---------------------------------------------
-        ```python
+        ```text
         T
         ```
         ---------------------------------------------
@@ -399,7 +399,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         @Todo
         ---------------------------------------------
-        ```python
+        ```text
         @Todo
         ```
         ---------------------------------------------
@@ -425,7 +425,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         @Todo
         ---------------------------------------------
-        ```python
+        ```text
         @Todo
         ```
         ---------------------------------------------
@@ -451,7 +451,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         Literal[1]
         ---------------------------------------------
-        ```python
+        ```text
         Literal[1]
         ```
         ---------------------------------------------
@@ -482,7 +482,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         Literal[1]
         ---------------------------------------------
-        ```python
+        ```text
         Literal[1]
         ```
         ---------------------------------------------
@@ -512,7 +512,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         Literal[2]
         ---------------------------------------------
-        ```python
+        ```text
         Literal[2]
         ```
         ---------------------------------------------
@@ -545,7 +545,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         Unknown | Literal[1]
         ---------------------------------------------
-        ```python
+        ```text
         Unknown | Literal[1]
         ```
         ---------------------------------------------
@@ -574,7 +574,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         int
         ---------------------------------------------
-        ```python
+        ```text
         int
         ```
         ---------------------------------------------
@@ -602,7 +602,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         Literal[1]
         ---------------------------------------------
-        ```python
+        ```text
         Literal[1]
         ```
         ---------------------------------------------
@@ -631,7 +631,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         int
         ---------------------------------------------
-        ```python
+        ```text
         int
         ```
         ---------------------------------------------
@@ -661,7 +661,7 @@ mod tests {
         assert_snapshot!(test.hover(), @r"
         str
         ---------------------------------------------
-        ```python
+        ```text
         str
         ```
         ---------------------------------------------

crates/ty_project/src/db.rs

@@ -83,20 +83,15 @@ impl ProjectDatabase {
 
     /// Checks all open files in the project and its dependencies.
     pub fn check(&self) -> Vec<Diagnostic> {
-        self.check_with_mode(CheckMode::OpenFiles)
+        let mut reporter = DummyReporter;
+        let reporter = AssertUnwindSafe(&mut reporter as &mut dyn Reporter);
+        self.project().check(self, reporter)
     }
 
     /// Checks all open files in the project and its dependencies, using the given reporter.
     pub fn check_with_reporter(&self, reporter: &mut dyn Reporter) -> Vec<Diagnostic> {
         let reporter = AssertUnwindSafe(reporter);
-        self.project().check(self, CheckMode::OpenFiles, reporter)
-    }
-
-    /// Check the project with the given mode.
-    pub fn check_with_mode(&self, mode: CheckMode) -> Vec<Diagnostic> {
-        let mut reporter = DummyReporter;
-        let reporter = AssertUnwindSafe(&mut reporter as &mut dyn Reporter);
-        self.project().check(self, mode, reporter)
+        self.project().check(self, reporter)
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
@@ -162,17 +157,6 @@ impl std::fmt::Debug for ProjectDatabase {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum CheckMode {
-    /// Checks only the open files in the project.
-    OpenFiles,
-
-    /// Checks all files in the project, ignoring the open file set.
-    ///
-    /// This includes virtual files, such as those created by the language server.
-    AllFiles,
-}
-
 /// Stores memory usage information.
 pub struct SalsaMemoryDump {
     total_fields: usize,

crates/ty_project/src/lib.rs

@@ -1,7 +1,7 @@
 use crate::glob::{GlobFilterCheckMode, IncludeResult};
 use crate::metadata::options::{OptionDiagnostic, ToSettingsError};
 use crate::walk::{ProjectFilesFilter, ProjectFilesWalker};
-pub use db::{CheckMode, Db, ProjectDatabase, SalsaMemoryDump};
+pub use db::{Db, ProjectDatabase, SalsaMemoryDump};
 use files::{Index, Indexed, IndexedFiles};
 use metadata::settings::Settings;
 pub use metadata::{ProjectMetadata, ProjectMetadataError};
@@ -214,7 +214,6 @@ impl Project {
     pub(crate) fn check(
         self,
         db: &ProjectDatabase,
-        mode: CheckMode,
         mut reporter: AssertUnwindSafe<&mut dyn Reporter>,
     ) -> Vec<Diagnostic> {
         let project_span = tracing::debug_span!("Project::check");
@@ -229,11 +228,7 @@ impl Project {
                 .map(OptionDiagnostic::to_diagnostic),
         );
 
-        let files = match mode {
-            CheckMode::OpenFiles => ProjectFiles::new(db, self),
-            // TODO: Consider open virtual files as well
-            CheckMode::AllFiles => ProjectFiles::Indexed(self.files(db)),
-        };
+        let files = ProjectFiles::new(db, self);
         reporter.set_files(files.len());
 
         diagnostics.extend(

crates/ty_python_semantic/resources/mdtest/snapshots/dataclasses.md_-_Dataclasses_-_`dataclasses.KW_ONLY…_(dd1b8f2f71487f16).snap

@@ -4,7 +4,7 @@ expression: snapshot
 ---
 ---
 mdtest name: dataclasses.md - Dataclasses - `dataclasses.KW_ONLY`
-mdtest path: crates/ty_python_semantic/resources/mdtest/dataclasses/dataclasses.md
+mdtest path: crates/ty_python_semantic/resources/mdtest/dataclasses.md
 ---
 
 # Python source files

crates/ty_python_semantic/resources/mdtest/type_properties/is_assignable_to.md

@@ -1064,37 +1064,6 @@ static_assert(not is_assignable_to(A, Callable[[int], int]))
 reveal_type(A()(1))  # revealed: str
 ```
 
-### Subclass of
-
-#### Type of a class with constructor methods
-
-```py
-from typing import Callable
-from ty_extensions import static_assert, is_assignable_to
-
-class A:
-    def __init__(self, x: int) -> None: ...
-
-class B:
-    def __new__(cls, x: str) -> "B":
-        return super().__new__(cls)
-
-static_assert(is_assignable_to(type[A], Callable[[int], A]))
-static_assert(not is_assignable_to(type[A], Callable[[str], A]))
-
-static_assert(is_assignable_to(type[B], Callable[[str], B]))
-static_assert(not is_assignable_to(type[B], Callable[[int], B]))
-```
-
-#### Type with no generic parameters
-
-```py
-from typing import Callable, Any
-from ty_extensions import static_assert, is_assignable_to
-
-static_assert(is_assignable_to(type, Callable[..., Any]))
-```
-
 ## Generics
 
 ### Assignability of generic types parameterized by gradual types

crates/ty_python_semantic/resources/mdtest/type_properties/is_subtype_of.md

@@ -1752,28 +1752,6 @@ static_assert(not is_subtype_of(TypeOf[F], Callable[[], str]))
 static_assert(not is_subtype_of(TypeOf[F], Callable[[int], F]))
 ```
 
-### Subclass of
-
-#### Type of a class with constructor methods
-
-```py
-from typing import Callable
-from ty_extensions import TypeOf, static_assert, is_subtype_of
-
-class A:
-    def __init__(self, x: int) -> None: ...
-
-class B:
-    def __new__(cls, x: str) -> "B":
-        return super().__new__(cls)
-
-static_assert(is_subtype_of(type[A], Callable[[int], A]))
-static_assert(not is_subtype_of(type[A], Callable[[str], A]))
-
-static_assert(is_subtype_of(type[B], Callable[[str], B]))
-static_assert(not is_subtype_of(type[B], Callable[[int], B]))
-```
-
 ### Bound methods
 
 ```py

crates/ty_python_semantic/src/types.rs

@@ -412,14 +412,6 @@ impl<'db> PropertyInstanceType<'db> {
             self.setter(db).map(|ty| ty.materialize(db, variance)),
         )
     }
-
-    fn any_over_type(self, db: &'db dyn Db, type_fn: &dyn Fn(Type<'db>) -> bool) -> bool {
-        self.getter(db)
-            .is_some_and(|ty| ty.any_over_type(db, type_fn))
-            || self
-                .setter(db)
-                .is_some_and(|ty| ty.any_over_type(db, type_fn))
-    }
 }
 
 bitflags! {
@@ -753,110 +745,6 @@ impl<'db> Type<'db> {
         }
     }
 
-    /// Return `true` if `self`, or any of the types contained in `self`, match the closure passed in.
-    pub fn any_over_type(self, db: &'db dyn Db, type_fn: &dyn Fn(Type<'db>) -> bool) -> bool {
-        if type_fn(self) {
-            return true;
-        }
-
-        match self {
-            Self::AlwaysFalsy
-            | Self::AlwaysTruthy
-            | Self::Never
-            | Self::BooleanLiteral(_)
-            | Self::BytesLiteral(_)
-            | Self::ModuleLiteral(_)
-            | Self::FunctionLiteral(_)
-            | Self::ClassLiteral(_)
-            | Self::SpecialForm(_)
-            | Self::KnownInstance(_)
-            | Self::StringLiteral(_)
-            | Self::IntLiteral(_)
-            | Self::LiteralString
-            | Self::Dynamic(_)
-            | Self::BoundMethod(_)
-            | Self::WrapperDescriptor(_)
-            | Self::MethodWrapper(_)
-            | Self::DataclassDecorator(_)
-            | Self::DataclassTransformer(_) => false,
-
-            Self::GenericAlias(generic) => generic
-                .specialization(db)
-                .types(db)
-                .iter()
-                .copied()
-                .any(|ty| ty.any_over_type(db, type_fn)),
-
-            Self::Callable(callable) => {
-                let signatures = callable.signatures(db);
-                signatures.iter().any(|signature| {
-                    signature.parameters().iter().any(|param| {
-                        param
-                            .annotated_type()
-                            .is_some_and(|ty| ty.any_over_type(db, type_fn))
-                    }) || signature
-                        .return_ty
-                        .is_some_and(|ty| ty.any_over_type(db, type_fn))
-                })
-            }
-
-            Self::SubclassOf(subclass_of) => {
-                Type::from(subclass_of.subclass_of()).any_over_type(db, type_fn)
-            }
-
-            Self::TypeVar(typevar) => match typevar.bound_or_constraints(db) {
-                None => false,
-                Some(TypeVarBoundOrConstraints::UpperBound(bound)) => {
-                    bound.any_over_type(db, type_fn)
-                }
-                Some(TypeVarBoundOrConstraints::Constraints(constraints)) => constraints
-                    .elements(db)
-                    .iter()
-                    .any(|constraint| constraint.any_over_type(db, type_fn)),
-            },
-
-            Self::BoundSuper(bound_super) => {
-                Type::from(bound_super.pivot_class(db)).any_over_type(db, type_fn)
-                    || Type::from(bound_super.owner(db)).any_over_type(db, type_fn)
-            }
-
-            Self::Tuple(tuple) => tuple
-                .tuple(db)
-                .all_elements()
-                .any(|ty| ty.any_over_type(db, type_fn)),
-
-            Self::Union(union) => union
-                .elements(db)
-                .iter()
-                .any(|ty| ty.any_over_type(db, type_fn)),
-
-            Self::Intersection(intersection) => {
-                intersection
-                    .positive(db)
-                    .iter()
-                    .any(|ty| ty.any_over_type(db, type_fn))
-                    || intersection
-                        .negative(db)
-                        .iter()
-                        .any(|ty| ty.any_over_type(db, type_fn))
-            }
-
-            Self::ProtocolInstance(protocol) => protocol.any_over_type(db, type_fn),
-            Self::PropertyInstance(property) => property.any_over_type(db, type_fn),
-
-            Self::NominalInstance(instance) => match instance.class {
-                ClassType::NonGeneric(_) => false,
-                ClassType::Generic(generic) => generic
-                    .specialization(db)
-                    .types(db)
-                    .iter()
-                    .any(|ty| ty.any_over_type(db, type_fn)),
-            },
-
-            Self::TypeIs(type_is) => type_is.return_type(db).any_over_type(db, type_fn),
-        }
-    }
-
     pub const fn into_class_literal(self) -> Option<ClassLiteral<'db>> {
         match self {
             Type::ClassLiteral(class_type) => Some(class_type),
@@ -1559,16 +1447,6 @@ impl<'db> Type<'db> {
                 .into_callable(db)
                 .has_relation_to(db, target, relation),
 
-            // TODO: This is unsound so in future we can consider an opt-in option to disable it.
-            (Type::SubclassOf(subclass_of_ty), Type::Callable(_))
-                if subclass_of_ty.subclass_of().into_class().is_some() =>
-            {
-                let class = subclass_of_ty.subclass_of().into_class().unwrap();
-                class
-                    .into_callable(db)
-                    .has_relation_to(db, target, relation)
-            }
-
             // `Literal[str]` is a subtype of `type` because the `str` class object is an instance of its metaclass `type`.
             // `Literal[abc.ABC]` is a subtype of `abc.ABCMeta` because the `abc.ABC` class object
             // is an instance of its metaclass `abc.ABCMeta`.

crates/ty_python_semantic/src/types/function.rs

@@ -1145,11 +1145,11 @@ impl KnownFunction {
                 let [Some(casted_type), Some(source_type)] = parameter_types else {
                     return None;
                 };
-                let contains_unknown_or_todo =
+                let is_unknown_or_todo =
                     |ty| matches!(ty, Type::Dynamic(dynamic) if dynamic != DynamicType::Any);
                 if source_type.is_equivalent_to(db, *casted_type)
-                    && !casted_type.any_over_type(db, &|ty| contains_unknown_or_todo(ty))
-                    && !source_type.any_over_type(db, &|ty| contains_unknown_or_todo(ty))
+                    && !is_unknown_or_todo(*casted_type)
+                    && !is_unknown_or_todo(*source_type)
                 {
                     let builder = context.report_lint(&REDUNDANT_CAST, call_expression)?;
                     builder.into_diagnostic(format_args!(

crates/ty_python_semantic/src/types/instance.rs

@@ -229,15 +229,6 @@ impl<'db> ProtocolInstanceType<'db> {
         }
     }
 
-    /// Return `true` if the types of any of the members match the closure passed in.
-    pub(super) fn any_over_type(
-        self,
-        db: &'db dyn Db,
-        type_fn: &dyn Fn(Type<'db>) -> bool,
-    ) -> bool {
-        self.inner.interface(db).any_over_type(db, type_fn)
-    }
-
     /// Return `true` if this protocol type has the given type relation to the protocol `other`.
     ///
     /// TODO: consider the types of the members as well as their existence

crates/ty_python_semantic/src/types/protocol_class.rs

@@ -152,16 +152,6 @@ impl<'db> ProtocolInterface<'db> {
             .all(|member_name| other.inner(db).contains_key(member_name))
     }
 
-    /// Return `true` if the types of any of the members match the closure passed in.
-    pub(super) fn any_over_type(
-        self,
-        db: &'db dyn Db,
-        type_fn: &dyn Fn(Type<'db>) -> bool,
-    ) -> bool {
-        self.members(db)
-            .any(|member| member.any_over_type(db, type_fn))
-    }
-
     pub(super) fn normalized_impl(self, db: &'db dyn Db, visitor: &mut TypeVisitor<'db>) -> Self {
         Self::new(
             db,
@@ -371,14 +361,6 @@ impl<'a, 'db> ProtocolMember<'a, 'db> {
             }
         }
     }
-
-    fn any_over_type(&self, db: &'db dyn Db, type_fn: &dyn Fn(Type<'db>) -> bool) -> bool {
-        match &self.kind {
-            ProtocolMemberKind::Method(callable) => callable.any_over_type(db, type_fn),
-            ProtocolMemberKind::Property(property) => property.any_over_type(db, type_fn),
-            ProtocolMemberKind::Other(ty) => ty.any_over_type(db, type_fn),
-        }
-    }
 }
 
 /// Returns `true` if a declaration or binding to a given name in a protocol class body

crates/ty_server/src/logging.rs

@@ -4,9 +4,10 @@
 //! are written to `stderr` by default, which should appear in the logs for most LSP clients. A
 //! `logFile` path can also be specified in the settings, and output will be directed there
 //! instead.
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
 use std::sync::Arc;
 
-use ruff_db::system::{SystemPath, SystemPathBuf};
 use serde::Deserialize;
 use tracing::level_filters::LevelFilter;
 use tracing_subscriber::Layer;
@@ -14,14 +15,14 @@ use tracing_subscriber::fmt::time::ChronoLocal;
 use tracing_subscriber::fmt::writer::BoxMakeWriter;
 use tracing_subscriber::layer::SubscriberExt;
 
-pub(crate) fn init_logging(log_level: LogLevel, log_file: Option<&SystemPath>) {
+pub(crate) fn init_logging(log_level: LogLevel, log_file: Option<&Path>) {
     let log_file = log_file
         .map(|path| {
             // this expands `logFile` so that tildes and environment variables
             // are replaced with their values, if possible.
-            if let Some(expanded) = shellexpand::full(&path.to_string())
+            if let Some(expanded) = shellexpand::full(&path.to_string_lossy())
                 .ok()
-                .map(|path| SystemPathBuf::from(&*path))
+                .and_then(|path| PathBuf::from_str(&path).ok())
             {
                 expanded
             } else {
@@ -32,11 +33,14 @@ pub(crate) fn init_logging(log_level: LogLevel, log_file: Option<&SystemPath>) {
             std::fs::OpenOptions::new()
                 .create(true)
                 .append(true)
-                .open(path.as_std_path())
+                .open(&path)
                 .map_err(|err| {
                     #[expect(clippy::print_stderr)]
                     {
-                        eprintln!("Failed to open file at {path} for logging: {err}");
+                        eprintln!(
+                            "Failed to open file at {} for logging: {err}",
+                            path.display()
+                        );
                     }
                 })
                 .ok()

crates/ty_server/src/server.rs

@@ -173,7 +173,6 @@ impl Server {
             diagnostic_provider: Some(DiagnosticServerCapabilities::Options(DiagnosticOptions {
                 identifier: Some(crate::DIAGNOSTIC_NAME.into()),
                 inter_file_dependencies: true,
-                workspace_diagnostics: true,
                 ..Default::default()
             })),
             text_document_sync: Some(TextDocumentSyncCapability::Options(

crates/ty_server/src/server/api.rs

@@ -28,28 +28,23 @@ pub(super) fn request(req: server::Request) -> Task {
     let id = req.id.clone();
 
     match req.method.as_str() {
-        requests::DocumentDiagnosticRequestHandler::METHOD => background_document_request_task::<
+        requests::DocumentDiagnosticRequestHandler::METHOD => background_request_task::<
             requests::DocumentDiagnosticRequestHandler,
         >(
             req, BackgroundSchedule::Worker
         ),
-        requests::WorkspaceDiagnosticRequestHandler::METHOD => background_request_task::<
-            requests::WorkspaceDiagnosticRequestHandler,
-        >(
-            req, BackgroundSchedule::Worker
-        ),
-        requests::GotoTypeDefinitionRequestHandler::METHOD => background_document_request_task::<
+        requests::GotoTypeDefinitionRequestHandler::METHOD => background_request_task::<
             requests::GotoTypeDefinitionRequestHandler,
         >(
             req, BackgroundSchedule::Worker
         ),
-        requests::HoverRequestHandler::METHOD => background_document_request_task::<
+        requests::HoverRequestHandler::METHOD => background_request_task::<
             requests::HoverRequestHandler,
         >(req, BackgroundSchedule::Worker),
-        requests::InlayHintRequestHandler::METHOD => background_document_request_task::<
+        requests::InlayHintRequestHandler::METHOD => background_request_task::<
             requests::InlayHintRequestHandler,
         >(req, BackgroundSchedule::Worker),
-        requests::CompletionRequestHandler::METHOD => background_document_request_task::<
+        requests::CompletionRequestHandler::METHOD => background_request_task::<
             requests::CompletionRequestHandler,
         >(
             req, BackgroundSchedule::LatencySensitive
@@ -140,51 +135,7 @@ where
     }))
 }
 
-fn background_request_task<R: traits::BackgroundRequestHandler>(
-    req: server::Request,
-    schedule: BackgroundSchedule,
-) -> Result<Task>
-where
-    <<R as RequestHandler>::RequestType as Request>::Params: UnwindSafe,
-{
-    let retry = R::RETRY_ON_CANCELLATION.then(|| req.clone());
-    let (id, params) = cast_request::<R>(req)?;
-
-    Ok(Task::background(schedule, move |session: &Session| {
-        let cancellation_token = session
-            .request_queue()
-            .incoming()
-            .cancellation_token(&id)
-            .expect("request should have been tested for cancellation before scheduling");
-
-        let snapshot = session.take_workspace_snapshot();
-
-        Box::new(move |client| {
-            let _span = tracing::debug_span!("request", %id, method = R::METHOD).entered();
-
-            // Test again if the request was cancelled since it was scheduled on the background task
-            // and, if so, return early
-            if cancellation_token.is_cancelled() {
-                tracing::trace!(
-                    "Ignoring request id={id} method={} because it was cancelled",
-                    R::METHOD
-                );
-
-                // We don't need to send a response here because the `cancel` notification
-                // handler already responded with a message.
-                return;
-            }
-
-            let result = ruff_db::panic::catch_unwind(|| R::run(snapshot, client, params));
-
-            if let Some(response) = request_result_to_response::<R>(&id, client, result, retry) {
-                respond::<R>(&id, response, client);
-            }
-        })
-    }))
-}
-
-fn background_document_request_task<R: traits::BackgroundDocumentRequestHandler>(
+fn background_request_task<R: traits::BackgroundDocumentRequestHandler>(
     req: server::Request,
     schedule: BackgroundSchedule,
 ) -> Result<Task>
@@ -217,7 +168,7 @@ where
         };
 
         let Some(snapshot) = session.take_snapshot(url) else {
-            tracing::warn!("Ignoring request because snapshot for path `{path:?}` doesn't exist");
+            tracing::warn!("Ignoring request because snapshot for path `{path:?}` doesn't exist.");
             return Box::new(|_| {});
         };
 
@@ -258,7 +209,7 @@ fn request_result_to_response<R>(
     request: Option<lsp_server::Request>,
 ) -> Option<Result<<<R as RequestHandler>::RequestType as Request>::Result>>
 where
-    R: traits::RetriableRequestHandler,
+    R: traits::BackgroundDocumentRequestHandler,
 {
     match result {
         Ok(response) => Some(response),

crates/ty_server/src/server/api/diagnostics.rs

@@ -166,7 +166,7 @@ pub(super) fn compute_diagnostics(
 
 /// Converts the tool specific [`Diagnostic`][ruff_db::diagnostic::Diagnostic] to an LSP
 /// [`Diagnostic`].
-pub(super) fn to_lsp_diagnostic(
+fn to_lsp_diagnostic(
     db: &dyn Db,
     diagnostic: &ruff_db::diagnostic::Diagnostic,
     encoding: PositionEncoding,

crates/ty_server/src/server/api/notifications/did_close.rs

@@ -41,12 +41,7 @@ impl SyncNotificationHandler for DidCloseTextDocumentHandler {
             );
         }
 
-        if !session.global_settings().diagnostic_mode().is_workspace() {
-            // The server needs to clear the diagnostics regardless of whether the client supports
-            // pull diagnostics or not. This is because the client only has the capability to fetch
-            // the diagnostics but does not automatically clear them when a document is closed.
-            clear_diagnostics(&key, client);
-        }
+        clear_diagnostics(&key, client);
 
         Ok(())
     }

crates/ty_server/src/server/api/requests.rs

@@ -4,7 +4,6 @@ mod goto_type_definition;
 mod hover;
 mod inlay_hints;
 mod shutdown;
-mod workspace_diagnostic;
 
 pub(super) use completion::CompletionRequestHandler;
 pub(super) use diagnostic::DocumentDiagnosticRequestHandler;
@@ -12,4 +11,3 @@ pub(super) use goto_type_definition::GotoTypeDefinitionRequestHandler;
 pub(super) use hover::HoverRequestHandler;
 pub(super) use inlay_hints::InlayHintRequestHandler;
 pub(super) use shutdown::ShutdownHandler;
-pub(super) use workspace_diagnostic::WorkspaceDiagnosticRequestHandler;

crates/ty_server/src/server/api/requests/completion.rs

@@ -8,9 +8,7 @@ use ty_project::ProjectDatabase;
 
 use crate::DocumentSnapshot;
 use crate::document::PositionExt;
-use crate::server::api::traits::{
-    BackgroundDocumentRequestHandler, RequestHandler, RetriableRequestHandler,
-};
+use crate::server::api::traits::{BackgroundDocumentRequestHandler, RequestHandler};
 use crate::session::client::Client;
 
 pub(crate) struct CompletionRequestHandler;
@@ -20,6 +18,8 @@ impl RequestHandler for CompletionRequestHandler {
 }
 
 impl BackgroundDocumentRequestHandler for CompletionRequestHandler {
+    const RETRY_ON_CANCELLATION: bool = true;
+
     fn document_url(params: &CompletionParams) -> Cow<Url> {
         Cow::Borrowed(&params.text_document_position.text_document.uri)
     }
@@ -65,7 +65,3 @@ impl BackgroundDocumentRequestHandler for CompletionRequestHandler {
         Ok(Some(response))
     }
 }
-
-impl RetriableRequestHandler for CompletionRequestHandler {
-    const RETRY_ON_CANCELLATION: bool = true;
-}

crates/ty_server/src/server/api/requests/diagnostic.rs

@@ -8,9 +8,7 @@ use lsp_types::{
 
 use crate::server::Result;
 use crate::server::api::diagnostics::{Diagnostics, compute_diagnostics};
-use crate::server::api::traits::{
-    BackgroundDocumentRequestHandler, RequestHandler, RetriableRequestHandler,
-};
+use crate::server::api::traits::{BackgroundDocumentRequestHandler, RequestHandler};
 use crate::session::DocumentSnapshot;
 use crate::session::client::Client;
 use ty_project::ProjectDatabase;
@@ -45,9 +43,7 @@ impl BackgroundDocumentRequestHandler for DocumentDiagnosticRequestHandler {
             }),
         ))
     }
-}
 
-impl RetriableRequestHandler for DocumentDiagnosticRequestHandler {
     fn salsa_cancellation_error() -> lsp_server::ResponseError {
         lsp_server::ResponseError {
             code: lsp_server::ErrorCode::ServerCancelled as i32,

crates/ty_server/src/server/api/requests/goto_type_definition.rs

@@ -8,9 +8,7 @@ use ty_project::ProjectDatabase;
 
 use crate::DocumentSnapshot;
 use crate::document::{PositionExt, ToLink};
-use crate::server::api::traits::{
-    BackgroundDocumentRequestHandler, RequestHandler, RetriableRequestHandler,
-};
+use crate::server::api::traits::{BackgroundDocumentRequestHandler, RequestHandler};
 use crate::session::client::Client;
 
 pub(crate) struct GotoTypeDefinitionRequestHandler;
@@ -72,5 +70,3 @@ impl BackgroundDocumentRequestHandler for GotoTypeDefinitionRequestHandler {
         }
     }
 }
-
-impl RetriableRequestHandler for GotoTypeDefinitionRequestHandler {}

crates/ty_server/src/server/api/requests/hover.rs

@@ -2,9 +2,7 @@ use std::borrow::Cow;
 
 use crate::DocumentSnapshot;
 use crate::document::{PositionExt, ToRangeExt};
-use crate::server::api::traits::{
-    BackgroundDocumentRequestHandler, RequestHandler, RetriableRequestHandler,
-};
+use crate::server::api::traits::{BackgroundDocumentRequestHandler, RequestHandler};
 use crate::session::client::Client;
 use lsp_types::request::HoverRequest;
 use lsp_types::{HoverContents, HoverParams, MarkupContent, Url};
@@ -75,5 +73,3 @@ impl BackgroundDocumentRequestHandler for HoverRequestHandler {
         }))
     }
 }
-
-impl RetriableRequestHandler for HoverRequestHandler {}

crates/ty_server/src/server/api/requests/inlay_hints.rs

@@ -2,9 +2,7 @@ use std::borrow::Cow;
 
 use crate::DocumentSnapshot;
 use crate::document::{RangeExt, TextSizeExt};
-use crate::server::api::traits::{
-    BackgroundDocumentRequestHandler, RequestHandler, RetriableRequestHandler,
-};
+use crate::server::api::traits::{BackgroundDocumentRequestHandler, RequestHandler};
 use crate::session::client::Client;
 use lsp_types::request::InlayHintRequest;
 use lsp_types::{InlayHintParams, Url};
@@ -66,5 +64,3 @@ impl BackgroundDocumentRequestHandler for InlayHintRequestHandler {
         Ok(Some(inlay_hints))
     }
 }
-
-impl RetriableRequestHandler for InlayHintRequestHandler {}

crates/ty_server/src/server/api/requests/workspace_diagnostic.rs

@@ -1,108 +0,0 @@
-use lsp_types::request::WorkspaceDiagnosticRequest;
-use lsp_types::{
-    FullDocumentDiagnosticReport, Url, WorkspaceDiagnosticParams, WorkspaceDiagnosticReport,
-    WorkspaceDiagnosticReportResult, WorkspaceDocumentDiagnosticReport,
-    WorkspaceFullDocumentDiagnosticReport,
-};
-use rustc_hash::FxHashMap;
-use ty_project::CheckMode;
-
-use crate::server::Result;
-use crate::server::api::diagnostics::to_lsp_diagnostic;
-use crate::server::api::traits::{
-    BackgroundRequestHandler, RequestHandler, RetriableRequestHandler,
-};
-use crate::session::WorkspaceSnapshot;
-use crate::session::client::Client;
-use crate::system::file_to_url;
-
-pub(crate) struct WorkspaceDiagnosticRequestHandler;
-
-impl RequestHandler for WorkspaceDiagnosticRequestHandler {
-    type RequestType = WorkspaceDiagnosticRequest;
-}
-
-impl BackgroundRequestHandler for WorkspaceDiagnosticRequestHandler {
-    fn run(
-        snapshot: WorkspaceSnapshot,
-        _client: &Client,
-        _params: WorkspaceDiagnosticParams,
-    ) -> Result<WorkspaceDiagnosticReportResult> {
-        let index = snapshot.index();
-
-        if !index.global_settings().diagnostic_mode().is_workspace() {
-            tracing::debug!("Workspace diagnostics is disabled; returning empty report");
-            return Ok(WorkspaceDiagnosticReportResult::Report(
-                WorkspaceDiagnosticReport { items: vec![] },
-            ));
-        }
-
-        let mut items = Vec::new();
-
-        for db in snapshot.projects() {
-            let diagnostics = db.check_with_mode(CheckMode::AllFiles);
-
-            // Group diagnostics by URL
-            let mut diagnostics_by_url: FxHashMap<Url, Vec<_>> = FxHashMap::default();
-
-            for diagnostic in diagnostics {
-                if let Some(span) = diagnostic.primary_span() {
-                    let file = span.expect_ty_file();
-                    let Some(url) = file_to_url(db, file) else {
-                        tracing::debug!("Failed to convert file to URL at {}", file.path(db));
-                        continue;
-                    };
-                    diagnostics_by_url.entry(url).or_default().push(diagnostic);
-                }
-            }
-
-            items.reserve(diagnostics_by_url.len());
-
-            // Convert to workspace diagnostic report format
-            for (url, file_diagnostics) in diagnostics_by_url {
-                let version = index
-                    .key_from_url(url.clone())
-                    .ok()
-                    .and_then(|key| index.make_document_ref(&key))
-                    .map(|doc| i64::from(doc.version()));
-
-                // Convert diagnostics to LSP format
-                let lsp_diagnostics = file_diagnostics
-                    .into_iter()
-                    .map(|diagnostic| {
-                        to_lsp_diagnostic(db, &diagnostic, snapshot.position_encoding())
-                    })
-                    .collect::<Vec<_>>();
-
-                items.push(WorkspaceDocumentDiagnosticReport::Full(
-                    WorkspaceFullDocumentDiagnosticReport {
-                        uri: url,
-                        version,
-                        full_document_diagnostic_report: FullDocumentDiagnosticReport {
-                            // TODO: We don't implement result ID caching yet
-                            result_id: None,
-                            items: lsp_diagnostics,
-                        },
-                    },
-                ));
-            }
-        }
-
-        Ok(WorkspaceDiagnosticReportResult::Report(
-            WorkspaceDiagnosticReport { items },
-        ))
-    }
-}
-
-impl RetriableRequestHandler for WorkspaceDiagnosticRequestHandler {
-    fn salsa_cancellation_error() -> lsp_server::ResponseError {
-        lsp_server::ResponseError {
-            code: lsp_server::ErrorCode::ServerCancelled as i32,
-            message: "server cancelled the request".to_owned(),
-            data: serde_json::to_value(lsp_types::DiagnosticServerCancellationData {
-                retrigger_request: true,
-            })
-            .ok(),
-        }
-    }
-}

crates/ty_server/src/server/api/traits.rs

@@ -1,7 +1,7 @@
 //! A stateful LSP implementation that calls into the ty API.
 
 use crate::session::client::Client;
-use crate::session::{DocumentSnapshot, Session, WorkspaceSnapshot};
+use crate::session::{DocumentSnapshot, Session};
 
 use lsp_types::notification::Notification as LSPNotification;
 use lsp_types::request::Request;
@@ -25,24 +25,11 @@ pub(super) trait SyncRequestHandler: RequestHandler {
     ) -> super::Result<<<Self as RequestHandler>::RequestType as Request>::Result>;
 }
 
-pub(super) trait RetriableRequestHandler: RequestHandler {
-    /// Whether this request can be cancelled if the Salsa database is modified.
+/// A request handler that can be run on a background thread.
+pub(super) trait BackgroundDocumentRequestHandler: RequestHandler {
+    /// Whether this request be retried if it was cancelled due to a modification to the Salsa database.
     const RETRY_ON_CANCELLATION: bool = false;
 
-    /// The error to return if the request was cancelled due to a modification to the Salsa database.
-    fn salsa_cancellation_error() -> lsp_server::ResponseError {
-        lsp_server::ResponseError {
-            code: lsp_server::ErrorCode::ContentModified as i32,
-            message: "content modified".to_string(),
-            data: None,
-        }
-    }
-}
-
-/// A request handler that can be run on a background thread.
-///
-/// This handler is specific to requests that operate on a single document.
-pub(super) trait BackgroundDocumentRequestHandler: RetriableRequestHandler {
     fn document_url(
         params: &<<Self as RequestHandler>::RequestType as Request>::Params,
     ) -> std::borrow::Cow<lsp_types::Url>;
@@ -53,15 +40,14 @@ pub(super) trait BackgroundDocumentRequestHandler: RetriableRequestHandler {
         client: &Client,
         params: <<Self as RequestHandler>::RequestType as Request>::Params,
     ) -> super::Result<<<Self as RequestHandler>::RequestType as Request>::Result>;
-}
 
-/// A request handler that can be run on a background thread.
-pub(super) trait BackgroundRequestHandler: RetriableRequestHandler {
-    fn run(
-        snapshot: WorkspaceSnapshot,
-        client: &Client,
-        params: <<Self as RequestHandler>::RequestType as Request>::Params,
-    ) -> super::Result<<<Self as RequestHandler>::RequestType as Request>::Result>;
+    fn salsa_cancellation_error() -> lsp_server::ResponseError {
+        lsp_server::ResponseError {
+            code: lsp_server::ErrorCode::ContentModified as i32,
+            message: "content modified".to_string(),
+            data: None,
+        }
+    }
 }
 
 /// A supertrait for any server notification handler.

crates/ty_server/src/session.rs

@@ -2,7 +2,7 @@
 
 use std::collections::{BTreeMap, VecDeque};
 use std::ops::{Deref, DerefMut};
-use std::panic::AssertUnwindSafe;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 use anyhow::{Context, anyhow};
@@ -224,14 +224,6 @@ impl Session {
         self.index().key_from_url(url)
     }
 
-    pub(crate) fn take_workspace_snapshot(&self) -> WorkspaceSnapshot {
-        WorkspaceSnapshot {
-            projects: AssertUnwindSafe(self.projects.values().cloned().collect()),
-            index: self.index.clone().unwrap(),
-            position_encoding: self.position_encoding,
-        }
-    }
-
     pub(crate) fn initialize_workspaces(&mut self, workspace_settings: Vec<(Url, ClientOptions)>) {
         assert!(!self.workspaces.all_initialized());
 
@@ -243,7 +235,14 @@ impl Session {
             // In the future, index the workspace directories to find all projects
             // and create a project database for each.
             let system = LSPSystem::new(self.index.as_ref().unwrap().clone());
-            let system_path = workspace.root();
+
+            let Some(system_path) = SystemPath::from_std_path(workspace.root()) else {
+                tracing::warn!(
+                    "Ignore workspace `{}` because it's root contains non UTF8 characters",
+                    workspace.root().display()
+                );
+                continue;
+            };
 
             let root = system_path.to_path_buf();
             let project = ProjectMetadata::discover(&root, &system)
@@ -383,10 +382,6 @@ impl Session {
     pub(crate) fn client_capabilities(&self) -> &ResolvedClientCapabilities {
         &self.resolved_client_capabilities
     }
-
-    pub(crate) fn global_settings(&self) -> Arc<ClientSettings> {
-        self.index().global_settings()
-    }
 }
 
 /// A guard that holds the only reference to the index and allows modifying it.
@@ -466,27 +461,6 @@ impl DocumentSnapshot {
     }
 }
 
-/// An immutable snapshot of the current state of [`Session`].
-pub(crate) struct WorkspaceSnapshot {
-    projects: AssertUnwindSafe<Vec<ProjectDatabase>>,
-    index: Arc<index::Index>,
-    position_encoding: PositionEncoding,
-}
-
-impl WorkspaceSnapshot {
-    pub(crate) fn projects(&self) -> &[ProjectDatabase] {
-        &self.projects
-    }
-
-    pub(crate) fn index(&self) -> &index::Index {
-        &self.index
-    }
-
-    pub(crate) fn position_encoding(&self) -> PositionEncoding {
-        self.position_encoding
-    }
-}
-
 #[derive(Debug, Default)]
 pub(crate) struct Workspaces {
     workspaces: BTreeMap<Url, Workspace>,
@@ -499,15 +473,11 @@ impl Workspaces {
             .to_file_path()
             .map_err(|()| anyhow!("Workspace URL is not a file or directory: {url:?}"))?;
 
-        // Realistically I don't think this can fail because we got the path from a Url
-        let system_path = SystemPathBuf::from_path_buf(path)
-            .map_err(|_| anyhow!("Workspace URL is not valid UTF8"))?;
-
         self.workspaces.insert(
             url,
             Workspace {
                 options,
-                root: system_path,
+                root: path,
             },
         );
 
@@ -550,12 +520,12 @@ impl<'a> IntoIterator for &'a Workspaces {
 
 #[derive(Debug)]
 pub(crate) struct Workspace {
-    root: SystemPathBuf,
+    root: PathBuf,
     options: ClientOptions,
 }
 
 impl Workspace {
-    pub(crate) fn root(&self) -> &SystemPath {
+    pub(crate) fn root(&self) -> &Path {
         &self.root
     }
 }

crates/ty_server/src/session/options.rs

@@ -1,5 +1,6 @@
+use std::path::PathBuf;
+
 use lsp_types::Url;
-use ruff_db::system::SystemPathBuf;
 use rustc_hash::FxHashMap;
 use serde::Deserialize;
 
@@ -46,26 +47,6 @@ pub(crate) struct ClientOptions {
     /// Settings under the `python.*` namespace in VS Code that are useful for the ty language
     /// server.
     python: Option<Python>,
-    /// Diagnostic mode for the language server.
-    diagnostic_mode: Option<DiagnosticMode>,
-}
-
-/// Diagnostic mode for the language server.
-#[derive(Clone, Copy, Debug, Default, Deserialize)]
-#[cfg_attr(test, derive(PartialEq, Eq))]
-#[serde(rename_all = "camelCase")]
-pub(crate) enum DiagnosticMode {
-    /// Check only currently open files.
-    #[default]
-    OpenFilesOnly,
-    /// Check all files in the workspace.
-    Workspace,
-}
-
-impl DiagnosticMode {
-    pub(crate) fn is_workspace(self) -> bool {
-        matches!(self, DiagnosticMode::Workspace)
-    }
 }
 
 impl ClientOptions {
@@ -77,7 +58,6 @@ impl ClientOptions {
                 .and_then(|python| python.ty)
                 .and_then(|ty| ty.disable_language_services)
                 .unwrap_or_default(),
-            diagnostic_mode: self.diagnostic_mode.unwrap_or_default(),
         }
     }
 }
@@ -109,7 +89,7 @@ pub(crate) struct TracingOptions {
     pub(crate) log_level: Option<LogLevel>,
 
     /// Path to the log file - tildes and environment variables are supported.
-    pub(crate) log_file: Option<SystemPathBuf>,
+    pub(crate) log_file: Option<PathBuf>,
 }
 
 /// This is the exact schema for initialization options sent in by the client during

crates/ty_server/src/session/settings.rs

@@ -1,5 +1,3 @@
-use super::options::DiagnosticMode;
-
 /// Resolved client settings for a specific document. These settings are meant to be
 /// used directly by the server, and are *not* a 1:1 representation with how the client
 /// sends them.
@@ -7,15 +5,10 @@ use super::options::DiagnosticMode;
 #[cfg_attr(test, derive(PartialEq, Eq))]
 pub(crate) struct ClientSettings {
     pub(super) disable_language_services: bool,
-    pub(super) diagnostic_mode: DiagnosticMode,
 }
 
 impl ClientSettings {
     pub(crate) fn is_language_services_disabled(&self) -> bool {
         self.disable_language_services
     }
-
-    pub(crate) fn diagnostic_mode(&self) -> DiagnosticMode {
-        self.diagnostic_mode
-    }
 }