@zzzen/pyright-internal 1.2.0-dev.20240107 → 1.2.0-dev.20240114

package/dist/analyzer/checker.d.ts

@@ -105,6 +105,7 @@ export declare class Checker extends ParseTreeWalker {
     private _validateIsInstanceCall;
     private _validateUnsafeProtocolOverlap;
     private _isTypeSupportedTypeForIsInstance;
+    private _validateNotDataProtocol;
     private _isSymbolPrivate;
     private _reportDeprecatedClassProperty;
     private _reportDeprecatedUseForMemberAccess;
@@ -125,6 +126,7 @@ export declare class Checker extends ParseTreeWalker {
     private _reportDuplicateEnumMembers;
     private _validateProtocolCompatibility;
     private _validateDataClassPostInit;
+    private _isUnimplementedProtocolMethod;
     private _validateFinalClassNotAbstract;
     private _validateInstanceVariableInitialization;
     private _validateProtocolTypeParamVariance;

package/dist/analyzer/checker.js

@@ -1954,6 +1954,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             else if ((0, types_1.isClassInstance)(exceptionType)) {
                 const iterableType = (_b = (_a = this._evaluator.getTypeOfIterator({ type: exceptionType }, /* isAsync */ false, errorNode)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 resultingExceptionType = (0, typeUtils_1.mapSubtypes)(iterableType, (subtype) => {
+                    subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
                     if ((0, types_1.isAnyOrUnknown)(subtype) || (0, types_1.isNever)(subtype)) {
                         return subtype;
                     }
@@ -2553,12 +2554,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!isInstanceCheck) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
-                if ((0, types_1.isInstantiableClass)(arg1Subtype) &&
-                    types_1.ClassType.isProtocolClass(arg1Subtype) &&
-                    !(0, protocols_1.isMethodOnlyProtocol)(arg1Subtype)) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.dataProtocolUnsupported().format({
-                        name: arg1Subtype.details.name,
-                    }));
+                if ((0, types_1.isClassInstance)(arg1Subtype) &&
+                    types_1.ClassType.isTupleClass(arg1Subtype) &&
+                    arg1Subtype.tupleTypeArguments) {
+                    arg1Subtype.tupleTypeArguments.forEach((typeArg) => {
+                        this._validateNotDataProtocol(typeArg.type, diag);
+                    });
+                }
+                else {
+                    this._validateNotDataProtocol(arg1Subtype, diag);
                 }
             });
             if (!diag.isEmpty()) {
@@ -2761,6 +2765,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
             subtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
+            if (subtype.specialForm && types_1.ClassType.isBuiltIn(subtype.specialForm, 'TypeAliasType')) {
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAliasInstanceCheck());
+                isSupported = false;
+                return;
+            }
             switch (subtype.category) {
                 case 2 /* TypeCategory.Any */:
                 case 1 /* TypeCategory.Unknown */:
@@ -2809,6 +2818,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
         return isSupported;
     }
+    _validateNotDataProtocol(type, diag) {
+        if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isProtocolClass(type) && !(0, protocols_1.isMethodOnlyProtocol)(type)) {
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.dataProtocolUnsupported().format({
+                name: type.details.name,
+            }));
+        }
+    }
     _isSymbolPrivate(nameValue, scopeType) {
         // All variables within the scope of a function or a list
         // comprehension are considered private.
@@ -3444,14 +3460,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
                 else if (decls[0].type === 5 /* DeclarationType.Function */) {
-                    if (decls.every((decl) => decl.type !== 5 /* DeclarationType.Function */ || ParseTreeUtils.isSuiteEmpty(decl.node.suite))) {
-                        if (!decls[0].uri.hasExtension('.pyi')) {
-                            if (!isSymbolImplemented(name)) {
-                                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
-                                    name,
-                                    classType: member.classType.details.name,
-                                }));
-                            }
+                    if (this._isUnimplementedProtocolMethod(member.symbol)) {
+                        if (!isSymbolImplemented(name)) {
+                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
+                                name,
+                                classType: member.classType.details.name,
+                            }));
                         }
                     }
                 }
@@ -3533,6 +3547,42 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             paramIndex++;
         });
     }
+    // Determine whether a method defined in a protocol should be considered
+    // "unimplemented". This is an under-specified part of the typing spec.
+    _isUnimplementedProtocolMethod(symbol) {
+        const symbolType = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+        // Behavior differs between stub files and source files.
+        const decls = symbol.getDeclarations();
+        const isDeclaredInStubFile = decls.length > 0 && (0, sourceMapper_1.isStubFile)(decls[0].uri);
+        if ((0, types_1.isFunction)(symbolType)) {
+            const decl = symbolType.details.declaration;
+            if (decl) {
+                return isDeclaredInStubFile
+                    ? types_1.FunctionType.isAbstractMethod(symbolType)
+                    : ParseTreeUtils.isSuiteEmpty(decl.node.suite);
+            }
+        }
+        else if ((0, types_1.isOverloadedFunction)(symbolType)) {
+            // If an implementation is present and has an empty body, assume
+            // the function is unimplemented.
+            const impl = types_1.OverloadedFunctionType.getImplementation(symbolType);
+            if (impl) {
+                const decl = impl.details.declaration;
+                if (decl) {
+                    return ParseTreeUtils.isSuiteEmpty(decl.node.suite);
+                }
+                return false;
+            }
+            if (isDeclaredInStubFile) {
+                // If no implementation was present, see if any of the overloads
+                // are marked as abstract.
+                const overloads = types_1.OverloadedFunctionType.getOverloads(symbolType);
+                return overloads.some((overload) => types_1.FunctionType.isAbstractMethod(overload));
+            }
+            return true;
+        }
+        return false;
+    }
     // If a class is marked final, it must implement all abstract methods,
     // otherwise it is of no use.
     _validateFinalClassNotAbstract(classType, errorNode) {