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

package/lib/tsserver.js

@@ -2332,7 +2332,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231129`;
+var version = `${versionMajorMinor}.0-dev.20231201`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6686,6 +6686,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 || {});
@@ -6732,6 +6733,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 VarianceFlags = /* @__PURE__ */ ((VarianceFlags2) => {
@@ -38324,7 +38326,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"],
@@ -46467,7 +46469,7 @@ function createBinder() {
   }
   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;
     }
@@ -46565,7 +46567,7 @@ function createBinder() {
     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);
@@ -51701,6 +51703,10 @@ function createTypeChecker(host) {
   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);
@@ -56924,11 +56930,14 @@ function createTypeChecker(host) {
       }
     }
     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);
+          }
         }
       }
     }
@@ -58228,7 +58237,6 @@ function createTypeChecker(host) {
     return links.resolvedSymbol;
   }
   function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) {
-    var _a, _b, _c;
     const links = getSymbolLinks(symbol);
     if (!links[resolutionKind]) {
       const isStatic2 = resolutionKind === "resolvedExports" /* resolvedExports */;
@@ -58247,7 +58255,7 @@ function createTypeChecker(host) {
           }
         }
       }
-      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) {
@@ -58544,6 +58552,15 @@ function createTypeChecker(host) {
     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*/
@@ -58917,6 +58934,18 @@ function createTypeChecker(host) {
   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);
@@ -58924,7 +58953,14 @@ function createTypeChecker(host) {
     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;
@@ -59005,7 +59041,7 @@ function createTypeChecker(host) {
     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);
@@ -59147,9 +59183,12 @@ function createTypeChecker(host) {
     }
     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) {
@@ -59198,7 +59237,12 @@ function createTypeChecker(host) {
       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);
             }
@@ -59688,13 +59732,17 @@ function createTypeChecker(host) {
     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;
@@ -59804,7 +59852,22 @@ function createTypeChecker(host) {
       }
       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;
@@ -61661,6 +61724,8 @@ function createTypeChecker(host) {
       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 */) {
@@ -61765,6 +61830,41 @@ function createTypeChecker(host) {
       }
     }
   }
+  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));
   }
@@ -61830,6 +61930,9 @@ function createTypeChecker(host) {
       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) {
@@ -62042,9 +62145,9 @@ function createTypeChecker(host) {
     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 */
@@ -62058,6 +62161,7 @@ function createTypeChecker(host) {
     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;
     }
@@ -62086,6 +62190,25 @@ function createTypeChecker(host) {
     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) {
@@ -62108,7 +62231,7 @@ function createTypeChecker(host) {
           result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
         }
       } else {
-        result = createIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
+        result = createIntersectionType(typeSet, objectFlags, aliasSymbol, aliasTypeArguments);
       }
       intersectionTypes.set(id, result);
     }
@@ -62265,7 +62388,7 @@ function createTypeChecker(host) {
     );
   }
   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);
@@ -62749,7 +62872,7 @@ function createTypeChecker(host) {
       }
     }
     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));
       }
     }
@@ -68657,12 +68780,12 @@ function createTypeChecker(host) {
     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(
@@ -68679,7 +68802,7 @@ function createTypeChecker(host) {
       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;
@@ -68801,7 +68924,8 @@ function createTypeChecker(host) {
           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 */) {
@@ -69076,7 +69200,7 @@ function createTypeChecker(host) {
       }
     }
     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;
@@ -75818,19 +75942,9 @@ function createTypeChecker(host) {
         return Debug.fail();
     }
   }
-  function getDiagnosticSpanForCallNode(node, doNotIncludeArguments) {
-    let start2;
-    let length2;
+  function getDiagnosticSpanForCallNode(node) {
     const sourceFile = getSourceFileOfNode(node);
-    if (isPropertyAccessExpression(node.expression)) {
-      const nameSpan = getErrorSpanForNode(sourceFile, node.expression.name);
-      start2 = nameSpan.start;
-      length2 = doNotIncludeArguments ? nameSpan.length : node.end - start2;
-    } else {
-      const expressionSpan = getErrorSpanForNode(sourceFile, node.expression);
-      start2 = expressionSpan.start;
-      length2 = doNotIncludeArguments ? expressionSpan.length : node.end - start2;
-    }
+    const { start: start2, length: length2 } = getErrorSpanForNode(sourceFile, isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression);
     return { start: start2, length: length2, sourceFile };
   }
   function getDiagnosticForCallNode(node, message, ...args) {
@@ -75847,6 +75961,18 @@ function createTypeChecker(host) {
       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;
@@ -76148,7 +76274,7 @@ function createTypeChecker(host) {
             const { file, start: start2, length: length2 } = diags[0];
             diag2 = { file, start: start2, 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);
@@ -76468,7 +76594,7 @@ function createTypeChecker(host) {
       }
       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;
     }
@@ -76478,8 +76604,12 @@ function createTypeChecker(host) {
     }
     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);
@@ -76676,11 +76806,7 @@ function createTypeChecker(host) {
       addRelatedInfo(diagnostic, createDiagnosticForNode(errorTarget, relatedInfo));
     }
     if (isCallExpression(errorTarget.parent)) {
-      const { start: start2, length: length2 } = getDiagnosticSpanForCallNode(
-        errorTarget.parent,
-        /*doNotIncludeArguments*/
-        true
-      );
+      const { start: start2, length: length2 } = getDiagnosticSpanForCallNode(errorTarget.parent);
       diagnostic.start = start2;
       diagnostic.length = length2;
     }
@@ -80050,16 +80176,19 @@ function createTypeChecker(host) {
       }
     }
   }
-  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) {
@@ -80104,7 +80233,7 @@ function createTypeChecker(host) {
       /*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)) {
@@ -80976,7 +81105,8 @@ function createTypeChecker(host) {
     }
     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));
       }
@@ -137685,7 +137815,7 @@ function transpileModule(input, transpileOptions) {
         options
       ),
       setExternalModuleIndicator: getSetExternalModuleIndicator(options),
-      jsDocParsingMode: 1 /* ParseNone */
+      jsDocParsingMode: transpileOptions.jsDocParsingMode ?? 1 /* ParseNone */
     }
   );
   if (transpileOptions.moduleName) {
@@ -165805,6 +165935,17 @@ function provideInlayHints(context) {
             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/typescript.d.ts

@@ -11618,6 +11618,7 @@ declare namespace ts {
         moduleName?: string;
         renamedDependencies?: MapLike<string>;
         transformers?: CustomTransformers;
+        jsDocParsingMode?: JSDocParsingMode;
     }
     interface TranspileOutput {
         outputText: string;