pythongh-132493: Lazily determine protocol attributes

pythongh-132494 made typing.py eagerly import annotationlib again because
typing contains several protocols. Avoid this by determining annotations
lazily. This should also make protocol creation faster:

Unpatched:

$ ./python.exe -m timeit -s 'from typing import Protocol, runtime_checkable' '''@runtime_checkable
class MyProtocol(Protocol):
    def meth(self): pass
'''
50000 loops, best of 5: 9.28 usec per loop
$ ./python.exe -m timeit -s 'from typing import Protocol, runtime_checkable' '''class MyProtocol(Protocol):
    def meth(self): pass
'''
50000 loops, best of 5: 9.05 usec per loop

Patched:

$ ./python.exe -m timeit -s 'from typing import Protocol, runtime_checkable' '''@runtime_checkable
class MyProtocol(Protocol):
    def meth(self): pass
'''
50000 loops, best of 5: 7.69 usec per loop
$ ./python.exe -m timeit -s 'from typing import Protocol, runtime_checkable' '''class MyProtocol(Protocol):
    def meth(self): pass
'''
50000 loops, best of 5: 7.78 usec per loop

This was on a debug build though and I haven't compared it with versions where Protocol just accessed
`.__annotations__` directly, and it's not a huge difference, so I don't think it's worth calling out the
optimization too much.

A downside of this change is that any errors that happen during the determination of attributes now
happen only the first time isinstance() is called. This seems OK since these errors happen only in
fairly exotic circumstances.

Another downside is that any attributes added after class initialization now get picked up as protocol
members. This came up in the typing test suite due to `@final`, but may cause issues elsewhere too.

Author: JelleZijlstra

Lib/test/test_typing.py

@@ -4542,10 +4542,15 @@ class classproperty:
             def __get__(self, instance, type):
                 raise CustomError
 
+        @runtime_checkable
+        class Commentable(Protocol):
+            evil = classproperty()
+
+        class Normal:
+            evil = None
+
         with self.assertRaises(TypeError) as cm:
-            @runtime_checkable
-            class Commentable(Protocol):
-                evil = classproperty()
+            isinstance(Normal(), Commentable)
 
         exc = cm.exception
         self.assertEqual(

Lib/typing.py

@@ -1777,6 +1777,8 @@ class _TypingEllipsis:
     '__parameters__', '__orig_bases__',  '__orig_class__',
     '_is_protocol', '_is_runtime_protocol', '__protocol_attrs__',
     '__non_callable_proto_members__', '__type_params__',
+    '__protocol_attrs_cache__', '__non_callable_proto_members_cache__',
+    '__final__',
 })
 
 _SPECIAL_NAMES = frozenset({
@@ -1941,11 +1943,6 @@ def __new__(mcls, name, bases, namespace, /, **kwargs):
                     )
         return super().__new__(mcls, name, bases, namespace, **kwargs)
 
-    def __init__(cls, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        if getattr(cls, "_is_protocol", False):
-            cls.__protocol_attrs__ = _get_protocol_attrs(cls)
-
     def __subclasscheck__(cls, other):
         if cls is Protocol:
             return type.__subclasscheck__(cls, other)
@@ -1997,14 +1994,44 @@ def __instancecheck__(cls, instance):
                 val = getattr_static(instance, attr)
             except AttributeError:
                 break
-            # this attribute is set by @runtime_checkable:
             if val is None and attr not in cls.__non_callable_proto_members__:
                 break
         else:
             return True
 
         return False
 
+    @property
+    def __protocol_attrs__(cls):
+        try:
+            return cls.__protocol_attrs_cache__
+        except AttributeError:
+            protocol_attrs = _get_protocol_attrs(cls)
+            cls.__protocol_attrs_cache__ = protocol_attrs
+            return protocol_attrs
+
+    @property
+    def __non_callable_proto_members__(cls):
+        # PEP 544 prohibits using issubclass()
+        # with protocols that have non-method members.
+        try:
+            return cls.__non_callable_proto_members_cache__
+        except AttributeError:
+            non_callable_members = set()
+            for attr in cls.__protocol_attrs__:
+                try:
+                    is_callable = callable(getattr(cls, attr, None))
+                except Exception as e:
+                    raise TypeError(
+                        f"Failed to determine whether protocol member {attr!r} "
+                        "is a method member"
+                    ) from e
+                else:
+                    if not is_callable:
+                        non_callable_members.add(attr)
+            cls.__non_callable_proto_members_cache__ = non_callable_members
+            return non_callable_members
+
 
 @classmethod
 def _proto_hook(cls, other):
@@ -2220,22 +2247,6 @@ def close(self): ...
         raise TypeError('@runtime_checkable can be only applied to protocol classes,'
                         ' got %r' % cls)
     cls._is_runtime_protocol = True
-    # PEP 544 prohibits using issubclass()
-    # with protocols that have non-method members.
-    # See gh-113320 for why we compute this attribute here,
-    # rather than in `_ProtocolMeta.__init__`
-    cls.__non_callable_proto_members__ = set()
-    for attr in cls.__protocol_attrs__:
-        try:
-            is_callable = callable(getattr(cls, attr, None))
-        except Exception as e:
-            raise TypeError(
-                f"Failed to determine whether protocol member {attr!r} "
-                "is a method member"
-            ) from e
-        else:
-            if not is_callable:
-                cls.__non_callable_proto_members__.add(attr)
     return cls