@zzzen/pyright-internal 1.2.0-dev.20250309 → 1.2.0-dev.20250316

package/dist/analyzer/typeEvaluator.js

@@ -194,7 +194,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let deferredClassCompletions = [];
     let cancellationToken;
     let printExpressionSpaceCount = 0;
-    let incompleteGenerationCount = 0;
+    let incompleteGenCount = 0;
     const returnTypeInferenceContextStack = [];
     let returnTypeInferenceTypeCache;
     const signatureTrackerStack = [];
@@ -255,7 +255,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!cacheEntry) {
             return false;
         }
-        return (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount);
+        return !cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenCount === incompleteGenCount;
     }
     function readTypeCache(node, flags) {
         const cacheEntry = readTypeCacheEntry(node);
@@ -290,22 +290,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             ? returnTypeInferenceTypeCache
             : typeCache;
         if (!typeResult.isIncomplete) {
-            incompleteGenerationCount++;
+            incompleteGenCount++;
         }
         else {
             const oldValue = typeCacheToUse.get(node.id);
             if (oldValue !== undefined && !(0, types_1.isTypeSame)(typeResult.type, oldValue.typeResult.type)) {
-                incompleteGenerationCount++;
+                incompleteGenCount++;
             }
         }
-        typeCacheToUse.set(node.id, { typeResult, flags, incompleteGenerationCount: incompleteGenerationCount });
+        typeCacheToUse.set(node.id, { typeResult, flags, incompleteGenCount });
         // If the entry is located within a part of the parse tree that is currently being
         // "speculatively" evaluated, track it so we delete the cached entry when we leave
         // this speculative context.
         if (isSpeculativeModeInUse(node)) {
             speculativeTypeTracker.trackEntry(typeCacheToUse, node.id);
             if (allowSpeculativeCaching) {
-                speculativeTypeTracker.addSpeculativeType(node, typeResult, incompleteGenerationCount, inferenceContext?.expectedType);
+                speculativeTypeTracker.addSpeculativeType(node, typeResult, incompleteGenCount, inferenceContext?.expectedType);
             }
         }
     }
@@ -531,23 +531,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfExpression(node, flags = 0 /* EvalFlags.None */, inferenceContext) {
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
-        if (cacheEntry &&
-            (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount)) {
-            if (printExpressionTypes) {
-                console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? ' Errors' : ''}`);
+        if (cacheEntry) {
+            if (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenCount === incompleteGenCount) {
+                if (printExpressionTypes) {
+                    console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? ' Errors' : ''}`);
+                }
+                return cacheEntry.typeResult;
             }
-            return cacheEntry.typeResult;
         }
-        else {
-            // Is it cached in the speculative type cache?
-            const cacheEntry = speculativeTypeTracker.getSpeculativeType(node, inferenceContext?.expectedType);
-            if (cacheEntry &&
-                (!cacheEntry.typeResult.isIncomplete ||
-                    cacheEntry.incompleteGenerationCount === incompleteGenerationCount)) {
+        // Is it cached in the speculative type cache?
+        const specCacheEntry = speculativeTypeTracker.getSpeculativeType(node, inferenceContext?.expectedType);
+        if (specCacheEntry) {
+            if (!specCacheEntry.typeResult.isIncomplete ||
+                specCacheEntry.incompleteGenerationCount === incompleteGenCount) {
                 if (printExpressionTypes) {
-                    console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(cacheEntry.typeResult.type)}`);
+                    console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(specCacheEntry.typeResult.type)}`);
                 }
-                return cacheEntry.typeResult;
+                return specCacheEntry.typeResult;
             }
         }
         if (printExpressionTypes) {
@@ -6904,11 +6904,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             case 3 /* TypeCategory.Never */:
             case 1 /* TypeCategory.Unknown */:
             case 2 /* TypeCategory.Any */: {
-                // Touch all of the args so they're marked accessed. Don't bother
-                // doing this if the call type is incomplete because this will need
-                // to be done again once it is complete.
-                touchArgTypes();
-                return { returnType: expandedCallType };
+                // Create a dummy callable that accepts all arguments and validate
+                // that the argument expressions are valid.
+                const dummyFunctionType = types_1.FunctionType.createInstance('', '', '', 0 /* FunctionTypeFlags.None */);
+                types_1.FunctionType.addDefaultParams(dummyFunctionType);
+                const dummyCallResult = validateCallForFunction(errorNode, argList, dummyFunctionType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
+                return { ...dummyCallResult, returnType: expandedCallType };
             }
             case 4 /* TypeCategory.Function */: {
                 return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
@@ -7563,6 +7564,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 let isArgCompatibleWithVariadic = false;
                 const argTypeResult = getTypeOfArg(argList[argIndex], /* inferenceContext */ undefined);
                 let listElementType;
+                let enforceIterable = false;
                 let advanceToNextArg = false;
                 // Handle the case where *args is being passed to a function defined
                 // with a ParamSpec and a Concatenate operator. PEP 612 indicates that
@@ -7622,6 +7624,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     listElementType = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
                     /* isAsync */ false, errorNode, 
                     /* emitNotIterableError */ false)?.type;
+                    if (!listElementType) {
+                        enforceIterable = true;
+                    }
                     if (paramInfo.param.category === 1 /* ParamCategory.ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
@@ -7636,7 +7641,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         argCategory: 0 /* ArgCategory.Simple */,
                         typeResult: { type: listElementType, isIncomplete: argTypeResult.isIncomplete },
                     }
-                    : { ...argList[argIndex] };
+                    : { ...argList[argIndex], enforceIterable };
                 if (argTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
@@ -8761,9 +8766,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 skippedBareTypeVarExpectedType = true;
             }
-            // If the expected type is unknown, don't use an expected type. Instead,
+            // If the expected type is Any, don't use an expected type. Instead,
             // use default rules for evaluating the expression type.
-            if (expectedType && (0, types_1.isUnknown)(expectedType)) {
+            if (expectedType && (0, types_1.isAnyOrUnknown)(expectedType)) {
                 expectedType = undefined;
             }
             // Was the argument's type precomputed by the caller?
@@ -8776,13 +8781,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     : 16 /* EvalFlags.NoFinal */ | 2 /* EvalFlags.NoSpecialize */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!typeResult?.isIncomplete));
                 argType = exprTypeResult.type;
+                // If the argument is unpacked and we are supposed to enforce
+                // that it's an iterator, do so now.
+                if (argParam.argument.argCategory === 1 /* ArgCategory.UnpackedList */ && argParam.argument.enforceIterable) {
+                    const iteratorType = getTypeOfIterator(exprTypeResult, 
+                    /* isAsync */ false, argParam.argument.valueExpression);
+                    // Try to prevent cascading errors if it was not iterable.
+                    argType = iteratorType?.type ?? types_1.UnknownType.create();
+                }
                 if (exprTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
-                if (exprTypeResult.typeErrors) {
-                    isCompatible = false;
-                }
-                else if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
+                if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
                     // Assign the argument type back to the expected type to assign
                     // values to any unification variables.
                     const clonedConstraints = constraints.clone();
@@ -15737,11 +15747,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (declaration.intrinsicType === 'int') {
                         return { type: intType };
                     }
-                    if (declaration.intrinsicType === 'Iterable[str]') {
-                        const iterableType = getBuiltInType(declaration.node, 'Iterable');
-                        if ((0, types_1.isInstantiableClass)(iterableType)) {
+                    if (declaration.intrinsicType === 'MutableSequence[str]') {
+                        const sequenceType = getBuiltInType(declaration.node, 'MutableSequence');
+                        if ((0, types_1.isInstantiableClass)(sequenceType)) {
                             return {
-                                type: types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(iterableType, [strType])),
+                                type: types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(sequenceType, [strType])),
                             };
                         }
                     }
@@ -16014,18 +16024,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             if (loaderActions.implicitImports) {
                 loaderActions.implicitImports.forEach((implicitImport, name) => {
+                    const existingLoaderField = moduleType.priv.loaderFields.get(name);
                     // Recursively apply loader actions.
                     let symbolType;
                     if (implicitImport.isUnresolved) {
                         symbolType = types_1.UnknownType.create();
                     }
                     else {
-                        const moduleName = moduleType.priv.moduleName ? moduleType.priv.moduleName + '.' + name : '';
-                        const importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.uri);
+                        let importedModuleType;
+                        const existingType = existingLoaderField?.getSynthesizedType();
+                        if (existingType?.type && (0, types_1.isModule)(existingType.type)) {
+                            importedModuleType = existingType.type;
+                        }
+                        else {
+                            const moduleName = moduleType.priv.moduleName
+                                ? moduleType.priv.moduleName + '.' + name
+                                : '';
+                            importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.uri);
+                        }
                         symbolType = applyLoaderActionsToModuleType(importedModuleType, implicitImport, importLookup);
                     }
-                    const importedModuleSymbol = symbol_1.Symbol.createWithType(0 /* SymbolFlags.None */, symbolType);
-                    moduleType.priv.loaderFields.set(name, importedModuleSymbol);
+                    if (!existingLoaderField) {
+                        const importedModuleSymbol = symbol_1.Symbol.createWithType(0 /* SymbolFlags.None */, symbolType);
+                        moduleType.priv.loaderFields.set(name, importedModuleSymbol);
+                    }
                 });
             }
             return moduleType;
@@ -16034,15 +16056,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // is pointing at a module, and we need to synthesize a
         // module type.
         if (resolvedDecl.type === 8 /* DeclarationType.Alias */) {
-            // Build a module type that corresponds to the declaration and
-            // its associated loader actions.
-            const moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.uri);
-            if (resolvedDecl.symbolName && resolvedDecl.submoduleFallback) {
-                return applyLoaderActionsToModuleType(moduleType, resolvedDecl.submoduleFallback, importLookup);
+            let moduleType;
+            // See if this is an import that shares a ModuleType with another
+            // import statement. If so, used the cached type. This happens when
+            // multiple import statements start with the same module name, such
+            // as "import a.b" and "import a.c".
+            if (resolvedDecl.node.nodeType === 24 /* ParseNodeType.ImportAs */) {
+                const cachedType = readTypeCache(resolvedDecl.node.d.module, 0 /* EvalFlags.None */);
+                if (cachedType && (0, types_1.isModule)(cachedType)) {
+                    moduleType = cachedType;
+                }
             }
-            else {
-                return applyLoaderActionsToModuleType(moduleType, resolvedDecl, importLookup);
+            if (!moduleType) {
+                // Build a module type that corresponds to the declaration and
+                // its associated loader actions.
+                moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.uri);
+                if (resolvedDecl.node.nodeType === 24 /* ParseNodeType.ImportAs */) {
+                    writeTypeCache(resolvedDecl.node.d.module, { type: moduleType }, 0 /* EvalFlags.None */);
+                }
             }
+            return applyLoaderActionsToModuleType(moduleType, resolvedDecl.symbolName && resolvedDecl.submoduleFallback
+                ? resolvedDecl.submoduleFallback
+                : resolvedDecl, importLookup);
         }
         const declaredType = getTypeForDeclaration(resolvedDecl);
         if (declaredType.type) {
@@ -19332,12 +19367,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // with the declared type. In strict mode, this will retain the "unknown type"
         // diagnostics while still providing reasonable completion suggestions.
         if ((0, typeUtils_1.isIncompleteUnknown)(narrowedType)) {
-            return { type: narrowedType };
+            return { type: narrowedType, isIncomplete: assignedTypeResult.isIncomplete };
         }
         else if ((0, types_1.isUnknown)(narrowedType)) {
-            return { type: (0, types_1.combineTypes)([narrowedType, declaredType]) };
+            return { type: (0, types_1.combineTypes)([narrowedType, declaredType]), isIncomplete: assignedTypeResult.isIncomplete };
         }
-        return { type: narrowedType };
+        return { type: narrowedType, isIncomplete: assignedTypeResult.isIncomplete };
     }
     function validateOverrideMethod(baseMethod, overrideMethod, baseClass, diag, enforceParamNames = true) {
         // If we're overriding a non-method with a method, report it as an error.