typescript 5.4.0-dev.20231129 → 5.4.0-dev.20231201

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20231129`;
+      version = `${versionMajorMinor}.0-dev.20231201`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4447,6 +4447,7 @@ ${lanes.join("\n")}
         TypeFlags2[TypeFlags2["IncludesWildcard"] = 8388608 /* IndexedAccess */] = "IncludesWildcard";
         TypeFlags2[TypeFlags2["IncludesEmptyObject"] = 16777216 /* Conditional */] = "IncludesEmptyObject";
         TypeFlags2[TypeFlags2["IncludesInstantiable"] = 33554432 /* Substitution */] = "IncludesInstantiable";
+        TypeFlags2[TypeFlags2["IncludesConstrainedTypeVariable"] = 268435456 /* StringMapping */] = "IncludesConstrainedTypeVariable";
         TypeFlags2[TypeFlags2["NotPrimitiveUnion"] = 36323331] = "NotPrimitiveUnion";
         return TypeFlags2;
       })(TypeFlags || {});
@@ -4493,6 +4494,7 @@ ${lanes.join("\n")}
         ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
         ObjectFlags3[ObjectFlags3["IsNeverIntersectionComputed"] = 16777216] = "IsNeverIntersectionComputed";
         ObjectFlags3[ObjectFlags3["IsNeverIntersection"] = 33554432] = "IsNeverIntersection";
+        ObjectFlags3[ObjectFlags3["IsConstrainedTypeVariable"] = 67108864] = "IsConstrainedTypeVariable";
         return ObjectFlags3;
       })(ObjectFlags || {});
       VarianceFlags = /* @__PURE__ */ ((VarianceFlags2) => {
@@ -37814,7 +37816,7 @@ ${lanes.join("\n")}
         ["esnext.disposable", "lib.esnext.disposable.d.ts"],
         ["esnext.bigint", "lib.es2020.bigint.d.ts"],
         ["esnext.string", "lib.es2022.string.d.ts"],
-        ["esnext.promise", "lib.es2021.promise.d.ts"],
+        ["esnext.promise", "lib.esnext.promise.d.ts"],
         ["esnext.weakref", "lib.es2021.weakref.d.ts"],
         ["esnext.decorators", "lib.esnext.decorators.d.ts"],
         ["decorators", "lib.decorators.d.ts"],
@@ -44310,7 +44312,7 @@ ${lanes.join("\n")}
     }
     function bindSpecialPropertyAssignment(node) {
       var _a;
-      const parentSymbol = lookupSymbolForPropertyAccess(node.left.expression, container) || lookupSymbolForPropertyAccess(node.left.expression, blockScopeContainer);
+      const parentSymbol = lookupSymbolForPropertyAccess(node.left.expression, blockScopeContainer) || lookupSymbolForPropertyAccess(node.left.expression, container);
       if (!isInJSFile(node) && !isFunctionSymbol(parentSymbol)) {
         return;
       }
@@ -44408,7 +44410,7 @@ ${lanes.join("\n")}
       return isBinaryExpression(propertyAccess.parent) ? getParentOfBinaryExpression(propertyAccess.parent).parent.kind === 312 /* SourceFile */ : propertyAccess.parent.parent.kind === 312 /* SourceFile */;
     }
     function bindPropertyAssignment(name, propertyAccess, isPrototypeProperty, containerIsClass) {
-      let namespaceSymbol = lookupSymbolForPropertyAccess(name, container) || lookupSymbolForPropertyAccess(name, blockScopeContainer);
+      let namespaceSymbol = lookupSymbolForPropertyAccess(name, blockScopeContainer) || lookupSymbolForPropertyAccess(name, container);
       const isToplevel = isTopLevelNamespaceAssignment(propertyAccess);
       namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, propertyAccess.expression, isToplevel, isPrototypeProperty, containerIsClass);
       bindPotentiallyNewExpandoMemberToNamespace(propertyAccess, namespaceSymbol, isPrototypeProperty);
@@ -49464,6 +49466,10 @@ ${lanes.join("\n")}
     function getParentOfSymbol(symbol) {
       return getMergedSymbol(symbol.parent && getLateBoundSymbol(symbol.parent));
     }
+    function getFunctionExpressionParentSymbolOrSymbol(symbol) {
+      var _a, _b;
+      return ((_a = symbol.valueDeclaration) == null ? void 0 : _a.kind) === 219 /* ArrowFunction */ || ((_b = symbol.valueDeclaration) == null ? void 0 : _b.kind) === 218 /* FunctionExpression */ ? getSymbolOfNode(symbol.valueDeclaration.parent) || symbol : symbol;
+    }
     function getAlternativeContainingModules(symbol, enclosingDeclaration) {
       const containingFile = getSourceFileOfNode(enclosingDeclaration);
       const id = getNodeId(containingFile);
@@ -54687,11 +54693,14 @@ ${lanes.join("\n")}
         }
       }
       if ((_a = symbol.parent) == null ? void 0 : _a.valueDeclaration) {
-        const typeNode2 = getEffectiveTypeAnnotationNode(symbol.parent.valueDeclaration);
-        if (typeNode2) {
-          const annotationSymbol = getPropertyOfType(getTypeFromTypeNode(typeNode2), symbol.escapedName);
-          if (annotationSymbol) {
-            return getNonMissingTypeOfSymbol(annotationSymbol);
+        const possiblyAnnotatedSymbol = getFunctionExpressionParentSymbolOrSymbol(symbol.parent);
+        if (possiblyAnnotatedSymbol.valueDeclaration) {
+          const typeNode2 = getEffectiveTypeAnnotationNode(possiblyAnnotatedSymbol.valueDeclaration);
+          if (typeNode2) {
+            const annotationSymbol = getPropertyOfType(getTypeFromTypeNode(typeNode2), symbol.escapedName);
+            if (annotationSymbol) {
+              return getNonMissingTypeOfSymbol(annotationSymbol);
+            }
           }
         }
       }
@@ -55991,7 +56000,6 @@ ${lanes.join("\n")}
       return links.resolvedSymbol;
     }
     function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) {
-      var _a, _b, _c;
       const links = getSymbolLinks(symbol);
       if (!links[resolutionKind]) {
         const isStatic2 = resolutionKind === "resolvedExports" /* resolvedExports */;
@@ -56010,7 +56018,7 @@ ${lanes.join("\n")}
             }
           }
         }
-        const assignments = (((_a = symbol.valueDeclaration) == null ? void 0 : _a.kind) === 219 /* ArrowFunction */ || ((_b = symbol.valueDeclaration) == null ? void 0 : _b.kind) === 218 /* FunctionExpression */) && ((_c = getSymbolOfNode(symbol.valueDeclaration.parent)) == null ? void 0 : _c.assignmentDeclarationMembers) || symbol.assignmentDeclarationMembers;
+        const assignments = getFunctionExpressionParentSymbolOrSymbol(symbol).assignmentDeclarationMembers;
         if (assignments) {
           const decls = arrayFrom(assignments.values());
           for (const member of decls) {
@@ -56307,6 +56315,15 @@ ${lanes.join("\n")}
       let result;
       for (let i = 0; i < signatureLists.length; i++) {
         const match = i === listIndex ? signature : findMatchingSignature(
+          signatureLists[i],
+          signature,
+          /*partialMatch*/
+          false,
+          /*ignoreThisTypes*/
+          false,
+          /*ignoreReturnTypes*/
+          true
+        ) || findMatchingSignature(
           signatureLists[i],
           signature,
           /*partialMatch*/
@@ -56680,6 +56697,18 @@ ${lanes.join("\n")}
     function replaceIndexedAccess(instantiable, type, replacement) {
       return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])]));
     }
+    function getLimitedConstraint(type) {
+      const constraint = getConstraintTypeFromMappedType(type.mappedType);
+      if (!(constraint.flags & 1048576 /* Union */ || constraint.flags & 2097152 /* Intersection */)) {
+        return;
+      }
+      const origin = constraint.flags & 1048576 /* Union */ ? constraint.origin : constraint;
+      if (!origin || !(origin.flags & 2097152 /* Intersection */)) {
+        return;
+      }
+      const limitedConstraint = getIntersectionType(origin.types.filter((t) => t !== type.constraintType));
+      return limitedConstraint !== neverType ? limitedConstraint : void 0;
+    }
     function resolveReverseMappedTypeMembers(type) {
       const indexInfo = getIndexInfoOfType(type.source, stringType);
       const modifiers = getMappedTypeModifiers(type.mappedType);
@@ -56687,7 +56716,14 @@ ${lanes.join("\n")}
       const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
       const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly)] : emptyArray;
       const members = createSymbolTable();
+      const limitedConstraint = getLimitedConstraint(type);
       for (const prop of getPropertiesOfType(type.source)) {
+        if (limitedConstraint) {
+          const propertyNameType = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
+          if (!isTypeAssignableTo(propertyNameType, limitedConstraint)) {
+            continue;
+          }
+        }
         const checkFlags = 8192 /* ReverseMapped */ | (readonlyMask && isReadonlySymbol(prop) ? 8 /* Readonly */ : 0);
         const inferredProp = createSymbol(4 /* Property */ | prop.flags & optionalMask, prop.escapedName, checkFlags);
         inferredProp.declarations = prop.declarations;
@@ -56768,7 +56804,7 @@ ${lanes.join("\n")}
       const constraintType = getConstraintTypeFromMappedType(type);
       const mappedType = type.target || type;
       const nameType = getNameTypeFromMappedType(mappedType);
-      const shouldLinkPropDeclarations = !nameType || isFilteringMappedType(mappedType);
+      const shouldLinkPropDeclarations = getMappedTypeNameTypeKind(mappedType) !== 2 /* Remapping */;
       const templateType = getTemplateTypeFromMappedType(mappedType);
       const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
       const templateModifiers = getMappedTypeModifiers(type);
@@ -56910,9 +56946,12 @@ ${lanes.join("\n")}
       }
       return false;
     }
-    function isFilteringMappedType(type) {
+    function getMappedTypeNameTypeKind(type) {
       const nameType = getNameTypeFromMappedType(type);
-      return !!nameType && isTypeAssignableTo(nameType, getTypeParameterFromMappedType(type));
+      if (!nameType) {
+        return 0 /* None */;
+      }
+      return isTypeAssignableTo(nameType, getTypeParameterFromMappedType(type)) ? 1 /* Filtering */ : 2 /* Remapping */;
     }
     function resolveStructuredTypeMembers(type) {
       if (!type.members) {
@@ -56961,7 +57000,12 @@ ${lanes.join("\n")}
         for (const current of type.types) {
           for (const prop of getPropertiesOfType(current)) {
             if (!members.has(prop.escapedName)) {
-              const combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName);
+              const combinedProp = getPropertyOfUnionOrIntersectionType(
+                type,
+                prop.escapedName,
+                /*skipObjectFunctionPropertyAugment*/
+                !!(type.flags & 2097152 /* Intersection */)
+              );
               if (combinedProp) {
                 members.set(prop.escapedName, combinedProp);
               }
@@ -57451,13 +57495,17 @@ ${lanes.join("\n")}
       return result;
     }
     function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
-      var _a, _b;
+      var _a, _b, _c;
       let property = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? void 0 : _b.get(name) : void 0;
       if (!property) {
         property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
         if (property) {
           const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
           properties.set(name, property);
+          if (skipObjectFunctionPropertyAugment && !((_c = type.propertyCache) == null ? void 0 : _c.get(name))) {
+            const properties2 = type.propertyCache || (type.propertyCache = createSymbolTable());
+            properties2.set(name, property);
+          }
         }
       }
       return property;
@@ -57567,7 +57615,22 @@ ${lanes.join("\n")}
         }
         return getPropertyOfObjectType(globalObjectType, name);
       }
-      if (type.flags & 3145728 /* UnionOrIntersection */) {
+      if (type.flags & 2097152 /* Intersection */) {
+        const prop = getPropertyOfUnionOrIntersectionType(
+          type,
+          name,
+          /*skipObjectFunctionPropertyAugment*/
+          true
+        );
+        if (prop) {
+          return prop;
+        }
+        if (!skipObjectFunctionPropertyAugment) {
+          return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
+        }
+        return void 0;
+      }
+      if (type.flags & 1048576 /* Union */) {
         return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
       }
       return void 0;
@@ -59424,6 +59487,8 @@ ${lanes.join("\n")}
         includes |= flags & 473694207 /* IncludesMask */;
         if (flags & 465829888 /* Instantiable */)
           includes |= 33554432 /* IncludesInstantiable */;
+        if (flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */)
+          includes |= 268435456 /* IncludesConstrainedTypeVariable */;
         if (type === wildcardType)
           includes |= 8388608 /* IncludesWildcard */;
         if (!strictNullChecks && flags & 98304 /* Nullable */) {
@@ -59528,6 +59593,41 @@ ${lanes.join("\n")}
         }
       }
     }
+    function removeConstrainedTypeVariables(types) {
+      const typeVariables = [];
+      for (const type of types) {
+        if (getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
+          const index = type.types[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
+          pushIfUnique(typeVariables, type.types[index]);
+        }
+      }
+      for (const typeVariable of typeVariables) {
+        const primitives = [];
+        for (const type of types) {
+          if (getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
+            const index = type.types[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
+            if (type.types[index] === typeVariable) {
+              insertType(primitives, type.types[1 - index]);
+            }
+          }
+        }
+        const constraint = getBaseConstraintOfType(typeVariable);
+        if (everyType(constraint, (t) => containsType(primitives, t))) {
+          let i = types.length;
+          while (i > 0) {
+            i--;
+            const type = types[i];
+            if (getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
+              const index = type.types[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
+              if (type.types[index] === typeVariable && containsType(primitives, type.types[1 - index])) {
+                orderedRemoveItemAt(types, i);
+              }
+            }
+          }
+          insertType(types, typeVariable);
+        }
+      }
+    }
     function isNamedUnionType(type) {
       return !!(type.flags & 1048576 /* Union */ && (type.aliasSymbol || type.origin));
     }
@@ -59593,6 +59693,9 @@ ${lanes.join("\n")}
         if (includes & 128 /* StringLiteral */ && includes & 134217728 /* TemplateLiteral */) {
           removeStringLiteralsMatchedByTemplateLiterals(typeSet);
         }
+        if (includes & 268435456 /* IncludesConstrainedTypeVariable */) {
+          removeConstrainedTypeVariables(typeSet);
+        }
         if (unionReduction === 2 /* Subtype */) {
           typeSet = removeSubtypes(typeSet, !!(includes & 524288 /* Object */));
           if (!typeSet) {
@@ -59805,9 +59908,9 @@ ${lanes.join("\n")}
       types[index] = getUnionTypeFromSortedList(result, 32768 /* PrimitiveUnion */);
       return true;
     }
-    function createIntersectionType(types, aliasSymbol, aliasTypeArguments) {
+    function createIntersectionType(types, objectFlags, aliasSymbol, aliasTypeArguments) {
       const result = createType(2097152 /* Intersection */);
-      result.objectFlags = getPropagatingFlagsOfTypes(
+      result.objectFlags = objectFlags | getPropagatingFlagsOfTypes(
         types,
         /*excludeKinds*/
         98304 /* Nullable */
@@ -59821,6 +59924,7 @@ ${lanes.join("\n")}
       const typeMembershipMap = /* @__PURE__ */ new Map();
       const includes = addTypesToIntersection(typeMembershipMap, 0, types);
       const typeSet = arrayFrom(typeMembershipMap.values());
+      let objectFlags = 0 /* None */;
       if (includes & 131072 /* Never */) {
         return contains(typeSet, silentNeverType) ? silentNeverType : neverType;
       }
@@ -59849,6 +59953,25 @@ ${lanes.join("\n")}
       if (typeSet.length === 1) {
         return typeSet[0];
       }
+      if (typeSet.length === 2) {
+        const typeVarIndex = typeSet[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
+        const typeVariable = typeSet[typeVarIndex];
+        const primitiveType = typeSet[1 - typeVarIndex];
+        if (typeVariable.flags & 8650752 /* TypeVariable */ && (primitiveType.flags & (402784252 /* Primitive */ | 67108864 /* NonPrimitive */) || includes & 16777216 /* IncludesEmptyObject */)) {
+          const constraint = getBaseConstraintOfType(typeVariable);
+          if (constraint && everyType(constraint, (t) => !!(t.flags & (402784252 /* Primitive */ | 67108864 /* NonPrimitive */)) || isEmptyAnonymousObjectType(t))) {
+            if (isTypeStrictSubtypeOf(constraint, primitiveType)) {
+              return typeVariable;
+            }
+            if (!(constraint.flags & 1048576 /* Union */ && someType(constraint, (c) => isTypeStrictSubtypeOf(c, primitiveType)))) {
+              if (!isTypeStrictSubtypeOf(primitiveType, constraint)) {
+                return neverType;
+              }
+            }
+            objectFlags = 67108864 /* IsConstrainedTypeVariable */;
+          }
+        }
+      }
       const id = getTypeListId(typeSet) + getAliasId(aliasSymbol, aliasTypeArguments);
       let result = intersectionTypes.get(id);
       if (!result) {
@@ -59871,7 +59994,7 @@ ${lanes.join("\n")}
             result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
           }
         } else {
-          result = createIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
+          result = createIntersectionType(typeSet, objectFlags, aliasSymbol, aliasTypeArguments);
         }
         intersectionTypes.set(id, result);
       }
@@ -60028,7 +60151,7 @@ ${lanes.join("\n")}
       );
     }
     function shouldDeferIndexType(type, indexFlags = 0 /* None */) {
-      return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) || type.flags & 1048576 /* Union */ && !(indexFlags & 4 /* NoReducibleCheck */) && isGenericReducibleType(type) || type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && some(type.types, isEmptyAnonymousObjectType));
+      return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && (!hasDistributiveNameType(type) || getMappedTypeNameTypeKind(type) === 2 /* Remapping */) || type.flags & 1048576 /* Union */ && !(indexFlags & 4 /* NoReducibleCheck */) && isGenericReducibleType(type) || type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && some(type.types, isEmptyAnonymousObjectType));
     }
     function getIndexType(type, indexFlags = defaultIndexFlags) {
       type = getReducedType(type);
@@ -60512,7 +60635,7 @@ ${lanes.join("\n")}
         }
       }
       if (isGenericMappedType(objectType)) {
-        if (!getNameTypeFromMappedType(objectType) || isFilteringMappedType(objectType)) {
+        if (getMappedTypeNameTypeKind(objectType) !== 2 /* Remapping */) {
           return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), (t) => getSimplifiedType(t, writing));
         }
       }
@@ -66420,12 +66543,12 @@ ${lanes.join("\n")}
       return false;
     }
     function isValidTypeForTemplateLiteralPlaceholder(source, target) {
-      if (source === target || target.flags & (1 /* Any */ | 4 /* String */)) {
-        return true;
-      }
       if (target.flags & 2097152 /* Intersection */) {
         return every(target.types, (t) => t === emptyTypeLiteralType || isValidTypeForTemplateLiteralPlaceholder(source, t));
       }
+      if (target.flags & 4 /* String */ || isTypeAssignableTo(source, target)) {
+        return true;
+      }
       if (source.flags & 128 /* StringLiteral */) {
         const value = source.value;
         return !!(target.flags & 8 /* Number */ && isValidNumberString(
@@ -66442,7 +66565,7 @@ ${lanes.join("\n")}
         const texts = source.texts;
         return texts.length === 2 && texts[0] === "" && texts[1] === "" && isTypeAssignableTo(source.types[0], target);
       }
-      return isTypeAssignableTo(source, target);
+      return false;
     }
     function inferTypesFromTemplateLiteralType(source, target) {
       return source.flags & 128 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arraysEqual(source.texts, target.texts) ? map(source.types, getStringLikeTypeForType) : inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : void 0;
@@ -66564,7 +66687,8 @@ ${lanes.join("\n")}
             source = getIntersectionType(sources);
             target = getIntersectionType(targets);
           }
-        } else if (target.flags & (8388608 /* IndexedAccess */ | 33554432 /* Substitution */)) {
+        }
+        if (target.flags & (8388608 /* IndexedAccess */ | 33554432 /* Substitution */)) {
           target = getActualTypeVariable(target);
         }
         if (target.flags & 8650752 /* TypeVariable */) {
@@ -66839,7 +66963,7 @@ ${lanes.join("\n")}
         }
       }
       function inferToMappedType(source, target, constraintType) {
-        if (constraintType.flags & 1048576 /* Union */) {
+        if (constraintType.flags & 1048576 /* Union */ || constraintType.flags & 2097152 /* Intersection */) {
           let result = false;
           for (const type of constraintType.types) {
             result = inferToMappedType(source, target, type) || result;
@@ -73581,19 +73705,9 @@ ${lanes.join("\n")}
           return Debug.fail();
       }
     }
-    function getDiagnosticSpanForCallNode(node, doNotIncludeArguments) {
-      let start;
-      let length2;
+    function getDiagnosticSpanForCallNode(node) {
       const sourceFile = getSourceFileOfNode(node);
-      if (isPropertyAccessExpression(node.expression)) {
-        const nameSpan = getErrorSpanForNode(sourceFile, node.expression.name);
-        start = nameSpan.start;
-        length2 = doNotIncludeArguments ? nameSpan.length : node.end - start;
-      } else {
-        const expressionSpan = getErrorSpanForNode(sourceFile, node.expression);
-        start = expressionSpan.start;
-        length2 = doNotIncludeArguments ? expressionSpan.length : node.end - start;
-      }
+      const { start, length: length2 } = getErrorSpanForNode(sourceFile, isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression);
       return { start, length: length2, sourceFile };
     }
     function getDiagnosticForCallNode(node, message, ...args) {
@@ -73610,6 +73724,18 @@ ${lanes.join("\n")}
         return createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), node, message);
       }
     }
+    function getErrorNodeForCallNode(callLike) {
+      if (isCallOrNewExpression(callLike)) {
+        return isPropertyAccessExpression(callLike.expression) ? callLike.expression.name : callLike.expression;
+      }
+      if (isTaggedTemplateExpression(callLike)) {
+        return isPropertyAccessExpression(callLike.tag) ? callLike.tag.name : callLike.tag;
+      }
+      if (isJsxOpeningLikeElement(callLike)) {
+        return callLike.tagName;
+      }
+      return callLike;
+    }
     function isPromiseResolveArityError(node) {
       if (!isCallExpression(node) || !isIdentifier(node.expression))
         return false;
@@ -73911,7 +74037,7 @@ ${lanes.join("\n")}
               const { file, start, length: length2 } = diags[0];
               diag2 = { file, start, length: length2, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related };
             } else {
-              diag2 = createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), node, chain, related);
+              diag2 = createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), getErrorNodeForCallNode(node), chain, related);
             }
             addImplementationSuccessElaboration(candidatesForArgumentError[0], diag2);
             diagnostics.add(diag2);
@@ -74231,7 +74357,7 @@ ${lanes.join("\n")}
         }
         return resolveErrorCall(node);
       }
-      if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
+      if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunctionOrConstructor)) {
         skippedGenericFunction(node, checkMode);
         return resolvingSignature;
       }
@@ -74241,8 +74367,12 @@ ${lanes.join("\n")}
       }
       return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags);
     }
-    function isGenericFunctionReturningFunction(signature) {
-      return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature)));
+    function isGenericFunctionReturningFunctionOrConstructor(signature) {
+      if (!signature.typeParameters) {
+        return false;
+      }
+      const returnType = getReturnTypeOfSignature(signature);
+      return isFunctionType(returnType) || isConstructorType(returnType);
     }
     function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) {
       return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144 /* TypeParameter */) || !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & 1048576 /* Union */) && !(getReducedType(apparentFuncType).flags & 131072 /* Never */) && isTypeAssignableTo(funcType, globalFunctionType);
@@ -74439,11 +74569,7 @@ ${lanes.join("\n")}
         addRelatedInfo(diagnostic, createDiagnosticForNode(errorTarget, relatedInfo));
       }
       if (isCallExpression(errorTarget.parent)) {
-        const { start, length: length2 } = getDiagnosticSpanForCallNode(
-          errorTarget.parent,
-          /*doNotIncludeArguments*/
-          true
-        );
+        const { start, length: length2 } = getDiagnosticSpanForCallNode(errorTarget.parent);
         diagnostic.start = start;
         diagnostic.length = length2;
       }
@@ -77813,16 +77939,19 @@ ${lanes.join("\n")}
         }
       }
     }
-    function getReturnTypeOfSingleNonGenericCallSignature(funcType) {
+    function getNonGenericReturnTypeOfSingleCallSignature(funcType) {
       const signature = getSingleCallSignature(funcType);
-      if (signature && !signature.typeParameters) {
-        return getReturnTypeOfSignature(signature);
+      if (signature) {
+        const returnType = getReturnTypeOfSignature(signature);
+        if (!signature.typeParameters || !couldContainTypeVariables(returnType)) {
+          return returnType;
+        }
       }
     }
     function getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) {
       const funcType = checkExpression(expr.expression);
       const nonOptionalType = getOptionalExpressionType(funcType, expr.expression);
-      const returnType = getReturnTypeOfSingleNonGenericCallSignature(funcType);
+      const returnType = getNonGenericReturnTypeOfSingleCallSignature(funcType);
       return returnType && propagateOptionalTypeMarker(returnType, expr, nonOptionalType !== funcType);
     }
     function getTypeOfExpression(node) {
@@ -77867,7 +77996,7 @@ ${lanes.join("\n")}
         /*requireStringLiteralLikeArgument*/
         true
       ) && !isSymbolOrSymbolForCall(expr)) {
-        return isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : getReturnTypeOfSingleNonGenericCallSignature(checkNonNullExpression(expr.expression));
+        return isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : getNonGenericReturnTypeOfSingleCallSignature(checkNonNullExpression(expr.expression));
       } else if (isAssertionExpression(expr) && !isConstTypeReference(expr.type)) {
         return getTypeFromTypeNode(expr.type);
       } else if (isLiteralExpression(node) || isBooleanLiteral(node)) {
@@ -78739,7 +78868,8 @@ ${lanes.join("\n")}
       }
       const objectType = type.objectType;
       const indexType = type.indexType;
-      if (isTypeAssignableTo(indexType, getIndexType(objectType, 0 /* None */))) {
+      const objectIndexType = isGenericMappedType(objectType) && getMappedTypeNameTypeKind(objectType) === 2 /* Remapping */ ? getIndexTypeForMappedType(objectType, 0 /* None */) : getIndexType(objectType, 0 /* None */);
+      if (isTypeAssignableTo(indexType, objectIndexType)) {
         if (accessNode.kind === 212 /* ElementAccessExpression */ && isAssignmentTarget(accessNode) && getObjectFlags(objectType) & 32 /* Mapped */ && getMappedTypeModifiers(objectType) & 1 /* IncludeReadonly */) {
           error2(accessNode, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
         }
@@ -136050,7 +136180,7 @@ ${lanes.join("\n")}
           options
         ),
         setExternalModuleIndicator: getSetExternalModuleIndicator(options),
-        jsDocParsingMode: 1 /* ParseNone */
+        jsDocParsingMode: transpileOptions.jsDocParsingMode ?? 1 /* ParseNone */
       }
     );
     if (transpileOptions.moduleName) {
@@ -165147,6 +165277,17 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               visitForDisplayParts(node.type);
             }
             break;
+          case 181 /* IndexSignature */:
+            Debug.assertNode(node, isIndexSignatureDeclaration);
+            Debug.assertEqual(node.parameters.length, 1);
+            parts.push({ text: "[" });
+            visitForDisplayParts(node.parameters[0]);
+            parts.push({ text: "]" });
+            if (node.type) {
+              parts.push({ text: ": " });
+              visitForDisplayParts(node.type);
+            }
+            break;
           case 173 /* MethodSignature */:
             Debug.assertNode(node, isMethodSignature);
             if ((_b = node.modifiers) == null ? void 0 : _b.length) {

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231129`;
+var version = `${versionMajorMinor}.0-dev.20231201`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3105,6 +3105,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["IncludesWildcard"] = 8388608 /* IndexedAccess */] = "IncludesWildcard";
   TypeFlags2[TypeFlags2["IncludesEmptyObject"] = 16777216 /* Conditional */] = "IncludesEmptyObject";
   TypeFlags2[TypeFlags2["IncludesInstantiable"] = 33554432 /* Substitution */] = "IncludesInstantiable";
+  TypeFlags2[TypeFlags2["IncludesConstrainedTypeVariable"] = 268435456 /* StringMapping */] = "IncludesConstrainedTypeVariable";
   TypeFlags2[TypeFlags2["NotPrimitiveUnion"] = 36323331] = "NotPrimitiveUnion";
   return TypeFlags2;
 })(TypeFlags || {});
@@ -3151,6 +3152,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
   ObjectFlags3[ObjectFlags3["IsNeverIntersectionComputed"] = 16777216] = "IsNeverIntersectionComputed";
   ObjectFlags3[ObjectFlags3["IsNeverIntersection"] = 33554432] = "IsNeverIntersection";
+  ObjectFlags3[ObjectFlags3["IsConstrainedTypeVariable"] = 67108864] = "IsConstrainedTypeVariable";
   return ObjectFlags3;
 })(ObjectFlags || {});
 var SignatureFlags = /* @__PURE__ */ ((SignatureFlags4) => {
@@ -25706,7 +25708,7 @@ var libEntries = [
   ["esnext.disposable", "lib.esnext.disposable.d.ts"],
   ["esnext.bigint", "lib.es2020.bigint.d.ts"],
   ["esnext.string", "lib.es2022.string.d.ts"],
-  ["esnext.promise", "lib.es2021.promise.d.ts"],
+  ["esnext.promise", "lib.esnext.promise.d.ts"],
   ["esnext.weakref", "lib.es2021.weakref.d.ts"],
   ["esnext.decorators", "lib.esnext.decorators.d.ts"],
   ["decorators", "lib.decorators.d.ts"],

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.4.0-dev.20231129",
+    "version": "5.4.0-dev.20231201",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -114,5 +114,5 @@
         "node": "20.1.0",
         "npm": "8.19.4"
     },
-    "gitHead": "2869579b2cad770ae20617e4148741c2ce35ffdc"
+    "gitHead": "5bc66177388247d3e270653f94d82a8dabd56d69"
 }