Pyright

Behavior Changes:
* Improved consistency of unreachable code. Previously, unreachable code was not supported for `if` or `else` suites when the condition type was narrowed to `Never`.
* Changed hover provider output for type aliases to conform more closely with the new Python 3.12 `type` syntax.

Enhancements:
* Added support for detecting mismatched property types in base classes used for multiple inheritance.
* Improved `reportUninitializedInstanceVariable` check to handle dataclass variables that are initialized implicitly by the synthesized `__init__` method.
* Added support for walrus (assignment) operator within set literal expressions if the python version is >= 3.10. The grammar was changed in 3.10 to support this.

Bug Fixes:
* Fixed recent regression in `reportUninitializedInstanceVariable` check relating to `NamedTuple` instance variables.
* Fixed bug that leads to a false negative when a subscript object used in an index expression supports `__index__` but the indexed object specifies that it requires `int`.
* Fixed recent regression that results in a runtime assert (and therefore a crash) in certain circumstances when computing the MRO for a class.
* Fixed bug that results in an incorrect overload implementation diagnostic when using `tuple[()]` in overloads.
* Improved diagnostic messages for type errors detected during `__set__` and `__delete__` calls to a descriptor object.
* Fixed bug that results in a false positive error when using a callback protocol with a function-scoped type variable.
* Fixed bug that incorrectly evaluates a constructor call to a constructor that infers a class-scoped ParamSpec when the passed function is generic.
* Fixed bug that leads to a spurious "unbound variable" diagnostic when a variable is assigned a value using a walrus operator and is later used in a `**` call argument.
* Fixed bug that results in incorrect type narrowing in the negative (fall-through) case of a match expression when the subject expression is an unbounded tuple.

Bug Fixes:
* Fixed a bug that causes `warnings.deprecated` not to work if the python version is 3.13. This was caused by recent changes to typeshed stubs.
* Fixed bug that results in inconsistent diagnostics when surrounding an argument expression with parentheses.
* Fixed bug that causes a "bare" `type` (with no type argument) or `type[Any]` to be treated as a possible descriptor object.
* Fixed regression that results in an internal assertion (and crash) related to TypeVar variance inference.
* Fixed a bug in the "type printer" (the component responsible for translating a type into its textual form) for type aliases defined using PEP 695 syntax.
* Fixed bug that resulted in the incorrect synthesis of `__dataclass_fields__` for named tuples.
* (Contributed by InSync) Fixed `stubPath`'s default value in configuration schema.
* Fixed bug in pattern matching for `Callable()` in the negative (fall-through) case.
* Fixed bug that results in unions consisting of different specialized forms of a generic TypedDict to "lose" all but one of these subtypes.

Behavior Changes:
* Changed inference behavior for generator functions with no reachable `yield` or `yield from` statements. The "yield type" (the first type argument to `Generator`) is now inferred as `Never` in this case rather than `None`.
* Changed the behavior of double underscored symbols that are part of a module's namespace when that module is not a stub or in a "py.typed" package. Such symbols are no longer ignored, although they are considered private.
* Changed the way that PEP 695 type aliases are displayed when hovering over a reference to the type alias. Previously, the symbol was displayed as `TypeAliasType` rather than the expanded type alias type.

Enhancements:
* Added support for `deprecated` objects that are instantiated prior to being used as a decorator. This allows for a factory usage pattern.
* Added check for illegal use of `Protocol` type argument that is not a type parameter. The runtime generates an exception for this condition.

Bug Fixes:
* Fixed bug that results in incorrect truthy/falsy type narrowing for an enum that overrides `__bool__`.
* Fixed bug that results in a false positive when accessing a generic attribute in a base class from a subclass that explicitly specializes the generic type.
* Fixed bug that results in duplicate and (contradictory) diagnostic outputs in certain cases where `reveal_type` is used in a loop.
* Fixed a bug that results in incorrect (local) type evaluation of an instance variable with a declared type when assigned within a loop that uses an augmented assignment.
* Fixed bug that causes `Final` annotation not to be honored when wrapped in an `Annotated` annotation.
* Fixed bug that results in a false positive error under certain circumstances involving tuple type narrowing in a loop.
* Fixed bug that led to divergent behaviors between pyrightconfig.json and pyproject.toml configurations. Specifically, default exclude patterns were not added in the case of pyproject.toml. Thanks to augustelalande for contributing to this fix.
* Fixed bug that results in parameter types being converted to `Any` when converting a `NewType` or dataclass constructor to a callable.

Enhancements:
* Updated typeshed stubs to the latest version.
* Implemented provisional support for PEP 746, which provides consistency checks for metadata used in an `Annotated` annotation.
* Added check for `except*` to enforce that exception class does not derive from `BaseExceptionGroup`.
* Added the ability to override type checking configuration settings for each execution environment. This allows, for example, a test directory to use different settings than the directories that contain production code.

Behavior Changes:
* Added extra blank line to JSON output to assist with parsing when used in watch mode.
* Changed the import resolution order to better reflect runtime behavior and match a proposed change to the typing spec. In particular, stdlib typeshed stubs are now resolved prior to `site_packages`.

Bug Fixes:
* Fixed bug that results in a false positive error under certain circumstances involving a call to a higher-order generic function with another function that involves a class with a contravariant type variable.
* Fixed bug that results in a confusing error message when stub generation fails.
* Fixed bug that results in false positive when evaluating the call to a generic function that involves a type variable used in both a covariant and contravariant (or invariant) position and both literal and non-literal types are involved.
* Fixed bug that results in a false negative when solving a type variable that involves an invariant context.
* Fixed a bug that can result in incorrect type inference for a subexpression that is part of an assignment expression if executed with an inference context (bidirectional type inference).
* Fixed bug in `x is E` type narrowing pattern where `E` is an enum literal and `x` is a supertype of `E` like `object`.

Behavior Changes:
* Changed behavior of constructor call evaluation when `__new__` evaluation results in type evaluation errors. Previously, pyright skipped the `__init__` evaluation in this case. It now proceeds to evaluate `__init__`, potentially generating redundant errors.
* Removed support for inlined TypedDict annotations. This was an experimental feature that never gained enough support to make it into a PEP.
* Changed behavior of pyright to match the latest typing spec when it encounters an attribute with a type annotation within an `Enum` class body in a stub. These are now treated as non-member attributes rather than members. Typeshed stubs have been updated to conform to the new standard.
* Added diagnostic check for an enum member with a type annotation. The typing spec says that this should be considered a typing error.

Enhancements:
* Updated typeshed stubs to the latest version.

Bug Fixes:
* Fixed regression that results in the incorrect type evaluation for the `value` attribute of a `StrEnum` or `IntEnum` class.
* Fixed a bug that results in incorrect type compatibility checks for a callable that uses `*args: *tuple[T, *tuple[S, ...]]`.
* Fixed a bug that results in an unsolved TypeVar when calling `list(tuple())`.
* Fixed bug that leads to inconsistent narrowing-on-assignment behavior when a `tuple` instance with unknown type arguments is assigned to a target symbol with a declared `tuple` type.
* Fixed bug that results in a false negative when a `Final` class variable is assigned a value in the class body and reassigned a value in the `__init__` method.

Behavior Changes:
* Changed tuple expression inference behavior to not preserve literal entry types if the tuple expression is embedded within another tuple, set, list, or dictionary expression.
* [Contribution by ujan-r] Use typeshed version info for stdlib module list.

Enhancements:
* Improved diagnostic messages for parameter mismatch.
* Added support for configuration inheritance through an "extends" configuration option.
* Added support for custom ".toml" files specified via the `-p` option on the command line.

Bug Fixes:
* Fixed bug that results in a false negative syntax error when a PEP-695 type alias uses a keyword as a name.
* Fixed a bug that leads to a false positive error when first argument to `super` call is an instance of a metaclass.
* Fixed recent regression that results in a false positive when accessing an enum member from an instance of an enum class.
* Fixed bug that results in a false negative when determining if a callable type is compatible with another callable type and the first has a `*args` parameter and the second has a single positional+keyword parameter.
* Fixed a bug in the code flow engine that results in incorrect type evaluation in certain cases involving codependent variables in a loop.
* Fixed a bug that results in incorrect type narrowing for a type guard function that uses `TypeIs[type[T]]`.
* Fixed regression related to "converter" field parameter for dataclasses when the converter refers to a generic class constructor.
* Fixed a bug that results in a false negative when a generic function has a parameter with a generic type and a default argument value. This could lead to a typing hole when considering subtyping rules for callables.
* Fixed a bug in the dataclass "converter" support that resulted in an error if the converter is `tuple`.
* Fixed regression that results in incorrect type evaluation for annotations that involve nested protocols (such as `P[P[T]]`).
* Fixed a bug that resulted in an infinite loop when a function that uses an `*args: *Ts` parameter is passed as an argument to itself.
* Fixed bug that leads to a false negative when calling a callback function that returns a callable with a generic parameter type.

Behavior Changes:
* Changed the handling of `Enum` subclasses that explicitly override `value` or `name` to avoid using the special-case logic for computing these types. This is done regardless of whether the class uses a custom metaclass.
* Changed support for dataclass "converter" field parameter to be off by default. The "enableExperimentalFeatures" must now be enabled to use this feature. If and when PEP 712 is approved, it will be moved out of experimental.
* Added support for using `Literal` and various other special forms in a value expression.

Enhancements:
* Added support for recent addendum to typing spec that provides a special case for dataclasses so `ClassVar` and `Final` can be used together to distinguish between a regular `Final` instance variable and a `ClassVar` that is also `Final`.
* Updated typeshed stubs to the latest version.
* Improved type printer (the component that converts an internal type to textual format for diagnostic messages) so it better handles special forms like `Literal` or unions when used in a value expression.