refactor(types): Type parameters and return value of Request #2741

rchl · 2026-01-30T22:43:08Z

Type params and return value of Request object. Typing Request ensures that all the send_request variants infer param/return types and enforce those for the handlers/chained promise. So more safety.

Also type Notification and Response but those don't benefit much from typing since there is no response to handle.

rchl · 2026-01-30T22:44:47Z

plugin/core/protocol.py

+P = TypeVar('P', bound=None | bool | int | Uint | float | str | Mapping[str, Any] | Iterable[Any])
 R = TypeVar('R')


Those are defined in two places. Potentially could be imported from a single place but importing such generic names feels weird. Perhaps should be given more meaningful names and then imported? Or leave as is?

rchl · 2026-01-30T22:46:47Z

plugin/rename_file.py

+    def handle_rename_async(self, responses: list[tuple[WorkspaceEdit | None | Error, weakref.ref[Session]]],
                            label: str, rename_command_args: dict[str, Any]) -> None:
        for response, weak_session in responses:
            if (session := weak_session()) and response:
+                if isinstance(response, Error):
+                    print(f'LSP: Error response during rename: {response}')
+                    return
                prompt_for_workspace_edits(session, response, label=label) \
                    .then(partial(self.on_prompt_for_workspace_edits_concluded, weak_session, response, label)) \
                    .then(lambda accepted: accepted and self.window.run_command('lsp_rename_path', rename_command_args))


Previously Error was not handled but in theory it can happen. I just interrupt rename if that happens but probably it's not the best way to do it...

rchl · 2026-01-30T22:49:01Z

plugin/core/protocol.py

+    result: NotRequired[Any]
+
+
+class Request(Generic[P, R]):


We could have third generic for error result but it's the same in 99.9% of cases and it would not be possible to optionally provide it (at least until Python 3.13) so skipped it. Only initialize really used different error type but we haven't used anything from it so using standard ResponseError works for it too.

rchl · 2026-01-30T22:49:32Z

plugin/hierarchy.py

 class HierarchyDataProvider(TreeDataProvider):

    def __init__(
        self,
        weaksession: weakref.ref[Session],
-        request: Callable[..., Request],
-        request_handler: Callable[..., list[HierarchyItemWrapper]],
+        request: Callable[[Any], Request[Any, Any]],
+        request_handler: Callable[[Any], Any],
        root_elements: list[HierarchyItemWrapper]


Cheating with Any here since typing this properly is pretty much impossible without refactoring.

plugin/session_buffer.py

plugin/core/views.py

plugin/session_buffer.py

plugin/core/protocol.py

jwortmann · 2026-01-31T14:25:50Z

plugin/core/protocol.py

 UINT_MAX = INT_MAX

-R = TypeVar('R')
+LspPayload: TypeAlias = Union[None, bool, int, Uint, float, str, Mapping[str, Any], Iterable[Any]]


This should be exactly LSPAny, no?

That triggers errors:

Type "InitializeParams" cannot be assigned to type variable "P@Request" Type "InitializeParams" is not assignable to upper bound "LSPAny" for type variable "P@Request" Type "InitializeParams" is not assignable to type "LSPAny" "InitializeParams" is not assignable to "Dict[str, LSPAny]" "InitializeParams" is not assignable to "List[LSPAny]" "InitializeParams" is not assignable to "str" "InitializeParams" is not assignable to "int" "InitializeParams" is not assignable to "float" "InitializeParams" is not assignable to "bool" ... (basedpyright)

We actually need Mapping[str, Any], Iterable[Any] here.

More specifically we need Iterable[Any] because this works too: Union[LSPAny, Iterable[Any]]

I've asked Claude and it gave me the following (hopefully true) answer.

The issue is that TypedDict is not considered compatible with dict[str, T] by type checkers, even though at runtime they're both dictionaries. TypedDict is a specific structured type with known keys, while dict[str, T] is a general mapping.

Solution 1: Cast to dict (Runtime)

from __future__ import annotations from typing import TypeAlias, TypedDict, cast Uint = int class InitializeParams(TypedDict): foo: int LSPArray: TypeAlias = list[LSPAny] LSPObject: TypeAlias = dict[str, LSPAny] LSPAny: TypeAlias = LSPObject | LSPArray | str | int | Uint | float | bool | None def f(p: LSPAny) -> None: pass a: InitializeParams = {'foo': 1} f(cast(dict, a)) # ✓ Works

Solution 2: Include TypedDict Types in LSPAny

from __future__ import annotations from typing import TypeAlias, TypedDict, Mapping, Any Uint = int class InitializeParams(TypedDict): foo: int LSPArray: TypeAlias = list[LSPAny] LSPObject: TypeAlias = dict[str, LSPAny] | Mapping[str, Any] LSPAny: TypeAlias = LSPObject | LSPArray | str | int | Uint | float | bool | None def f(p: LSPAny) -> None: pass a: InitializeParams = {'foo': 1} f(a) # ✓ Works

Solution 3: Use Protocol or Mapping

from __future__ import annotations from typing import TypeAlias, TypedDict, Any from collections.abc import Mapping Uint = int class InitializeParams(TypedDict): foo: int LSPArray: TypeAlias = list[LSPAny] LSPObject: TypeAlias = Mapping[str, Any] # More permissive LSPAny: TypeAlias = LSPObject | LSPArray | str | int | Uint | float | bool | None def f(p: LSPAny) -> None: pass a: InitializeParams = {'foo': 1} f(a) # ✓ Works

Solution 4: Add type: ignore Comment

from __future__ import annotations from typing import TypeAlias, TypedDict Uint = int class InitializeParams(TypedDict): foo: int LSPArray: TypeAlias = list[LSPAny] LSPObject: TypeAlias = dict[str, LSPAny] LSPAny: TypeAlias = LSPObject | LSPArray | str | int | Uint | float | bool | None def f(p: LSPAny) -> None: pass a: InitializeParams = {'foo': 1} f(a) # type: ignore[arg-type]

Why This Happens

Type checkers like mypy and Pyright treat TypedDict as incompatible with dict[str, T] because:

TypedDict has fixed, known keys with specific types

dict[str, T] has arbitrary string keys all with the same type

They're structurally different from a type-safety perspective

Best Solution: Use Solution 3 with Mapping[str, Any] if you want maximum compatibility with various dict-like objects including TypedDicts.

Note that we can always update LSPAny in https://github.com/sublimelsp/lsp-python-types to be what we want if we think it makes sense.

I noticed that after 5e19a9e I would get a similar type incompatibility when using session.execute_command
https://github.com/sublimelsp/LSP-Tinymist/blob/4fe344f28e9a6fcae8cb1beda23c565b00612923/plugin.py#L267

So yes, I think making LSPAny more permissive for type checkers would be a good idea. I would also go with solution 3.

Edit: Although my use case that is linked above is the other way round compared to the example from Claude; the argument is typed LSPAny and the function input is PreviewResult (TypedDict). Would need to check if that works too.

It's a different issue.

plugin/core/protocol.py

refactor(types): Type parameters and return value of Request

01de664

rchl commented Jan 30, 2026

View reviewed changes

3.8 compat

945fe5a

jwortmann reviewed Jan 31, 2026

View reviewed changes

plugin/session_buffer.py Outdated Show resolved Hide resolved

jwortmann reviewed Jan 31, 2026

View reviewed changes

plugin/core/views.py Show resolved Hide resolved

rchl added 2 commits January 31, 2026 10:53

silence type checker warning

cdf4059

move pyright settings to pyproject.toml

907eadd

rchl commented Jan 31, 2026

View reviewed changes

plugin/session_buffer.py Outdated Show resolved Hide resolved

ignore for flake8

bd2b5a8

rchl commented Jan 31, 2026

View reviewed changes

plugin/core/protocol.py Outdated Show resolved Hide resolved

rchl added 3 commits January 31, 2026 11:13

tweak types

9f49ecb

comment

290dd6c

Merge branch 'main' into refactor/request

4864ec4

jwortmann reviewed Jan 31, 2026

View reviewed changes

rchl added 5 commits January 31, 2026 17:55

Better JSONRpcPayload

377440c

use new types

0a3d09b

Merge remote-tracking branch 'origin/main' into refactor/request

ee8d19b

simplify and improve execute_command type

7d38580

fix

8f8263c

rchl mentioned this pull request Jan 31, 2026

Improve types sublimelsp/LSP-Tinymist#11

Open

		P = TypeVar('P', bound=None \| bool \| int \| Uint \| float \| str \| Mapping[str, Any] \| Iterable[Any])
		R = TypeVar('R')

refactor(types): Type parameters and return value of Request #2741

Are you sure you want to change the base?

refactor(types): Type parameters and return value of Request #2741

Uh oh!

Conversation

rchl commented Jan 30, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

rchl Jan 30, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

rchl Jan 30, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Solution 1: Cast to dict (Runtime)

Solution 2: Include TypedDict Types in LSPAny

Solution 3: Use Protocol or Mapping

Solution 4: Add type: ignore Comment

Why This Happens

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jwortmann Jan 31, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

rchl Jan 30, 2026 •

edited

Loading

rchl Jan 30, 2026 •

edited

Loading

jwortmann Jan 31, 2026 •

edited

Loading