This is possibly a repro without pattern-matching:

from typing import Generic, TypeVar

T = TypeVar("T")

class Foo(Generic[T]):
    attr: T
    def __init__(self, attr: T) -> None:
        self.attr = attr
        
class Bar(Foo[T]): ...

x: Foo[str] = Bar("idk")

if isinstance(x, Bar):
    reveal_type(x.attr)  # Any (should be str!)

https://mypy-play.net/?mypy=latest&python=3.10&gist=5ba0af842f3a9d75ab0498009e0d92cb

I think it is something similar to #13607 🤔
But, I am not sure. I didn't have any time to debug this yet.

There are couple of this with this example:

from typing import Generic, TypeVar

T = TypeVar("T")


class Base(Generic[T]):
    ...

class A(Base[T]):
    x: T

    __match_args__ = ('x', )

    def __init__(self, x: T):
        self.x = x


a: Base[str] = A("foo")
reveal_type(a)  # Base[str] (correct)

match a:
    case A(b):
        reveal_type(b)  # Any (incorrect! Should be builtins.str)

Right now it is unclear to me: how to properly handle Base in the first place? It does not have x, it does not have __init__, it does not have __match_args__. Should it be even allowed to match A(b)? Probably yes, but this example is hard to process.

@sobolevn my understanding is that it doesn't matter that Base doesn't have __match_args__ or __init__, this should only matter for the case statements.

...but in the end the problem doesn't appear specific to match as @AlexWaygood demonstrates.

The core problem is that mypy should infer that the T in A[T] can only be str once the value is narrowed to Base[str].

Yeap, this is another problem :)
I am actually working on code that @AlexWaygood provided. It is much easier for me to understand.

Ok, the problem is in this line:

Ideally, we should use something like map_instance_to_supertype to preserve type information about current type arguments.

But, we need a completely new approach for this. It is not implemented at all.

So, we take the subtype, go for all the route inside mro tree to find our supertype.
Then, in reverse order we apply type arguments from one parent to its subclass until we reach the our instance.

Then, we return the mapped instance and it will solve our problem.

Ok, I found map_type_from_supertype