@zzzen/pyright-internal 1.1.254 → 1.2.0-dev.2022-07-02

package/dist/analyzer/checker.js

@@ -57,6 +57,7 @@ const staticExpressions_1 = require("./staticExpressions");
 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");
@@ -459,6 +460,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitFor(node) {
         this._evaluator.evaluateTypesForStatement(node);
+        if (node.typeComment) {
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.annotationNotSupported(), node.typeComment);
+        }
         return true;
     }
     visitList(node) {
@@ -495,6 +499,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         node.withItems.forEach((item) => {
             this._evaluator.evaluateTypesForStatement(item);
         });
+        if (node.typeComment) {
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.annotationNotSupported(), node.typeComment);
+        }
         return true;
     }
     visitReturn(node) {
@@ -1769,14 +1776,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             else if (otherDecl.type === 3 /* Function */) {
                 const primaryType = this._evaluator.getTypeForDeclaration(primaryDecl);
+                let duplicateIsOk = false;
                 // If the return type has not yet been inferred, do so now.
                 if (primaryType && (0, types_1.isFunction)(primaryType)) {
                     this._evaluator.getFunctionInferredReturnType(primaryType);
                 }
-                let duplicateIsOk = false;
                 const otherType = this._evaluator.getTypeForDeclaration(otherDecl);
                 const suite1 = ParseTreeUtils.getEnclosingSuite(primaryDecl.node);
                 const suite2 = ParseTreeUtils.getEnclosingSuite(otherDecl.node);
+                // Allow same-signature overrides in cases where the declarations
+                // are not within the same statement suite (e.g. one in the "if"
+                // and another in the "else").
                 const isInSameStatementList = suite1 === suite2;
                 // If the return type has not yet been inferred, do so now.
                 if (otherType && (0, types_1.isFunction)(otherType)) {
@@ -1784,10 +1794,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 // If both declarations are functions, it's OK if they
                 // both have the same signatures.
-                if (primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
+                if (!isInSameStatementList && primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
                     duplicateIsOk = true;
                 }
-                if (!duplicateIsOk || isInSameStatementList) {
+                if (!duplicateIsOk) {
                     const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, otherDecl.isMethod
                         ? localize_1.Localizer.Diagnostic.obscuredMethodDeclaration().format({ name })
                         : localize_1.Localizer.Diagnostic.obscuredFunctionDeclaration().format({ name }), otherDecl.node.name);
@@ -1816,18 +1826,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                 }
-                else if (primaryType && !(0, typeUtils_1.isProperty)(primaryType)) {
-                    if (primaryDecl.type === 3 /* Function */ || primaryDecl.type === 4 /* Class */) {
-                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredVariableDeclaration().format({ name }), otherDecl.node);
-                        addPrimaryDeclInfo(diag);
-                    }
-                }
             }
         }
     }
     _conditionallyReportUnusedSymbol(name, symbol, scopeType) {
-        const accessedSymbolMap = this._fileInfo.accessedSymbolMap;
-        if (symbol.isIgnoredForProtocolMatch() || accessedSymbolMap.has(symbol.id)) {
+        const accessedSymbolSet = this._fileInfo.accessedSymbolSet;
+        if (symbol.isIgnoredForProtocolMatch() || accessedSymbolSet.has(symbol.id)) {
             return;
         }
         // A name of "_" means "I know this symbol isn't used", so
@@ -2087,18 +2091,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const filterType = (varType) => {
             const filteredTypes = [];
             for (const filterType of classTypeList) {
-                // Handle the special case where the variable type is a TypedDict and
-                // we're filtering against 'dict'. TypedDict isn't derived from dict,
-                // but at runtime, isinstance returns True.
-                const filterIsSuperclass = types_1.ClassType.isDerivedFrom(varType, filterType) ||
-                    (isInstanceCheck &&
-                        types_1.ClassType.isProtocolClass(filterType) &&
-                        this._evaluator.assignType(filterType, varType)) ||
-                    (types_1.ClassType.isBuiltIn(filterType, 'dict') && types_1.ClassType.isTypedDictClass(varType));
-                const filterIsSubclass = types_1.ClassType.isDerivedFrom(filterType, varType) ||
-                    (isInstanceCheck &&
-                        types_1.ClassType.isProtocolClass(varType) &&
-                        this._evaluator.assignType(varType, filterType));
+                const filterIsSuperclass = (0, typeGuards_1.isIsinstanceFilterSuperclass)(this._evaluator, varType, filterType, filterType, isInstanceCheck);
+                const filterIsSubclass = (0, typeGuards_1.isIsinstanceFilterSubclass)(this._evaluator, varType, filterType, filterType, isInstanceCheck);
                 // Normally, a class should never be both a subclass and a
                 // superclass. However, this can happen if one of the classes
                 // derives from an unknown type. In this case, we'll add an
@@ -2645,8 +2639,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         // Collect the list of init-only variables in the order they were declared.
         const initOnlySymbolMap = new Map();
-        for (let i = classType.details.mro.length - 1; i >= 0; i--) {
-            const mroClass = classType.details.mro[i];
+        types_1.ClassType.getReverseMro(classType).forEach((mroClass) => {
             if ((0, types_1.isClass)(mroClass) && types_1.ClassType.isDataClass(mroClass)) {
                 mroClass.details.fields.forEach((symbol, name) => {
                     if (symbol.isInitVar()) {
@@ -2654,7 +2647,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 });
             }
-        }
+        });
         const postInitType = this._evaluator.getTypeOfMember(postInitMember);
         if (!(0, types_1.isFunction)(postInitType) ||
             !types_1.FunctionType.isInstanceMethod(postInitType) ||