Why does the unknown type propagate over after an explicit annotation

[ItsDrike]

From what I understand, Unknown is a special type internal to pyright, that's essentially just an implicit Any. However, it seems to act differently than Any, when assigning to an explicitly annotated variable. The Unknown type seems to propagate in a union result, forcing me to use cast there, I don't really understand why that is though, I thought it would act similarly to Any here, why doesn't it?

from typing import Any, reveal_type

# Just some setup, not that relevant

def helper(*args):
    """Helper function to return a tuple[Unknown, ...] type."""
    return args


unknown = helper()[0]  # I know this would be a runtime error, not relevant to the question though
reveal_type(unknown)  # Unknown

any: Any = "hi"

string: str = "hello"

# Relevant

x: int = any
reveal_type(x)  # int

y: int = string  # pyright: ignore[reportAssignmentType]
reveal_type(y)  # int (not str | int)

z: int = unknown
reveal_type(z)  # Unknown | int (why?)

[erictraut]

You're correct that Unknown is unique to pyright. It's not defined as part of the typing spec. In most cases, it's treated the same as Any.

In this case, I've intentionally deviated from this principle because of the way the reportUnknown... checks work within pyright. If Unknown were not retained as part of the assignment, it would be possible for unknown values to go unreported in strict mode.

If you're not interested in receiving diagnostics for Unknown values, you should use "standard" type checking mode rather than "strict".

[ItsDrike]

I'm aware of the unknown rules used in strict mode and I have some interest in using those rules, but I still don't quite understand the reason behind propagating unknown when there's an explicit annotation. Why wouldn't something like this be enough?

x: int = unknown  # pyright: ignore[reportUnknownVariableType]
reveal_type(x)  # int
y: int = x  # this should be fine, now

Why should the unknown type propagate here and also cause the same problem on the y = x assignment later? Why not just emit the diagnostic during the assignment when the type being assigned, without any further propagation?

[ItsDrike]

After giving it some more thought, I suppose one downside of the approach above would be that the ignore comments would be necessary whenever working with anything unknown, whereas with this, a cast is necessary, and the cast is probably a cleaner thing here.

Is that the reason? Or is there something more behind it?

[erictraut]

A # pyright: ignore comment does not affect type evaluation behavior; it simply suppresses any diagnostics on that line.

The reportUnknown... checks report the use of an Unknown. If Unknown was not retained, you would see no strict-mode diagnostic in this code sequence despite the fact that it represents a typing hole.

x: int = unknown
y: int = x