@zzzen/pyright-internal 1.2.0-dev.20230122 → 1.2.0-dev.20230205

package/dist/analyzer/checker.js

@@ -1,17 +1,4 @@
 "use strict";
-/*
- * checker.ts
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT license.
- * Author: Eric Traut
- *
- * A parse tree walker that performs static type checking for
- * a source file. Most of its work is performed by the type
- * evaluator, but this module touches every node in the file
- * to ensure that all statements and expressions are evaluated
- * and checked. It also performs some additional checks that
- * cannot (or should not be) performed lazily.
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
@@ -33,6 +20,20 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Checker = void 0;
+/*
+ * checker.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * A parse tree walker that performs static type checking for
+ * a source file. Most of its work is performed by the type
+ * evaluator, but this module touches every node in the file
+ * to ensure that all statements and expressions are evaluated
+ * and checked. It also performs some additional checks that
+ * cannot (or should not be) performed lazily.
+ */
+const vscode_languageserver_1 = require("vscode-languageserver");
 const debug_1 = require("../common/debug");
 const diagnostic_1 = require("../common/diagnostic");
 const diagnosticRules_1 = require("../common/diagnosticRules");
@@ -104,12 +105,13 @@ const deprecatedSpecialForms = new Map([
 // functions to be emitted.
 const isPrintCodeComplexityEnabled = false;
 class Checker extends parseTreeWalker_1.ParseTreeWalker {
-    constructor(_importResolver, _evaluator, _parseResults, _sourceMapper) {
+    constructor(_importResolver, _evaluator, _parseResults, _sourceMapper, _dependentFiles) {
         super();
         this._importResolver = _importResolver;
         this._evaluator = _evaluator;
         this._parseResults = _parseResults;
         this._sourceMapper = _sourceMapper;
+        this._dependentFiles = _dependentFiles;
         this._isUnboundCheckSuppressed = false;
         // A list of all nodes that are defined within the module that
         // have their own scopes.
@@ -764,6 +766,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateComparisonTypes(node);
             }
         }
+        else if (node.operator === 39 /* Is */ || node.operator === 40 /* IsNot */) {
+            // Don't apply this rule if it's within an assert.
+            if (!ParseTreeUtils.isWithinAssertExpression(node)) {
+                this._validateComparisonTypesForIsOperator(node);
+            }
+        }
         else if (node.operator === 41 /* In */ || node.operator === 42 /* NotIn */) {
             // Don't apply this rule if it's within an assert.
             if (!ParseTreeUtils.isWithinAssertExpression(node)) {
@@ -1154,6 +1162,36 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }), node);
         }
     }
+    // Determines whether the types of the two operands for an "is" or "is not"
+    // operation have overlapping types.
+    _validateComparisonTypesForIsOperator(node) {
+        const rightType = this._evaluator.getType(node.rightExpression);
+        if (!rightType || !(0, types_1.isNoneInstance)(rightType)) {
+            return;
+        }
+        const leftType = this._evaluator.getType(node.leftExpression);
+        if (!leftType) {
+            return;
+        }
+        let foundMatchForNone = false;
+        (0, typeUtils_1.doForEachSubtype)(leftType, (subtype) => {
+            subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
+            if (this._evaluator.assignType(subtype, types_1.NoneType.createInstance())) {
+                foundMatchForNone = true;
+            }
+        });
+        const getMessage = () => {
+            return node.operator === 39 /* Is */
+                ? localize_1.Localizer.Diagnostic.comparisonAlwaysFalse()
+                : localize_1.Localizer.Diagnostic.comparisonAlwaysTrue();
+        };
+        if (!foundMatchForNone) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
+                leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
+                rightType: this._evaluator.printType(rightType),
+            }), node);
+        }
+    }
     // Determines whether the types of the two operands for an == or != operation
     // have overlapping types.
     _validateComparisonTypes(node) {
@@ -1732,11 +1770,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     _validateSymbolTables() {
+        var _a;
+        const dependentFileInfo = (_a = this._dependentFiles) === null || _a === void 0 ? void 0 : _a.map((p) => AnalyzerNodeInfo.getFileInfo(p.parseTree));
         for (const scopedNode of this._scopedNodes) {
             const scope = AnalyzerNodeInfo.getScope(scopedNode);
             if (scope) {
                 scope.symbolTable.forEach((symbol, name) => {
-                    this._conditionallyReportUnusedSymbol(name, symbol, scope.type);
+                    this._conditionallyReportUnusedSymbol(name, symbol, scope.type, dependentFileInfo);
                     this._reportIncompatibleDeclarations(name, symbol);
                     this._reportMultipleFinalDeclarations(name, symbol, scope.type);
                     this._reportMultipleTypeAliasDeclarations(name, symbol);
@@ -2079,11 +2119,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    _conditionallyReportUnusedSymbol(name, symbol, scopeType) {
+    _conditionallyReportUnusedSymbol(name, symbol, scopeType, dependentFileInfo) {
         const accessedSymbolSet = this._fileInfo.accessedSymbolSet;
-        if (symbol.isIgnoredForProtocolMatch() ||
-            accessedSymbolSet.has(symbol.id) ||
-            this._fileInfo.ipythonMode === sourceFile_1.IPythonMode.CellDocs) {
+        if (symbol.isIgnoredForProtocolMatch() || accessedSymbolSet.has(symbol.id)) {
+            return;
+        }
+        // If this file is implicitly imported by other files, we need to make sure the symbol defined in
+        // the current file is not accessed from those other files.
+        if (dependentFileInfo && dependentFileInfo.some((i) => i.accessedSymbolSet.has(symbol.id))) {
             return;
         }
         // A name of "_" means "I know this symbol isn't used", so
@@ -2650,7 +2693,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const stdlibPath = this._importResolver.getTypeshedStdLibPath(this._fileInfo.executionEnvironment);
         if (stdlibPath && this._importResolver.isStdlibModule(module, this._fileInfo.executionEnvironment)) {
             // If the definition for this name is in 'user' module, it is overwriting the stdlib module.
-            const definitions = definitionProvider_1.DefinitionProvider.getDefinitionsForNode(this._sourceMapper, namePartNodes[namePartNodes.length - 1], definitionProvider_1.DefinitionFilter.All, this._evaluator);
+            const definitions = definitionProvider_1.DefinitionProvider.getDefinitionsForNode(this._sourceMapper, namePartNodes[namePartNodes.length - 1], definitionProvider_1.DefinitionFilter.All, this._evaluator, vscode_languageserver_1.CancellationToken.None);
             const paths = definitions ? definitions.map((d) => d.path) : [];
             paths.forEach((p) => {
                 if (!p.startsWith(stdlibPath) && !(0, sourceMapper_1.isStubFile)(p) && this._sourceMapper.isUserCode(p)) {