Added special-case logic to detect when a class-like symbol created by calling NewType is used as an actual class for assignability or member accesses. This addresses #10550. (#10562)

Author: erictraut

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

@@ -5717,6 +5717,17 @@ export function createTypeEvaluator(
             case TypeCategory.Class: {
                 let typeResult: TypeResult | undefined;
 
+                // If this is a class-like function created via NewType, treat
+                // it like a function for purposes of member accesses.
+                if (
+                    ClassType.isNewTypeClass(baseType) &&
+                    !baseType.priv.includeSubclasses &&
+                    prefetched?.functionClass &&
+                    isClass(prefetched.functionClass)
+                ) {
+                    baseType = ClassType.cloneAsInstance(prefetched.functionClass);
+                }
+
                 const enumMemberResult = getTypeOfEnumMember(
                     evaluatorInterface,
                     node,
@@ -10279,6 +10290,19 @@ export function createTypeEvaluator(
                         }
 
                         if (isClass(subtype)) {
+                            // Specifically handle the case where the subtype is a class-like
+                            // object created by calling NewType. At runtime, it's actually
+                            // a FunctionType object.
+                            if (
+                                isClassInstance(subtype) &&
+                                ClassType.isNewTypeClass(subtype) &&
+                                !subtype.priv.includeSubclasses
+                            ) {
+                                if (prefetched?.functionClass) {
+                                    return prefetched.functionClass;
+                                }
+                            }
+
                             return convertToInstantiable(stripLiteralValue(subtype));
                         }
 
@@ -13512,12 +13536,7 @@ export function createTypeEvaluator(
             const initType = FunctionType.createSynthesizedInstance('__init__');
             FunctionType.addParam(
                 initType,
-                FunctionParam.create(
-                    ParamCategory.Simple,
-                    ClassType.cloneAsInstance(classType),
-                    FunctionParamFlags.TypeDeclared,
-                    'self'
-                )
+                FunctionParam.create(ParamCategory.Simple, AnyType.create(), FunctionParamFlags.TypeDeclared, 'self')
             );
             FunctionType.addParam(
                 initType,
@@ -13538,7 +13557,7 @@ export function createTypeEvaluator(
             const newType = FunctionType.createSynthesizedInstance('__new__', FunctionTypeFlags.ConstructorMethod);
             FunctionType.addParam(
                 newType,
-                FunctionParam.create(ParamCategory.Simple, classType, FunctionParamFlags.TypeDeclared, 'cls')
+                FunctionParam.create(ParamCategory.Simple, AnyType.create(), FunctionParamFlags.TypeDeclared, 'cls')
             );
             FunctionType.addDefaultParams(newType);
             newType.shared.declaredReturnType = ClassType.cloneAsInstance(classType);
@@ -24439,6 +24458,15 @@ export function createTypeEvaluator(
             }
         }
 
+        // If the source is a class-like type created by a call to NewType, treat it
+        // as a FunctionClass instance rather than an instantiable class for
+        // purposes of assignability. This reflects its actual runtime type.
+        if (isInstantiableClass(srcType) && ClassType.isNewTypeClass(srcType) && !srcType.priv.includeSubclasses) {
+            if (prefetched?.functionClass && isInstantiableClass(prefetched?.functionClass)) {
+                srcType = ClassType.cloneAsInstance(prefetched.functionClass);
+            }
+        }
+
         if (recursionCount > maxTypeRecursionCount) {
             return true;
         }

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

@@ -68,13 +68,13 @@ class TD1(TypedDict):
 
 
 def func2(x: MyString):
-    # This should generate an error because isinstance can't be used
-    # with a NewType.
+    # This should generate two errors because isinstance can't be used
+    # with a NewType and it violates the isinstance siganture.
     if isinstance(x, MyString):
         pass
 
-    # This should generate an error because issubclass can't be used
-    # with a NewType.
+    # This should generate two errors because issubclass can't be used
+    # with a NewType and it violates the issubclass signature.
     if issubclass(type(x), (MyString, int)):
         pass
 

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

@@ -0,0 +1,15 @@
+# This sample tests that classes created with NewType are treated
+# as though they're functions at runtime.
+
+from typing import NewType
+
+MyStr = NewType("MyStr", str)
+
+# This should generate an error.
+v1: type = MyStr
+
+# This should generate an error.
+MyStr.capitalize
+
+MyStr.__name__ # OK
+

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

@@ -266,7 +266,7 @@ test('MissingSuper1', () => {
 test('NewType1', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['newType1.py']);
 
-    TestUtils.validateResults(analysisResults, 11);
+    TestUtils.validateResults(analysisResults, 13);
 });
 
 test('NewType2', () => {
@@ -299,6 +299,12 @@ test('NewType6', () => {
     TestUtils.validateResults(analysisResults, 1);
 });
 
+test('NewType7', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['newType7.py']);
+
+    TestUtils.validateResults(analysisResults, 2);
+});
+
 test('isInstance1', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['isinstance1.py']);