@zzzen/pyright-internal 1.2.0-dev.20240225 → 1.2.0-dev.20240307

package/dist/analyzer/typeEvaluator.js

@@ -805,6 +805,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const exprTypeResult = getTypeOfExpression(node.expression, flags, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
         const typeResult = {
             type: getTypeOfAwaitable(exprTypeResult.type, node.expression),
+            isIncomplete: exprTypeResult.isIncomplete,
+            typeErrors: exprTypeResult.typeErrors,
         };
         if (exprTypeResult.isIncomplete) {
             typeResult.isIncomplete = true;
@@ -1549,7 +1551,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // see if we can find a better signature from the `__new__` method.
                         if (!constructorType || isObjectInit || isDefaultParams) {
                             const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluatorInterface, callNode, subtype, 0 /* MemberAccessFlags.Default */);
-                            if (newMethodResult && !newMethodResult.typeErrors && (0, types_1.isFunction)(newMethodResult.type)) {
+                            if (newMethodResult && !newMethodResult.typeErrors) {
                                 if ((0, types_1.isFunction)(newMethodResult.type) &&
                                     newMethodResult.type.details.fullName !== 'builtins.object.__new__') {
                                     constructorType = newMethodResult.type;
@@ -2036,10 +2038,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (checkCodeFlowTooComplex(node)) {
             return true;
         }
-        const codeFlowResult = analyzer.getTypeFromCodeFlow(flowNode, 
-        /* reference */ undefined, 
-        /* targetSymbolId */ undefined, 
-        /* typeAtStart */ types_1.UnboundType.create());
+        const codeFlowResult = analyzer.getTypeFromCodeFlow(flowNode, /* reference */ undefined, {
+            typeAtStart: types_1.UnboundType.create(),
+        });
         return codeFlowResult.type !== undefined && !(0, types_1.isNever)(codeFlowResult.type);
     }
     // Determines whether there is a code flow path from sourceNode to sinkNode.
@@ -2194,8 +2195,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiagAddendum) {
                     diagAddendum = expectedTypeDiagAddendum;
                 }
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatch().format(printSrcDestTypes(type, declaredType)) +
-                    diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_c = (_b = diagAddendum.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : srcExpression) !== null && _c !== void 0 ? _c : nameNode);
+                if (!isTypeIncomplete) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatch().format(printSrcDestTypes(type, declaredType)) +
+                        diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_c = (_b = diagAddendum.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : srcExpression) !== null && _c !== void 0 ? _c : nameNode);
+                }
                 // Replace the assigned type with the (unnarrowed) declared type.
                 destType = declaredType;
             }
@@ -2979,8 +2982,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                         }
                     }
-                    const codeFlowTypeResult = getFlowTypeOfReference(node, symbol.id, typeAtStart, 
-                    /* startNode */ undefined, {
+                    const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
+                        targetSymbolId: symbol.id,
+                        typeAtStart,
                         skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
                     });
                     if (codeFlowTypeResult.type) {
@@ -3133,7 +3137,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (symbolWithScope.symbol.isInitiallyUnbound()) {
                             typeAtStart = types_1.UnboundType.create();
                         }
-                        return getFlowTypeOfReference(node, symbolWithScope.symbol.id, typeAtStart, innerScopeNode);
+                        return getFlowTypeOfReference(node, innerScopeNode, {
+                            targetSymbolId: symbolWithScope.symbol.id,
+                            typeAtStart,
+                        });
                     }
                 }
             }
@@ -3457,8 +3464,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             // See if we can refine the type based on code flow analysis.
-            const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, typeAtStart, 
-            /* startNode */ undefined, {
+            const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
+                targetSymbolId: symbol_1.indeterminateSymbolId,
+                typeAtStart,
                 isTypeAtStartIncomplete,
                 skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
             });
@@ -4385,10 +4393,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             if (baseTypeSupportsIndexNarrowing) {
                 // Before performing code flow analysis, update the cache to prevent recursion.
-                writeTypeCache(node, indexTypeResult, flags);
+                writeTypeCache(node, { ...indexTypeResult, isIncomplete: true }, flags);
                 // See if we can refine the type based on code flow analysis.
-                const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, indexTypeResult.type, 
-                /* startNode */ undefined, {
+                const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
+                    targetSymbolId: symbol_1.indeterminateSymbolId,
+                    typeAtStart: indexTypeResult.type,
                     isTypeAtStartIncomplete: !!baseTypeResult.isIncomplete || !!indexTypeResult.isIncomplete,
                     skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
                 });
@@ -4750,8 +4759,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return createLiteralType(concreteSubtype, node, flags);
                 }
                 if (types_1.ClassType.isBuiltIn(concreteSubtype, 'InitVar')) {
-                    // Special-case InitVar, used in data classes.
+                    // Special-case InitVar, used in dataclasses.
                     const typeArgs = getTypeArgs(node, flags);
+                    if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+                        if ((flags & 32768 /* EvaluatorFlags.VariableTypeAnnotation */) === 0) {
+                            addError(localize_1.LocMessage.initVarNotAllowed(), node.baseExpression);
+                        }
+                    }
                     if (typeArgs.length === 1) {
                         return typeArgs[0].type;
                     }
@@ -8981,6 +8995,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeAnyOrUnknown(), (_c = argList[1].node) !== null && _c !== void 0 ? _c : errorNode);
             isBaseClassAny = true;
         }
+        // Specifically disallow Annotated.
+        if (baseClass.specialForm &&
+            (0, types_1.isInstantiableClass)(baseClass.specialForm) &&
+            types_1.ClassType.isBuiltIn(baseClass.specialForm, 'Annotated')) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeNotAClass(), argList[1].node || errorNode);
+            return undefined;
+        }
         if (!(0, types_1.isInstantiableClass)(baseClass)) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeNotAClass(), argList[1].node || errorNode);
             return undefined;
@@ -13872,7 +13893,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // flow analysis starts from the reference node, but startNode can be
     // specified to override this in a few special cases (functions and
     // lambdas) to support analysis of captured variables.
-    function getFlowTypeOfReference(reference, targetSymbolId, typeAtStart, startNode, options) {
+    function getFlowTypeOfReference(reference, startNode, options) {
         var _a;
         // See if this execution scope requires code flow for this reference expression.
         const referenceKey = (0, codeFlowTypes_1.createKeyForReference)(reference);
@@ -13901,7 +13922,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (flowNode === undefined) {
             return { type: undefined, isIncomplete: false };
         }
-        return analyzer.getTypeFromCodeFlow(flowNode, reference, targetSymbolId, typeAtStart, options);
+        return analyzer.getTypeFromCodeFlow(flowNode, reference, options);
     }
     // Specializes the specified (potentially generic) class type using
     // the specified type arguments, reporting errors as appropriate.
@@ -14006,10 +14027,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
                 }
                 case 'ReadOnly': {
-                    if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
-                        return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
-                    }
-                    break;
+                    return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
                 }
                 case 'Self': {
                     return { type: createSelfType(classType, errorNode, typeArgs, flags) };
@@ -15561,7 +15579,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // into account argument types to infer the return type.
     function getFunctionEffectiveReturnType(type, args, inferTypeIfNeeded = true) {
         const specializedReturnType = types_1.FunctionType.getSpecializedReturnType(type, /* includeInferred */ false);
-        if (specializedReturnType) {
+        if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
             return adjustCallableReturnType(specializedReturnType, /* trackedSignatures */ undefined);
         }
         if (inferTypeIfNeeded) {
@@ -15906,22 +15924,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        // See if the dest type is a TypedDict class and the source is a compatible dict.
-        if (types_1.ClassType.isTypedDictClass(destType) && types_1.ClassType.isBuiltIn(srcType, 'dict')) {
-            if (srcType.typeArguments &&
-                srcType.typeArguments.length === 2 &&
-                (0, types_1.isClassInstance)(srcType.typeArguments[0]) &&
-                types_1.ClassType.isBuiltIn(srcType.typeArguments[0], 'str')) {
-                const dictValueType = (0, typedDicts_1.getTypedDictDictEquivalent)(evaluatorInterface, destType, recursionCount);
-                if (dictValueType &&
-                    assignType(dictValueType, srcType.typeArguments[1], 
-                    /* diag */ undefined, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, 1 /* AssignTypeFlags.EnforceInvariance */, recursionCount + 1)) {
-                    return true;
-                }
-            }
-        }
         // Handle special-case type promotions.
         if (destType.includePromotions) {
             const promotionList = typePromotions.get(destType.details.fullName);
@@ -16168,15 +16170,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isVariadicTypeVar)(destTypeArgs[destUnboundedOrVariadicIndex].type)) {
                     if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                         const removedArgs = srcTypeArgs.splice(destUnboundedOrVariadicIndex, srcArgsToCapture);
-                        // Package up the remaining type arguments into a tuple object.
-                        const variadicTuple = makeTupleObject(removedArgs.map((typeArg) => {
-                            return {
-                                type: typeArg.type,
-                                isUnbounded: typeArg.isUnbounded,
-                                isOptional: typeArg.isOptional,
-                            };
-                        }), 
-                        /* isUnpackedTuple */ true);
+                        let variadicTuple;
+                        // If we're left with a single unpacked variadic type var, there's no
+                        // need to wrap it in a nested tuple.
+                        if (removedArgs.length === 1 && (0, types_1.isUnpackedVariadicTypeVar)(removedArgs[0].type)) {
+                            variadicTuple = removedArgs[0].type;
+                        }
+                        else {
+                            // Package up the remaining type arguments into a tuple object.
+                            variadicTuple = makeTupleObject(removedArgs.map((typeArg) => {
+                                return {
+                                    type: typeArg.type,
+                                    isUnbounded: typeArg.isUnbounded,
+                                    isOptional: typeArg.isOptional,
+                                };
+                            }), 
+                            /* isUnpackedTuple */ true);
+                        }
                         srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
                             type: variadicTuple,
                             isUnbounded: false,
@@ -17396,6 +17406,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isTypeSame)(destType, srcSubtype, { ignorePseudoGeneric: true }, recursionCount)) {
                 return false;
             }
+            if ((0, typeUtils_1.isIncompleteUnknown)(srcSubtype)) {
+                return false;
+            }
             const destTypeVarName = types_1.TypeVarType.getNameWithScope(destType);
             // Determine which conditions on this type apply to this type variable.
             // There might be more than one of them.
@@ -18373,9 +18386,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     !(0, symbolNameUtils_1.isPrivateOrProtectedName)(baseParam.name || '') &&
                     baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly &&
                     baseParam.category === 0 /* ParameterCategory.Simple */ &&
+                    enforceParamNames &&
                     baseParam.name !== overrideParam.name) {
                     if (overrideParam.category === 0 /* ParameterCategory.Simple */) {
-                        if (enforceParamNames && !baseParam.isNameSynthesized) {
+                        if (!baseParam.isNameSynthesized) {
                             if (overrideParamDetails.params[i].source === parameterUtils_1.ParameterSource.PositionOnly) {
                                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
                                     index: i + 1,