@zzzen/pyright-internal 1.2.0-dev.20220904 → 1.2.0-dev.20220918

package/dist/analyzer/checker.js

@@ -291,7 +291,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             });
             // Check for invalid use of ParamSpec P.args and P.kwargs.
-            const paramSpecParams = functionTypeResult.functionType.details.parameters.filter((param) => {
+            const paramSpecParams = types_1.FunctionType.getFunctionParameters(functionTypeResult.functionType).filter((param) => {
                 if (param.typeAnnotation && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
                     if (param.category !== 0 /* Simple */ && param.name && param.type.paramSpecAccess) {
                         return true;
@@ -374,7 +374,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Verify that strict type guard functions don't violate the constraints
             // of strict type guards.
             this._validateStrictTypeGuardFunction(node, functionTypeResult.functionType, containingClassNode !== undefined);
-            this._validateFunctionTypeVarUsage(node, functionTypeResult.functionType);
+            this._validateFunctionTypeVarUsage(node, functionTypeResult);
         }
         // If we're at the module level within a stub file, report a diagnostic
         // if there is a '__getattr__' function defined when in strict mode.
@@ -440,6 +440,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         var _a;
         this._validateIsInstanceCall(node);
         this._validateIllegalDefaultParamInitializer(node);
+        this._validateStandardCollectionInstantiation(node);
         if (this._fileInfo.diagnosticRuleSet.reportUnusedCallResult !== 'none' ||
             this._fileInfo.diagnosticRuleSet.reportUnusedCoroutine !== 'none') {
             if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* StatementList */) {
@@ -1000,6 +1001,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
+    _validateStandardCollectionInstantiation(node) {
+        const leftType = this._evaluator.getType(node.leftExpression);
+        if (leftType &&
+            (0, types_1.isInstantiableClass)(leftType) &&
+            types_1.ClassType.isBuiltIn(leftType) &&
+            !leftType.includeSubclasses &&
+            leftType.aliasName) {
+            const nonInstantiable = ['List', 'Set', 'Dict', 'Tuple'];
+            if (nonInstantiable.some((name) => name === leftType.aliasName)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.collectionAliasInstantiation().format({
+                    type: leftType.aliasName,
+                    alias: leftType.details.name,
+                }), node.leftExpression);
+            }
+        }
+    }
     _validateContainmentTypes(node) {
         const leftType = this._evaluator.getType(node.leftExpression);
         const containerType = this._evaluator.getType(node.rightExpression);
@@ -1171,11 +1188,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return !(0, types_1.isNoneInstance)(type) && !(0, types_1.isNever)(type) && !(0, types_1.isAnyOrUnknown)(type);
     }
     // Verifies that each local type variable is used more than once.
-    _validateFunctionTypeVarUsage(node, type) {
+    _validateFunctionTypeVarUsage(node, functionTypeResult) {
         // Skip this check entirely if it's disabled.
         if (this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse === 'none') {
             return;
         }
+        const type = functionTypeResult.functionType;
         const localTypeVarUsage = new Map();
         const classTypeVarUsage = new Map();
         let exemptBoundTypeVar = true;
@@ -1314,9 +1332,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     isUsedInReturnType = false;
                 }
             }
+            // Skip this check if the function is overloaded because the TypeVar
+            // will be solved in terms of the overload signatures.
+            const skipUnsolvableTypeVarCheck = (0, types_1.isOverloadedFunction)(functionTypeResult.decoratedType) &&
+                !types_1.FunctionType.isOverloaded(functionTypeResult.functionType);
             if (isUsedInReturnType &&
                 usage.paramTypeWithEllipsisUsageCount > 0 &&
-                usage.paramTypeUsageCount === usage.paramTypeWithEllipsisUsageCount) {
+                usage.paramTypeUsageCount === usage.paramTypeWithEllipsisUsageCount &&
+                !skipUnsolvableTypeVarCheck) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarUnsolvableRemedy());
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse, diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.Localizer.Diagnostic.typeVarPossiblyUnsolvable().format({