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

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // 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 = [];
@@ -3671,6 +3671,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 || {});
@@ -3717,6 +3718,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) => {
@@ -33897,7 +33899,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"],
@@ -41785,7 +41787,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;
     }
@@ -41883,7 +41885,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);
@@ -46974,6 +46976,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);
@@ -52197,11 +52203,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);
+          }
         }
       }
     }
@@ -53501,7 +53510,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 */;
@@ -53520,7 +53528,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) {
@@ -53817,6 +53825,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*/
@@ -54190,6 +54207,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);
@@ -54197,7 +54226,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;
@@ -54278,7 +54314,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);
@@ -54420,9 +54456,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) {
@@ -54471,7 +54510,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);
             }
@@ -54961,13 +55005,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;
@@ -55077,7 +55125,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;
@@ -56934,6 +56997,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 */) {
@@ -57038,6 +57103,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));
   }
@@ -57103,6 +57203,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) {
@@ -57315,9 +57418,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 */
@@ -57331,6 +57434,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;
     }
@@ -57359,6 +57463,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) {
@@ -57381,7 +57504,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);
     }
@@ -57538,7 +57661,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);
@@ -58022,7 +58145,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));
       }
     }
@@ -63930,12 +64053,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(
@@ -63952,7 +64075,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;
@@ -64074,7 +64197,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 */) {
@@ -64349,7 +64473,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;
@@ -71091,19 +71215,9 @@ function createTypeChecker(host) {
         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) {
@@ -71120,6 +71234,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;
@@ -71421,7 +71547,7 @@ function createTypeChecker(host) {
             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);
@@ -71741,7 +71867,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;
     }
@@ -71751,8 +71877,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);
@@ -71949,11 +72079,7 @@ function createTypeChecker(host) {
       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;
     }
@@ -75323,16 +75449,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) {
@@ -75377,7 +75506,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)) {
@@ -76249,7 +76378,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 */) {
         error(accessNode, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
       }