@zzzen/pyright-internal 1.2.0-dev.20240616 → 1.2.0-dev.20240630

package/dist/analyzer/typeEvaluator.js

@@ -2143,15 +2143,38 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function addDiagnosticWithSuppressionCheck(diagLevel, message, node, range) {
-        if (!isDiagnosticSuppressedForNode(node) && isNodeReachable(node)) {
+        var _a;
+        if (isDiagnosticSuppressedForNode(node)) {
+            // See if this node is suppressed but the diagnostic should be generated
+            // anyway so it can be used by the caller that requested the suppression.
+            const suppressionEntry = suppressedNodeStack.find((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode.node) && suppressedNode.suppressedDiags);
+            (_a = suppressionEntry === null || suppressionEntry === void 0 ? void 0 : suppressionEntry.suppressedDiags) === null || _a === void 0 ? void 0 : _a.push(message);
+            return undefined;
+        }
+        if (isNodeReachable(node)) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            return fileInfo.diagnosticSink.addDiagnosticWithTextRange(diagLevel, message, range || node);
+            return fileInfo.diagnosticSink.addDiagnosticWithTextRange(diagLevel, message, range !== null && range !== void 0 ? range : node);
         }
         return undefined;
     }
     function isDiagnosticSuppressedForNode(node) {
-        return (suppressedNodeStack.some((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode)) ||
-            speculativeTypeTracker.isSpeculative(node, /* ignoreIfDiagnosticsAllowed */ true));
+        if (speculativeTypeTracker.isSpeculative(node, /* ignoreIfDiagnosticsAllowed */ true)) {
+            return true;
+        }
+        return suppressedNodeStack.some((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode.node));
+    }
+    // This function is similar to isDiagnosticSuppressedForNode except that it
+    // returns false if diagnostics are suppressed for the node but the caller
+    // has requested that diagnostics be generated anyway.
+    function canSkipDiagnosticForNode(node) {
+        if (speculativeTypeTracker.isSpeculative(node, /* ignoreIfDiagnosticsAllowed */ true)) {
+            return true;
+        }
+        const suppressedEntries = suppressedNodeStack.filter((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode.node));
+        if (suppressedEntries.length === 0) {
+            return false;
+        }
+        return suppressedEntries.every((entry) => !entry.suppressedDiags);
     }
     function addDiagnostic(rule, message, node, range) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -4230,6 +4253,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             /* skipUnknownArgCheck */ true, 
             /* inferenceContext */ undefined, 
             /* signatureTracker */ undefined);
+        }, (suppressedDiags) => {
+            // If diagnostics were recorded when suppressed, add them to the
+            // diagnostic as messages.
+            if (diag) {
+                suppressedDiags.forEach((message) => {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessageMultiline(message);
+                });
+            }
         });
         // Collect deprecation information associated with the member access method.
         let deprecationInfo;
@@ -4252,28 +4283,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 memberAccessDeprecationInfo: deprecationInfo,
             };
         }
-        // Errors were detected when evaluating the access method call.
-        if (usage.method === 'set') {
-            if (usage.setType &&
-                (0, types_1.isFunction)(methodType) &&
-                methodType.details.parameters.length >= 2 &&
-                !usage.setType.isIncomplete) {
-                const setterType = types_1.FunctionType.getEffectiveParameterType(methodType, 1);
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeIncompatible().format({
-                    destType: printType(setterType),
-                    sourceType: printType(usage.setType.type),
-                }));
-            }
-            else if ((0, types_1.isOverloadedFunction)(methodType)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocMessage.noOverload().format({ name: accessMethodName }));
-            }
-        }
-        else {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.descriptorAccessCallFailed().format({
-                name: accessMethodName,
-                className: printType((0, typeUtils_1.convertToInstance)(methodClassType)),
-            }));
-        }
         return {
             type: types_1.UnknownType.create(),
             typeErrors: true,
@@ -5179,7 +5188,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             });
             positionalIndexType = makeTupleObject(tupleTypeArgs);
         }
-        let argList = [
+        const argList = [
             {
                 argumentCategory: 0 /* ArgumentCategory.Simple */,
                 typeResult: { type: positionalIndexType, isIncomplete: isPositionalIndexTypeIncomplete },
@@ -5216,44 +5225,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 node: arg,
             });
         });
-        let callResult;
-        // Speculatively attempt the call. We may need to replace the index
-        // type with 'int', and we don't want to emit errors before we know
-        // which type to use.
-        if (keywordArgs.length === 0 && unpackedDictArgs.length === 0 && positionalArgs.length === 1) {
-            useSpeculativeMode(node, () => {
-                callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
-                /* typeVarContext */ undefined, 
-                /* skipUnknownArgCheck */ true, 
-                /* inferenceContext */ undefined, 
-                /* signatureTracker */ undefined);
-                if (callResult.argumentErrors) {
-                    // If the object supports "__index__" magic method, convert
-                    // the index to an int and try again.
-                    if ((0, types_1.isClassInstance)(positionalIndexType)) {
-                        const altArgList = [...argList];
-                        altArgList[0] = { ...altArgList[0] };
-                        const indexMethod = getBoundMagicMethod(positionalIndexType, '__index__');
-                        if (indexMethod) {
-                            const intType = getBuiltInObject(node, 'int');
-                            if ((0, types_1.isClassInstance)(intType)) {
-                                altArgList[0].typeResult = { type: intType };
-                            }
-                        }
-                        callResult = validateCallArguments(node, altArgList, { type: itemMethodType }, 
-                        /* typeVarContext */ undefined, 
-                        /* skipUnknownArgCheck */ true, 
-                        /* inferenceContext */ undefined, 
-                        /* signatureTracker */ undefined);
-                        // We were successful, so replace the arg list.
-                        if (!callResult.argumentErrors) {
-                            argList = altArgList;
-                        }
-                    }
-                }
-            });
-        }
-        callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
+        const callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
         /* typeVarContext */ undefined, 
         /* skipUnknownArgCheck */ true, 
         /* inferenceContext */ undefined, 
@@ -6398,7 +6370,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (filteredMatchResults.length === 0) {
             // Skip the error message if we're in speculative mode because it's very
             // expensive, and we're going to suppress the diagnostic anyway.
-            if (!isDiagnosticSuppressedForNode(errorNode)) {
+            if (!canSkipDiagnosticForNode(errorNode)) {
                 const functionName = typeResult.type.overloads[0].details.name || '<anonymous function>';
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 const argTypes = argList.map((t) => {
@@ -6490,7 +6462,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // We couldn't find any valid overloads. Skip the error message if we're
         // in speculative mode because it's very expensive, and we're going to
         // suppress the diagnostic anyway.
-        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+        if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
             const result = evaluateUsingBestMatchingOverload(
             /* skipUnknownArgCheck */ true, 
             /* emitNoOverloadFoundError */ true);
@@ -7250,7 +7222,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         tooManyPositionals = true;
                     }
                     if (tooManyPositionals) {
-                        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                        if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
@@ -7284,7 +7256,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isTypeVar)(argTypeResult.type) &&
                         argTypeResult.type.paramSpecAccess === 'args' &&
                         paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
-                        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                        if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
@@ -7350,7 +7322,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // It's not allowed to use unpacked arguments with a variadic *args
                 // parameter unless the argument is a variadic arg as well.
                 if (isParamVariadic && !isArgCompatibleWithVariadic) {
-                    if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                    if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
                     }
                     reportedArgError = true;
@@ -7407,7 +7379,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         : 0 /* ParameterCategory.Simple */;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
-                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 // Have we run out of arguments and still have parameters left to fill?
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, remainingArgCount === 1
                                     ? localize_1.LocMessage.argMorePositionalExpectedOne()
@@ -7490,7 +7462,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 argsRemainingCount--;
             }
             if (argsRemainingCount > 0) {
-                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, argsRemainingCount === 1
                         ? localize_1.LocMessage.argMorePositionalExpectedOne()
                         : localize_1.LocMessage.argMorePositionalExpectedCount().format({
@@ -7508,7 +7480,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             while (argIndex < argList.length) {
                 if (argList[argIndex].argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
                     // Verify that the type used in this expression is a SupportsKeysAndGetItem[str, T].
-                    const argType = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType), signatureTracker).type;
+                    const argTypeResult = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType), signatureTracker);
+                    const argType = argTypeResult.type;
+                    if (argTypeResult.isIncomplete) {
+                        isTypeIncomplete = true;
+                    }
                     if ((0, types_1.isAnyOrUnknown)(argType)) {
                         unpackedDictionaryArgType = argType;
                     }
@@ -7572,7 +7548,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                         });
                         if (!diag.isEmpty()) {
-                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
                             }
                             reportedArgError = true;
@@ -7632,7 +7608,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 });
                             }
                             if (!isValidMappingType) {
-                                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                                if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
                                 }
                                 reportedArgError = true;
@@ -7653,7 +7629,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         const paramEntry = paramMap.get(paramNameValue);
                         if (paramEntry && !paramEntry.isPositionalOnly) {
                             if (paramEntry.argsReceived > 0) {
-                                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                                if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
                                 }
                                 reportedArgError = true;
@@ -7697,7 +7673,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             trySetActive(argList[argIndex], paramDetails.params[paramDetails.kwargsIndex].param);
                         }
                         else {
-                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramNameMissing().format({ name: paramName.value }), paramName);
                             }
                             reportedArgError = true;
@@ -7708,7 +7684,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             paramSpecArgList.push(argList[argIndex]);
                         }
                         else {
-                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                     ? localize_1.LocMessage.argPositionalExpectedOne()
                                     : localize_1.LocMessage.argPositionalExpectedCount().format({
@@ -7784,9 +7760,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return !entry || entry.argsReceived < entry.argsNeeded;
                 });
                 if (unassignedParams.length > 0) {
-                    if (!isDiagnosticSuppressedForNode(errorNode)) {
+                    if (!canSkipDiagnosticForNode(errorNode)) {
                         const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
-                        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                        if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, unassignedParams.length === 1
                                 ? localize_1.LocMessage.argMissingForParam().format({ name: missingParamNames })
                                 : localize_1.LocMessage.argMissingForParams().format({ names: missingParamNames }), errorNode);
@@ -7857,7 +7833,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (containsVariadicTypeVar &&
                             argParam.argument.argumentCategory !== 1 /* ArgumentCategory.UnpackedList */ &&
                             !argParam.mapsToVarArgList) {
-                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
                             }
                             reportedArgError = true;
@@ -8230,6 +8206,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             paramSpecTypeVarContext.forEach((paramSpecTypeVarContext) => {
                 if (paramSpecTypeVarContext) {
                     specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(specializedReturnType, paramSpecTypeVarContext);
+                    // It's possible that one or more of the TypeVars or ParamSpecs
+                    // in the typeVarContext refer to TypeVars that were solved in
+                    // the paramSpecTypeVarContext. Apply these solved TypeVars accordingly.
+                    (0, typeUtils_1.applySourceContextTypeVars)(typeVarContext, paramSpecTypeVarContext);
                 }
             });
         }
@@ -8636,7 +8616,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // printing types if the diagnostic is disabled.
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
             if (fileInfo.diagnosticRuleSet.reportArgumentType !== 'none' &&
-                !isDiagnosticSuppressedForNode(argParam.errorNode) &&
+                !canSkipDiagnosticForNode(argParam.errorNode) &&
                 !isTypeIncomplete) {
                 const argTypeText = printType(argType);
                 const paramTypeText = printType(argParam.paramType);
@@ -10178,9 +10158,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }, {
                 dependentType: inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType,
-                allowDiagnostics: !forceSpeculative &&
-                    !isDiagnosticSuppressedForNode(node) &&
-                    !(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete),
+                allowDiagnostics: !forceSpeculative && !canSkipDiagnosticForNode(node) && !(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete),
             });
             // Mark the function type as no longer being evaluated.
             functionType.details.flags &= ~131072 /* FunctionTypeFlags.PartiallyEvaluated */;
@@ -11458,87 +11436,87 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     writeTypeCache(node.rightExpression, { type: rightHandType }, 0 /* EvaluatorFlags.None */);
                 }
             }
-            if (!rightHandType) {
-                // Determine whether there is a declared type.
-                const declaredType = getDeclaredTypeForExpression(node.leftExpression, {
-                    method: 'set',
-                });
-                let typeAliasNameNode;
-                let isSpeculativeTypeAlias = false;
-                if (isDeclaredTypeAlias(node.leftExpression)) {
-                    typeAliasNameNode = node.leftExpression.valueExpression;
-                    if (!isLegalTypeAliasExpressionForm(node.rightExpression)) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAliasIllegalExpressionForm(), node.rightExpression);
-                    }
-                }
-                else if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
-                    const symbolWithScope = lookUpSymbolRecursive(node.leftExpression, node.leftExpression.value, 
-                    /* honorCodeFlow */ false);
-                    if (symbolWithScope) {
-                        const decls = symbolWithScope.symbol.getDeclarations();
-                        if (decls.length === 1 && isPossibleTypeAliasOrTypedDict(decls[0])) {
-                            typeAliasNameNode = node.leftExpression;
-                            isSpeculativeTypeAlias = true;
-                        }
-                    }
-                }
-                // Synthesize a type variable that represents the type alias while we're
-                // evaluating it. This allows us to handle recursive definitions.
-                let typeAliasTypeVar;
-                if (typeAliasNameNode) {
-                    typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${typeAliasNameNode.value}`);
-                    typeAliasTypeVar.details.isSynthesized = true;
-                    typeAliasTypeVar.details.recursiveTypeAliasName = typeAliasNameNode.value;
-                    const scopeId = ParseTreeUtils.getScopeIdForNode(typeAliasNameNode);
-                    typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
-                    typeAliasTypeVar.details.recursiveTypeAliasIsPep695Syntax = false;
-                    typeAliasTypeVar.scopeId = scopeId;
-                    // Write the type back to the type cache. It will be replaced below.
-                    writeTypeCache(node, { type: typeAliasTypeVar }, /* flags */ undefined);
-                    writeTypeCache(node.leftExpression, { type: typeAliasTypeVar }, /* flags */ undefined);
-                    if (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
-                        writeTypeCache(node.leftExpression.valueExpression, { type: typeAliasTypeVar }, 
-                        /* flags */ undefined);
-                    }
-                }
-                const srcTypeResult = getTypeOfExpression(node.rightExpression, flags, (0, typeUtils_1.makeInferenceContext)(declaredType));
-                let srcType = srcTypeResult.type;
-                expectedTypeDiagAddendum = srcTypeResult.expectedTypeDiagAddendum;
-                if (srcTypeResult.isIncomplete) {
-                    isIncomplete = true;
+        }
+        if (!rightHandType) {
+            // Determine whether there is a declared type.
+            const declaredType = getDeclaredTypeForExpression(node.leftExpression, {
+                method: 'set',
+            });
+            let typeAliasNameNode;
+            let isSpeculativeTypeAlias = false;
+            if (isDeclaredTypeAlias(node.leftExpression)) {
+                typeAliasNameNode = node.leftExpression.valueExpression;
+                if (!isLegalTypeAliasExpressionForm(node.rightExpression)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAliasIllegalExpressionForm(), node.rightExpression);
                 }
-                // If the RHS is a constant boolean expression, assign it a literal type.
-                const constExprValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(node.rightExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
-                if (constExprValue !== undefined) {
-                    const boolType = getBuiltInObject(node, 'bool');
-                    if ((0, types_1.isClassInstance)(boolType)) {
-                        srcType = types_1.ClassType.cloneWithLiteral(boolType, constExprValue);
-                    }
-                }
-                // If this is an enum, transform the type as required.
-                rightHandType = srcType;
-                if (typeAliasNameNode) {
-                    // If this was a speculative type alias, it becomes a real type alias
-                    // only if the evaluated type is an instantiable type.
-                    if (!isSpeculativeTypeAlias || isLegalImplicitTypeAliasType(rightHandType)) {
-                        // If this is a type alias, record its name based on the assignment target.
-                        rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, typeAliasNameNode, 
-                        /* isPep695Syntax */ false, 
-                        /* isPep695TypeVarType */ false);
-                        (0, debug_1.assert)(typeAliasTypeVar !== undefined);
-                        if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, rightHandType)) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIsRecursiveDirect().format({
-                                name: typeAliasNameNode.value,
-                            }), node.rightExpression);
-                            rightHandType = types_1.UnknownType.create();
-                        }
-                        // Set the resulting type to the boundType of the original type alias
-                        // to support recursive type aliases.
-                        typeAliasTypeVar.details.boundType = rightHandType;
-                        // Record the type parameters within the recursive type alias so it
-                        // can be specialized.
-                        typeAliasTypeVar.details.recursiveTypeParameters = (_a = rightHandType.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeParameters;
+            }
+            else if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
+                const symbolWithScope = lookUpSymbolRecursive(node.leftExpression, node.leftExpression.value, 
+                /* honorCodeFlow */ false);
+                if (symbolWithScope) {
+                    const decls = symbolWithScope.symbol.getDeclarations();
+                    if (decls.length === 1 && isPossibleTypeAliasOrTypedDict(decls[0])) {
+                        typeAliasNameNode = node.leftExpression;
+                        isSpeculativeTypeAlias = true;
+                    }
+                }
+            }
+            // Synthesize a type variable that represents the type alias while we're
+            // evaluating it. This allows us to handle recursive definitions.
+            let typeAliasTypeVar;
+            if (typeAliasNameNode) {
+                typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${typeAliasNameNode.value}`);
+                typeAliasTypeVar.details.isSynthesized = true;
+                typeAliasTypeVar.details.recursiveTypeAliasName = typeAliasNameNode.value;
+                const scopeId = ParseTreeUtils.getScopeIdForNode(typeAliasNameNode);
+                typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
+                typeAliasTypeVar.details.recursiveTypeAliasIsPep695Syntax = false;
+                typeAliasTypeVar.scopeId = scopeId;
+                // Write the type back to the type cache. It will be replaced below.
+                writeTypeCache(node, { type: typeAliasTypeVar }, /* flags */ undefined);
+                writeTypeCache(node.leftExpression, { type: typeAliasTypeVar }, /* flags */ undefined);
+                if (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
+                    writeTypeCache(node.leftExpression.valueExpression, { type: typeAliasTypeVar }, 
+                    /* flags */ undefined);
+                }
+            }
+            const srcTypeResult = getTypeOfExpression(node.rightExpression, flags, (0, typeUtils_1.makeInferenceContext)(declaredType));
+            let srcType = srcTypeResult.type;
+            expectedTypeDiagAddendum = srcTypeResult.expectedTypeDiagAddendum;
+            if (srcTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+            // If the RHS is a constant boolean expression, assign it a literal type.
+            const constExprValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(node.rightExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+            if (constExprValue !== undefined) {
+                const boolType = getBuiltInObject(node, 'bool');
+                if ((0, types_1.isClassInstance)(boolType)) {
+                    srcType = types_1.ClassType.cloneWithLiteral(boolType, constExprValue);
+                }
+            }
+            // If this is an enum, transform the type as required.
+            rightHandType = srcType;
+            if (typeAliasNameNode) {
+                // If this was a speculative type alias, it becomes a real type alias
+                // only if the evaluated type is an instantiable type.
+                if (!isSpeculativeTypeAlias || isLegalImplicitTypeAliasType(rightHandType)) {
+                    // If this is a type alias, record its name based on the assignment target.
+                    rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, typeAliasNameNode, 
+                    /* isPep695Syntax */ false, 
+                    /* isPep695TypeVarType */ false);
+                    (0, debug_1.assert)(typeAliasTypeVar !== undefined);
+                    if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, rightHandType)) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIsRecursiveDirect().format({
+                            name: typeAliasNameNode.value,
+                        }), node.rightExpression);
+                        rightHandType = types_1.UnknownType.create();
                     }
+                    // Set the resulting type to the boundType of the original type alias
+                    // to support recursive type aliases.
+                    typeAliasTypeVar.details.boundType = rightHandType;
+                    // Record the type parameters within the recursive type alias so it
+                    // can be specialized.
+                    typeAliasTypeVar.details.recursiveTypeParameters = (_a = rightHandType.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeParameters;
                 }
             }
         }
@@ -13373,6 +13351,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             !functionDecl.raiseStatements) {
             return false;
         }
+        const statements = functionDecl.node.suite.statements;
+        if (statements.some((statement) => statement.nodeType !== 47 /* ParseNodeType.StatementList */)) {
+            return false;
+        }
         for (const raiseStatement of functionDecl.raiseStatements) {
             if (!raiseStatement.typeExpression || raiseStatement.valueExpression) {
                 return false;
@@ -13902,6 +13884,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 nodeToEvaluate = parent;
                 continue;
             }
+            // Forward-declared type annotation expressions need to be be evaluated
+            // in context so they have the appropriate flags set. Most of these cases
+            // will have been detected above when calling getParentAnnotationNode,
+            // but TypeAlias expressions are not handled there.
+            const stringEnclosure = ParseTreeUtils.getParentNodeOfType(parent, 48 /* ParseNodeType.StringList */);
+            if (stringEnclosure) {
+                nodeToEvaluate = stringEnclosure;
+                continue;
+            }
             // The left expression of a call or member access expression is not generally contextual.
             if (parent.nodeType === 9 /* ParseNodeType.Call */ || parent.nodeType === 35 /* ParseNodeType.MemberAccess */) {
                 if (nodeToEvaluate === parent.leftExpression) {
@@ -13925,17 +13916,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // The base expression of an index expression is not contextual.
                 if (nodeToEvaluate === parent.baseExpression) {
                     flags = 2 /* EvaluatorFlags.IndexBaseDefaults */;
-                    break;
                 }
             }
-            else if (parent.nodeType === 48 /* ParseNodeType.StringList */ && nodeToEvaluate === parent.typeAnnotation) {
-                // Forward-declared type annotation expressions need to be be evaluated
-                // in context so they have the appropriate flags set. Most of these cases
-                // will have been detected above when calling getParentAnnotationNode,
-                // but TypeAlias expressions are not handled there.
-                nodeToEvaluate = parent;
-                continue;
-            }
             if (!(0, parseNodes_1.isExpressionNode)(parent)) {
                 // If we've hit a non-expression node, we generally want to
                 // stop. However, there are a few special "pass through"
@@ -14208,7 +14190,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // don't bother doing additional work.
         let cacheEntry = readTypeCacheEntry(subnode);
         if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
-            return cacheEntry.typeResult;
+            const typeResult = cacheEntry.typeResult;
+            // Handle the special case where a function or class is partially evaluated.
+            // Indicate that these are not complete types.
+            if ((0, types_1.isFunction)(typeResult.type) && types_1.FunctionType.isPartiallyEvaluated(typeResult.type)) {
+                return { ...typeResult, isIncomplete: true };
+            }
+            if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isPartiallyEvaluated(typeResult.type)) {
+                return { ...typeResult, isIncomplete: true };
+            }
+            return typeResult;
         }
         callback();
         cacheEntry = readTypeCacheEntry(subnode);
@@ -14234,7 +14225,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Allocate a new code flow analyzer.
-        const analyzer = codeFlowEngine.createCodeFlowAnalyzer(typeAtStart);
+        const analyzer = codeFlowEngine.createCodeFlowAnalyzer();
         if (entries) {
             entries.push({ typeAtStart, codeFlowAnalyzer: analyzer });
         }
@@ -14327,6 +14318,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         0) {
                         addError(localize_1.LocMessage.protocolNotAllowed(), errorNode);
                     }
+                    typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.forEach((typeArg) => {
+                        if (typeArg.typeList || !(0, types_1.isTypeVar)(typeArg.type)) {
+                            addError(localize_1.LocMessage.protocolTypeArgMustBeTypeParam(), typeArg.node);
+                        }
+                    });
                     return {
                         type: createSpecialType(classType, typeArgs, 
                         /* paramLimit */ undefined, 
@@ -14445,18 +14441,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (firstDefaultParamIndex >= 0) {
                 minTypeArgCount = firstDefaultParamIndex;
             }
-            // Classes that accept inlined type dict type args allow only one.
-            if (typeArgs[0].inlinedTypeDict) {
-                if (typeArgs.length > 1) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
-                        name: classType.aliasName || classType.details.name,
-                        expected: 1,
-                        received: typeArgCount,
-                    }), typeArgs[1].node);
-                }
-                return { type: typeArgs[0].inlinedTypeDict };
-            }
-            else if (typeArgCount > typeParameters.length) {
+            if (typeArgCount > typeParameters.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     if (typeParameters.length === 0) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
@@ -14839,11 +14824,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return symbolWithScope;
     }
     // Disables recording of errors and warnings.
-    function suppressDiagnostics(node, callback) {
-        suppressedNodeStack.push(node);
+    function suppressDiagnostics(node, callback, diagCallback) {
+        suppressedNodeStack.push({ node, suppressedDiags: diagCallback ? [] : undefined });
         try {
             const result = callback();
-            suppressedNodeStack.pop();
+            const poppedNode = suppressedNodeStack.pop();
+            if (diagCallback && (poppedNode === null || poppedNode === void 0 ? void 0 : poppedNode.suppressedDiags)) {
+                diagCallback(poppedNode.suppressedDiags);
+            }
             return result;
         }
         catch (e) {
@@ -16090,7 +16078,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const prevTypeCache = returnTypeInferenceTypeCache;
             returnTypeInferenceContextStack.push({
                 functionNode,
-                codeFlowAnalyzer: codeFlowEngine.createCodeFlowAnalyzer(/* typeAtStart */ undefined),
+                codeFlowAnalyzer: codeFlowEngine.createCodeFlowAnalyzer(),
             });
             try {
                 returnTypeInferenceTypeCache = new Map();
@@ -16503,6 +16491,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         while (destTypeArgs.length > srcTypeArgs.length && destTypeArgs[destTypeArgs.length - 1].isOptional) {
             destTypeArgs.splice(destTypeArgs.length - 1, 1);
         }
+        const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
+        let skipAdjustSrc = false;
         // If we're doing reverse type mappings and the source contains a variadic
         // TypeVar, we need to adjust the dest so the reverse type mapping assignment
         // can be performed.
@@ -16528,10 +16518,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         isUnbounded: false,
                     });
                 }
+                skipAdjustSrc = true;
             }
         }
         else {
-            const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
             if (destUnboundedOrVariadicIndex >= 0 && srcArgsToCapture >= 0) {
                 // If the dest contains a variadic element, determine which source
                 // args map to this element and package them up into an unpacked tuple.
@@ -16560,30 +16550,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             isUnbounded: false,
                         });
                     }
+                    skipAdjustSrc = true;
                 }
-                else {
-                    // If possible, package up the source entries that correspond to
-                    // the dest unbounded tuple. This isn't possible if the source contains
-                    // an unbounded tuple outside of this range.
-                    if (srcUnboundedIndex < 0 ||
-                        (srcUnboundedIndex >= destUnboundedOrVariadicIndex &&
-                            srcUnboundedIndex < destUnboundedOrVariadicIndex + srcArgsToCapture)) {
-                        const removedArgTypes = srcTypeArgs
-                            .splice(destUnboundedOrVariadicIndex, srcArgsToCapture)
-                            .map((t) => {
-                            if ((0, types_1.isTypeVar)(t.type) &&
-                                (0, types_1.isUnpackedVariadicTypeVar)(t.type) &&
-                                !t.type.isVariadicInUnion) {
-                                return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
-                            }
-                            return t.type;
-                        });
-                        srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
-                            type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
-                            isUnbounded: false,
-                        });
+            }
+        }
+        if (!skipAdjustSrc && destUnboundedOrVariadicIndex >= 0 && srcArgsToCapture >= 0) {
+            // If possible, package up the source entries that correspond to
+            // the dest unbounded tuple. This isn't possible if the source contains
+            // an unbounded tuple outside of this range.
+            if (srcUnboundedIndex < 0 ||
+                (srcUnboundedIndex >= destUnboundedOrVariadicIndex &&
+                    srcUnboundedIndex < destUnboundedOrVariadicIndex + srcArgsToCapture)) {
+                const removedArgTypes = srcTypeArgs.splice(destUnboundedOrVariadicIndex, srcArgsToCapture).map((t) => {
+                    if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type) && !t.type.isVariadicInUnion) {
+                        return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
                     }
-                }
+                    return t.type;
+                });
+                srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
+                    type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
+                    isUnbounded: false,
+                });
             }
         }
         return destTypeArgs.length === srcTypeArgs.length;
@@ -17367,7 +17354,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return true;
             }
             if ((0, types_1.isFunction)(concreteSrcType)) {
-                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(concreteSrcType)), flags, recursionCount)) {
+                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(concreteSrcType)), flags, recursionCount)) {
                     return true;
                 }
             }