@zzzen/pyright-internal 1.2.0-dev.20240421 → 1.2.0-dev.20240505

package/dist/analyzer/typeEvaluator.js

@@ -1685,7 +1685,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // where the type isn't declared in this class but is in
                     // a parent class.
                     if (!((_a = getDeclaredTypeOfSymbol(symbol, expression)) === null || _a === void 0 ? void 0 : _a.type) &&
-                        symbolWithScope.scope.type === 2 /* ScopeType.Class */) {
+                        symbolWithScope.scope.type === 3 /* ScopeType.Class */) {
                         const enclosingClass = ParseTreeUtils.getEnclosingClassOrFunction(expression);
                         if (enclosingClass && enclosingClass.nodeType === 10 /* ParseNodeType.Class */) {
                             const classTypeInfo = getTypeOfClass(enclosingClass);
@@ -2203,7 +2203,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(nameNode);
         // If this is a class scope and there is no type declared for this class variable,
         // see if a parent class has a type declared.
-        if (declaredType === undefined && symbolWithScope.scope.type === 2 /* ScopeType.Class */) {
+        if (declaredType === undefined && symbolWithScope.scope.type === 3 /* ScopeType.Class */) {
             const containingClass = ParseTreeUtils.getEnclosingClass(nameNode);
             if (containingClass) {
                 const classType = getTypeOfClass(containingClass);
@@ -2244,7 +2244,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // variable that can be overridden by a child class, use the more general
             // version by stripping off the literal.
             const scope = ScopeUtils.getScopeForNode(nameNode);
-            if ((scope === null || scope === void 0 ? void 0 : scope.type) === 2 /* ScopeType.Class */) {
+            if ((scope === null || scope === void 0 ? void 0 : scope.type) === 3 /* ScopeType.Class */) {
                 if (types_1.TypeBase.isInstance(destType) &&
                     !(0, symbolNameUtils_1.isConstantName)(nameValue) &&
                     !isFinalVariable(symbolWithScope.symbol)) {
@@ -2945,143 +2945,131 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let type;
         let isIncomplete = false;
         const allowForwardReferences = (flags & 4 /* EvaluatorFlags.AllowForwardReferences */) !== 0 || fileInfo.isStubFile;
-        // Does this name refer to a PEP 695-style type parameter?
-        const typeParamSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(node);
-        if (typeParamSymbol) {
-            symbol = typeParamSymbol;
-            (0, debug_1.assert)(symbol.getDeclarations().length === 1);
-            const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(symbol);
-            (0, debug_1.assert)((decl === null || decl === void 0 ? void 0 : decl.type) === 3 /* DeclarationType.TypeParameter */);
-            type = getTypeOfTypeParameter(decl.node);
+        // Look for the scope that contains the value definition and
+        // see if it has a declared type.
+        let symbolWithScope = lookUpSymbolRecursive(node, name, !allowForwardReferences, allowForwardReferences && (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0);
+        if (!symbolWithScope) {
+            // If the node is part of a "from X import Y as Z" statement and the node
+            // is the "Y" (non-aliased) name, we need to look up the alias symbol
+            // since the non-aliased name is not in the symbol table.
+            const alias = getAliasFromImport(node);
+            if (alias) {
+                symbolWithScope = lookUpSymbolRecursive(alias, alias.value, !allowForwardReferences, allowForwardReferences && (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0);
+            }
+        }
+        if (symbolWithScope) {
+            let useCodeFlowAnalysis = !allowForwardReferences;
+            // If the symbol is implicitly imported from the builtin
+            // scope, there's no need to use code flow analysis.
+            if (symbolWithScope.scope.type === 5 /* ScopeType.Builtin */) {
+                useCodeFlowAnalysis = false;
+            }
+            symbol = symbolWithScope.symbol;
             setSymbolAccessed(fileInfo, symbol, node);
-        }
-        else {
-            // Look for the scope that contains the value definition and
-            // see if it has a declared type.
-            let symbolWithScope = lookUpSymbolRecursive(node, name, !allowForwardReferences, allowForwardReferences && (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0);
-            if (!symbolWithScope) {
-                // If the node is part of a "from X import Y as Z" statement and the node
-                // is the "Y" (non-aliased) name, we need to look up the alias symbol
-                // since the non-aliased name is not in the symbol table.
-                const alias = getAliasFromImport(node);
-                if (alias) {
-                    symbolWithScope = lookUpSymbolRecursive(alias, alias.value, !allowForwardReferences, allowForwardReferences && (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0);
+            // 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,
+                    };
                 }
             }
-            if (symbolWithScope) {
-                let useCodeFlowAnalysis = !allowForwardReferences;
-                // If the symbol is implicitly imported from the builtin
-                // scope, there's no need to use code flow analysis.
-                if (symbolWithScope.scope.type === 4 /* ScopeType.Builtin */) {
-                    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.
-                const effectiveTypeInfo = getEffectiveTypeOfSymbolForUsage(symbol, useCodeFlowAnalysis ? node : undefined);
-                let effectiveType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(effectiveTypeInfo.type);
-                if (effectiveTypeInfo.isIncomplete) {
-                    if ((0, types_1.isUnbound)(effectiveType)) {
-                        effectiveType = types_1.UnknownType.create(/* isIncomplete */ true);
-                    }
-                    isIncomplete = true;
+            // 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.
+            const effectiveTypeInfo = getEffectiveTypeOfSymbolForUsage(symbol, useCodeFlowAnalysis ? node : undefined);
+            let effectiveType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(effectiveTypeInfo.type);
+            if (effectiveTypeInfo.isIncomplete) {
+                if ((0, types_1.isUnbound)(effectiveType)) {
+                    effectiveType = types_1.UnknownType.create(/* isIncomplete */ true);
                 }
-                if (effectiveTypeInfo.isRecursiveDefinition && isNodeReachable(node)) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.recursiveDefinition().format({ name }), node);
-                }
-                const isSpecialBuiltIn = !!effectiveType && (0, types_1.isInstantiableClass)(effectiveType) && types_1.ClassType.isSpecialBuiltIn(effectiveType);
-                type = effectiveType;
-                if (useCodeFlowAnalysis && !isSpecialBuiltIn) {
-                    // See if code flow analysis can tell us anything more about the type.
-                    // If the symbol is declared outside of our execution scope, use its effective
-                    // type. If it's declared inside our execution scope, it generally starts
-                    // as unbound at the start of the code flow.
-                    let typeAtStart = effectiveType;
-                    let isTypeAtStartIncomplete = false;
-                    if (!symbolWithScope.isBeyondExecutionScope && symbol.isInitiallyUnbound()) {
-                        typeAtStart = types_1.UnboundType.create();
-                        // Is this a module-level scope? If so, see if it's an alias of a builtin.
-                        if (symbolWithScope.scope.type === 3 /* ScopeType.Module */) {
-                            (0, debug_1.assert)(symbolWithScope.scope.parent);
-                            const builtInSymbol = symbolWithScope.scope.parent.lookUpSymbol(name);
-                            if (builtInSymbol) {
-                                const builtInEffectiveType = getEffectiveTypeOfSymbolForUsage(builtInSymbol);
-                                typeAtStart = builtInEffectiveType.type;
-                            }
-                        }
-                    }
-                    if (symbolWithScope.isBeyondExecutionScope) {
-                        const outerScopeTypeResult = getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType);
-                        if (outerScopeTypeResult === null || outerScopeTypeResult === void 0 ? void 0 : outerScopeTypeResult.type) {
-                            type = outerScopeTypeResult.type;
-                            typeAtStart = type;
-                            isTypeAtStartIncomplete = !!outerScopeTypeResult.isIncomplete;
+                isIncomplete = true;
+            }
+            if (effectiveTypeInfo.isRecursiveDefinition && isNodeReachable(node)) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.recursiveDefinition().format({ name }), node);
+            }
+            const isSpecialBuiltIn = !!effectiveType && (0, types_1.isInstantiableClass)(effectiveType) && types_1.ClassType.isSpecialBuiltIn(effectiveType);
+            type = effectiveType;
+            if (useCodeFlowAnalysis && !isSpecialBuiltIn) {
+                // See if code flow analysis can tell us anything more about the type.
+                // If the symbol is declared outside of our execution scope, use its effective
+                // type. If it's declared inside our execution scope, it generally starts
+                // as unbound at the start of the code flow.
+                let typeAtStart = effectiveType;
+                let isTypeAtStartIncomplete = false;
+                if (!symbolWithScope.isBeyondExecutionScope && symbol.isInitiallyUnbound()) {
+                    typeAtStart = types_1.UnboundType.create();
+                    // Is this a module-level scope? If so, see if it's an alias of a builtin.
+                    if (symbolWithScope.scope.type === 4 /* ScopeType.Module */) {
+                        (0, debug_1.assert)(symbolWithScope.scope.parent);
+                        const builtInSymbol = symbolWithScope.scope.parent.lookUpSymbol(name);
+                        if (builtInSymbol) {
+                            const builtInEffectiveType = getEffectiveTypeOfSymbolForUsage(builtInSymbol);
+                            typeAtStart = builtInEffectiveType.type;
                         }
                     }
-                    const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
-                        targetSymbolId: symbol.id,
-                        typeAtStart: { type: typeAtStart, isIncomplete: isTypeAtStartIncomplete },
-                        skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
-                    });
-                    if (codeFlowTypeResult.type) {
-                        type = codeFlowTypeResult.type;
-                    }
-                    if (codeFlowTypeResult.isIncomplete) {
-                        isIncomplete = true;
+                }
+                if (symbolWithScope.isBeyondExecutionScope) {
+                    const outerScopeTypeResult = getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType);
+                    if (outerScopeTypeResult === null || outerScopeTypeResult === void 0 ? void 0 : outerScopeTypeResult.type) {
+                        type = outerScopeTypeResult.type;
+                        typeAtStart = type;
+                        isTypeAtStartIncomplete = !!outerScopeTypeResult.isIncomplete;
                     }
                 }
-                // Detect, report, and fill in missing type arguments if appropriate.
-                type = reportMissingTypeArguments(node, type, flags);
-                if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-                    // Verify that the name does not refer to a (non type alias) variable.
-                    if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
-                        let isAllowedTypeForVariable = (0, types_1.isTypeVar)(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type);
-                        if ((0, types_1.isClass)(type) &&
-                            !type.includeSubclasses &&
-                            !symbol.hasTypedDeclarations() &&
-                            types_1.ClassType.isValidTypeAliasClass(type)) {
-                            // This check exempts class types that are created by calling
-                            // NewType, NamedTuple, etc.
-                            isAllowedTypeForVariable = true;
-                        }
-                        // Disable for assignments in the typings.pyi file, since it defines special forms.
-                        if (!isAllowedTypeForVariable && !fileInfo.isTypingStubFile) {
-                            // This might be a union that was previously a type alias
-                            // but was reconstituted in such a way that we lost the
-                            // typeAliasInfo. Avoid the false positive error by suppressing
-                            // the error when it looks like a plausible type alias type.
-                            if (effectiveTypeInfo.includesIllegalTypeAliasDecl ||
-                                !types_1.TypeBase.isInstantiable(type) ||
-                                (flags & 2 /* EvaluatorFlags.DoNotSpecialize */) !== 0) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationVariable(), node);
-                                type = types_1.UnknownType.create();
-                            }
+                const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
+                    targetSymbolId: symbol.id,
+                    typeAtStart: { type: typeAtStart, isIncomplete: isTypeAtStartIncomplete },
+                    skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
+                });
+                if (codeFlowTypeResult.type) {
+                    type = codeFlowTypeResult.type;
+                }
+                if (codeFlowTypeResult.isIncomplete) {
+                    isIncomplete = true;
+                }
+            }
+            // Detect, report, and fill in missing type arguments if appropriate.
+            type = reportMissingTypeArguments(node, type, flags);
+            if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+                // Verify that the name does not refer to a (non type alias) variable.
+                if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
+                    let isAllowedTypeForVariable = (0, types_1.isTypeVar)(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type);
+                    if ((0, types_1.isClass)(type) &&
+                        !type.includeSubclasses &&
+                        !symbol.hasTypedDeclarations() &&
+                        types_1.ClassType.isValidTypeAliasClass(type)) {
+                        // This check exempts class types that are created by calling
+                        // NewType, NamedTuple, etc.
+                        isAllowedTypeForVariable = true;
+                    }
+                    // Disable for assignments in the typings.pyi file, since it defines special forms.
+                    if (!isAllowedTypeForVariable && !fileInfo.isTypingStubFile) {
+                        // This might be a union that was previously a type alias
+                        // but was reconstituted in such a way that we lost the
+                        // typeAliasInfo. Avoid the false positive error by suppressing
+                        // the error when it looks like a plausible type alias type.
+                        if (effectiveTypeInfo.includesIllegalTypeAliasDecl ||
+                            !types_1.TypeBase.isInstantiable(type) ||
+                            (flags & 2 /* EvaluatorFlags.DoNotSpecialize */) !== 0) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationVariable(), node);
+                            type = types_1.UnknownType.create();
                         }
                     }
                 }
             }
+        }
+        else {
+            // Handle the special case of "reveal_type" and "reveal_locals".
+            if (name === 'reveal_type' || name === 'reveal_locals') {
+                type = types_1.AnyType.create();
+            }
             else {
-                // Handle the special case of "reveal_type" and "reveal_locals".
-                if (name === 'reveal_type' || name === 'reveal_locals') {
-                    type = types_1.AnyType.create();
-                }
-                else {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUndefinedVariable, localize_1.LocMessage.symbolIsUndefined().format({ name }), node);
-                    type = types_1.UnknownType.create();
-                }
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUndefinedVariable, localize_1.LocMessage.symbolIsUndefined().format({ name }), node);
+                type = types_1.UnknownType.create();
             }
         }
         if ((0, types_1.isParamSpec)(type)) {
@@ -3145,6 +3133,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             ScopeUtils.getScopeForNode(decl.node) === symbolWithScope.scope)) {
             return undefined;
         }
+        // If the symbol is a non-final variable in the global scope, it is not
+        // eligible because it could be modified by other modules.
+        if (!decls.every((decl) => {
+            var _a;
+            return decl.type !== 1 /* DeclarationType.Variable */ ||
+                decl.isFinal ||
+                ((_a = ScopeUtils.getScopeForNode(decl.node)) === null || _a === void 0 ? void 0 : _a.type) !== 4 /* ScopeType.Module */;
+        })) {
+            return undefined;
+        }
         // If the symbol is a variable captured by an inner function
         // or lambda, see if we can infer the type from the outer scope.
         const scopeHierarchy = ScopeUtils.getScopeHierarchy(node, symbolWithScope.scope);
@@ -5852,7 +5850,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             scope = ScopeUtils.getScopeForNode(curNode);
             // Stop when we get a valid scope that's not a list comprehension
             // scope. That includes lambdas, functions, classes, and modules.
-            if (scope && scope.type !== 0 /* ScopeType.ListComprehension */) {
+            if (scope && scope.type !== 1 /* ScopeType.ListComprehension */) {
                 break;
             }
             curNode = curNode.parent;
@@ -8146,7 +8144,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Calculate the return type.
-        let returnType = getFunctionEffectiveReturnType(type, matchResults.argParams);
+        let returnType = getFunctionEffectiveReturnType(type, { args: matchResults.argParams, errorNode });
         if (condition.length > 0) {
             returnType = types_1.TypeBase.cloneForCondition(returnType, condition);
         }
@@ -9202,8 +9200,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!(0, types_1.isClassInstance)(arg1Type) || !(0, typeUtils_1.isTupleClass)(arg1Type) || arg1Type.tupleTypeArguments === undefined) {
             return undefined;
         }
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
-        /* declaredMetaclass */ undefined, arg1Type.details.effectiveMetaclass);
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), metaclass, arg1Type.details.effectiveMetaclass);
         arg1Type.tupleTypeArguments.forEach((typeArg) => {
             const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
             if ((0, typeUtils_1.isEffectivelyInstantiable)(specializedType)) {
@@ -9362,6 +9359,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const keyTypes = [];
         const valueTypes = [];
         let isIncomplete = false;
+        let typeErrors = false;
         // Handle TypedDict's as a special case.
         if (types_1.ClassType.isTypedDictClass(concreteExpectedType)) {
             // Remove any conditions associated with the type so the resulting type isn't
@@ -9369,13 +9367,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             concreteExpectedType = types_1.TypeBase.cloneForCondition(concreteExpectedType, undefined);
             const expectedTypedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, concreteExpectedType);
             // Infer the key and value types if possible.
-            if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
+            const keyValueTypeResult = getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
             /* forceStrictInference */ true, 
             /* isValueTypeInvariant */ true, 
             /* expectedKeyType */ undefined, 
-            /* expectedValueType */ undefined, expectedTypedDictEntries, expectedDiagAddendum)) {
+            /* expectedValueType */ undefined, expectedTypedDictEntries, expectedDiagAddendum);
+            if (keyValueTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (keyValueTypeResult.typeErrors) {
+                typeErrors = true;
+            }
             const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, concreteExpectedType, keyTypes, valueTypes, 
             // Don't overwrite existing expectedDiagAddendum messages if they were
             // already provided by getKeyValueTypesFromDictionary.
@@ -9423,10 +9425,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Infer the key and value types if possible.
-        if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
-        /* forceStrictInference */ true, isValueTypeInvariant, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum)) {
+        const keyValueResult = getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
+        /* forceStrictInference */ true, isValueTypeInvariant, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum);
+        if (keyValueResult.isIncomplete) {
             isIncomplete = true;
         }
+        if (keyValueResult.typeErrors) {
+            typeErrors = true;
+        }
         const specializedKeyType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedKeyType), keyTypes.map((result) => result.type), 
         /* isNarrowable */ false);
         const specializedValueType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedValueType), valueTypes.map((result) => result.type), !isValueTypeInvariant);
@@ -9434,7 +9440,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return undefined;
         }
         const type = getBuiltInObject(node, 'dict', [specializedKeyType, specializedValueType]);
-        return { type, isIncomplete };
+        return { type, isIncomplete, typeErrors };
     }
     // Attempts to infer the type of a dictionary statement. If hasExpectedType
     // is true, strict inference is used for the subexpressions.
@@ -9446,12 +9452,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const valueTypeResults = [];
         let isEmptyContainer = false;
         let isIncomplete = false;
+        let typeErrors = false;
         // Infer the key and value types if possible.
-        if (getKeyAndValueTypesFromDictionary(node, keyTypeResults, valueTypeResults, 
+        const keyValueResult = getKeyAndValueTypesFromDictionary(node, keyTypeResults, valueTypeResults, 
         /* forceStrictInference */ hasExpectedType, 
-        /* isValueTypeInvariant */ false)) {
+        /* isValueTypeInvariant */ false);
+        if (keyValueResult.isIncomplete) {
             isIncomplete = true;
         }
+        if (keyValueResult.typeErrors) {
+            typeErrors = true;
+        }
         // Strip any literal values.
         const keyTypes = keyTypeResults.map((t) => stripLiteralValue(t.type));
         const valueTypes = valueTypeResults.map((t) => stripLiteralValue(t.type));
@@ -9485,10 +9496,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return { type: types_1.UnknownType.create() };
             }
         }
-        return { type, isIncomplete };
+        return { type, isIncomplete, typeErrors };
     }
     function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, isValueTypeInvariant, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
         let isIncomplete = false;
+        let typeErrors = false;
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
             var _a, _b, _c, _d;
@@ -9499,6 +9511,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (keyTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
+                if (keyTypeResult.typeErrors) {
+                    typeErrors = true;
+                }
                 const keyType = keyTypeResult.type;
                 if (!keyTypeResult.isIncomplete && !keyTypeResult.typeErrors) {
                     verifySetEntryOrDictKeyIsHashable(entryNode.keyExpression, keyType, /* isDictKey */ true);
@@ -9537,6 +9552,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (valueTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
+                if (valueTypeResult.typeErrors) {
+                    typeErrors = true;
+                }
                 if (forceStrictInference || index < maxEntriesToUseForInference) {
                     // If an existing key has the same literal type, delete the previous
                     // key since we're overwriting it here.
@@ -9572,6 +9590,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (unexpandedTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
+                if (unexpandedTypeResult.typeErrors) {
+                    typeErrors = true;
+                }
                 const unexpandedType = unexpandedTypeResult.type;
                 if ((0, types_1.isAnyOrUnknown)(unexpandedType)) {
                     addUnknown = false;
@@ -9629,6 +9650,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (dictEntryTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
+                if (dictEntryTypeResult.typeErrors) {
+                    typeErrors = true;
+                }
                 // The result should be a tuple.
                 if ((0, types_1.isClassInstance)(dictEntryType) && (0, typeUtils_1.isTupleClass)(dictEntryType)) {
                     const typeArgs = (_d = dictEntryType.tupleTypeArguments) === null || _d === void 0 ? void 0 : _d.map((t) => t.type);
@@ -9648,7 +9672,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         });
-        return isIncomplete;
+        return { type: types_1.AnyType.create(), isIncomplete, typeErrors };
     }
     function getTypeOfListOrSet(node, flags, inferenceContext) {
         var _a;
@@ -9945,23 +9969,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return undefined;
             });
         }
-        if (expectedFunctionTypes.length <= 1) {
-            return getTypeOfLambdaWithExpectedType(node, expectedFunctionTypes.length > 0 ? expectedFunctionTypes[0] : undefined, inferenceContext, 
-            /* forceSpeculative */ false);
-        }
-        // Sort the expected types for deterministic results.
-        expectedFunctionTypes = (0, typeUtils_1.sortTypes)(expectedFunctionTypes);
+        let expectedSubtype;
         // If there's more than one type, try each in turn until we find one that works.
-        for (const expectedFunctionType of expectedFunctionTypes) {
-            const result = getTypeOfLambdaWithExpectedType(node, expectedFunctionType, inferenceContext, 
-            /* forceSpeculative */ true);
-            if (!result.typeErrors) {
-                return getTypeOfLambdaWithExpectedType(node, expectedFunctionType, inferenceContext, 
-                /* forceSpeculative */ false);
+        if (expectedFunctionTypes.length > 1) {
+            // Sort the expected types for deterministic results.
+            expectedFunctionTypes = (0, typeUtils_1.sortTypes)(expectedFunctionTypes);
+            for (const subtype of expectedFunctionTypes) {
+                const result = getTypeOfLambdaWithExpectedType(node, subtype, inferenceContext, 
+                /* forceSpeculative */ true);
+                if (!result.typeErrors) {
+                    expectedSubtype = subtype;
+                    break;
+                }
             }
         }
-        return getTypeOfLambdaWithExpectedType(node, expectedFunctionTypes[0], inferenceContext, 
-        /* forceSpeculative */ true);
+        if (!expectedSubtype && expectedFunctionTypes.length > 0) {
+            expectedSubtype = expectedFunctionTypes[0];
+        }
+        return getTypeOfLambdaWithExpectedType(node, expectedSubtype, inferenceContext, /* forceSpeculative */ false);
     }
     function getTypeOfLambdaWithExpectedType(node, expectedType, inferenceContext, forceSpeculative) {
         let isIncomplete = !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete);
@@ -10958,7 +10983,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         for (const typeArg of typeArgs) {
             let typeArgType = typeArg.type;
-            if (!validateTypeArg(typeArg, { allowVariadicTypeVar: true, allowUnpackedTuples: true })) {
+            if (!validateTypeArg(typeArg, {
+                allowVariadicTypeVar: fileInfo.diagnosticRuleSet.enableExperimentalFeatures,
+            })) {
                 typeArgType = types_1.UnknownType.create();
             }
             else if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeArgType)) {
@@ -11539,7 +11566,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const scope = ScopeUtils.getScopeForNode(node);
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         let classFlags = 0 /* ClassTypeFlags.None */;
-        if ((scope === null || scope === void 0 ? void 0 : scope.type) === 4 /* ScopeType.Builtin */ ||
+        if ((scope === null || scope === void 0 ? void 0 : scope.type) === 5 /* ScopeType.Builtin */ ||
             fileInfo.isTypingStubFile ||
             fileInfo.isTypingExtensionsStubFile ||
             fileInfo.isBuiltInStubFile ||
@@ -12045,7 +12072,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (hashSymbol && hashSymbol.isClassMember() && !hashSymbol.getSynthesizedType()) {
                     skipSynthesizeHash = true;
                 }
-                const synthesizeMethods = () => (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
+                const synthesizeMethods = () => (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, isNamedTupleSubclass, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
                 // If this is a NamedTuple subclass, immediately synthesize dataclass methods
                 // because we also need to update the MRO classes in this case. For regular
                 // dataclasses, we'll defer the  method synthesis to avoid circular dependencies.
@@ -12202,9 +12229,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function evaluateTypeParameterList(node) {
         const paramTypes = [];
+        const typeParamScope = AnalyzerNodeInfo.getScope(node);
         node.parameters.forEach((param) => {
             var _a;
-            const paramSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(param.name);
+            const paramSymbol = typeParamScope === null || typeParamScope === void 0 ? void 0 : typeParamScope.symbolTable.get(param.name.value);
             if (!paramSymbol) {
                 // This can happen if the code is unreachable.
                 return;
@@ -14633,13 +14661,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function lookUpSymbolRecursive(node, name, honorCodeFlow, preferGlobalScope = false) {
         var _a;
-        const scope = ScopeUtils.getScopeForNode(node);
-        let symbolWithScope = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(name);
-        const scopeType = (_a = scope === null || scope === void 0 ? void 0 : scope.type) !== null && _a !== void 0 ? _a : 3 /* ScopeType.Module */;
+        const scopeNodeInfo = ParseTreeUtils.getEvaluationScopeNode(node);
+        const scope = AnalyzerNodeInfo.getScope(scopeNodeInfo.node);
+        let symbolWithScope = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(name, { useProxyScope: !!scopeNodeInfo.useProxyScope });
+        const scopeType = (_a = scope === null || scope === void 0 ? void 0 : scope.type) !== null && _a !== void 0 ? _a : 4 /* ScopeType.Module */;
         // Functions and list comprehensions don't allow access to implicitly
         // aliased symbols in outer scopes if they haven't yet been assigned
         // within the local scope.
-        const scopeTypeHonorsCodeFlow = scopeType !== 1 /* ScopeType.Function */ && scopeType !== 0 /* ScopeType.ListComprehension */;
+        let scopeTypeHonorsCodeFlow = scopeType !== 2 /* ScopeType.Function */ && scopeType !== 1 /* ScopeType.ListComprehension */;
+        // TypeParameter scopes don't honor code flow, but if the symbol is resolved
+        // using the proxy scope for the TypeParameter scope, we should use code flow.
+        if (scopeType === 0 /* ScopeType.TypeParameter */ && symbolWithScope && symbolWithScope.scope === scope) {
+            scopeTypeHonorsCodeFlow = false;
+        }
         if (symbolWithScope && honorCodeFlow && scopeTypeHonorsCodeFlow) {
             // Filter the declarations based on flow reachability.
             const reachableDecl = symbolWithScope.symbol.getDeclarations().find((decl) => {
@@ -14671,11 +14705,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If none of the declarations are reachable from the current node,
             // search for the symbol in outer scopes.
             if (!reachableDecl) {
-                if (symbolWithScope.scope.type !== 1 /* ScopeType.Function */) {
+                if (symbolWithScope.scope.type !== 2 /* ScopeType.Function */) {
                     let nextScopeToSearch = symbolWithScope.scope.parent;
-                    const isOutsideCallerModule = symbolWithScope.isOutsideCallerModule || symbolWithScope.scope.type === 3 /* ScopeType.Module */;
+                    const isOutsideCallerModule = symbolWithScope.isOutsideCallerModule || symbolWithScope.scope.type === 4 /* ScopeType.Module */;
                     let isBeyondExecutionScope = symbolWithScope.isBeyondExecutionScope || symbolWithScope.scope.isIndependentlyExecutable();
-                    if (symbolWithScope.scope.type === 2 /* ScopeType.Class */) {
+                    if (symbolWithScope.scope.type === 3 /* ScopeType.Class */) {
                         // There is an odd documented behavior for classes in that
                         // symbol resolution skips to the global scope rather than
                         // the next scope in the chain.
@@ -14686,7 +14720,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                     }
                     if (nextScopeToSearch) {
-                        symbolWithScope = nextScopeToSearch.lookUpSymbolRecursive(name, isOutsideCallerModule, isBeyondExecutionScope);
+                        symbolWithScope = nextScopeToSearch.lookUpSymbolRecursive(name, {
+                            isOutsideCallerModule,
+                            isBeyondExecutionScope,
+                        });
                     }
                     else {
                         symbolWithScope = undefined;
@@ -14702,16 +14739,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // resolution over local resolutions.
         if (symbolWithScope && preferGlobalScope) {
             let curSymbolWithScope = symbolWithScope;
-            while (curSymbolWithScope.scope.type !== 3 /* ScopeType.Module */ &&
-                curSymbolWithScope.scope.type !== 4 /* ScopeType.Builtin */ &&
+            while (curSymbolWithScope.scope.type !== 4 /* ScopeType.Module */ &&
+                curSymbolWithScope.scope.type !== 5 /* ScopeType.Builtin */ &&
+                curSymbolWithScope.scope.type !== 0 /* ScopeType.TypeParameter */ &&
                 curSymbolWithScope.scope.parent) {
-                curSymbolWithScope = curSymbolWithScope.scope.parent.lookUpSymbolRecursive(name, curSymbolWithScope.isOutsideCallerModule, curSymbolWithScope.isBeyondExecutionScope || curSymbolWithScope.scope.isIndependentlyExecutable());
+                curSymbolWithScope = curSymbolWithScope.scope.parent.lookUpSymbolRecursive(name, {
+                    isOutsideCallerModule: curSymbolWithScope.isOutsideCallerModule,
+                    isBeyondExecutionScope: curSymbolWithScope.isBeyondExecutionScope ||
+                        curSymbolWithScope.scope.isIndependentlyExecutable(),
+                });
                 if (!curSymbolWithScope) {
                     break;
                 }
             }
-            if ((curSymbolWithScope === null || curSymbolWithScope === void 0 ? void 0 : curSymbolWithScope.scope.type) === 3 /* ScopeType.Module */ ||
-                (curSymbolWithScope === null || curSymbolWithScope === void 0 ? void 0 : curSymbolWithScope.scope.type) === 4 /* ScopeType.Builtin */) {
+            if ((curSymbolWithScope === null || curSymbolWithScope === void 0 ? void 0 : curSymbolWithScope.scope.type) === 4 /* ScopeType.Module */ ||
+                (curSymbolWithScope === null || curSymbolWithScope === void 0 ? void 0 : curSymbolWithScope.scope.type) === 5 /* ScopeType.Builtin */) {
                 symbolWithScope = curSymbolWithScope;
             }
         }
@@ -14989,17 +15031,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Determine if this is part of a "type" statement.
             const isWithinTypeAliasStatement = !!ParseTreeUtils.getParentNodeOfType(node, 77 /* ParseNodeType.TypeAlias */);
             const allowForwardReferences = isWithinTypeAnnotation || isWithinTypeAliasStatement || fileInfo.isStubFile;
-            let symbol;
-            const typeParamSymbol = AnalyzerNodeInfo.getTypeParameterSymbol(node);
-            if (typeParamSymbol) {
-                symbol = typeParamSymbol;
-            }
-            else {
-                const symbolWithScope = lookUpSymbolRecursive(node, node.value, !allowForwardReferences, isWithinTypeAnnotation);
-                symbol = symbolWithScope === null || symbolWithScope === void 0 ? void 0 : symbolWithScope.symbol;
-            }
-            if (symbol) {
-                (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
+            const symbolWithScope = lookUpSymbolRecursive(node, node.value, !allowForwardReferences, isWithinTypeAnnotation);
+            if (symbolWithScope) {
+                (0, collectionUtils_1.appendArray)(declarations, symbolWithScope.symbol.getDeclarations());
             }
         }
         return declarations;
@@ -15256,6 +15290,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, ParseTreeUtils.getScopeIdForNode(scopeNode.nodeType === 77 /* ParseNodeType.TypeAlias */ ? scopeNode.name : scopeNode), scopeNode.name.value, scopeType);
         }
+        writeTypeCache(node, { type: typeVar }, /* flags */ undefined);
+        writeTypeCache(node.name, { type: typeVar }, /* flags */ undefined);
         return typeVar;
     }
     function getInferredTypeOfDeclaration(symbol, decl) {
@@ -15849,17 +15885,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // a type annotation, that type is returned. If not, an attempt is made to infer
     // the return type. If a list of args is provided, the inference logic may take
     // into account argument types to infer the return type.
-    function getFunctionEffectiveReturnType(type, args, inferTypeIfNeeded = true) {
+    function getFunctionEffectiveReturnType(type, callSiteInfo, inferTypeIfNeeded = true) {
         const specializedReturnType = types_1.FunctionType.getSpecializedReturnType(type, /* includeInferred */ false);
         if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
             return adjustCallableReturnType(type, specializedReturnType, /* liveTypeVarScopes */ []);
         }
         if (inferTypeIfNeeded) {
-            return getFunctionInferredReturnType(type, args);
+            return getFunctionInferredReturnType(type, callSiteInfo);
         }
         return types_1.UnknownType.create();
     }
-    function _getFunctionInferredReturnType(type, args) {
+    function _getFunctionInferredReturnType(type, callSiteInfo) {
         var _a;
         let returnType;
         let isIncomplete = false;
@@ -15927,7 +15963,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             types_1.FunctionType.hasUnannotatedParams(type) &&
             !types_1.FunctionType.isStubDefinition(type) &&
             !types_1.FunctionType.isPyTypedDefinition(type) &&
-            args) {
+            callSiteInfo) {
             let hasDecorators = false;
             let isAsync = false;
             const declNode = (_a = type.details.declaration) === null || _a === void 0 ? void 0 : _a.node;
@@ -15942,7 +15978,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // We can't use this technique if decorators or async are used because they
             // would need to be applied to the inferred return type.
             if (!hasDecorators && !isAsync) {
-                const contextualReturnType = getFunctionInferredReturnTypeUsingArguments(type, args);
+                const contextualReturnType = getFunctionInferredReturnTypeUsingArguments(type, callSiteInfo);
                 if (contextualReturnType) {
                     returnType = contextualReturnType;
                 }
@@ -15950,7 +15986,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return returnType;
     }
-    function getFunctionInferredReturnTypeUsingArguments(type, args) {
+    function getFunctionInferredReturnTypeUsingArguments(type, callSiteInfo) {
+        const args = callSiteInfo.args;
         let contextualReturnType;
         if (!type.details.declaration) {
             return undefined;
@@ -15988,6 +16025,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const paramTypes = [];
         let isResultFromCache = false;
+        // If the call is located in a loop, don't use literal argument types
+        // for the same reason we don't do literal math in loops.
+        const stripLiteralArgTypes = ParseTreeUtils.isWithinLoop(callSiteInfo.errorNode);
         // Suppress diagnostics because we don't want to generate errors.
         suppressDiagnostics(functionNode, () => {
             var _a, _b;
@@ -16033,6 +16073,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (!paramType) {
                             paramType = types_1.UnknownType.create();
                         }
+                        if (stripLiteralArgTypes) {
+                            paramType = stripLiteralValue(paramType);
+                        }
                         paramTypes.push(paramType);
                         writeTypeCache(param.name, { type: paramType }, 0 /* EvaluatorFlags.None */);
                     }
@@ -17520,21 +17563,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return types_1.ClassType.isSpecialFormClass(classType);
     }
-    // Determines whether a type is "subsumed by" (i.e. is a proper subtype of) one
-    // of the other type.
+    // Determines whether a type is "subsumed by" (i.e. is a proper subtype of) another type.
     function isTypeSubsumedByOtherType(type, otherType, allowAnyToSubsume, recursionCount = 0) {
         const concreteType = makeTopLevelTypeVarsConcrete(type);
-        const otherTypes = (0, types_1.isUnion)(otherType) ? otherType.subtypes : [otherType];
-        for (const otherType of otherTypes) {
-            if ((0, types_1.isTypeSame)(otherType, type)) {
+        const otherSubtypes = (0, types_1.isUnion)(otherType) ? otherType.subtypes : [otherType];
+        for (const otherSubtype of otherSubtypes) {
+            if ((0, types_1.isTypeSame)(otherSubtype, type)) {
                 continue;
             }
-            if ((0, types_1.isAnyOrUnknown)(otherType)) {
+            if ((0, types_1.isAnyOrUnknown)(otherSubtype)) {
                 if (allowAnyToSubsume) {
                     return true;
                 }
             }
-            else if (isProperSubtype(otherType, concreteType, recursionCount)) {
+            else if (isProperSubtype(otherSubtype, concreteType, recursionCount)) {
                 return true;
             }
         }
@@ -19047,19 +19089,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         : firstParamType);
                 }
             }
-            else if (!assignType(memberTypeFirstParamType, firstParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), typeVarContext, 
-            /* srcTypeVarContext */ undefined, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArguments */, recursionCount)) {
-                if (memberTypeFirstParam.name &&
-                    !memberTypeFirstParam.isNameSynthesized &&
-                    memberTypeFirstParam.hasDeclaredType) {
-                    if (diag) {
-                        diag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
-                            type: printType(baseType),
-                            methodName: memberType.details.name || '<anonymous>',
-                            paramName: memberTypeFirstParam.name,
-                        }));
+            else {
+                const subDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
+                if (!assignType(memberTypeFirstParamType, firstParamType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), typeVarContext, 
+                /* srcTypeVarContext */ undefined, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArguments */, recursionCount)) {
+                    if (memberTypeFirstParam.name &&
+                        !memberTypeFirstParam.isNameSynthesized &&
+                        memberTypeFirstParam.hasDeclaredType) {
+                        if (subDiag) {
+                            subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
+                                type: printType(baseType),
+                                methodName: memberType.details.name || '<anonymous>',
+                                paramName: memberTypeFirstParam.name,
+                            }));
+                        }
+                        return undefined;
                     }
-                    return undefined;
                 }
             }
         }