Merge 1.1.392

package.json

@@ -31,7 +31,7 @@
     "devDependencies": {
         "@detachhead/ts-helpers": "^16.2.0",
         "@types/glob": "^7.2.0",
-        "@types/node": "^22.7.0",
+        "@types/node": "^22.10.5",
         "@types/yargs": "^16.0.9",
         "@typescript-eslint/eslint-plugin": "^6.21.0",
         "@typescript-eslint/parser": "^6.21.0",

packages/browser-pyright/package.json

@@ -26,12 +26,12 @@
     },
     "devDependencies": {
         "@types/copy-webpack-plugin": "^8.0.1",
-        "@types/node": "^22.7.0",
+        "@types/node": "^22.10.5",
         "copy-webpack-plugin": "^11.0.0",
         "shx": "^0.3.4",
         "ts-loader": "^9.5.1",
         "typescript": "~5.5.4",
-        "webpack": "^5.94.0",
+        "webpack": "^5.97.1",
         "webpack-cli": "^5.1.4",
         "webpack-virtual-modules": "^0.6.2"
     },

packages/pyright-internal/package.json

@@ -2,7 +2,7 @@
     "name": "pyright-internal",
     "displayName": "pyright",
     "description": "Type checker for the Python language",
-    "version": "1.1.391",
+    "version": "1.1.392",
     "license": "MIT",
     "private": true,
     "files": [
@@ -43,9 +43,9 @@
         "@types/command-line-args": "^5.2.3",
         "@types/diff": "^5.2.2",
         "@types/fs-extra": "^11.0.4",
-        "@types/jest": "^29.5.13",
-        "@types/lodash": "^4.17.7",
-        "@types/node": "^22.7.0",
+        "@types/jest": "^29.5.14",
+        "@types/lodash": "^4.17.14",
+        "@types/node": "^22.10.5",
         "@types/tmp": "^0.2.6",
         "copy-webpack-plugin": "^11.0.0",
         "esbuild-loader": "^3.2.0",
@@ -56,7 +56,7 @@
         "ts-jest": "^29.2.5",
         "ts-loader": "^9.5.1",
         "typescript": "~5.5.4",
-        "webpack": "^5.94.0",
+        "webpack": "^5.97.1",
         "webpack-cli": "^5.1.4",
         "word-wrap": "1.2.5"
     }

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

@@ -5978,34 +5978,18 @@ export class Checker extends ParseTreeWalker {
 
         if (isFunction(overriddenType) || isOverloaded(overriddenType)) {
             const diagAddendum = new DiagnosticAddendum();
-            let overrideFunction: FunctionType | undefined;
 
-            if (isFunction(overrideType)) {
-                overrideFunction = overrideType;
-            } else if (isOverloaded(overrideType)) {
-                // Use the last overload.
-                const impl = OverloadedType.getImplementation(overrideType);
-
-                // If the last overload isn't an implementation, skip the check for this symbol.
-                if (!impl || !isFunction(impl)) {
-                    return;
-                }
-
-                overrideFunction = impl;
-            }
-
-            if (overrideFunction) {
+            if (isFunction(overrideType) || isOverloaded(overrideType)) {
                 if (
                     !this._evaluator.validateOverrideMethod(
                         overriddenType,
-                        overrideFunction,
+                        overrideType,
                         /* baseClass */ undefined,
                         diagAddendum,
                         /* enforceParamNameMatch */ true
                     )
                 ) {
-                    const decl = overrideFunction.shared.declaration;
-                    if (decl && decl.type === DeclarationType.Function) {
+                    if (overrideDecl && overrideDecl.type === DeclarationType.Function) {
                         diag = this._evaluator.addDiagnostic(
                             DiagnosticRule.reportIncompatibleMethodOverride,
                             LocMessage.baseClassMethodTypeIncompatible().format({
@@ -6745,7 +6729,7 @@ export class Checker extends ParseTreeWalker {
             selfSpecializeClass(childClassType, { useBoundTypeVars: true })
         );
 
-        const baseType = partiallySpecializeType(
+        let baseType = partiallySpecializeType(
             this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol),
             baseClass,
             this._evaluator.getTypeClassType(),
@@ -6761,6 +6745,7 @@ export class Checker extends ParseTreeWalker {
 
         if (childClassType.shared.typeVarScopeId) {
             overrideType = makeTypeVarsBound(overrideType, [childClassType.shared.typeVarScopeId]);
+            baseType = makeTypeVarsBound(baseType, [childClassType.shared.typeVarScopeId]);
         }
 
         if (isFunction(baseType) || isOverloaded(baseType)) {

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

@@ -423,16 +423,20 @@ function validateNewMethod(
 
     const constraints = new ConstraintTracker();
 
-    const callResult = evaluator.useSpeculativeMode(useSpeculativeModeForArgs ? errorNode : undefined, () => {
-        return evaluator.validateCallArgs(
-            errorNode,
-            argList,
-            newMethodTypeResult,
-            constraints,
-            skipUnknownArgCheck,
-            inferenceContext
-        );
-    });
+    const callResult = evaluator.useSpeculativeMode(
+        useSpeculativeModeForArgs ? errorNode : undefined,
+        () => {
+            return evaluator.validateCallArgs(
+                errorNode,
+                argList,
+                newMethodTypeResult,
+                constraints,
+                skipUnknownArgCheck,
+                inferenceContext
+            );
+        },
+        { dependentType: newMethodTypeResult.type }
+    );
 
     if (callResult.isTypeIncomplete) {
         isTypeIncomplete = true;

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

@@ -35,7 +35,7 @@ import { TokenType } from '../parser/tokenizerTypes';
 import * as AnalyzerNodeInfo from './analyzerNodeInfo';
 import { ModuleNameAndType } from './importResolver';
 import { ImportResult, ImportType } from './importResult';
-import { findTokenAfter, getTokenAt } from './parseTreeUtils';
+import { getTokenAfter, getTokenAt } from './parseTreeUtils';
 import * as SymbolNameUtils from './symbolNameUtils';
 
 export interface ImportStatement {
@@ -797,8 +797,8 @@ function getEditsPreservingFirstCommentAfterCommaIfExist(
         return [{ start: offsetOfPreviousNodeEnd, length }];
     }
 
-    const commaToken = findTokenAfter(
-        parseFileResults.tokenizerOutput,
+    const commaToken = getTokenAfter(
+        parseFileResults.tokenizerOutput.tokens,
         TextRange.getEnd(previousNode),
         (t) => t.type === TokenType.Comma
     );

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

@@ -56,7 +56,7 @@ export class ParentDirectoryCache {
             this._libPathCache ??
             this._importRootGetter()
                 .map((r) => fs.realCasePath(r))
-                .filter((r) => r !== root)
+                .filter((r) => !r.equals(root))
                 .filter((r) => r.startsWith(root));
 
         if (this._libPathCache.some((p) => sourceFileUri.startsWith(p))) {

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

@@ -1909,6 +1909,35 @@ export function getTokenAtLeft(
     return tokens.getItemAt(index);
 }
 
+export function getTokenIndexAfter(
+    tokens: TextRangeCollection<Token>,
+    position: number,
+    predicate: (t: Token) => boolean
+) {
+    const index = tokens.getItemAtPosition(position);
+    if (index < 0) {
+        return -1;
+    }
+
+    for (let i = index; i < tokens.length; i++) {
+        const token = tokens.getItemAt(i);
+        if (predicate(token)) {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+export function getTokenAfter(tokens: TextRangeCollection<Token>, position: number, predicate: (t: Token) => boolean) {
+    const index = getTokenIndexAfter(tokens, position, predicate);
+    if (index < 0) {
+        return undefined;
+    }
+
+    return tokens.getItemAt(index);
+}
+
 export function isWhitespace(token: Token) {
     return token.type === TokenType.NewLine || token.type === TokenType.Indent || token.type === TokenType.Dedent;
 }
@@ -1941,24 +1970,6 @@ export function getIndexOfTokenOverlapping(tokens: TextRangeCollection<Token>, p
     return TextRange.overlaps(token, position) ? index : -1;
 }
 
-export function findTokenAfter(tokenizerOutput: TokenizerOutput, offset: number, predicate: (t: Token) => boolean) {
-    const tokens = tokenizerOutput.tokens;
-
-    const index = tokens.getItemAtPosition(offset);
-    if (index < 0) {
-        return undefined;
-    }
-
-    for (let i = index; i < tokens.length; i++) {
-        const token = tokens.getItemAt(i);
-        if (predicate(token)) {
-            return token;
-        }
-    }
-
-    return undefined;
-}
-
 export function getCommentsAtTokenIndex(tokens: TextRangeCollection<Token>, index: number) {
     let token = getTokenAtIndex(tokens, index);
     if (!token) {

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

@@ -962,7 +962,8 @@ export class Program {
             this._importResolver,
             this._configOptions,
             this.serviceProvider,
-            new LogTracker(this._console, 'Cloned')
+            new LogTracker(this._console, 'Cloned'),
+            this._disableChecker
         );
 
         // Cloned program will use whatever user files the program currently has.

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

@@ -142,7 +142,7 @@ export function clonePropertyWithSetter(
         const typeAnnotation = getTypeAnnotationForParam(errorNode, 1);
         if (typeAnnotation) {
             // Verify consistency of the type.
-            const fgetType = evaluator.getGetterTypeFromProperty(classType, /* inferTypeIfNeeded */ false);
+            const fgetType = evaluator.getGetterTypeFromProperty(classType);
             if (fgetType && !isAnyOrUnknown(fgetType)) {
                 const fsetType = evaluator.getTypeOfAnnotation(typeAnnotation, {
                     typeVarGetsCurScope: true,

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

@@ -654,7 +654,7 @@ function assignToProtocolInternal(
                     }
                 } else {
                     // Extract the property type from the property class.
-                    let getterType = evaluator.getGetterTypeFromProperty(destMemberType, /* inferTypeIfNeeded */ true);
+                    let getterType = evaluator.getGetterTypeFromProperty(destMemberType);
 
                     if (getterType) {
                         getterType = partiallySpecializeType(getterType, mroClass, evaluator.getTypeClassType());

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

@@ -58,7 +58,7 @@ export interface SpeculativeModeOptions {
 // a context is popped off the stack, all of the speculative type cache
 // entries that were created within that context are removed from the
 // corresponding type caches because they are no longer valid.
-// Each type context also contains a map of "speculative types" that are
+// The tracker also also contains a map of "speculative types" that are
 // contextually evaluated based on an "expected type" and potentially
 // one or more "dependent types". The "expected type" applies in cases
 // where the speculative root node is being evaluated with bidirectional