@zzzen/pyright-internal 1.2.0-dev.20240818 → 1.2.0-dev.20240825

package/dist/analyzer/typeEvaluator.js

@@ -617,13 +617,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 48 /* ParseNodeType.StringList */: {
-                const isExpectingType = (flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0 && !isAnnotationLiteralValue(node);
-                if (isExpectingType) {
+                if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0) {
                     // Don't report expecting type errors again. We will have already
                     // reported them when analyzing the contents of the string.
                     expectingInstantiable = false;
                 }
-                typeResult = getTypeOfStringList(node, flags, isExpectingType);
+                typeResult = getTypeOfStringList(node, flags);
                 break;
             }
             case 40 /* ParseNodeType.Number */: {
@@ -889,9 +888,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
-    function getTypeOfStringList(node, flags, isExpectingType) {
+    function getTypeOfStringList(node, flags) {
         let typeResult;
-        if (isExpectingType) {
+        if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0) {
             let updatedFlags = flags | 4 /* EvalFlags.ForwardRefs */ | 128 /* EvalFlags.InstantiableType */;
             // In most cases, annotations within a string are not parsed by the interpreter.
             // There are a few exceptions (e.g. the "bound" value for a TypeVar constructor).
@@ -901,7 +900,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (node.d.annotation) {
                 typeResult = getTypeOfExpression(node.d.annotation, updatedFlags);
             }
-            else if (!node.d.annotation && node.d.strings.length === 1) {
+            else if (node.d.strings.length === 1) {
                 const tokenFlags = node.d.strings[0].d.token.flags;
                 if (tokenFlags & 32 /* StringTokenFlags.Bytes */) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationBytesString(), node);
@@ -2094,20 +2093,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return (codeFlowEngine.getFlowNodeReachability(sinkFlowNode, sourceFlowNode, /* ignoreNoReturn */ true) ===
             typeEvaluatorTypes_1.Reachability.Reachable);
     }
-    // Determines whether the specified string literal is part
-    // of a Literal['xxx'] statement. If so, we will not treat
-    // the string as a normal forward-declared type annotation.
-    function isAnnotationLiteralValue(node) {
-        if (node.parent && node.parent.nodeType === 27 /* ParseNodeType.Index */) {
-            const baseType = getTypeOfExpression(node.parent.d.leftExpr).type;
-            if (baseType && (0, types_1.isInstantiableClass)(baseType)) {
-                if (types_1.ClassType.isSpecialBuiltIn(baseType, 'Literal')) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
     function addInformation(message, node, range) {
         return addDiagnosticWithSuppressionCheck('information', message, node, range);
     }
@@ -10083,7 +10068,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         paramsArePositionOnly = false;
                     }
                 }
-                const functionParam = types_1.FunctionParam.create(param.d.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(), types_1.FunctionParamFlags.TypeDeclared, param.d.name ? param.d.name.d.value : undefined, param.d.defaultValue ? types_1.AnyType.create(/* isEllipsis */ true) : undefined);
+                const functionParam = types_1.FunctionParam.create(param.d.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(), types_1.FunctionParamFlags.TypeDeclared, param.d.name ? param.d.name.d.value : undefined, param.d.defaultValue ? types_1.AnyType.create(/* isEllipsis */ true) : undefined, param.d.defaultValue);
                 types_1.FunctionType.addParam(functionType, functionParam);
             });
             if (paramsArePositionOnly && functionType.shared.parameters.length > 0) {
@@ -10851,65 +10836,77 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & typeExprFlags) === 0) {
             return { type: classType };
         }
-        if (typeArgs) {
+        let type;
+        if (typeArgs && typeArgs.length > 0) {
+            type = typeArgs[0].type;
             if (typeArgs.length < 2) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotatedTypeArgMissing(), errorNode);
             }
             else {
-                validateAnnotatedMetadata(errorNode, typeArgs[0].type, typeArgs.slice(1));
+                type = validateAnnotatedMetadata(errorNode, typeArgs[0].type, typeArgs.slice(1));
             }
         }
-        if (!typeArgs || typeArgs.length === 0) {
+        if (!type || !typeArgs || typeArgs.length === 0) {
             return { type: types_1.AnyType.create() };
         }
         if (typeArgs[0].typeList) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[0].node);
         }
         return {
-            type: types_1.TypeBase.cloneAsSpecialForm(typeArgs[0].type, classType),
+            type: types_1.TypeBase.cloneAsSpecialForm(type, classType),
             isReadOnly: typeArgs[0].isReadOnly,
             isRequired: typeArgs[0].isRequired,
             isNotRequired: typeArgs[0].isNotRequired,
         };
     }
-    // Enforces metadata consistency as specified in PEP 746.
-    function validateAnnotatedMetadata(errorNode, annotatedType, metaArgs) {
+    // Enforces metadata consistency as specified in PEP 746 and associates
+    // refinement type predicates with the base type.
+    function validateAnnotatedMetadata(errorNode, baseType, metaArgs) {
+        for (const metaArg of metaArgs) {
+            validateTypeMetadata(errorNode, baseType, metaArg);
+        }
+        return baseType;
+    }
+    // Determines whether the metadata object is compatible with the base type.
+    function validateTypeMetadata(errorNode, baseType, metaArg) {
         var _a;
         // This is an experimental feature because PEP 746 hasn't been accepted.
         if (!AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
-            return;
+            return true;
         }
-        for (const metaArg of metaArgs) {
-            if ((0, types_1.isClass)(metaArg.type)) {
-                const supportsTypeMethod = (_a = getTypeOfBoundMember(
-                /* errorNode */ undefined, metaArg.type, '__supports_type__')) === null || _a === void 0 ? void 0 : _a.type;
-                if (!supportsTypeMethod) {
-                    continue;
-                }
-                // "Call" the __supports_type__ method to determine if the type is supported.
-                const callResult = useSpeculativeMode(errorNode, () => validateCallArgs(errorNode, [
-                    {
-                        argCategory: 0 /* ArgCategory.Simple */,
-                        typeResult: { type: (0, typeUtils_1.convertToInstance)(annotatedType) },
-                    },
-                ], { type: supportsTypeMethod }, 
-                /* constraints */ undefined, 
-                /* skipUnknownArgCheck */ true, 
-                /* inferenceContext */ undefined));
-                if (callResult.isTypeIncomplete || !callResult.returnType) {
-                    continue;
-                }
-                // If there are no errors and the return type is potentially truthy,
-                // we know that the type is supported by this metadata object.
-                if (!callResult.argumentErrors && canBeTruthy(callResult.returnType)) {
-                    continue;
-                }
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.annotatedMetadataInconsistent().format({
-                    metadataType: printType(metaArg.type),
-                    type: printType((0, typeUtils_1.convertToInstance)(annotatedType)),
-                }), metaArg.node);
-            }
+        if (!(0, types_1.isClass)(metaArg.type)) {
+            return true;
+        }
+        const supportsTypeMethod = (_a = getTypeOfBoundMember(
+        /* errorNode */ undefined, metaArg.type, '__supports_type__')) === null || _a === void 0 ? void 0 : _a.type;
+        if (!supportsTypeMethod) {
+            return true;
+        }
+        // "Call" the __supports_type__ method to determine if the type is supported.
+        const callResult = useSpeculativeMode(errorNode, () => validateCallArgs(errorNode, [
+            {
+                argCategory: 0 /* ArgCategory.Simple */,
+                typeResult: { type: (0, typeUtils_1.convertToInstance)(baseType) },
+            },
+        ], { type: supportsTypeMethod }, 
+        /* constraints */ undefined, 
+        /* skipUnknownArgCheck */ true, 
+        /* inferenceContext */ undefined));
+        if (!callResult.returnType) {
+            return true;
+        }
+        // If there are no errors and the return type is potentially truthy,
+        // we know that the type is supported by this metadata object.
+        if (!callResult.argumentErrors && canBeTruthy(callResult.returnType)) {
+            return true;
         }
+        if (!callResult.isTypeIncomplete) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.annotatedMetadataInconsistent().format({
+                metadataType: printType(metaArg.type),
+                type: printType((0, typeUtils_1.convertToInstance)(baseType)),
+            }), metaArg.node);
+        }
+        return false;
     }
     // Creates one of several "special" types that are defined in typing.pyi
     // but not declared in their entirety. This includes the likes of "Tuple",
@@ -12822,7 +12819,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 paramType = paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create();
                 const functionParam = types_1.FunctionParam.create(param.d.category, paramType, (isTypeInferred ? types_1.FunctionParamFlags.TypeInferred : types_1.FunctionParamFlags.None) |
-                    (paramTypeNode ? types_1.FunctionParamFlags.TypeDeclared : types_1.FunctionParamFlags.None), param.d.name ? param.d.name.d.value : undefined, defaultValueType);
+                    (paramTypeNode ? types_1.FunctionParamFlags.TypeDeclared : types_1.FunctionParamFlags.None), param.d.name ? param.d.name.d.value : undefined, defaultValueType, param.d.defaultValue);
                 types_1.FunctionType.addParam(functionType, functionParam);
                 if (types_1.FunctionParam.isTypeDeclared(functionParam)) {
                     (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParamsSeen, (0, typeUtils_1.getTypeVarArgsRecursive)(paramType), functionType.shared.typeVarScopeId);
@@ -15058,7 +15055,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Synthesize an alias declaration for this name part. The only
                     // time this case is used is for IDE services such as
                     // the find all references, hover provider and etc.
-                    declarations.push((0, declarationUtils_1.createSynthesizedAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
+                    declarations.push((0, declarationUtils_1.synthesizeAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
                 }
             }
         }
@@ -16585,14 +16582,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             prevSrcType = curSrcType;
         }
-        // If we're enforcing invariance, literal types must match as well.
-        if ((flags & 1 /* AssignTypeFlags.Invariant */) !== 0) {
-            const srcIsLiteral = srcType.priv.literalValue !== undefined;
-            const destIsLiteral = destType.priv.literalValue !== undefined;
-            if (srcIsLiteral !== destIsLiteral) {
-                return false;
-            }
-        }
         // Handle tuple, which supports a variable number of type arguments.
         if (destType.priv.tupleTypeArgs && curSrcType.priv.tupleTypeArgs) {
             return (0, tuples_1.assignTupleTypeArgs)(evaluatorInterface, destType, curSrcType, diag, constraints, flags, recursionCount);
@@ -18258,7 +18247,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     else {
                         remainingParams.push(types_1.FunctionParam.create(p.category, types_1.FunctionType.getParamType(effectiveSrcType, index), p.flags, p.name, types_1.FunctionType.getParamDefaultType(effectiveSrcType, index)
                             ? types_1.AnyType.create(/* isEllipsis */ true)
-                            : undefined));
+                            : undefined, p.defaultExpr));
                     }
                 });
                 // If there are remaining parameters and the source and dest do not contain
@@ -19080,7 +19069,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // evaluating (and caching) the inferred return type if there is no defined return type.
         getEffectiveReturnType(memberType);
         const specializedFunction = solveAndApplyConstraints(memberType, constraints);
-        return types_1.FunctionType.clone(specializedFunction, stripFirstParam, baseType);
+        if ((0, types_1.isFunction)(specializedFunction)) {
+            return types_1.FunctionType.clone(specializedFunction, stripFirstParam, baseType);
+        }
+        if ((0, types_1.isOverloaded)(specializedFunction)) {
+            // For overloaded functions, use the first overload. This isn't
+            // strictly correct, but this is an extreme edge case.
+            return types_1.FunctionType.clone(types_1.OverloadedType.getOverloads(specializedFunction)[0], stripFirstParam, baseType);
+        }
+        return undefined;
     }
     function isFinalVariable(symbol) {
         return symbol.getDeclarations().some((decl) => isFinalVariableDeclaration(decl));
@@ -19269,14 +19266,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         parseOptions.isStubFile = fileInfo.isStubFile;
         parseOptions.pythonVersion = fileInfo.executionEnvironment.pythonVersion;
         parseOptions.reportErrorsForParsedStringContents = true;
-        const parseResults = parser.parseTextExpression(dummyFileContents, valueOffset, textValue.length, parseOptions, 
-        /* parseTextMode */ undefined, 
+        const parseResults = parser.parseTextExpression(dummyFileContents, valueOffset, textValue.length, parseOptions, 0 /* ParseTextMode.Expression */, 
         /* initialParenDepth */ undefined, fileInfo.typingSymbolAliases);
-        if (parseResults.parseTree && parseResults.parseTree.nodeType !== 62 /* ParseNodeType.FunctionAnnotation */) {
+        if (parseResults.parseTree) {
+            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
             parseResults.diagnostics.forEach((diag) => {
-                addDiagnosticWithSuppressionCheck('error', diag.message, node);
+                fileInfo.diagnosticSink.addDiagnosticWithTextRange('error', diag.message, node);
             });
             parseResults.parseTree.parent = node;
+            // Add the new subtree to the parse tree so it can participate in
+            // language server operations like find and replace.
+            node.d.annotation = parseResults.parseTree;
             return parseResults.parseTree;
         }
         return undefined;