@zzzen/pyright-internal 1.2.0-dev.20220807 → 1.2.0-dev.20220814

package/dist/analyzer/typeEvaluator.js

@@ -2856,7 +2856,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // cannot be used in this location.
     function validateTypeVarUsage(node, type, flags) {
         var _a;
-        if (types_1.TypeBase.isInstantiable(type) && !(0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
+        if (types_1.TypeBase.isInstantiable(type) && !type.scopeId && !(0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
             const scopedTypeVarInfo = findScopedTypeVar(node, type);
             type = scopedTypeVarInfo.type;
             if ((flags & 2048 /* DisallowTypeVarsWithScopeId */) !== 0 && type.scopeId !== undefined) {
@@ -3239,12 +3239,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    // Handle the special case of LiteralString.
-                    if (types_1.ClassType.isBuiltIn(baseType, 'LiteralString') &&
-                        strClassType &&
-                        (0, types_1.isInstantiableClass)(strClassType)) {
-                        baseType = types_1.ClassType.cloneAsInstance(strClassType);
-                    }
                     // Handle the special case of 'name' and 'value' members within an enum.
                     const enumMemberResult = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete);
                     if (enumMemberResult) {
@@ -5442,7 +5436,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Is this a union type? If so, we can expand it.
             const argType = contextFreeArgTypes[indexToExpand];
             if ((0, types_1.isUnion)(argType)) {
-                unionToExpand = argType;
+                unionToExpand = makeTopLevelTypeVarsConcrete(argType);
+                break;
+            }
+            else if ((0, types_1.isTypeVar)(argType) && argType.details.constraints.length > 1) {
+                unionToExpand = makeTopLevelTypeVarsConcrete(argType);
                 break;
             }
             indexToExpand++;
@@ -7678,7 +7676,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* declaredMetaclass */ undefined, arg1Type.details.effectiveMetaclass);
         arg1Type.tupleTypeArguments.forEach((typeArg) => {
             const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
-            if ((0, types_1.isInstantiableClass)(specializedType) || (0, types_1.isAnyOrUnknown)(specializedType)) {
+            if ((0, types_1.isInstantiableClass)(specializedType) ||
+                (0, types_1.isAnyOrUnknown)(specializedType) ||
+                ((0, types_1.isClassInstance)(specializedType) && types_1.ClassType.isBuiltIn(specializedType, 'type'))) {
                 classType.details.baseClasses.push(specializedType);
             }
             else {
@@ -8350,12 +8350,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return subtype;
             }
-            if ((0, types_1.isClassInstance)(subtype) &&
-                types_1.ClassType.isBuiltIn(subtype, 'LiteralString') &&
-                strClassType &&
-                (0, types_1.isInstantiableClass)(strClassType)) {
-                return handleSubtype(types_1.ClassType.cloneAsInstance(strClassType));
-            }
             if ((0, types_1.isClassInstance)(subtype) || (0, types_1.isInstantiableClass)(subtype) || (0, types_1.isTypeVar)(subtype)) {
                 return handleSubtype(subtype);
             }
@@ -8576,6 +8570,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isAnyOrUnknown)(unexpandedType)) {
                     addUnknown = false;
                 }
+                else if ((0, types_1.isClassInstance)(unexpandedType) && types_1.ClassType.isTypedDictClass(unexpandedType)) {
+                    // Handle dictionary expansion for a TypedDict.
+                    if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
+                        const strObject = types_1.ClassType.cloneAsInstance(strClassType);
+                        const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, unexpandedType, 
+                        /* allowNarrowed */ true);
+                        tdEntries.forEach((entry, name) => {
+                            if (entry.isRequired || entry.isProvided) {
+                                keyTypes.push(types_1.ClassType.cloneWithLiteral(strObject, name));
+                                valueTypes.push(entry.valueType);
+                            }
+                        });
+                        addUnknown = false;
+                    }
+                }
                 else {
                     // Verify that the type supports the `keys` and `__getitem__` methods.
                     // This protocol is defined in the _typeshed stub. If we can't find
@@ -10002,6 +10011,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return cachedType;
             }
             const specialType = createSpecialBuiltInClass(node, assignedName, aliasMapEntry);
+            // Handle 'LiteralString' specially because we want it to act as
+            // though it derives from 'str'.
+            if (assignedName === 'LiteralString') {
+                specialType.details.baseClasses.push(strClassType !== null && strClassType !== void 0 ? strClassType : types_1.AnyType.create());
+                (0, typeUtils_1.computeMroLinearization)(specialType);
+            }
             writeTypeCache(node, specialType, 0 /* None */, /* isIncomplete */ false);
             return specialType;
         }
@@ -15375,11 +15390,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // For all remaining source subtypes, attempt to find a dest subtype
             // whose primary type matches.
             if (!isIncompatible) {
-                [...remainingSrcSubtypes].forEach((srcSubtype) => {
-                    const destTypeIndex = remainingDestSubtypes.findIndex((destSubtype) => (0, types_1.isClass)(srcSubtype) &&
-                        (0, types_1.isClass)(destSubtype) &&
-                        types_1.TypeBase.isInstance(srcSubtype) === types_1.TypeBase.isInstance(destSubtype) &&
-                        types_1.ClassType.isSameGenericClass(srcSubtype, destSubtype));
+                (0, typeUtils_1.sortTypes)(remainingSrcSubtypes).forEach((srcSubtype) => {
+                    const destTypeIndex = remainingDestSubtypes.findIndex((destSubtype) => {
+                        if ((0, types_1.isClass)(srcSubtype) &&
+                            (0, types_1.isClass)(destSubtype) &&
+                            types_1.TypeBase.isInstance(srcSubtype) === types_1.TypeBase.isInstance(destSubtype) &&
+                            types_1.ClassType.isSameGenericClass(srcSubtype, destSubtype)) {
+                            return true;
+                        }
+                        if ((0, types_1.isFunction)(srcSubtype) || (0, types_1.isOverloadedFunction)(srcSubtype)) {
+                            if ((0, types_1.isFunction)(destSubtype) || (0, types_1.isOverloadedFunction)(destSubtype)) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    });
                     if (destTypeIndex >= 0) {
                         if (!assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                             isIncompatible = true;
@@ -17023,6 +17048,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         removeFalsinessFromType,
         verifyRaiseExceptionType,
         verifyDeleteExpression,
+        validateOverloadedFunctionArguments,
         isAfterNodeReachable,
         isNodeReachable,
         isAsymmetricDescriptorAssignment,