@zzzen/pyright-internal 1.2.0-dev.20240929 → 1.2.0-dev.20241013

package/dist/analyzer/typeEvaluator.js

@@ -152,15 +152,6 @@ const maxOverloadUnionExpansionCount = 64;
 // Maximum number of recursive function return type inference attempts
 // that can be concurrently pending before we give up.
 const maxInferFunctionReturnRecursionCount = 12;
-// In certain loops, it's possible to construct arbitrarily-deep containers
-// (tuples, lists, sets, or dicts) which can lead to infinite type analysis.
-// This limits the depth.
-const maxInferredContainerDepth = 8;
-// If a tuple expression with no declared type contains a large number
-// of elements, it can cause performance issues. This value limits the
-// number of elements that will be included in the tuple type before
-// we default to tuple[Unknown, ...].
-const maxInferredTupleEntryCount = 256;
 // Maximum recursion amount when comparing two recursive type aliases.
 // Increasing this can greatly increase the time required to evaluate
 // two recursive type aliases that have the same definition. Decreasing
@@ -639,7 +630,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 52 /* ParseNodeType.Tuple */: {
-                typeResult = getTypeOfTuple(node, flags, inferenceContext);
+                typeResult = (0, tuples_1.getTypeOfTuple)(evaluatorInterface, node, flags, inferenceContext);
                 break;
             }
             case 14 /* ParseNodeType.Constant */: {
@@ -863,8 +854,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true) };
         }
         else {
-            const ellipsisType = (_b = (_a = getBuiltInObject(node, 'EllipsisType')) !== null && _a !== void 0 ? _a : getBuiltInObject(node, 'ellipsis')) !== null && _b !== void 0 ? _b : types_1.AnyType.create();
-            typeResult = { type: ellipsisType };
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0 && (flags & 65536 /* EvalFlags.AllowEllipsis */) === 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisContext(), node);
+                typeResult = { type: types_1.UnknownType.create() };
+            }
+            else {
+                const ellipsisType = (_b = (_a = getBuiltInObject(node, 'EllipsisType')) !== null && _a !== void 0 ? _a : getBuiltInObject(node, 'ellipsis')) !== null && _b !== void 0 ? _b : types_1.AnyType.create();
+                typeResult = { type: ellipsisType };
+            }
         }
         return typeResult;
     }
@@ -1112,7 +1109,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
-            var _a;
             if ((0, types_1.isClass)(subtype)) {
                 if (subtype.priv.literalValue !== undefined) {
                     subtype = types_1.ClassType.cloneWithLiteral(subtype, /* value */ undefined);
@@ -1121,9 +1117,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Handle "LiteralString" specially.
                     if (strClass && (0, types_1.isInstantiableClass)(strClass)) {
                         let strInstance = types_1.ClassType.cloneAsInstance(strClass);
-                        if ((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition) {
-                            strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
-                        }
+                        strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
                         return strInstance;
                     }
                 }
@@ -1557,10 +1551,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return undefined;
     }
     function getBoundMagicMethod(classType, memberName, selfType, diag, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-            return undefined;
-        }
-        recursionCount++;
         const boundMethodResult = getTypeOfBoundMember(
         /* errorNode */ undefined, classType, memberName, 
         /* usage */ undefined, diag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, selfType, recursionCount);
@@ -1571,6 +1561,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return boundMethodResult.type;
         }
         if ((0, types_1.isClassInstance)(boundMethodResult.type)) {
+            if (recursionCount > types_1.maxTypeRecursionCount) {
+                return undefined;
+            }
+            recursionCount++;
             return getBoundMagicMethod(boundMethodResult.type, '__call__', selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType), diag, recursionCount);
         }
         if ((0, types_1.isAnyOrUnknown)(boundMethodResult.type)) {
@@ -2311,7 +2305,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const isTypeAlias = !!declaredType && (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias');
         if (declaredType && !isTypeAlias) {
             let diagAddendum = new diagnostic_1.DiagnosticAddendum();
-            if (!assignType(declaredType, typeResult.type, diagAddendum)) {
+            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(nameNode);
+            const boundDeclaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveScopeIds);
+            const srcType = (0, typeUtils_1.makeTypeVarsBound)(typeResult.type, liveScopeIds);
+            if (!assignType(boundDeclaredType, srcType, diagAddendum)) {
                 // If there was an expected type mismatch, use that diagnostic
                 // addendum because it will be more informative.
                 if (expectedTypeDiagAddendum) {
@@ -2645,7 +2642,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             var _a;
             if ((0, types_1.isParamSpec)(subtype)) {
                 if (subtype.priv.paramSpecAccess === 'args') {
-                    return makeTupleObject([{ type: getObjectType(), isUnbounded: true }]);
+                    return (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: getObjectType(), isUnbounded: true }]);
                 }
                 else if (subtype.priv.paramSpecAccess === 'kwargs') {
                     if (dictClass && (0, types_1.isInstantiableClass)(dictClass) && strClass && (0, types_1.isInstantiableClass)(strClass)) {
@@ -2676,7 +2673,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return types_1.AnyType.create();
                 }
                 // Fall back to "*tuple[object, ...]".
-                return makeTupleObject([{ type: getObjectType(), isUnbounded: true }], /* isUnpacked */ true);
+                return (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: getObjectType(), isUnbounded: true }], 
+                /* isUnpacked */ true);
             }
             if ((0, types_1.isTypeVar)(subtype)) {
                 // If this is a recursive type alias placeholder
@@ -2716,6 +2714,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         useBoundTypeVars: types_1.TypeVarType.isBound(subtype),
                     });
                 }
+                if (subtype.priv.isUnpacked && (0, types_1.isClass)(boundType)) {
+                    boundType = types_1.ClassType.cloneForUnpacked(boundType);
+                }
                 boundType = types_1.TypeBase.isInstantiable(subtype) ? (0, typeUtils_1.convertToInstantiable)(boundType) : boundType;
                 return (0, typeUtils_1.addConditionToType)(boundType, [{ typeVar: subtype, constraintIndex: 0 }]);
             }
@@ -2892,11 +2893,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
-                const annotationType = getTypeOfAnnotation(target.d.annotation, {
+                let annotationType = getTypeOfAnnotation(target.d.annotation, {
                     varTypeAnnotation: true,
                     allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(target.d.valueExpr),
                     allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(target.d.valueExpr),
                 });
+                if (annotationType) {
+                    const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(target);
+                    annotationType = (0, typeUtils_1.makeTypeVarsBound)(annotationType, liveScopeIds);
+                }
                 // Handle a bare "Final" or "ClassVar" in a special manner.
                 const isBareFinalOrClassVar = (0, types_1.isClassInstance)(annotationType) &&
                     (types_1.ClassType.isBuiltIn(annotationType, 'Final') || types_1.ClassType.isBuiltIn(annotationType, 'ClassVar'));
@@ -3145,6 +3150,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                 type = validateSymbolIsTypeExpression(node, type, !!effectiveTypeInfo.includesVariableDecl);
             }
+            if ((0, types_1.isTypeVar)(type) && !type.shared.isSynthesized) {
+                type = validateTypeVarUsage(node, type, flags);
+            }
             // Add TypeForm details if appropriate.
             type = addTypeFormForSymbol(node, type, flags, !!effectiveTypeInfo.includesVariableDecl);
         }
@@ -3158,7 +3166,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 type = types_1.UnknownType.create();
             }
         }
-        if ((0, types_1.isParamSpec)(type)) {
+        if ((0, types_1.isParamSpec)(type) && type.priv.scopeId) {
             if (flags & 32 /* EvalFlags.NoParamSpec */) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), node);
                 type = types_1.UnknownType.create();
@@ -3175,9 +3183,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        if ((0, types_1.isTypeVar)(type) && !type.shared.isSynthesized) {
-            type = validateTypeVarUsage(node, type, flags);
-        }
         return { type, isIncomplete };
     }
     function addTypeFormForSymbol(node, type, flags, includesVarDecl) {
@@ -3233,7 +3238,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
             return true;
         }
-        if ((0, types_1.isTypeVar)(type) && !type.priv.scopeId) {
+        if ((0, types_1.isTypeVar)(type)) {
             return true;
         }
         // Exempts class types that are created by calling NewType, NamedTuple, etc.
@@ -3472,7 +3477,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (type.priv.scopeId && !scopedTypeVarInfo.foundInterveningClass) {
                 return type;
             }
-            if (!type.shared.isSynthesized) {
+            if (!type.shared.isSynthesized && (flags & 128 /* EvalFlags.InstantiableType */) !== 0) {
                 const message = (0, types_1.isParamSpec)(type)
                     ? localize_1.LocMessage.paramSpecNotUsedByOuterScope()
                     : localize_1.LocMessage.typeVarNotUsedByOuterScope();
@@ -4793,7 +4798,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                         });
                     }
-                    const tupleObject = makeTupleObject(variadicTypes, /* isUnpacked */ true);
+                    const tupleObject = (0, tuples_1.makeTupleObject)(evaluatorInterface, variadicTypes, /* isUnpacked */ true);
                     typeArgs = [
                         ...typeArgs.slice(0, variadicIndex),
                         { node: typeArgs[variadicIndex].node, type: tupleObject },
@@ -4805,7 +4810,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Add an empty tuple that maps to the TypeVarTuple type parameter.
                 typeArgs.push({
                     node: errorNode,
-                    type: makeTupleObject([], /* isUnpacked */ true),
+                    type: (0, tuples_1.makeTupleObject)(evaluatorInterface, [], /* isUnpacked */ true),
                 });
             }
         }
@@ -4853,7 +4858,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 });
             }
             else if ((0, types_1.isTypeVarTuple)(param) && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
-                defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }], 
+                defaultType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: types_1.UnknownType.create(), isUnbounded: true }], 
                 /* isUnpacked */ true);
             }
             else {
@@ -4898,22 +4903,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         inferVarianceForTypeAlias(baseType);
         const typeParams = aliasInfo.shared.typeParams;
-        let typeArgs = adjustTypeArgsForTypeVarTuple(getTypeArgs(node, flags), typeParams, node);
+        let typeArgs;
+        typeArgs = adjustTypeArgsForTypeVarTuple(getTypeArgs(node, flags), typeParams, node);
         let reportedError = false;
-        // PEP 612 says that if the class has only one type parameter consisting
-        // of a ParamSpec, the list of arguments does not need to be enclosed in
-        // a list. We'll handle that case specially here. Presumably this applies to
-        // type aliases as well.
-        if (typeParams.length === 1 && (0, types_1.isParamSpec)(typeParams[0]) && typeArgs) {
-            if (typeArgs.every((typeArg) => !(0, typeUtils_1.isEllipsisType)(typeArg.type) && !typeArg.typeList && !(0, types_1.isParamSpec)(typeArg.type))) {
-                typeArgs = [
-                    {
-                        type: types_1.UnknownType.create(),
-                        node: typeArgs.length > 0 ? typeArgs[0].node : node,
-                        typeList: typeArgs,
-                    },
-                ];
-            }
+        typeArgs = transformTypeArgsForParamSpec(typeParams, typeArgs, node);
+        if (!typeArgs) {
+            typeArgs = [];
+            reportedError = true;
         }
         let minTypeArgCount = typeParams.length;
         const firstDefaultParamIndex = typeParams.findIndex((param) => !!param.shared.isDefaultExplicit);
@@ -4950,8 +4946,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const typeList = typeArgs[index].typeList;
                 if (typeList) {
                     const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */);
-                    typeList.forEach((paramType, paramIndex) => {
-                        types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, (0, typeUtils_1.convertToInstance)(paramType.type), types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `__p${paramIndex}`));
+                    typeList.forEach((paramTypeResult, paramIndex) => {
+                        let paramType = paramTypeResult.type;
+                        if (!validateTypeArg(paramTypeResult)) {
+                            paramType = types_1.UnknownType.create();
+                        }
+                        types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, (0, typeUtils_1.convertToInstance)(paramType), types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `__p${paramIndex}`));
                     });
                     if (typeList.length > 0) {
                         types_1.FunctionType.addPositionOnlyParamSeparator(functionType);
@@ -5283,14 +5283,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Looks at uses of the type parameters within the type and adjusts the
     // variances accordingly. For example, if the type is `Mapping[T1, T2]`,
     // then T1 will be set to invariant and T2 will be set to covariant.
-    function updateUsageVariancesRecursive(type, typeAliasTypeParams, usageVariances, varianceContext, recursionCount = 0) {
+    function updateUsageVariancesRecursive(type, typeAliasTypeParams, usageVariances, varianceContext, pendingTypes = [], recursionCount = 0) {
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return;
         }
         const transformedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
-        // If this is a recursive type alias, use a lower recursion limit.
+        // If this is a recursive type alias, see if we've already recursed
+        // seen it once before in the recursion stack. If so, don't recurse
+        // further.
         if (transformedType !== type) {
-            if (recursionCount > maxRecursiveTypeAliasRecursionCount) {
+            const pendingOverlaps = pendingTypes.filter((pendingType) => (0, types_1.isTypeSame)(pendingType, type));
+            if (pendingOverlaps.length > 1) {
                 return;
             }
         }
@@ -5303,7 +5306,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     usageVariances[typeParamIndex] = (0, typeUtils_1.combineVariances)(usageVariances[typeParamIndex], variance);
                 }
                 else {
-                    updateUsageVariancesRecursive(subtype, typeAliasTypeParams, usageVariances, variance, recursionCount);
+                    pendingTypes.push(type);
+                    updateUsageVariancesRecursive(subtype, typeAliasTypeParams, usageVariances, variance, pendingTypes, recursionCount);
+                    pendingTypes.pop();
                 }
             });
         }
@@ -5349,12 +5354,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         });
     }
-    function makeTupleObject(typeArgs, isUnpacked = false) {
-        if (tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
-            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClass, typeArgs, /* isTypeArgExplicit */ true, isUnpacked));
-        }
-        return types_1.UnknownType.create();
-    }
     function getIndexAccessMagicMethodName(usage) {
         if (usage.method === 'get') {
             return '__getitem__';
@@ -5443,7 +5442,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else if (positionalArgs.length === 0 && unpackedListArgs.length === 0) {
             // Handle the case where there are no positionals provided but there are keywords.
-            positionalIndexType = makeTupleObject([]);
+            positionalIndexType = (0, tuples_1.makeTupleObject)(evaluatorInterface, []);
         }
         else {
             // Package up all of the positionals into a tuple.
@@ -5464,7 +5463,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const iterableType = (_b = (_a = getTypeOfIterator(typeResult, /* isAsync */ false, arg.d.valueExpr)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 tupleTypeArgs.push({ type: iterableType, isUnbounded: true });
             });
-            positionalIndexType = makeTupleObject(tupleTypeArgs);
+            positionalIndexType = (0, tuples_1.makeTupleObject)(evaluatorInterface, tupleTypeArgs);
         }
         const argList = [
             {
@@ -5567,7 +5566,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else if ((options === null || options === void 0 ? void 0 : options.isAnnotatedClass) && argIndex > 0) {
                 // If it's an Annotated[a, b, c], only the first index should be
-                // treated as a type.The others can be regular(non - type) objects.
+                // treated as a type. The others can be regular (non-type) objects.
                 adjFlags =
                     32 /* EvalFlags.NoParamSpec */ | 64 /* EvalFlags.NoTypeVarTuple */ | 2 /* EvalFlags.NoSpecialize */ | 131072 /* EvalFlags.NoClassVar */;
                 if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(node))) {
@@ -5593,38 +5592,70 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             });
             // Set the node's type so it isn't reevaluated later.
             setTypeResultForNode(node.d.items[0].d.valueExpr, { type: types_1.UnknownType.create() });
-        }
-        else {
-            node.d.items.forEach((arg, index) => {
-                const typeResult = getTypeArgTypeResult(arg.d.valueExpr, index);
-                if (arg.d.argCategory !== 0 /* ArgCategory.Simple */) {
-                    if (arg.d.argCategory === 1 /* ArgCategory.UnpackedList */) {
-                        if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass) || index === 0) {
-                            if ((0, types_1.isTypeVarTuple)(typeResult.type) && !typeResult.type.priv.isUnpacked) {
-                                typeResult.type = types_1.TypeVarType.cloneForUnpacked(typeResult.type);
-                            }
-                            else if ((0, types_1.isInstantiableClass)(typeResult.type) &&
-                                !typeResult.type.priv.includeSubclasses &&
-                                (0, typeUtils_1.isTupleClass)(typeResult.type)) {
-                                typeResult.type = types_1.ClassType.cloneForUnpacked(typeResult.type);
+            return typeArgs;
+        }
+        node.d.items.forEach((arg, index) => {
+            const typeResult = getTypeArgTypeResult(arg.d.valueExpr, index);
+            if (arg.d.argCategory !== 0 /* ArgCategory.Simple */) {
+                if (arg.d.argCategory === 1 /* ArgCategory.UnpackedList */) {
+                    if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass) || index === 0) {
+                        const unpackedType = applyUnpackToTupleLike(typeResult.type);
+                        if (unpackedType) {
+                            typeResult.type = unpackedType;
+                        }
+                        else {
+                            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackNotAllowed(), arg.d.valueExpr);
+                                typeResult.typeErrors = true;
                             }
                             else {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackNotAllowed(), arg.d.valueExpr);
+                                typeResult.type = types_1.UnknownType.create();
                             }
                         }
                     }
                 }
-                if (arg.d.name) {
+            }
+            if (arg.d.name) {
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), arg.d.valueExpr);
+                    typeResult.typeErrors = true;
                 }
-                if (arg.d.valueExpr.nodeType !== 0 /* ParseNodeType.Error */ ||
-                    arg.d.valueExpr.d.category !== 3 /* ErrorExpressionCategory.MissingIndexOrSlice */) {
-                    typeArgs.push(typeResult);
+                else {
+                    typeResult.type = types_1.UnknownType.create();
                 }
-            });
-        }
+            }
+            if (arg.d.valueExpr.nodeType !== 0 /* ParseNodeType.Error */ ||
+                arg.d.valueExpr.d.category !== 3 /* ErrorExpressionCategory.MissingIndexOrSlice */) {
+                typeArgs.push(typeResult);
+            }
+        });
         return typeArgs;
     }
+    function applyUnpackToTupleLike(type) {
+        if ((0, types_1.isTypeVarTuple)(type)) {
+            if (!type.priv.isUnpacked) {
+                return types_1.TypeVarType.cloneForUnpacked(type);
+            }
+            return undefined;
+        }
+        if ((0, types_1.isParamSpec)(type)) {
+            return undefined;
+        }
+        // Is this a TypeVar that has a tuple upper bound?
+        if ((0, types_1.isTypeVar)(type)) {
+            const upperBound = type.shared.boundType;
+            if (upperBound && (0, types_1.isClassInstance)(upperBound) && (0, typeUtils_1.isTupleClass)(upperBound)) {
+                return types_1.TypeVarType.cloneForUnpacked(type);
+            }
+            return undefined;
+        }
+        if ((0, types_1.isInstantiableClass)(type) && !type.priv.includeSubclasses) {
+            if ((0, typeUtils_1.isTupleClass)(type)) {
+                return types_1.ClassType.cloneForUnpacked(type);
+            }
+        }
+        return undefined;
+    }
     function getTypeArg(node, flags) {
         let typeResult;
         let adjustedFlags = flags | 128 /* EvalFlags.InstantiableType */ | 1 /* EvalFlags.ConvertEllipsisToAny */ | 8 /* EvalFlags.StrLiteralAsType */;
@@ -5657,138 +5688,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
-    function getTypeOfTuple(node, flags, inferenceContext) {
-        var _a;
-        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0 && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
-            // This is allowed inside of an index trailer, specifically
-            // to support Tuple[()], which is the documented way to annotate
-            // a zero-length tuple.
-            const diag = new diagnostic_1.DiagnosticAddendum();
-            diag.addMessage(localize_1.LocAddendum.useTupleInstead());
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.tupleInAnnotation() + diag.getString(), node);
-            return { type: types_1.UnknownType.create() };
-        }
-        if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0 && node.d.items.length === 0 && !inferenceContext) {
-            return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
-        }
-        flags &= ~(256 /* EvalFlags.TypeExpression */ | 8 /* EvalFlags.StrLiteralAsType */ | 128 /* EvalFlags.InstantiableType */);
-        // If the expected type is a union, recursively call for each of the subtypes
-        // to find one that matches.
-        let expectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
-        let expectedTypeContainsAny = inferenceContext && (0, types_1.isAny)(inferenceContext.expectedType);
-        if (inferenceContext && (0, types_1.isUnion)(inferenceContext.expectedType)) {
-            let matchingSubtype;
-            (0, typeUtils_1.doForEachSubtype)(inferenceContext.expectedType, (subtype) => {
-                if ((0, types_1.isAny)(subtype)) {
-                    expectedTypeContainsAny = true;
-                }
-                if (!matchingSubtype) {
-                    const subtypeResult = useSpeculativeMode(node, () => {
-                        return getTypeOfTupleWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(subtype));
-                    });
-                    if (subtypeResult && assignType(subtype, subtypeResult.type)) {
-                        matchingSubtype = subtype;
-                    }
-                }
-            }, 
-            /* sortSubtypes */ true);
-            expectedType = matchingSubtype;
-        }
-        let expectedTypeDiagAddendum;
-        if (expectedType) {
-            const result = getTypeOfTupleWithContext(node, flags, (0, typeUtils_1.makeInferenceContext)(expectedType));
-            if (result && !result.typeErrors) {
-                return result;
-            }
-            expectedTypeDiagAddendum = result === null || result === void 0 ? void 0 : result.expectedTypeDiagAddendum;
-        }
-        const typeResult = getTypeOfTupleInferred(node, flags);
-        // If there was an expected type of Any, replace the resulting type
-        // with Any rather than return a type with unknowns.
-        if (expectedTypeContainsAny) {
-            typeResult.type = types_1.AnyType.create();
-        }
-        return { ...typeResult, expectedTypeDiagAddendum };
-    }
-    function getTypeOfTupleWithContext(node, flags, inferenceContext) {
-        inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
-        if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
-            return undefined;
-        }
-        if (!tupleClass || !(0, types_1.isInstantiableClass)(tupleClass)) {
-            return undefined;
-        }
-        // Build an array of expected types.
-        let expectedTypes = [];
-        if ((0, typeUtils_1.isTupleClass)(inferenceContext.expectedType) && inferenceContext.expectedType.priv.tupleTypeArgs) {
-            expectedTypes = inferenceContext.expectedType.priv.tupleTypeArgs.map((t) => (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(t.type));
-            const unboundedIndex = inferenceContext.expectedType.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded);
-            if (unboundedIndex >= 0) {
-                if (expectedTypes.length > node.d.items.length) {
-                    expectedTypes.splice(unboundedIndex, 1);
-                }
-                else {
-                    while (expectedTypes.length < node.d.items.length) {
-                        expectedTypes.splice(unboundedIndex, 0, expectedTypes[unboundedIndex]);
-                    }
-                }
-            }
-        }
-        else {
-            const tupleConstraints = new constraintTracker_1.ConstraintTracker();
-            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClass), inferenceContext.expectedType, tupleConstraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
-                return undefined;
-            }
-            const specializedTuple = solveAndApplyConstraints(tupleClass, tupleConstraints);
-            if (!specializedTuple.priv.typeArgs || specializedTuple.priv.typeArgs.length !== 1) {
-                return undefined;
-            }
-            const homogenousType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(specializedTuple.priv.typeArgs[0]);
-            for (let i = 0; i < node.d.items.length; i++) {
-                expectedTypes.push(homogenousType);
-            }
-        }
-        const entryTypeResults = node.d.items.map((expr, index) => getTypeOfExpression(expr, flags | 268435456 /* EvalFlags.StripTupleLiterals */, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete)));
-        const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        // Copy any expected type diag addenda for precision error reporting.
-        let expectedTypeDiagAddendum;
-        if (entryTypeResults.some((result) => result.expectedTypeDiagAddendum)) {
-            expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
-            entryTypeResults.forEach((result) => {
-                if (result.expectedTypeDiagAddendum) {
-                    expectedTypeDiagAddendum.addAddendum(result.expectedTypeDiagAddendum);
-                }
-            });
-        }
-        // If the tuple contains a very large number of entries, it's probably
-        // generated code. If we encounter type errors, don't bother building
-        // the full tuple type.
-        let type;
-        if (node.d.items.length > maxInferredTupleEntryCount && entryTypeResults.some((result) => result.typeErrors)) {
-            type = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]);
-        }
-        else {
-            type = makeTupleObject(buildTupleTypesList(entryTypeResults, /* stripLiterals */ false));
-        }
-        return { type, expectedTypeDiagAddendum, isIncomplete };
-    }
-    function getTypeOfTupleInferred(node, flags) {
-        const entryTypeResults = node.d.items.map((expr) => getTypeOfExpression(expr, flags | 268435456 /* EvalFlags.StripTupleLiterals */));
-        const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        // If the tuple contains a very large number of entries, it's probably
-        // generated code. Rather than taking the time to evaluate every entry,
-        // simply return an unknown type in this case.
-        if (node.d.items.length > maxInferredTupleEntryCount) {
-            return { type: makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]) };
-        }
-        const type = makeTupleObject(buildTupleTypesList(entryTypeResults, (flags & 268435456 /* EvalFlags.StripTupleLiterals */) !== 0));
-        if (isIncomplete) {
-            if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
-                return { type: types_1.UnknownType.create() };
-            }
-        }
-        return { type, isIncomplete };
-    }
     function buildTupleTypesList(entryTypeResults, stripLiterals) {
         const entryTypes = [];
         for (const typeResult of entryTypeResults) {
@@ -5999,7 +5898,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeFormArgs(), node);
             return { type: types_1.UnknownType.create() };
         }
-        const typeFormResult = getTypeOfArgExpectingType((0, typeUtils_1.convertNodeToArg)(node.d.args[0]), {
+        const typeFormResult = getTypeOfArgExpectingType(convertNodeToArg(node.d.args[0]), {
             typeFormArg: isTypeFormSupported(node),
             noNonTypeSpecialForms: true,
             typeExpression: true,
@@ -6022,7 +5921,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (arg0TypeResult.isIncomplete) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
-        const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgExpectingType((0, typeUtils_1.convertNodeToArg)(node.d.args[1]), {
+        const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgExpectingType(convertNodeToArg(node.d.args[1]), {
             typeExpression: true,
         }).type);
         // We'll replace TypeGuard and TypeIs with bool for purposes of assert_type testing.
@@ -6041,6 +5940,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type: arg0TypeResult.type };
     }
+    function convertNodeToArg(node) {
+        return {
+            argCategory: node.d.argCategory,
+            name: node.d.name,
+            valueExpression: node.d.valueExpr,
+        };
+    }
     function getTypeOfRevealType(node, inferenceContext) {
         let arg0Value;
         let expectedRevealTypeNode;
@@ -6071,7 +5977,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else if (arg.d.name.d.value === 'expected_type') {
                 expectedRevealTypeNode = arg.d.valueExpr;
-                expectedRevealType = (0, typeUtils_1.convertToInstance)(getTypeOfArgExpectingType((0, typeUtils_1.convertNodeToArg)(arg), {
+                expectedRevealType = (0, typeUtils_1.convertToInstance)(getTypeOfArgExpectingType(convertNodeToArg(arg), {
                     typeExpression: true,
                 }).type);
             }
@@ -7314,7 +7220,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function evaluateCastCall(argList, errorNode) {
         var _a;
         // Verify that the cast is necessary.
-        const castToType = getTypeOfArgExpectingType(argList[0], { typeExpression: true }).type;
+        let castToType = getTypeOfArgExpectingType(argList[0], { typeExpression: true }).type;
+        const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        castToType = (0, typeUtils_1.makeTypeVarsBound)(castToType, liveScopeIds);
         let castFromType = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
         if ((_a = castFromType.props) === null || _a === void 0 ? void 0 : _a.specialForm) {
             castFromType = castFromType.props.specialForm;
@@ -7351,7 +7259,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     argCategory: 1 /* ArgCategory.UnpackedList */,
                                     valueExpression: undefined,
                                     typeResult: {
-                                        type: makeTupleObject([tupleTypeArg]),
+                                        type: (0, tuples_1.makeTupleObject)(evaluatorInterface, [tupleTypeArg]),
                                     },
                                 });
                             }
@@ -7547,7 +7455,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const paramInfo = paramDetails.params[paramIndex];
             const paramType = paramInfo.type;
             const paramName = paramInfo.param.name;
-            const isParamVariadic = paramInfo.param.category === 1 /* ParamCategory.ArgsList */ && (0, types_1.isTypeVarTuple)(paramType);
+            const isParamVariadic = paramInfo.param.category === 1 /* ParamCategory.ArgsList */ && (0, types_1.isUnpacked)(paramType);
             if (argList[argIndex].argCategory === 1 /* ArgCategory.UnpackedList */) {
                 let isArgCompatibleWithVariadic = false;
                 const argTypeResult = getTypeOfArg(argList[argIndex], /* inferenceContext */ undefined);
@@ -7679,7 +7587,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         paramType.priv.tupleTypeArgs.length > 0) {
                         effectiveParamType = paramType.priv.tupleTypeArgs[0].type;
                     }
-                    paramCategory = (0, types_1.isTypeVarTuple)(effectiveParamType) ? 1 /* ParamCategory.ArgsList */ : 0 /* ParamCategory.Simple */;
+                    paramCategory = (0, types_1.isUnpacked)(effectiveParamType) ? 1 /* ParamCategory.ArgsList */ : 0 /* ParamCategory.Simple */;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
                             if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
@@ -8158,7 +8066,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 !isTypeVarTupleFullyMatched) {
                 const paramType = paramDetails.params[paramDetails.argsIndex].type;
                 const variadicArgs = validateArgTypeParams.filter((argParam) => argParam.mapsToVarArgList);
-                if ((0, types_1.isTypeVarTuple)(paramType) && !paramType.priv.isInUnion) {
+                if ((0, types_1.isUnpacked)(paramType) && (!(0, types_1.isTypeVarTuple)(paramType) || !paramType.priv.isInUnion)) {
                     const tupleTypeArgs = variadicArgs.map((argParam) => {
                         var _a;
                         const argType = getTypeOfArg(argParam.argument, /* inferenceContext */ undefined).type;
@@ -8182,20 +8090,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         };
                     });
                     let specializedTuple;
-                    if (tupleTypeArgs.length === 1 &&
-                        !tupleTypeArgs[0].isUnbounded &&
-                        ((0, types_1.isUnpackedClass)(tupleTypeArgs[0].type) || (0, types_1.isTypeVarTuple)(tupleTypeArgs[0].type))) {
-                        // If there is a single unpacked tuple or unpacked variadic type variable
-                        // (including an unpacked TypeVarTuple union) within this tuple,
-                        // simplify the type.
-                        specializedTuple = tupleTypeArgs[0].type;
+                    if (tupleTypeArgs.length === 1 && !tupleTypeArgs[0].isUnbounded) {
+                        const entryType = tupleTypeArgs[0].type;
+                        if ((0, types_1.isUnpacked)(entryType)) {
+                            specializedTuple = (0, typeUtils_1.makePacked)(entryType);
+                        }
                     }
-                    else {
-                        specializedTuple = makeTupleObject(tupleTypeArgs, /* isUnpacked */ true);
+                    if (!specializedTuple) {
+                        specializedTuple = (0, tuples_1.makeTupleObject)(evaluatorInterface, tupleTypeArgs, /* isUnpacked */ false);
                     }
                     const combinedArg = {
-                        paramCategory: 1 /* ParamCategory.ArgsList */,
-                        paramType,
+                        paramCategory: 0 /* ParamCategory.Simple */,
+                        paramType: (0, typeUtils_1.makePacked)(paramType),
                         requiresTypeVarMatching: true,
                         argument: {
                             argCategory: 0 /* ArgCategory.Simple */,
@@ -8521,7 +8427,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
-            specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpacked */ false);
+            specializedReturnType = types_1.ClassType.cloneForPacked(specializedReturnType);
         }
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         specializedReturnType = adjustCallableReturnType(errorNode, specializedReturnType, liveTypeVarScopes);
@@ -9100,7 +9006,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
         const typeVar = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(typeVarName, types_1.TypeVarKind.TypeVarTuple), types_1.ClassType.cloneAsInstance(classType));
-        typeVar.shared.defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]);
+        typeVar.shared.defaultType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [
+            { type: types_1.UnknownType.create(), isUnbounded: true },
+        ]);
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
             const paramNameNode = argList[i].name;
@@ -9222,6 +9130,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const typeResult = getTypeOfExpressionExpectingType(node, {
                 allowParamSpec: true,
                 allowTypeVarsWithoutScopeId: true,
+                allowEllipsis: true,
                 typeExpression: true,
             });
             if (typeResult.typeErrors) {
@@ -9752,7 +9661,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             /* tupleTypeArgs */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
         if (isIncomplete) {
-            if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+            if ((0, typeUtils_1.getContainerDepth)(type) > typeEvaluatorTypes_1.maxInferredContainerDepth) {
                 return { type: types_1.UnknownType.create() };
             }
         }
@@ -10119,7 +10028,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             /* tupleTypeArgs */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
         if (isIncomplete) {
-            if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+            if ((0, typeUtils_1.getContainerDepth)(type) > typeEvaluatorTypes_1.maxInferredContainerDepth) {
                 return { type: types_1.UnknownType.create() };
             }
         }
@@ -10519,7 +10428,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!expectedValueOrElementType || !(0, typeUtils_1.containsLiteralType)(expectedValueOrElementType)) {
                 valueType = stripLiteralValue(valueType);
             }
-            type = makeTupleObject([
+            type = (0, tuples_1.makeTupleObject)(evaluatorInterface, [
                 { type: keyType, isUnbounded: false },
                 { type: valueType, isUnbounded: false },
             ]);
@@ -10785,16 +10694,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // As per the specification, we support None, int, bool, str, bytes literals
         // plus enum values.
         const literalTypes = [];
+        let isValidTypeForm = true;
         for (const item of node.d.items) {
             let type;
             const itemExpr = item.d.valueExpr;
             if (item.d.argCategory !== 0 /* ArgCategory.Simple */) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
-                type = types_1.UnknownType.create();
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
+                    type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
+                }
             }
             else if (item.d.name) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
-                type = types_1.UnknownType.create();
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
+                    type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
+                }
             }
             else if (itemExpr.nodeType === 48 /* ParseNodeType.StringList */) {
                 const isBytes = (itemExpr.d.strings[0].d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
@@ -10805,11 +10721,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'str', value);
                 }
-                itemExpr.d.strings.forEach((stringNode) => {
-                    if ((stringNode.d.token.flags & 512 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
-                    }
-                });
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    itemExpr.d.strings.forEach((stringNode) => {
+                        if ((stringNode.d.token.flags & 512 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
+                            isValidTypeForm = false;
+                        }
+                    });
+                }
             }
             else if (itemExpr.nodeType === 40 /* ParseNodeType.Number */) {
                 if (!itemExpr.d.isImaginary && itemExpr.d.isInteger) {
@@ -10865,6 +10784,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalUnsupportedType(), item);
                     type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
                 }
                 else {
                     return types_1.ClassType.cloneAsInstance(classType);
@@ -10876,7 +10796,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnion)(result) && unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
             result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(unionTypeClass));
         }
-        if (isTypeFormSupported(node)) {
+        if (isTypeFormSupported(node) && isValidTypeForm) {
             result = types_1.TypeBase.cloneWithTypeForm(result, (0, typeUtils_1.convertToInstance)(result));
         }
         return result;
@@ -11087,16 +11007,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return classType;
         }
-        let typeArgType = typeArgs[0].type;
-        if ((0, types_1.isUnion)(typeArgType) && typeArgType.priv.subtypes.length === 1) {
-            typeArgType = typeArgType.priv.subtypes[0];
-        }
+        const typeArgType = typeArgs[0].type;
         if ((flags & 2097152 /* EvalFlags.AllowUnpackedTuple */) !== 0) {
-            if ((0, types_1.isInstantiableClass)(typeArgType) && !typeArgType.priv.includeSubclasses && (0, typeUtils_1.isTupleClass)(typeArgType)) {
-                return types_1.ClassType.cloneForUnpacked(typeArgType);
-            }
-            if ((0, types_1.isTypeVarTuple)(typeArgType) && !typeArgType.priv.isUnpacked) {
-                return types_1.TypeVarType.cloneForUnpacked(typeArgType);
+            const unpackedType = applyUnpackToTupleLike(typeArgType);
+            if (unpackedType) {
+                return unpackedType;
             }
             if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
                 return classType;
@@ -11210,44 +11125,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // 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 true;
-        }
-        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;
+        // This function was added for draft PEP 746, but the functionality
+        // has been removed for now while the PEP is being revised.
+        return true;
     }
     // Creates one of several "special" types that are defined in typing.pyi
     // but not declared in their entirety. This includes the likes of "Tuple",
@@ -11409,7 +11289,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // is allowed if it's an unpacked TypeVarTuple or tuple. None is also allowed
         // since it is used to define NoReturn in typeshed stubs).
         if (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0])) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
+            }
             isValidTypeForm = false;
         }
         let unionType = (0, types_1.combineTypes)(types, { skipElideRedundantLiterals: true });
@@ -11462,9 +11344,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function transformTypeForTypeAlias(type, errorNode, typeAliasPlaceholder, isPep695TypeVarType, typeParamNodes) {
         var _a;
-        if (!types_1.TypeBase.isInstantiable(type)) {
-            return type;
-        }
         // If this is a recursive type alias that hasn't yet been fully resolved
         // (i.e. there is no boundType associated with it), don't apply the transform.
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
@@ -11526,6 +11405,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }), errorNode);
             }
         }
+        if (!types_1.TypeBase.isInstantiable(type)) {
+            return type;
+        }
         sharedInfo.typeParams = typeParams.length > 0 ? typeParams : undefined;
         let typeAlias = types_1.TypeBase.cloneForTypeAlias(type, {
             shared: sharedInfo,
@@ -11774,8 +11656,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!rightHandType) {
-            // Determine whether there is a declared type.
-            const declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: 'set' });
             let typeAliasNameNode;
             let typeAliasPlaceholder;
             let isSpeculativeTypeAlias = false;
@@ -11819,6 +11699,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     writeTypeCache(node.d.leftExpr.d.valueExpr, { type: typeAliasPlaceholder }, /* flags */ undefined);
                 }
             }
+            let declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: 'set' });
+            if (declaredType) {
+                const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                declaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveTypeVarScopes);
+            }
             const srcTypeResult = getTypeOfExpression(node.d.rightExpr, flags, (0, typeUtils_1.makeInferenceContext)(declaredType));
             rightHandType = srcTypeResult.type;
             expectedTypeDiagAddendum = srcTypeResult.expectedTypeDiagAddendum;
@@ -13461,9 +13346,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return type;
                 }
                 if ((0, types_1.isUnpackedClass)(type)) {
-                    return types_1.ClassType.cloneForUnpacked(type, /* isUnpacked */ false);
+                    return types_1.ClassType.cloneForPacked(type);
                 }
-                return makeTupleObject([{ type, isUnbounded: !(0, types_1.isTypeVarTuple)(type) }]);
+                return (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type, isUnbounded: !(0, types_1.isTypeVarTuple)(type) }]);
             }
             case 2 /* ParamCategory.KwargsDict */: {
                 // Leave a ParamSpec alone.
@@ -13493,7 +13378,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             awaitableFunctionType.shared.declaredReturnType = createAwaitableReturnType(node, functionType.shared.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         }
         else {
-            awaitableFunctionType.priv.inferredReturnType = createAwaitableReturnType(node, getFunctionInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType));
+            awaitableFunctionType.priv.inferredReturnType = createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType));
         }
         return awaitableFunctionType;
     }
@@ -14883,39 +14768,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Handle ParamSpec arguments and fill in any missing type arguments with Unknown.
         let typeArgTypes = [];
         const fullTypeParams = types_1.ClassType.getTypeParams(classType);
-        // PEP 612 says that if the class has only one type parameter consisting
-        // of a ParamSpec, the list of arguments does not need to be enclosed in
-        // a list. We'll handle that case specially here.
-        if (fullTypeParams.length === 1 && (0, types_1.isParamSpec)(fullTypeParams[0]) && typeArgs) {
-            if (typeArgs.every((typeArg) => !(0, typeUtils_1.isEllipsisType)(typeArg.type) && !typeArg.typeList && !(0, types_1.isParamSpec)(typeArg.type))) {
-                if (typeArgs.length !== 1 ||
-                    !(0, types_1.isInstantiableClass)(typeArgs[0].type) ||
-                    !types_1.ClassType.isBuiltIn(typeArgs[0].type, 'Concatenate')) {
-                    // Package up the type arguments into a typeList.
-                    typeArgs =
-                        typeArgs.length > 0
-                            ? [
-                                {
-                                    type: types_1.UnknownType.create(),
-                                    node: typeArgs[0].node,
-                                    typeList: typeArgs,
-                                },
-                            ]
-                            : [];
-                }
-            }
-            else if (typeArgs.length > 1) {
-                const paramSpecTypeArg = typeArgs.find((typeArg) => (0, types_1.isParamSpec)(typeArg.type));
-                if (paramSpecTypeArg) {
-                    isValidTypeForm = false;
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), paramSpecTypeArg.node);
-                }
-                const listTypeArg = typeArgs.find((typeArg) => !!typeArg.typeList);
-                if (listTypeArg) {
-                    isValidTypeForm = false;
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), listTypeArg.node);
-                }
-            }
+        typeArgs = transformTypeArgsForParamSpec(fullTypeParams, typeArgs, errorNode);
+        if (!typeArgs) {
+            isValidTypeForm = false;
         }
         const constraints = new constraintTracker_1.ConstraintTracker();
         fullTypeParams.forEach((typeParam, index) => {
@@ -15022,6 +14877,57 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type: specializedClass };
     }
+    // PEP 612 says that if the class has only one type parameter consisting
+    // of a ParamSpec, the list of arguments does not need to be enclosed in
+    // a list. We'll handle that case specially here.
+    function transformTypeArgsForParamSpec(typeParams, typeArgs, errorNode) {
+        if (typeParams.length !== 1 || !(0, types_1.isParamSpec)(typeParams[0]) || !typeArgs) {
+            return typeArgs;
+        }
+        if (typeArgs.length > 1) {
+            for (const typeArg of typeArgs) {
+                if ((0, types_1.isParamSpec)(typeArg.type)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), typeArg.node);
+                    return undefined;
+                }
+                if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisContext(), typeArg.node);
+                    return undefined;
+                }
+                if ((0, types_1.isInstantiableClass)(typeArg.type) && types_1.ClassType.isBuiltIn(typeArg.type, 'Concatenate')) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateContext(), typeArg.node);
+                    return undefined;
+                }
+                if (typeArg.typeList) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), typeArg.node);
+                    return undefined;
+                }
+            }
+        }
+        if (typeArgs.length === 1) {
+            // Don't transform a type list.
+            if (typeArgs[0].typeList) {
+                return typeArgs;
+            }
+            const typeArgType = typeArgs[0].type;
+            // Don't transform a single ParamSpec or ellipsis.
+            if ((0, types_1.isParamSpec)(typeArgType) || (0, typeUtils_1.isEllipsisType)(typeArgType)) {
+                return typeArgs;
+            }
+            // Don't transform a Concatenate.
+            if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isBuiltIn(typeArgType, 'Concatenate')) {
+                return typeArgs;
+            }
+        }
+        // Package up the type arguments into a type list.
+        return [
+            {
+                type: types_1.UnknownType.create(),
+                node: typeArgs.length > 0 ? typeArgs[0].node : errorNode,
+                typeList: typeArgs,
+            },
+        ];
+    }
     function getTypeOfArg(arg, inferenceContext) {
         var _a, _b;
         if (arg.typeResult) {
@@ -15091,6 +14997,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (options === null || options === void 0 ? void 0 : options.convertEllipsisToAny) {
             flags |= 1 /* EvalFlags.ConvertEllipsisToAny */;
         }
+        if (options === null || options === void 0 ? void 0 : options.allowEllipsis) {
+            flags |= 65536 /* EvalFlags.AllowEllipsis */;
+        }
         if (options === null || options === void 0 ? void 0 : options.noNonTypeSpecialForms) {
             flags |= 67108864 /* EvalFlags.NoNonTypeSpecialForms */;
         }
@@ -15528,7 +15437,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (paramDecl) {
                                 declarations.push(paramDecl);
                             }
-                            else if (types_1.ClassType.isDataClass(baseType) || types_1.ClassType.isTypedDictClass(baseType)) {
+                            else if (types_1.ClassType.isDataClass(baseType) ||
+                                types_1.ClassType.isTypedDictClass(baseType) ||
+                                types_1.ClassType.hasNamedTupleEntry(baseType, paramName)) {
                                 const lookupResults = (0, typeUtils_1.lookUpClassMember)(baseType, paramName);
                                 if (lookupResults) {
                                     (0, collectionUtils_1.appendArray)(declarations, lookupResults.symbol.getDeclarations());
@@ -15783,7 +15694,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeVar.shared.isDefaultExplicit = true;
             }
             else {
-                typeVar.shared.defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]);
+                typeVar.shared.defaultType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [
+                    { type: types_1.UnknownType.create(), isUnbounded: true },
+                ]);
             }
         }
         else {
@@ -15813,7 +15726,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (scopeNode.nodeType === 10 /* ParseNodeType.Class */) {
                 scopeType = 0 /* TypeVarScopeType.Class */;
                 // Set the variance to "auto" for class-scoped TypeVars.
-                typeVar.shared.declaredVariance = 0 /* Variance.Auto */;
+                typeVar.shared.declaredVariance =
+                    (0, types_1.isParamSpec)(typeVar) || (0, types_1.isTypeVarTuple)(typeVar) ? 2 /* Variance.Invariant */ : 0 /* Variance.Auto */;
             }
             else if (scopeNode.nodeType === 31 /* ParseNodeType.Function */) {
                 scopeType = 1 /* TypeVarScopeType.Function */;
@@ -15821,7 +15735,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 (0, debug_1.assert)(scopeNode.nodeType === 77 /* ParseNodeType.TypeAlias */);
                 scopeType = 2 /* TypeVarScopeType.TypeAlias */;
-                typeVar.shared.declaredVariance = 0 /* Variance.Auto */;
+                typeVar.shared.declaredVariance =
+                    (0, types_1.isParamSpec)(typeVar) || (0, types_1.isTypeVarTuple)(typeVar) ? 2 /* Variance.Invariant */ : 0 /* Variance.Auto */;
             }
             typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, ParseTreeUtils.getScopeIdForNode(scopeNode.nodeType === 77 /* ParseNodeType.TypeAlias */ ? scopeNode.d.name : scopeNode), scopeNode.d.name.d.value, scopeType);
         }
@@ -16426,7 +16341,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return specializedReturnType;
         }
         if (!(options === null || options === void 0 ? void 0 : options.skipInferReturnType)) {
-            return getFunctionInferredReturnType(type, options === null || options === void 0 ? void 0 : options.callSiteInfo);
+            return getInferredReturnType(type, options === null || options === void 0 ? void 0 : options.callSiteInfo);
         }
         return types_1.UnknownType.create();
     }
@@ -17043,7 +16958,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const typeParam = destType.shared.typeParams[i];
                 const variance = types_1.TypeVarType.getVariance(typeParam);
                 if (curSrcType.priv.tupleTypeArgs) {
-                    typeArgType = (0, typeUtils_1.convertToInstance)(makeTupleObject(curSrcType.priv.tupleTypeArgs, /* isUnpacked */ true));
+                    typeArgType = (0, typeUtils_1.convertToInstance)((0, tuples_1.makeTupleObject)(evaluatorInterface, curSrcType.priv.tupleTypeArgs, /* isUnpacked */ true));
                 }
                 else {
                     typeArgType = i < srcTypeArgs.length ? srcTypeArgs[i] : types_1.UnknownType.create();
@@ -17509,6 +17424,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
             if ((0, types_1.isClass)(concreteSrcType) && types_1.TypeBase.isInstance(concreteSrcType)) {
+                // Handle the case where the source is an unpacked tuple.
+                if (!destType.priv.isUnpacked &&
+                    concreteSrcType.priv.isUnpacked &&
+                    concreteSrcType.priv.tupleTypeArgs) {
+                    return assignType(destType, (0, typeUtils_1.combineTupleTypeArgs)(concreteSrcType.priv.tupleTypeArgs), diag, constraints, flags, recursionCount);
+                }
                 // Handle enum literals that are assignable to another (non-Enum) literal.
                 // This can happen for IntEnum and StrEnum members.
                 if (types_1.ClassType.isEnumClass(concreteSrcType) &&
@@ -18360,7 +18281,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         });
         if (srcTupleTypes.length !== 1 || !(0, types_1.isTypeVarTuple)(srcTupleTypes[0].type)) {
-            const srcPositionalsType = makeTupleObject(srcTupleTypes, /* isUnpacked */ true);
+            const srcPositionalsType = (0, tuples_1.makeTupleObject)(evaluatorInterface, srcTupleTypes, /* isUnpacked */ true);
             // Snip out the portion of the source positionals that map to the variadic
             // dest parameter and replace it with a single parameter that is typed as a
             // tuple containing the individual types of the replaced parameters.
@@ -18427,11 +18348,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const destParamName = (_c = destParam.param.name) !== null && _c !== void 0 ? _c : '';
             const srcParamName = (_d = srcParam.param.name) !== null && _d !== void 0 ? _d : '';
             if (destParamName) {
-                const isDestPositionalOnly = destParam.kind === parameterUtils_1.ParamKind.Positional;
+                const isDestPositionalOnly = destParam.kind === parameterUtils_1.ParamKind.Positional || destParam.kind === parameterUtils_1.ParamKind.ExpandedArgs;
                 if (!isDestPositionalOnly &&
                     destParam.param.category !== 1 /* ParamCategory.ArgsList */ &&
                     srcParam.param.category !== 1 /* ParamCategory.ArgsList */) {
-                    if (srcParam.kind === parameterUtils_1.ParamKind.Positional) {
+                    if (srcParam.kind === parameterUtils_1.ParamKind.Positional || srcParam.kind === parameterUtils_1.ParamKind.ExpandedArgs) {
                         diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamPositionOnly().format({
                             name: destParamName,
                         }));
@@ -18616,10 +18537,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let destArgsType = destParamDetails.params[destParamDetails.argsIndex].type;
             let srcArgsType = srcParamDetails.params[srcParamDetails.argsIndex].type;
             if (!(0, types_1.isUnpacked)(destArgsType)) {
-                destArgsType = makeTupleObject([{ type: destArgsType, isUnbounded: true }], /* isUnpacked */ true);
+                destArgsType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: destArgsType, isUnbounded: true }], 
+                /* isUnpacked */ true);
             }
             if (!(0, types_1.isUnpacked)(srcArgsType)) {
-                srcArgsType = makeTupleObject([{ type: srcArgsType, isUnbounded: true }], /* isUnpacked */ true);
+                srcArgsType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: srcArgsType, isUnbounded: true }], 
+                /* isUnpacked */ true);
             }
             if (!assignParam(destArgsType, srcArgsType, destParamDetails.params[destParamDetails.argsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                 canAssign = false;
@@ -18973,7 +18896,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                         return assignedSubtype;
                     }
-                    if (!(0, types_1.isTypeVar)(declaredSubtype) && (0, types_1.isTypeVar)(assignedSubtype)) {
+                    if (!(0, types_1.isTypeVar)(declaredSubtype) &&
+                        (0, types_1.isTypeVar)(assignedSubtype) &&
+                        !types_1.TypeVarType.isBound(assignedSubtype)) {
                         // If the source is an unsolved TypeVar but the declared type is concrete,
                         // use the concrete type.
                         return declaredSubtype;
@@ -19868,7 +19793,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return codeFlowEngine.printControlFlowGraph(flowNode, reference, callName, logger);
     }
     // Track these apis internal usages when logging is on. otherwise, it should be noop.
-    const getFunctionInferredReturnType = wrapWithLogger(_getInferredReturnType);
+    const getInferredReturnType = wrapWithLogger(_getInferredReturnType);
     const evaluatorInterface = {
         runWithCancellationToken,
         getType,
@@ -19886,7 +19811,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         evaluateTypesForStatement,
         evaluateTypesForMatchStatement,
         evaluateTypesForCaseStatement,
-        evaluateTypeOfParam: evaluateTypeOfParam,
+        evaluateTypeOfParam,
         canBeTruthy,
         canBeFalsy,
         stripLiteralValue,
@@ -19913,7 +19838,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getTypeOfIterable,
         getTypeOfIterator,
         getGetterTypeFromProperty,
-        getTypeOfArg: getTypeOfArg,
+        getTypeOfArg,
+        convertNodeToArg,
+        buildTupleTypesList,
         markNamesAccessed,
         expandPromotionTypes,
         makeTopLevelTypeVarsConcrete,
@@ -19925,8 +19852,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getEffectiveTypeOfSymbolForUsage,
         getInferredTypeOfDeclaration,
         getDeclaredTypeForExpression,
-        getFunctionDeclaredReturnType: getDeclaredReturnType,
-        getFunctionInferredReturnType,
+        getDeclaredReturnType,
+        getInferredReturnType,
         getBestOverloadForArgs,
         getBuiltInType,
         getTypeOfMember,