@zzzen/pyright-internal 1.2.0-dev.20221127 → 1.2.0-dev.20221211

package/dist/analyzer/typeEvaluator.js

@@ -196,12 +196,21 @@ const maxEntriesToUseForInference = 64;
 // when inferring its type? We need to cut it off at some point
 // to avoid excessive computation.
 const maxDeclarationsToUseForInference = 64;
+// Maximum number of times to attempt effective type evaluation
+// of a variable that has no type declaration.
+const maxEffectiveTypeEvaluationAttempts = 16;
 // Maximum number of combinatoric union type expansions allowed
 // when resolving an overload.
 const maxOverloadUnionExpansionCount = 64;
 // Maximum number of recursive function return type inference attempts
 // that can be concurrently pending before we give up.
 const maxInferFunctionReturnRecursionCount = 12;
+// Maximum recursion amount when comparing two recursive type aliases.
+// Increasing this can greatly increase the time required to evaluate
+// two recursive type aliases that have the same definition. Decreasing
+// it can increase the chance of false negatives for such recursive
+// type aliases.
+const maxRecursiveTypeAliasRecursionCount = 10;
 // This switch enables a special debug mode that attempts to catch
 // bugs due to inconsistent evaluation flags used when reading types
 // from the type cache.
@@ -694,7 +703,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (flags & 65536 /* DisallowRecursiveTypeAliasPlaceholder */) {
-            if ((0, typeUtils_1.isTypeAliasPlaceholder)(typeResult.type)) {
+            if ((0, types_1.isTypeVar)(typeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(typeResult.type)) {
                 typeResult.type.details.illegalRecursionDetected = true;
             }
         }
@@ -1977,6 +1986,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (diagLevel === 'none') {
             return undefined;
         }
+        // Should we suppress this diagnostic because it's within an unannotated function?
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        if (!fileInfo.diagnosticRuleSet.analyzeUnannotatedFunctions) {
+            const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
+            // Is the target node within the body of the function? If so, suppress the diagnostic.
+            if (containingFunction &&
+                ParseTreeUtils.isUnannotatedFunction(containingFunction) &&
+                ParseTreeUtils.isNodeContainedWithin(node, containingFunction.suite)) {
+                return undefined;
+            }
+        }
         const diagnostic = addDiagnosticWithSuppressionCheck(diagLevel, message, node, range);
         if (diagnostic) {
             diagnostic.setRule(rule);
@@ -2749,15 +2769,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let type;
         let isIncomplete = false;
         const allowForwardReferences = (flags & 4 /* AllowForwardReferences */) !== 0 || fileInfo.isStubFile;
-        if (!evaluatorOptions.analyzeUnannotatedFunctions) {
-            const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
-            if (containingFunction && ParseTreeUtils.isUnannotatedFunction(containingFunction)) {
-                return {
-                    type: types_1.AnyType.create(),
-                    isIncomplete: false,
-                };
-            }
-        }
         // Does this name refer to a PEP 695-style type parameter?
         const typeParamSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(node);
         if (typeParamSymbol) {
@@ -2786,6 +2797,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     useCodeFlowAnalysis = false;
                 }
                 symbol = symbolWithScope.symbol;
+                setSymbolAccessed(fileInfo, symbol, node);
+                // If we're not supposed to be analyzing this function, skip the remaining work
+                // to determine the name's type. Simply evaluate its type as Any.
+                if (!fileInfo.diagnosticRuleSet.analyzeUnannotatedFunctions) {
+                    const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
+                    if (containingFunction && ParseTreeUtils.isUnannotatedFunction(containingFunction)) {
+                        return {
+                            type: types_1.AnyType.create(),
+                            isIncomplete: false,
+                        };
+                    }
+                }
                 // Get the effective type (either the declared type or the inferred type).
                 // If we're using code flow analysis, pass the usage node so we consider
                 // only the assignment nodes that are reachable from this usage.
@@ -2842,7 +2865,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // Detect, report, and fill in missing type arguments if appropriate.
                 type = reportMissingTypeArguments(node, type, flags);
-                setSymbolAccessed(fileInfo, symbol, node);
                 if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
                     // Verify that the name does not refer to a (non type alias) variable.
                     if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
@@ -4399,7 +4421,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (typeAliasResult) {
             return typeAliasResult;
         }
-        if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
+        if ((0, types_1.isTypeVar)(baseTypeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
             const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
             return { type };
@@ -5784,7 +5806,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
-        if (!validatedTypes && argList.length > 0) {
+        if (!validatedTypes && argList.some((arg) => arg.argumentCategory === 0 /* Simple */)) {
             // Suppress this error if the class was instantiated from a custom
             // metaclass because it's likely that it's a false positive. Also
             // suppress the error if the class's metaclass has a __call__ method.
@@ -6971,9 +6993,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 ((0, types_1.isClassInstance)(argType) &&
                                     (0, typeUtils_1.isTupleClass)(argType) &&
                                     argType.tupleTypeArguments &&
-                                    argType.tupleTypeArguments.some((arg) => (0, types_1.isUnpackedVariadicTypeVar)(arg.type)));
+                                    argType.tupleTypeArguments.length === 1 &&
+                                    (0, types_1.isUnpackedVariadicTypeVar)(argType.tupleTypeArguments[0].type));
                             if (containsVariadicTypeVar &&
-                                argParam.argument.argumentCategory !== 1 /* UnpackedList */) {
+                                argParam.argument.argumentCategory !== 1 /* UnpackedList */ &&
+                                !argParam.mapsToVarArgList) {
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
                                 reportedArgError = true;
                             }
@@ -8740,13 +8764,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let effectiveExpectedType = expectedType;
         if (expectedType && (0, types_1.isUnion)(expectedType)) {
             let matchingSubtype;
+            let matchingSubtypeResult;
             (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
-                if (!matchingSubtype) {
-                    const subtypeResult = useSpeculativeMode(node, () => {
-                        return getTypeOfDictionaryExpected(node, subtype);
-                    });
-                    if (subtypeResult && assignType(subtype, subtypeResult.type)) {
+                // Use shortcut if we've already found a match.
+                if (matchingSubtypeResult && !matchingSubtypeResult.typeErrors) {
+                    return;
+                }
+                const subtypeResult = useSpeculativeMode(node, () => {
+                    return getTypeOfDictionaryExpected(node, subtype);
+                });
+                if (subtypeResult && assignType(subtype, subtypeResult.type)) {
+                    // If this is the first result we're seeing or it's the first result
+                    // without errors, select it as the match.
+                    if (!matchingSubtypeResult || (matchingSubtypeResult.typeErrors && !subtypeResult.typeErrors)) {
                         matchingSubtype = subtype;
+                        matchingSubtypeResult = subtypeResult;
                     }
                 }
             });
@@ -9008,13 +9040,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let effectiveExpectedType = expectedType;
         if (expectedType && (0, types_1.isUnion)(expectedType)) {
             let matchingSubtype;
+            let matchingSubtypeResult;
             (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
-                if (!matchingSubtype) {
-                    const subtypeResult = useSpeculativeMode(node, () => {
-                        return getTypeOfListOrSetExpected(node, subtype);
-                    });
-                    if (subtypeResult && assignType(subtype, subtypeResult.type)) {
+                // Use shortcut if we've already found a match.
+                if (matchingSubtypeResult && !matchingSubtypeResult.typeErrors) {
+                    return;
+                }
+                const subtypeResult = useSpeculativeMode(node, () => {
+                    return getTypeOfListOrSetExpected(node, subtype);
+                });
+                if (subtypeResult && assignType(subtype, subtypeResult.type)) {
+                    // If this is the first result we're seeing or it's the first result
+                    // without errors, select it as the match.
+                    if (!matchingSubtypeResult || (matchingSubtypeResult.typeErrors && !subtypeResult.typeErrors)) {
                         matchingSubtype = subtype;
+                        matchingSubtypeResult = subtypeResult;
                     }
                 }
             });
@@ -9102,8 +9142,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 entryTypeResult = getElementTypeFromListComprehension(entry);
             }
             else {
-                entryTypeResult = getTypeOfExpression(entry, 
-                /* flags */ undefined, hasExpectedType ? types_1.NeverType.createNever() : undefined);
+                entryTypeResult = getTypeOfExpression(entry);
             }
             if (entryTypeResult.isIncomplete) {
                 isIncomplete = true;
@@ -11097,7 +11136,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (dataClassBehaviors) {
             (0, dataClasses_1.applyDataClassDefaultBehaviors)(classType, dataClassBehaviors);
-            (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, node.name, classType, initSubclassArgs);
+            (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, node.name, classType, initSubclassArgs, dataClassBehaviors);
         }
         // Run any class hooks that depend on this class.
         runClassTypeHooks(classType);
@@ -14415,6 +14454,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getEffectiveTypeOfSymbolForUsage(symbol).type;
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
+        var _a;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
             const declaredType = getDeclaredTypeOfSymbol(symbol, usageNode);
@@ -14438,12 +14478,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Look in the cache to see if we've computed this already.
         let cacheEntries = effectiveTypeCache.get(symbol.id);
+        let evaluationAttempts = 0;
         const usageNodeId = usageNode ? usageNode.id : undefined;
         const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
         if (cacheEntries) {
             const result = cacheEntries.get(effectiveTypeCacheKey);
             if (result) {
-                return result;
+                if (!result.isIncomplete) {
+                    return result;
+                }
+                evaluationAttempts = ((_a = result.evaluationAttempts) !== null && _a !== void 0 ? _a : 0) + 1;
             }
         }
         // Infer the type.
@@ -14571,8 +14615,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     isIncomplete = true;
                     // Note that at least one decl could not be evaluated because
-                    // it was already in the process of being evaluated.
-                    sawPendingEvaluation = true;
+                    // it was already in the process of being evaluated. Don't set
+                    // this flag if we've already attempted the type evaluation
+                    // many times because this probably means there's a cyclical
+                    // dependency that cannot be broken.
+                    if (evaluationAttempts < maxEffectiveTypeEvaluationAttempts) {
+                        sawPendingEvaluation = true;
+                    }
                 }
             }
         });
@@ -14583,6 +14632,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 includesVariableDecl,
                 includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
                 isRecursiveDefinition: false,
+                evaluationAttempts,
             };
             if (!includesSpeculativeResult) {
                 // Add the entry to the cache so we don't need to compute it next time.
@@ -14600,6 +14650,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             includesVariableDecl,
             includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
             isRecursiveDefinition: false,
+            evaluationAttempts,
         };
     }
     function getDeclaredTypeOfSymbol(symbol, usageNode) {
@@ -14702,6 +14753,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a;
         let returnType;
         let isIncomplete = false;
+        let analyzeUnannotatedFunctions = true;
         // Don't attempt to infer the return type for a stub file.
         if (types_1.FunctionType.isStubDefinition(type)) {
             return types_1.UnknownType.create();
@@ -14719,8 +14771,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if (type.details.declaration) {
                 const functionNode = type.details.declaration.node;
+                analyzeUnannotatedFunctions =
+                    AnalyzerNodeInfo.getFileInfo(functionNode).diagnosticRuleSet.analyzeUnannotatedFunctions;
                 // Skip return type inference if we are in "skip unannotated function" mode.
-                if (evaluatorOptions.analyzeUnannotatedFunctions && !checkCodeFlowTooComplex(functionNode.suite)) {
+                if (analyzeUnannotatedFunctions && !checkCodeFlowTooComplex(functionNode.suite)) {
                     const codeFlowComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(functionNode);
                     // For very complex functions that have no annotated parameter types,
                     // don't attempt to infer the return type because it can be extremely
@@ -14757,7 +14811,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // params, try to analyze the function with the provided argument types and
         // attempt to do a better job at inference.
         if (!isIncomplete &&
-            evaluatorOptions.analyzeUnannotatedFunctions &&
+            analyzeUnannotatedFunctions &&
             (0, typeUtils_1.isPartlyUnknown)(returnType) &&
             types_1.FunctionType.hasUnannotatedParams(type) &&
             !types_1.FunctionType.isStubDefinition(type) &&
@@ -15391,8 +15445,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Transform recursive type aliases if necessary.
-        destType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(destType);
-        srcType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(srcType);
+        const transformedDestType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(destType);
+        const transformedSrcType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(srcType);
+        // Did both the source and dest include recursive type aliases?
+        // If so, we are potentially dealing with different recursive type
+        // aliases that are defined in the same way.
+        if (transformedDestType !== destType &&
+            transformedSrcType !== srcType &&
+            (0, types_1.isUnion)(transformedDestType) &&
+            (0, types_1.isUnion)(transformedSrcType)) {
+            // Use a smaller recursive limit in this case to prevent runaway recursion.
+            if (recursionCount > maxRecursiveTypeAliasRecursionCount) {
+                return true;
+            }
+        }
+        destType = transformedDestType;
+        srcType = transformedSrcType;
         // If the source or dest is unbound, allow the assignment. The
         // error will be reported elsewhere.
         if ((0, types_1.isUnbound)(destType) || (0, types_1.isUnbound)(srcType)) {
@@ -15603,6 +15671,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isClassInstance)(expandedSrcType) && types_1.ClassType.isBuiltIn(expandedSrcType, 'type')) {
             const srcTypeArgs = expandedSrcType.typeArguments;
             let typeTypeArg;
+            let instantiableType;
             if (srcTypeArgs && srcTypeArgs.length >= 1) {
                 typeTypeArg = srcTypeArgs[0];
                 if ((0, types_1.isAnyOrUnknown)(typeTypeArg)) {
@@ -15611,19 +15680,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     return types_1.TypeBase.isInstantiable(destType);
                 }
+                instantiableType = (0, typeUtils_1.convertToInstantiable)(typeTypeArg);
             }
-            else {
+            else if (types_1.TypeBase.isInstantiable(destType)) {
                 typeTypeArg = objectType !== null && objectType !== void 0 ? objectType : types_1.AnyType.create();
+                instantiableType = expandedSrcType;
             }
-            if ((0, types_1.isClassInstance)(typeTypeArg) || (0, types_1.isTypeVar)(typeTypeArg)) {
-                if (assignType(destType, (0, typeUtils_1.convertToInstantiable)(typeTypeArg), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                    return true;
+            if (instantiableType && typeTypeArg) {
+                if ((0, types_1.isClassInstance)(typeTypeArg) || (0, types_1.isTypeVar)(typeTypeArg)) {
+                    if (assignType(destType, instantiableType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                        return true;
+                    }
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
+                        sourceType: printType(srcType),
+                        destType: printType(destType),
+                    }));
+                    return false;
                 }
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
-                    sourceType: printType(srcType),
-                    destType: printType(destType),
-                }));
-                return false;
             }
         }
         if ((0, types_1.isInstantiableClass)(destType)) {
@@ -16086,7 +16159,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // in case the destType is a union with hundreds of literals.
                 if ((0, types_1.isClassInstance)(srcType) &&
                     (0, typeUtils_1.isLiteralType)(srcType) &&
-                    types_1.UnionType.containsType(destType, srcType, recursionCount)) {
+                    types_1.UnionType.containsType(destType, srcType, /* exclusionSet */ undefined, recursionCount)) {
                     return true;
                 }
                 (0, typeUtils_1.doForEachSubtype)(destType, (subtype) => {
@@ -16792,6 +16865,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             name: p.name,
                             isNameSynthesized: p.isNameSynthesized,
                             hasDefault: !!p.hasDefault,
+                            defaultValueExpression: p.defaultValueExpression,
                             type: types_1.FunctionType.getEffectiveParameterType(effectiveSrcType, index),
                         });
                     }
@@ -17230,7 +17304,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isAnyOrUnknown)(srcType)) {
             return srcType;
         }
-        let effectiveSrcType = srcType;
+        let effectiveSrcType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(srcType);
         if ((0, types_1.isTypeVar)(srcType)) {
             if ((0, types_1.isTypeSame)(srcType, destType)) {
                 return srcType;
@@ -17244,7 +17318,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return srcType;
         }
         // If there's a bound type, make sure the source is derived from it.
-        if (destType.details.boundType) {
+        if (destType.details.boundType && !(0, typeUtils_1.isTypeAliasPlaceholder)(effectiveSrcType)) {
             if (!assignType(destType.details.boundType, effectiveSrcType, diag.createAddendum(), 
             /* destTypeVarContext */ undefined, 
             /* srcTypeVarContext */ undefined)) {
@@ -17285,6 +17359,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (constraints.length === 0) {
             return srcType;
         }
+        if ((0, typeUtils_1.isTypeAliasPlaceholder)(srcType)) {
+            return srcType;
+        }
         if ((0, types_1.isTypeVar)(srcType) && srcType.details.constraints.length > 0) {
             // Make sure all the source constraint types map to constraint types in the dest.
             if (srcType.details.constraints.every((sourceConstraint) => {