@zzzen/pyright-internal 1.2.0-dev.20230507 → 1.2.0-dev.20230514

package/dist/analyzer/backgroundAnalysisProgram.d.ts

@@ -45,7 +45,7 @@ export declare class BackgroundAnalysisProgram {
     startIndexing(indexOptions: IndexOptions): void;
     refreshIndexing(refreshOptions?: RefreshOptions): void;
     cancelIndexing(): void;
-    getIndexing(filePath: string): Map<string, import("../languageService/documentSymbolProvider").IndexResults> | undefined;
+    getIndexing(filePath: string): Map<string, import("../languageService/symbolIndexer").IndexResults> | undefined;
     getDiagnosticsForRange(filePath: string, range: Range, token: CancellationToken): Promise<Diagnostic[]>;
     writeTypeStub(targetImportPath: string, targetIsSingleFile: boolean, stubPath: string, token: CancellationToken): Promise<any>;
     invalidateAndForceReanalysis(rebuildUserFileIndexing: boolean, rebuildLibraryIndexing: boolean, refreshOptions?: RefreshOptions): void;

package/dist/analyzer/checker.js

@@ -213,7 +213,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.name);
             this._validateConstructorConsistency(classTypeResult.classType);
             this._validateFinalMemberOverrides(classTypeResult.classType);
-            this._validateInstanceVariableInitialization(classTypeResult.classType);
+            this._validateInstanceVariableInitialization(node, classTypeResult.classType);
             this._validateFinalClassNotAbstract(classTypeResult.classType, node);
             this._validateDataClassPostInit(classTypeResult.classType, node);
             this._validateProtocolCompatibility(classTypeResult.classType, node);
@@ -3297,7 +3297,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     // Reports the case where an instance variable is not declared or initialized
     // within the class body or constructor method.
-    _validateInstanceVariableInitialization(classType) {
+    _validateInstanceVariableInitialization(node, classType) {
         // This check doesn't apply to stub files.
         if (this._fileInfo.isStubFile) {
             return;
@@ -3313,7 +3313,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             (types_1.ClassType.supportsAbstractMethods(classType) && !types_1.ClassType.isFinal(classType))) {
             return;
         }
+        // If the class is final, see if it has any abstract base classes that define
+        // variables. We need to make sure these are initialized.
+        const abstractSymbols = new Map();
+        if (types_1.ClassType.isFinal(classType)) {
+            (0, typeUtils_1.getProtocolSymbolsRecursive)(classType, abstractSymbols, 512 /* SupportsAbstractMethods */);
+        }
         classType.details.fields.forEach((localSymbol, name) => {
+            abstractSymbols.delete(name);
             // This applies only to instance members.
             if (!localSymbol.isInstanceMember()) {
                 return;
@@ -3365,6 +3372,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Report the variable as uninitialized only on the first decl.
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUninitializedInstanceVariable, diagnosticRules_1.DiagnosticRule.reportUninitializedInstanceVariable, localize_1.Localizer.Diagnostic.uninitializedInstanceVariable().format({ name: name }), decls[0].node);
         });
+        // See if there are any variables from abstract base classes
+        // that are not initialized.
+        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        abstractSymbols.forEach((member, name) => {
+            const decls = member.symbol.getDeclarations();
+            if (decls.length === 0 || !(0, types_1.isClass)(member.classType)) {
+                return;
+            }
+            if (decls[0].type === 1 /* Variable */) {
+                // If none of the declarations involve assignments, assume it's
+                // not implemented in the protocol.
+                if (!decls.some((decl) => decl.type === 1 /* Variable */ && !!decl.inferredTypeSource)) {
+                    // This is a variable declaration that is not implemented in the
+                    // protocol base class. Make sure it's implemented in the derived class.
+                    diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.uninitializedAbstractVariable().format({
+                        name,
+                        classType: member.classType.details.name,
+                    }));
+                }
+            }
+        });
+        if (!diagAddendum.isEmpty()) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUninitializedInstanceVariable, diagnosticRules_1.DiagnosticRule.reportUninitializedInstanceVariable, localize_1.Localizer.Diagnostic.uninitializedAbstractVariables().format({ classType: classType.details.name }) +
+                diagAddendum.getString(), node.name);
+        }
     }
     // Validates that the type variables used in a generic protocol class have
     // the proper variance (invariant, covariant, contravariant). See PEP 544
@@ -3853,6 +3885,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
             return;
         }
+        if (baseClassAndSymbol.symbol.isIgnoredForOverrideChecks()) {
+            return;
+        }
         // If the base class doesn't provide a type declaration, we won't bother
         // proceeding with additional checks. Type inference is too inaccurate
         // in this case, plus it would be very slow.