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

package/dist/analyzer/checker.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Checker = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
+const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const diagnostic_1 = require("../common/diagnostic");
 const diagnosticRules_1 = require("../common/diagnosticRules");
@@ -61,9 +62,9 @@ const SymbolNameUtils = __importStar(require("./symbolNameUtils"));
 const symbolUtils_1 = require("./symbolUtils");
 const typeEvaluator_1 = require("./typeEvaluator");
 const typeGuards_1 = require("./typeGuards");
-const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
 const typeVarContext_1 = require("./typeVarContext");
+const types_1 = require("./types");
 const deprecatedAliases = new Map([
     ['Tuple', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.tuple', replacementText: 'tuple' }],
     ['List', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.list', replacementText: 'list' }],
@@ -213,7 +214,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);
@@ -829,28 +830,47 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitStringList(node) {
+        // If this is Python 3.11 or older, there are several restrictions
+        // associated with f-strings that we need to validate. Determine whether
+        // we're within an f-string (or multiple f-strings if nesting is used).
+        const fStringContainers = [];
+        if (this._fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_12) {
+            let curNode = node;
+            while (curNode) {
+                if (curNode.nodeType === 27 /* FormatString */) {
+                    fStringContainers.push(curNode);
+                }
+                curNode = curNode.parent;
+            }
+        }
         for (const stringNode of node.strings) {
-            if (stringNode.hasUnescapeErrors) {
-                const unescapedResult = (0, stringTokenUtils_1.getUnescapedString)(stringNode.token);
+            const stringTokens = stringNode.nodeType === 49 /* String */ ? [stringNode.token] : stringNode.middleTokens;
+            stringTokens.forEach((token) => {
+                const unescapedResult = (0, stringTokenUtils_1.getUnescapedString)(token);
+                let start = token.start;
+                if (token.type === 5 /* String */) {
+                    start += token.prefixLength + token.quoteMarkLength;
+                }
                 unescapedResult.unescapeErrors.forEach((error) => {
-                    const start = stringNode.token.start +
-                        stringNode.token.prefixLength +
-                        stringNode.token.quoteMarkLength +
-                        error.offset;
-                    const textRange = { start, length: error.length };
                     if (error.errorType === 0 /* InvalidEscapeSequence */) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidStringEscapeSequence, diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence, localize_1.Localizer.Diagnostic.stringUnsupportedEscape(), textRange);
-                    }
-                    else if (error.errorType === 1 /* EscapeWithinFormatExpression */) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, 'error', '', localize_1.Localizer.Diagnostic.formatStringEscape(), textRange);
-                    }
-                    else if (error.errorType === 2 /* SingleCloseBraceWithinFormatLiteral */) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, 'error', '', localize_1.Localizer.Diagnostic.formatStringBrace(), textRange);
-                    }
-                    else if (error.errorType === 3 /* UnterminatedFormatExpression */) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, 'error', '', localize_1.Localizer.Diagnostic.formatStringUnterminated(), textRange);
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidStringEscapeSequence, diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence, localize_1.Localizer.Diagnostic.stringUnsupportedEscape(), { start: start + error.offset, length: error.length });
                     }
                 });
+                // Prior to Python 3.12, it was not allowed to include a slash in an f-string.
+                if (fStringContainers.length > 0) {
+                    const escapeOffset = token.escapedValue.indexOf('\\');
+                    if (escapeOffset >= 0) {
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, 'error', '', localize_1.Localizer.Diagnostic.formatStringEscape(), { start, length: 1 });
+                    }
+                }
+            });
+            // Prior to Python 3.12, it was not allowed to nest strings that
+            // used the same quote scheme within an f-string.
+            if (fStringContainers.length > 0) {
+                const quoteTypeMask = 1 /* SingleQuote */ | 2 /* DoubleQuote */ | 4 /* Triplicate */;
+                if (fStringContainers.some((fStringContainer) => (fStringContainer.token.flags & quoteTypeMask) === (stringNode.token.flags & quoteTypeMask))) {
+                    this._evaluator.addError(localize_1.Localizer.Diagnostic.formatStringNestedQuote(), stringNode);
+                }
             }
         }
         if (node.typeAnnotation) {
@@ -862,8 +882,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitFormatString(node) {
-        node.expressions.forEach((formatExpr) => {
-            this._evaluator.getType(formatExpr);
+        node.fieldExpressions.forEach((expr) => {
+            this._evaluator.getType(expr);
+        });
+        node.formatExpressions.forEach((expr) => {
+            this._evaluator.getType(expr);
         });
         return true;
     }
@@ -2737,7 +2760,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const desc = {
             nameParts: moduleName.split('.'),
             leadingDots: 0,
-            importedSymbols: [],
+            importedSymbols: new Set(),
         };
         const stdlibPath = this._importResolver.getTypeshedStdLibPath(this._fileInfo.executionEnvironment);
         if (stdlibPath &&
@@ -2783,7 +2806,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const module = {
             nameParts,
             leadingDots: 0,
-            importedSymbols: [],
+            importedSymbols: new Set(),
         };
         // Make sure the module is a potential stdlib one so we don't spend the time
         // searching for the definition.
@@ -3297,7 +3320,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 +3336,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, 1024 /* SupportsAbstractMethods */);
+        }
         classType.details.fields.forEach((localSymbol, name) => {
+            abstractSymbols.delete(name);
             // This applies only to instance members.
             if (!localSymbol.isInstanceMember()) {
                 return;
@@ -3365,6 +3395,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
@@ -3780,14 +3835,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (!firstOverride) {
                 // If this is a method decorated with @override, validate that there
                 // is a base class method of the same name.
-                this._validateOverrideDecoratorNotPresent(typeOfSymbol);
+                this._validateOverrideDecoratorNotPresent(symbol, typeOfSymbol);
             }
             else {
-                this._validateOverrideDecoratorPresent(typeOfSymbol, firstOverride);
+                this._validateOverrideDecoratorPresent(symbol, typeOfSymbol, firstOverride);
             }
         });
     }
-    _validateOverrideDecoratorPresent(overrideType, baseMember) {
+    _validateOverrideDecoratorPresent(symbol, overrideType, baseMember) {
         var _a;
         // Skip this check if disabled.
         if (this._fileInfo.diagnosticRuleSet.reportImplicitOverride === 'none') {
@@ -3816,6 +3871,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (overrideFunction.details.name === '__init__' || overrideFunction.details.name === '__new__') {
             return;
         }
+        // If the declaration for the override function is not the same as the
+        // declaration for the symbol, the function was probably replaced by a decorator.
+        if (!symbol.getDeclarations().some((decl) => decl === overrideFunction.details.declaration)) {
+            return;
+        }
         const funcNode = overrideFunction.details.declaration.node;
         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportImplicitOverride, diagnosticRules_1.DiagnosticRule.reportImplicitOverride, localize_1.Localizer.Diagnostic.overrideDecoratorMissing().format({
             name: funcNode.name.value,
@@ -3825,7 +3885,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Determines whether the type is a function or overloaded function with an @override
     // decorator. In this case, an error is reported because no base class has declared
     // a method of the same name.
-    _validateOverrideDecoratorNotPresent(overrideType) {
+    _validateOverrideDecoratorNotPresent(symbol, overrideType) {
         var _a;
         let overrideFunction;
         if ((0, types_1.isFunction)(overrideType)) {
@@ -3846,6 +3906,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.details.declaration) || !types_1.FunctionType.isOverridden(overrideFunction)) {
             return;
         }
+        // If the declaration for the override function is not the same as the
+        // declaration for the symbol, the function was probably replaced by a decorator.
+        if (!symbol.getDeclarations().some((decl) => decl === overrideFunction.details.declaration)) {
+            return;
+        }
         const funcNode = overrideFunction.details.declaration.node;
         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overriddenMethodNotFound().format({ name: funcNode.name.value }), funcNode.name);
     }
@@ -3853,6 +3918,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.
@@ -4387,7 +4455,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     this._evaluator.addUnreachableCode(except, except.exceptSuite);
                 }
             }
-            exceptionTypesSoFar.push(...typesOfThisExcept);
+            (0, collectionUtils_1.appendArray)(exceptionTypesSoFar, typesOfThisExcept);
         });
     }
     _reportDuplicateImports() {