@zzzen/pyright-internal 1.2.0-dev.20230226 → 1.2.0-dev.20230312

package/dist/analyzer/checker.js

@@ -46,7 +46,6 @@ const parseNodes_1 = require("../parser/parseNodes");
 const stringTokenUtils_1 = require("../parser/stringTokenUtils");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const declaration_1 = require("./declaration");
-const declarationUtils_1 = require("./declarationUtils");
 const importResolver_1 = require("./importResolver");
 const importStatementUtils_1 = require("./importStatementUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
@@ -271,20 +270,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const functionTypeParam = functionTypeResult.functionType.details.parameters.find((p) => { var _a; return p.name === ((_a = param.name) === null || _a === void 0 ? void 0 : _a.value); });
                     if (functionTypeParam) {
                         const paramType = functionTypeParam.type;
-                        if ((0, types_1.isUnknown)(paramType) ||
-                            ((0, types_1.isTypeVar)(paramType) &&
-                                paramType.details.isSynthesized &&
-                                !paramType.details.isSynthesizedSelf)) {
-                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.paramTypeUnknown().format({ paramName: param.name.value }), param.name);
-                        }
-                        else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
-                            const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.paramType().format({
-                                paramType: this._evaluator.printType(paramType, { expandTypeAlias: true }),
-                            }));
-                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.paramTypePartiallyUnknown().format({
-                                paramName: param.name.value,
-                            }) + diagAddendum.getString(), param.name);
+                        if (this._fileInfo.diagnosticRuleSet.reportUnknownParameterType !== 'none') {
+                            if ((0, types_1.isUnknown)(paramType) ||
+                                ((0, types_1.isTypeVar)(paramType) &&
+                                    paramType.details.isSynthesized &&
+                                    !paramType.details.isSynthesizedSelf)) {
+                                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.paramTypeUnknown().format({ paramName: param.name.value }), param.name);
+                            }
+                            else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
+                                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.paramType().format({
+                                    paramType: this._evaluator.printType(paramType, { expandTypeAlias: true }),
+                                }));
+                                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.paramTypePartiallyUnknown().format({
+                                    paramName: param.name.value,
+                                }) + diagAddendum.getString(), param.name);
+                            }
                         }
                         let hasAnnotation = false;
                         if (functionTypeParam.typeAnnotation) {
@@ -296,7 +297,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 hasAnnotation = true;
                             }
                         }
-                        if (!hasAnnotation) {
+                        if (!hasAnnotation && this._fileInfo.diagnosticRuleSet.reportMissingParameterType !== 'none') {
                             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingParameterType, diagnosticRules_1.DiagnosticRule.reportMissingParameterType, localize_1.Localizer.Diagnostic.paramAnnotationMissing().format({ name: param.name.value }), param.name);
                         }
                     }
@@ -716,6 +717,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage, diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.Localizer.Diagnostic.typeCommentDeprecated(), node.typeAnnotationComment);
             }
         }
+        // If this isn't a class or global scope, explicit type aliases are not allowed.
+        if (node.leftExpression.nodeType === 54 /* TypeAnnotation */) {
+            const annotationType = this._evaluator.getTypeOfAnnotation(node.leftExpression.typeAnnotation);
+            if ((0, types_1.isClassInstance)(annotationType) && types_1.ClassType.isBuiltIn(annotationType, 'TypeAlias')) {
+                const scope = (0, scopeUtils_1.getScopeForNode)(node);
+                if (scope) {
+                    if (scope.type !== 2 /* Class */ &&
+                        scope.type !== 3 /* Module */ &&
+                        scope.type !== 4 /* Builtin */) {
+                        this._evaluator.addError(localize_1.Localizer.Diagnostic.typeAliasNotInModuleOrClass(), node.leftExpression.typeAnnotation);
+                    }
+                }
+            }
+        }
         return true;
     }
     visitAssignmentExpression(node) {
@@ -1875,14 +1890,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _reportMultipleFinalDeclarations(name, symbol, scopeType) {
-        if (!(0, symbolUtils_1.isFinalVariable)(symbol)) {
+        if (!this._evaluator.isFinalVariable(symbol)) {
             return;
         }
         const decls = symbol.getDeclarations();
         let sawFinal = false;
         let sawAssignment = false;
         decls.forEach((decl) => {
-            if ((0, declarationUtils_1.isFinalVariableDeclaration)(decl)) {
+            if (this._evaluator.isFinalVariableDeclaration(decl)) {
                 if (sawFinal) {
                     this._evaluator.addError(localize_1.Localizer.Diagnostic.finalRedeclaration().format({ name }), decl.node);
                 }
@@ -1928,7 +1943,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _reportMultipleTypeAliasDeclarations(name, symbol) {
         const decls = symbol.getDeclarations();
-        const typeAliasDecl = decls.find((decl) => (0, declarationUtils_1.isExplicitTypeAliasDeclaration)(decl));
+        const typeAliasDecl = decls.find((decl) => this._evaluator.isExplicitTypeAliasDeclaration(decl));
         // If this is a type alias, there should be only one declaration.
         if (typeAliasDecl && decls.length > 1) {
             decls.forEach((decl) => {
@@ -1939,6 +1954,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _reportIncompatibleDeclarations(name, symbol) {
+        var _a, _b, _c, _d;
         // If there's one or more declaration with a declared type,
         // all other declarations should match. The only exception is
         // for functions that have an overload.
@@ -2045,13 +2061,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             else if (otherDecl.type === 5 /* Function */) {
-                const primaryType = this._evaluator.getTypeForDeclaration(primaryDecl);
+                const primaryType = (_a = this._evaluator.getTypeForDeclaration(primaryDecl)) === null || _a === void 0 ? void 0 : _a.type;
                 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);
                 }
-                const otherType = this._evaluator.getTypeForDeclaration(otherDecl);
+                const otherType = (_b = this._evaluator.getTypeForDeclaration(otherDecl)) === null || _b === void 0 ? void 0 : _b.type;
                 const suite1 = ParseTreeUtils.getEnclosingSuite(primaryDecl.node);
                 const suite2 = ParseTreeUtils.getEnclosingSuite(otherDecl.node);
                 // Allow same-signature overrides in cases where the declarations
@@ -2095,12 +2111,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             else if (otherDecl.type === 1 /* Variable */) {
-                const primaryType = this._evaluator.getTypeForDeclaration(primaryDecl);
+                const primaryType = (_c = this._evaluator.getTypeForDeclaration(primaryDecl)) === null || _c === void 0 ? void 0 : _c.type;
                 if (otherDecl.typeAnnotationNode) {
                     if (otherDecl.node.nodeType === 38 /* Name */) {
                         let duplicateIsOk = false;
                         // It's OK if they both have the same declared type.
-                        const otherType = this._evaluator.getTypeForDeclaration(otherDecl);
+                        const otherType = (_d = this._evaluator.getTypeForDeclaration(otherDecl)) === null || _d === void 0 ? void 0 : _d.type;
                         if (primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
                             duplicateIsOk = true;
                         }
@@ -3007,7 +3023,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const parentSymbol = (0, typeUtils_1.lookUpClassMember)(classType, name, 1 /* SkipOriginalClass */);
             if (parentSymbol &&
                 (0, types_1.isInstantiableClass)(parentSymbol.classType) &&
-                (0, symbolUtils_1.isFinalVariable)(parentSymbol.symbol) &&
+                this._evaluator.isFinalVariable(parentSymbol.symbol) &&
                 !SymbolNameUtils.isPrivateName(name)) {
                 const decl = localSymbol.getDeclarations()[0];
                 this._evaluator.addError(localize_1.Localizer.Diagnostic.finalRedeclarationBySubclass().format({
@@ -3144,12 +3160,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Verify that the parameter types match.
         let paramIndex = 1;
         initOnlySymbolMap.forEach((symbol, fieldName) => {
+            var _a;
             if (paramIndex >= paramListDetails.params.length) {
                 return;
             }
             const param = paramListDetails.params[paramIndex].param;
             if (param.hasDeclaredType && param.typeAnnotation) {
-                const fieldType = this._evaluator.getDeclaredTypeOfSymbol(symbol);
+                const fieldType = (_a = this._evaluator.getDeclaredTypeOfSymbol(symbol)) === null || _a === void 0 ? void 0 : _a.type;
                 const paramType = types_1.FunctionType.getEffectiveParameterType(postInitType, paramListDetails.params[paramIndex].index);
                 const assignTypeDiag = new diagnostic_1.DiagnosticAddendum();
                 if (fieldType && !this._evaluator.assignType(paramType, fieldType, assignTypeDiag)) {
@@ -3653,7 +3670,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             // If the symbol has no declaration, and the type is inferred,
             // skip this check.
-            if (!symbol.hasTypedDeclarations() && !(0, symbolUtils_1.isFinalVariable)(symbol)) {
+            if (!symbol.hasTypedDeclarations() && !this._evaluator.isFinalVariable(symbol)) {
                 return;
             }
             // Get the symbol type defined in this class.
@@ -3874,8 +3891,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     // Verify that there is not a Final mismatch.
-                    const isBaseVarFinal = (0, symbolUtils_1.isFinalVariable)(baseClassAndSymbol.symbol);
-                    const overrideFinalVarDecl = decls.find((d) => (0, declarationUtils_1.isFinalVariableDeclaration)(d));
+                    const isBaseVarFinal = this._evaluator.isFinalVariable(baseClassAndSymbol.symbol);
+                    const overrideFinalVarDecl = decls.find((d) => this._evaluator.isFinalVariableDeclaration(d));
                     if (!isBaseVarFinal && overrideFinalVarDecl) {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.variableFinalOverride().format({
                             name: memberName,
@@ -3939,7 +3956,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // __new__ overrides should have a "cls" parameter.
             if (node.parameters.length === 0 ||
                 !node.parameters[0].name ||
-                !['cls', '_cls', '__cls', '__mcls'].some((name) => node.parameters[0].name.value === name)) {
+                !['cls', '_cls', '__cls', '__mcls', 'mcls', 'mcs'].some((name) => node.parameters[0].name.value === name)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.newClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
             }
             if (classType) {
@@ -4012,9 +4029,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 // Instance methods should have a "self" parameter.
                 if (firstParamIsSimple && paramName !== 'self') {
-                    // Special-case metaclasses, which can use "cls".
+                    // Special-case metaclasses, which can use "cls" or several variants.
                     let isLegalMetaclassName = false;
-                    if (paramName === 'cls') {
+                    if (['cls', 'mcls', 'mcs'].some((name) => name === paramName)) {
                         const classTypeInfo = this._evaluator.getTypeOfClass(classNode);
                         const typeType = this._evaluator.getBuiltInType(classNode, 'type');
                         if (typeType &&