Reject @runtime_checkable on non-protocol classes

packages/pyright-internal/src/analyzer/decorators.ts

@@ -409,7 +409,15 @@ export function applyClassDecorator(
         }
 
         if (FunctionType.isBuiltIn(decoratorType, 'runtime_checkable')) {
-            originalClassType.shared.flags |= ClassTypeFlags.RuntimeCheckable;
+            if (!ClassType.isProtocolClass(originalClassType)) {
+                evaluator.addDiagnostic(
+                    DiagnosticRule.reportGeneralTypeIssues,
+                    LocMessage.runtimeCheckableNotProtocol(),
+                    decoratorNode.d.expr
+                );
+            } else {
+                originalClassType.shared.flags |= ClassTypeFlags.RuntimeCheckable;
+            }
 
             // Don't call getTypeOfDecorator for runtime_checkable. It appears
             // frequently in stubs, and it's a waste of time to validate its

packages/pyright-internal/src/localization/localize.ts

@@ -900,6 +900,7 @@ export namespace Localizer {
                 getRawString('Diagnostic.returnTypeMismatch')
             );
         export const returnTypeUnknown = () => getRawString('Diagnostic.returnTypeUnknown');
+        export const runtimeCheckableNotProtocol = () => getRawString('Diagnostic.runtimeCheckableNotProtocol');
         export const returnTypePartiallyUnknown = () =>
             new ParameterizedString<{ returnType: string }>(getRawString('Diagnostic.returnTypePartiallyUnknown'));
         export const revealLocalsArgs = () => getRawString('Diagnostic.revealLocalsArgs');

packages/pyright-internal/src/localization/package.nls.en-us.json

@@ -1174,6 +1174,10 @@
         "returnTypeMismatch": "Type \"{exprType}\" is not assignable to return type \"{returnType}\"",
         "returnTypePartiallyUnknown": "Return type, \"{returnType}\", is partially unknown",
         "returnTypeUnknown": "Return type is unknown",
+        "runtimeCheckableNotProtocol": {
+            "message": "@runtime_checkable can be applied only to a Protocol class",
+            "comment": "{Locked='@runtime_checkable','Protocol'}"
+        },
         "revealLocalsArgs": {
             "message": "Expected no arguments for \"reveal_locals\" call",
             "comment": "{Locked='reveal_locals'}"

packages/pyright-internal/src/tests/samples/protocol54.py

@@ -0,0 +1,27 @@
+# This sample tests that @runtime_checkable can be applied only to
+# classes that are protocols (Protocol must appear in the base list).
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class P1(Protocol):
+    def foo(self) -> int: ...
+
+
+# This should generate an error because a subclass of a protocol is
+# not itself a protocol unless Protocol is listed as a base class.
+@runtime_checkable
+class P2(P1):
+    def bar(self) -> str: ...
+
+
+@runtime_checkable
+class P3(P1, Protocol):
+    def bar(self) -> str: ...
+
+
+# This should generate an error because C1 is not a protocol.
+@runtime_checkable
+class C1:
+    def foo(self) -> int: ...

packages/pyright-internal/src/tests/typeEvaluator7.test.ts

@@ -628,6 +628,12 @@ test('Protocol53', () => {
     TestUtils.validateResults(analysisResults2, 8);
 });
 
+test('Protocol54', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['protocol54.py']);
+
+    TestUtils.validateResults(analysisResults, 2);
+});
+
 test('ProtocolExplicit1', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['protocolExplicit1.py']);