Update to 2.0.4

lerna.json

@@ -2,7 +2,7 @@
     "packages": [
         "packages/*"
     ],
-    "version": "1.1.320",
+    "version": "1.1.323",
     "command": {
         "version": {
             "push": false,

packages/pyright-internal/package.json

@@ -2,7 +2,7 @@
     "name": "pyright-internal",
     "displayName": "pyright",
     "description": "Type checker for the Python language",
-    "version": "1.1.320",
+    "version": "1.1.323",
     "license": "MIT",
     "private": true,
     "files": [

packages/pyright-internal/src/analyzer/backgroundAnalysisProgram.ts

@@ -11,14 +11,15 @@ import { CancellationToken } from 'vscode-languageserver';
 
 import { BackgroundAnalysisBase } from '../backgroundAnalysisBase';
 import { ConfigOptions, ExecutionEnvironment } from '../common/configOptions';
-import { ConsoleInterface } from '../common/console';
 import { Diagnostic } from '../common/diagnostic';
 import { FileDiagnostics } from '../common/diagnosticSink';
 import { Range } from '../common/textRange';
 import { AnalysisCompleteCallback, analyzeProgram } from './analysis';
 import { CacheManager } from './cacheManager';
 import { ImportResolver } from './importResolver';
-import { MaxAnalysisTime, OpenFileOptions, Program, ISourceFileFactory } from './program';
+import { MaxAnalysisTime, OpenFileOptions, Program } from './program';
+import { ServiceProvider } from '../common/serviceProvider';
+import '../common/serviceProviderExtensions';
 
 export enum InvalidatedReason {
     Reanalyzed,
@@ -35,21 +36,19 @@ export class BackgroundAnalysisProgram {
 
     constructor(
         protected readonly serviceId: string,
-        private readonly _console: ConsoleInterface,
+        private readonly _serviceProvider: ServiceProvider,
         private _configOptions: ConfigOptions,
         private _importResolver: ImportResolver,
         private _backgroundAnalysis?: BackgroundAnalysisBase,
         private readonly _maxAnalysisTime?: MaxAnalysisTime,
         private readonly _disableChecker?: boolean,
-        cacheManager?: CacheManager,
-        sourceFileFactory?: ISourceFileFactory
+        cacheManager?: CacheManager
     ) {
         this._program = new Program(
             this.importResolver,
             this.configOptions,
-            this._console,
+            this._serviceProvider,
             undefined,
-            sourceFileFactory,
             this._disableChecker,
             cacheManager,
             serviceId
@@ -162,7 +161,7 @@ export class BackgroundAnalysisProgram {
             this._maxAnalysisTime,
             this._configOptions,
             this._onAnalysisCompletion,
-            this._console,
+            this._serviceProvider.console(),
             token
         );
     }
@@ -198,7 +197,7 @@ export class BackgroundAnalysisProgram {
             /* maxTime */ undefined,
             this._configOptions,
             this._onAnalysisCompletion,
-            this._console,
+            this._serviceProvider.console(),
             token
         );
         return this._program.writeTypeStub(targetImportPath, targetIsSingleFile, stubPath, token);
@@ -273,7 +272,7 @@ export class BackgroundAnalysisProgram {
 
 export type BackgroundAnalysisProgramFactory = (
     serviceId: string,
-    console: ConsoleInterface,
+    serviceProvider: ServiceProvider,
     configOptions: ConfigOptions,
     importResolver: ImportResolver,
     backgroundAnalysis?: BackgroundAnalysisBase,

packages/pyright-internal/src/analyzer/checker.ts

@@ -94,6 +94,7 @@ import { OperatorType, StringTokenFlags, TokenType } from '../parser/tokenizerTy
 import { AnalyzerFileInfo } from './analyzerFileInfo';
 import * as AnalyzerNodeInfo from './analyzerNodeInfo';
 import { Declaration, DeclarationType, isAliasDeclaration } from './declaration';
+import { getNameNodeForDeclaration } from './declarationUtils';
 import { ImportResolver, ImportedModuleDescriptor, createImportedModuleDescriptor } from './importResolver';
 import { ImportResult, ImportType } from './importResult';
 import { getRelativeModuleName, getTopLevelImports } from './importStatementUtils';
@@ -578,13 +579,15 @@ export class Checker extends ParseTreeWalker {
                 this.walk(param.typeAnnotationComment);
             }
 
+            // Look for method parameters that are typed with TypeVars that have the wrong variance.
             if (functionTypeResult) {
                 const annotationNode = param.typeAnnotation || param.typeAnnotationComment;
                 if (annotationNode && index < functionTypeResult.functionType.details.parameters.length) {
                     const paramType = functionTypeResult.functionType.details.parameters[index].type;
                     const exemptMethods = ['__init__', '__new__'];
 
                     if (
+                        containingClassNode &&
                         isTypeVar(paramType) &&
                         paramType.details.declaredVariance === Variance.Covariant &&
                         !paramType.details.isSynthesized &&
@@ -1039,6 +1042,7 @@ export class Checker extends ParseTreeWalker {
     override visitYieldFrom(node: YieldFromNode) {
         const yieldFromType = this._evaluator.getType(node.expression) || UnknownType.create();
         let yieldType: Type | undefined;
+        let sendType: Type | undefined;
 
         if (isClassInstance(yieldFromType) && ClassType.isBuiltIn(yieldFromType, 'Coroutine')) {
             // Handle the case of old-style (pre-await) coroutines.
@@ -1054,14 +1058,15 @@ export class Checker extends ParseTreeWalker {
             const generatorTypeArgs = getGeneratorTypeArgs(yieldType);
             if (generatorTypeArgs) {
                 yieldType = generatorTypeArgs.length >= 1 ? generatorTypeArgs[0] : UnknownType.create();
+                sendType = generatorTypeArgs.length >= 2 ? generatorTypeArgs[1] : undefined;
             } else {
                 yieldType =
                     this._evaluator.getTypeOfIterator({ type: yieldFromType }, /* isAsync */ false, node)?.type ??
                     UnknownType.create();
             }
         }
 
-        this._validateYieldType(node, yieldType);
+        this._validateYieldType(node, yieldType, sendType);
 
         return true;
     }
@@ -1492,11 +1497,14 @@ export class Checker extends ParseTreeWalker {
         }
 
         this._conditionallyReportShadowedImport(node);
+
         if (!node.isWildcardImport) {
             node.imports.forEach((importAs) => {
                 this._evaluator.evaluateTypesForStatement(importAs);
             });
         } else {
+            this._evaluator.evaluateTypesForStatement(node);
+
             const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
             if (
                 importInfo &&
@@ -2714,7 +2722,7 @@ export class Checker extends ParseTreeWalker {
                     UnknownType.create();
 
                 resultingExceptionType = mapSubtypes(iterableType, (subtype) => {
-                    if (isAnyOrUnknown(subtype)) {
+                    if (isAnyOrUnknown(subtype) || isNever(subtype)) {
                         return subtype;
                     }
 
@@ -5778,7 +5786,7 @@ export class Checker extends ParseTreeWalker {
                                 name: memberName,
                                 className: baseClassAndSymbol.classType.details.name,
                             }) + diagAddendum.getString(),
-                            lastDecl.node
+                            getNameNodeForDeclaration(lastDecl) ?? lastDecl.node
                         );
 
                         const origDecl = getLastTypedDeclaredForSymbol(baseClassAndSymbol.symbol);
@@ -5849,7 +5857,7 @@ export class Checker extends ParseTreeWalker {
                                 name: memberName,
                                 className: baseClassAndSymbol.classType.details.name,
                             }),
-                            lastDecl.node
+                            getNameNodeForDeclaration(lastDecl) ?? lastDecl.node
                         );
 
                         const origDecl = getLastTypedDeclaredForSymbol(baseClassAndSymbol.symbol);
@@ -6176,7 +6184,7 @@ export class Checker extends ParseTreeWalker {
 
     // Determines whether a yield or yield from node is compatible with the
     // return type annotation of the containing function.
-    private _validateYieldType(node: YieldNode | YieldFromNode, yieldType: Type) {
+    private _validateYieldType(node: YieldNode | YieldFromNode, yieldType: Type, sendType?: Type) {
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
         if (!enclosingFunctionNode || !enclosingFunctionNode.returnTypeAnnotation) {
             return;
@@ -6226,8 +6234,9 @@ export class Checker extends ParseTreeWalker {
             return;
         }
 
+        const generatorTypeArgs = [yieldType, sendType ?? UnknownType.create(), UnknownType.create()];
         const specializedGenerator = ClassType.cloneAsInstance(
-            ClassType.cloneForSpecialization(generatorType, [yieldType], /* isTypeArgumentExplicit */ true)
+            ClassType.cloneForSpecialization(generatorType, generatorTypeArgs, /* isTypeArgumentExplicit */ true)
         );
 
         const diagAddendum = new DiagnosticAddendum();
@@ -6319,7 +6328,7 @@ export class Checker extends ParseTreeWalker {
                 });
 
                 // Were all of the exception types overridden?
-                if (typesOfThisExcept.length === overriddenExceptionCount) {
+                if (typesOfThisExcept.length > 0 && typesOfThisExcept.length === overriddenExceptionCount) {
                     this._evaluator.addDiagnostic(
                         this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues,
                         DiagnosticRule.reportGeneralTypeIssues,

packages/pyright-internal/src/analyzer/codeFlowEngine.ts

@@ -274,7 +274,7 @@ export function getCodeFlowEngine(
                         'setIncompleteSubtype can be called only on a valid incomplete cache entry: ' +
                             `prev cache entry?: ${!cachedEntry} ` +
                             `index=${index} ` +
-                            `isPending=${isPending}` +
+                            `isPending=${isPending} ` +
                             `evaluationCount=${evaluationCount}`
                     );
                 }
@@ -956,16 +956,16 @@ export function getCodeFlowEngine(
                                             ? UnknownType.create(/* isIncomplete */ true)
                                             : NeverType.createNever()),
                                     flowTypeResult.isIncomplete,
-                                    /* isPending */ false,
+                                    /* isPending */ firstAntecedentTypeIsPending,
                                     entryEvaluationCount + 1
                                 );
                             } catch (e) {
-                                setIncompleteSubtype(
+                                cacheEntry = setIncompleteSubtype(
                                     loopNode,
                                     index,
                                     UnknownType.create(/* isIncomplete */ true),
                                     /* isIncomplete */ true,
-                                    /* isPending */ false,
+                                    /* isPending */ firstAntecedentTypeIsPending,
                                     entryEvaluationCount + 1
                                 );
                                 throw e;
@@ -1452,7 +1452,7 @@ export function getCodeFlowEngine(
             let subtypeCount = 0;
 
             // Evaluate the call base type.
-            const callTypeResult = evaluator.getTypeOfExpression(node.leftExpression, EvaluatorFlags.DoNotSpecialize);
+            const callTypeResult = evaluator.getTypeOfExpression(node.leftExpression, EvaluatorFlags.CallBaseDefaults);
             const callType = callTypeResult.type;
 
             doForEachSubtype(callType, (callSubtype) => {

packages/pyright-internal/src/analyzer/constraintSolver.ts

@@ -365,7 +365,7 @@ export function assignTypeToTypeVar(
                     )
                 ) {
                     if (!typeVarContext.isLocked() && isTypeVarInScope) {
-                        typeVarContext.setTypeVarType(destType, constrainedType);
+                        updateTypeVarType(evaluator, typeVarContext, destType, constrainedType, curWideTypeBound);
                     }
                 } else {
                     diag?.addMessage(
@@ -380,7 +380,7 @@ export function assignTypeToTypeVar(
         } else {
             // Assign the type to the type var.
             if (!typeVarContext.isLocked() && isTypeVarInScope) {
-                typeVarContext.setTypeVarType(destType, constrainedType);
+                updateTypeVarType(evaluator, typeVarContext, destType, constrainedType, curWideTypeBound);
             }
         }
 
@@ -708,29 +708,49 @@ export function assignTypeToTypeVar(
     }
 
     if (!typeVarContext.isLocked() && isTypeVarInScope) {
-        let newNarrowTypeBoundNoLiterals: Type | undefined;
+        updateTypeVarType(
+            evaluator,
+            typeVarContext,
+            destType,
+            newNarrowTypeBound,
+            newWideTypeBound,
+            (flags & (AssignTypeFlags.PopulatingExpectedType | AssignTypeFlags.RetainLiteralsForTypeVar)) !== 0
+        );
+    }
 
-        if (
-            newNarrowTypeBound &&
-            (flags & (AssignTypeFlags.PopulatingExpectedType | AssignTypeFlags.RetainLiteralsForTypeVar)) === 0
-        ) {
-            const strippedLiteral = isVariadicTypeVar(destType)
-                ? stripLiteralValueForUnpackedTuple(evaluator, newNarrowTypeBound)
-                : evaluator.stripLiteralValue(newNarrowTypeBound);
-
-            // Strip the literals from the narrow type bound and see if it is still
-            // narrower than the wide bound.
-            if (strippedLiteral !== newNarrowTypeBound) {
-                if (!newWideTypeBound || evaluator.assignType(newWideTypeBound, strippedLiteral)) {
-                    newNarrowTypeBoundNoLiterals = strippedLiteral;
-                }
+    return true;
+}
+
+// Updates the narrow and wide type bounds for a type variable. It also calculates the
+// narrowTypeBoundNoLiterals, which is a variant of the narrow type bound that has
+// literals stripped. By default, the constraint solver always uses the "no literals"
+// type in its solutions unless the version with literals is required to satisfy
+// the wide type bound.
+export function updateTypeVarType(
+    evaluator: TypeEvaluator,
+    typeVarContext: TypeVarContext,
+    destType: TypeVarType,
+    narrowTypeBound: Type | undefined,
+    wideTypeBound: Type | undefined,
+    forceRetainLiterals = false
+) {
+    let narrowTypeBoundNoLiterals: Type | undefined;
+
+    if (narrowTypeBound && !forceRetainLiterals) {
+        const strippedLiteral = isVariadicTypeVar(destType)
+            ? stripLiteralValueForUnpackedTuple(evaluator, narrowTypeBound)
+            : evaluator.stripLiteralValue(narrowTypeBound);
+
+        // Strip the literals from the narrow type bound and see if it is still
+        // narrower than the wide bound.
+        if (strippedLiteral !== narrowTypeBound) {
+            if (!wideTypeBound || evaluator.assignType(wideTypeBound, strippedLiteral)) {
+                narrowTypeBoundNoLiterals = strippedLiteral;
             }
         }
-
-        typeVarContext.setTypeVarType(destType, newNarrowTypeBound, newNarrowTypeBoundNoLiterals, newWideTypeBound);
     }
 
-    return true;
+    typeVarContext.setTypeVarType(destType, narrowTypeBound, narrowTypeBoundNoLiterals, wideTypeBound);
 }
 
 function assignTypeToParamSpec(
@@ -806,6 +826,7 @@ function assignTypeToParamSpec(
                         FunctionType.addParameter(newFunction, param);
                     });
                     newFunction.details.typeVarScopeId = srcType.details.typeVarScopeId;
+                    newFunction.details.constructorTypeVarScopeId = srcType.details.constructorTypeVarScopeId;
                     newFunction.details.paramSpecTypeVarScopeId = srcType.details.paramSpecTypeVarScopeId;
                     newFunction.details.docString = srcType.details.docString;
                     newFunction.details.paramSpec = srcType.details.paramSpec;
@@ -846,7 +867,7 @@ export function populateTypeVarContextBasedOnExpectedType(
 ): boolean {
     if (isAny(expectedType)) {
         type.details.typeParameters.forEach((typeParam) => {
-            typeVarContext.setTypeVarType(typeParam, expectedType);
+            updateTypeVarType(evaluator, typeVarContext, typeParam, expectedType, expectedType);
         });
         return true;
     }
@@ -891,10 +912,11 @@ export function populateTypeVarContextBasedOnExpectedType(
                 if (typeArgValue) {
                     const variance = TypeVarType.getVariance(entry.typeVar);
 
-                    typeVarContext.setTypeVarType(
+                    updateTypeVarType(
+                        evaluator,
+                        typeVarContext,
                         entry.typeVar,
                         variance === Variance.Covariant ? undefined : typeArgValue,
-                        /* narrowBoundNoLiterals */ undefined,
                         variance === Variance.Contravariant ? undefined : typeArgValue
                     );
 
@@ -1016,10 +1038,11 @@ export function populateTypeVarContextBasedOnExpectedType(
                             typeArgValue = UnknownType.create();
                         }
 
-                        typeVarContext.setTypeVarType(
+                        updateTypeVarType(
+                            evaluator,
+                            typeVarContext,
                             targetTypeVar,
                             variance === Variance.Covariant ? undefined : typeArgValue,
-                            /* narrowBoundNoLiterals */ undefined,
                             variance === Variance.Contravariant ? undefined : typeArgValue
                         );
                     } else {