Quoted forward references incorrectly resolve to shadowing class members

[TyceHerrman]

Describe the Bug

A quoted forward reference in a class body resolves against a same-named class
member. The Python typing conformance test expects the quoted reference to
resolve outside the class scope, while the equivalent unquoted annotation
resolves to the class member and is rejected as an invalid type.

Minimal reproduction:

from typing import assert_type


class ClassD:
    def int(self) -> None:
        ...

    x: "int" = 0  # OK: quoted reference resolves to builtins.int
    y: int = 0  # E: local method `int` isn't a legal type expression


assert_type(ClassD.x, int)

The quoted annotation produces an error for x:

Expected a type form, got instance of `(self: Self@ClassD) -> None`

It then treats ClassD.x as Unknown, producing a second failure:

assert_type(Unknown, int) failed

Expected behavior:

• Accept the quoted annotation "int" and resolve it to builtins.int.
• Continue rejecting the unquoted annotation int, which refers to the local
  method and isn't a valid type expression.
• Preserve ClassD.x as int without the cascading Unknown error.

The mismatch appears in
conformance.result.
The corresponding test is
annotations_forward_refs.py.

Related Work

• Issue #1900 discusses
  same-named methods shadowing types, but its reproduction uses unquoted
  annotations. Its discussion points to the expected error for the unquoted
  case in this conformance test.
• PR #1983 added an
  overload-specific lookup exception.
• Issue #357 and
  PR #3617 address unquoted
  forward references evaluated before Python 3.14.
• Issue #3387 and
  PR #3391 address a different
  from __future__ import annotations case.

This issue specifically covers lookup semantics for a quoted annotation when a
class member shadows the referenced name.

Sandbox Link

Not provided; the reproduction above is self-contained and comes directly from
the typing conformance suite.

[yangdanny97]

I'll note that proposal in python/typing#2144 changes that conformance test case to have different assertions, which are not fully compatible with the existing assertions

for example, in the proposed change all the quoted references are expected to resolve to the nested definition

class ClassD:
    ClassC: "ClassC"  # OK

    ClassF: "ClassF"  # E: circular reference

    str: "str" = ""  # E: circular reference

    z: "int" = 0  # E: Refers to the local int function

    def int(self) -> None:  # OK
        ...

    y: int = 0  # E: Refers to the local int function, which isn't a legal type expression

    x: "int" = 0  # E: Refers to a local int function

    def __init__(self) -> None:
        self.ClassC = ClassC()

[github-actions]

This issue has someone assigned, but has not had recent activity for more than 2 weeks.

If you are still working on this issue, please add a comment so everyone knows. Otherwise, please unassign yourself and allow someone else to take over.

Thank you for your contributions!