@typescript-deploys/pr-build 5.5.0-pr-49218-53 → 5.5.0-pr-58203-3

package/lib/lib.esnext.d.ts

@@ -25,3 +25,4 @@ and limitations under the License.
 /// <reference lib="esnext.collection" />
 /// <reference lib="esnext.array" />
 /// <reference lib="esnext.regexp" />
+/// <reference lib="esnext.string" />

package/lib/lib.esnext.string.d.ts

@@ -0,0 +1,29 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+/// <reference no-default-lib="true"/>
+
+interface String {
+    /**
+     * Returns true if all leading surrogates and trailing surrogates appear paired and in order.
+     */
+    isWellFormed(): boolean;
+
+    /**
+     * Returns a string where all lone or out-of-order surrogates have been replaced by the Unicode replacement character (U+FFFD).
+     */
+    toWellFormed(): string;
+}

package/lib/tsc.js

@@ -12083,6 +12083,10 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
       ],
       es2022: [
         "at"
+      ],
+      esnext: [
+        "isWellFormed",
+        "toWellFormed"
       ]
     })),
     StringConstructor: new Map(Object.entries({
@@ -25194,6 +25198,8 @@ function isJSDocImportTag(node) {
 // src/compiler/factory/nodeChildren.ts
 var nodeChildren = /* @__PURE__ */ new WeakMap();
 function getNodeChildren(node) {
+  if (!isNodeKind(node.kind))
+    return emptyArray;
   return nodeChildren.get(node);
 }
 function setNodeChildren(node, children) {
@@ -34442,6 +34448,7 @@ var libEntries = [
   ["esnext.object", "lib.esnext.object.d.ts"],
   ["esnext.array", "lib.esnext.array.d.ts"],
   ["esnext.regexp", "lib.esnext.regexp.d.ts"],
+  ["esnext.string", "lib.esnext.string.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -61239,37 +61246,7 @@ function createTypeChecker(host) {
     const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
     for (let i = 0; i < paramCount; i++) {
       const sourceType = i === restIndex ? getRestOrAnyTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
-      let targetType = i === restIndex ? getRestOrAnyTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
-      if (i === restIndex && targetType && sourceType && isTupleType(sourceType)) {
-        targetType = mapType(targetType, (t) => {
-          if (!isTupleType(t) || // When both sides are tuples of the same structure, we don't want to "propagate" types from elements of variable positions
-          // to the following positions as that would disallow signatures of the exact same structures when trailing fixed elements are involved:
-          //
-          // let fn: (...rest: [...string[], number]) => void = (...rest: [...string[], number]) => {}; // ok
-          //
-          // Since we want to allow contextual types to flow into paremeters, we don't need to differentiate between rest and variadic elements
-          // as that doesn't affect the contextual type of the parameter
-          isTupleTypeStructureMatching(sourceType, t, 2 /* MatchVariable */)) {
-            return t;
-          }
-          const elementTypes = [];
-          const elementFlags = [];
-          const sourceArity = getTypeReferenceArity(sourceType);
-          const targetArity = getTypeReferenceArity(t);
-          for (let i2 = 0; i2 < sourceArity; i2++) {
-            if (i2 >= targetArity) {
-              if (sourceType.target.elementFlags[i2] & 3 /* Fixed */) {
-                elementTypes.push(undefinedType);
-                elementFlags.push(sourceType.target.elementFlags[i2]);
-              }
-              continue;
-            }
-            elementTypes.push(getTupleElementType(t, i2));
-            elementFlags.push(sourceType.target.elementFlags[i2]);
-          }
-          return createTupleType(elementTypes, elementFlags);
-        });
-      }
+      const targetType = i === restIndex ? getRestOrAnyTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
       if (sourceType && targetType) {
         const sourceSig = checkMode & 3 /* Callback */ || isInstantiatedGenericParameter(source, i) ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
         const targetSig = checkMode & 3 /* Callback */ || isInstantiatedGenericParameter(target, i) ? void 0 : getSingleCallSignature(getNonNullableType(targetType));
@@ -64540,11 +64517,8 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function isTupleTypeStructureMatching(t1, t2, tupleStructureComparisonKind) {
-    return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f1, i) => {
-      const f2 = t2.target.elementFlags[i];
-      return f1 === f2 || !!(tupleStructureComparisonKind & 1 /* MatchFixed */ && f1 & 3 /* Fixed */ && f2 & 3 /* Fixed */) || !!(tupleStructureComparisonKind & 2 /* MatchVariable */ && f1 & 12 /* Variable */ && f2 & 12 /* Variable */);
-    });
+  function isTupleTypeStructureMatching(t1, t2) {
+    return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f, i) => (f & 12 /* Variable */) === (t2.target.elementFlags[i] & 12 /* Variable */));
   }
   function isZeroBigInt({ value }) {
     return value.base10Value === "0";
@@ -65785,7 +65759,7 @@ function createTypeChecker(host) {
             const targetArity = getTypeReferenceArity(target);
             const elementTypes = getTypeArguments(target);
             const elementFlags = target.target.elementFlags;
-            if (isTupleType(source) && isTupleTypeStructureMatching(source, target, 1 /* MatchFixed */)) {
+            if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
               for (let i = 0; i < targetArity; i++) {
                 inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
               }
@@ -71440,7 +71414,10 @@ function createTypeChecker(host) {
       if (indexInfo.isReadonly && (isAssignmentTarget(node) || isDeleteTarget(node))) {
         error(node, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType));
       }
-      propType = compilerOptions.noUncheckedIndexedAccess && !isAssignmentTarget(node) ? getUnionType([indexInfo.type, missingType]) : indexInfo.type;
+      propType = indexInfo.type;
+      if (compilerOptions.noUncheckedIndexedAccess && getAssignmentTargetKind(node) !== 1 /* Definite */) {
+        propType = getUnionType([propType, missingType]);
+      }
       if (compilerOptions.noPropertyAccessFromIndexSignature && isPropertyAccessExpression(node)) {
         error(right, Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, unescapeLeadingUnderscores(right.escapedText));
       }
@@ -71890,7 +71867,16 @@ function createTypeChecker(host) {
       return errorType;
     }
     const effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType;
-    const accessFlags = isAssignmentTarget(node) ? 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0) : 32 /* ExpressionPosition */;
+    const assignmentTargetKind = getAssignmentTargetKind(node);
+    let accessFlags;
+    if (assignmentTargetKind === 0 /* None */) {
+      accessFlags = 32 /* ExpressionPosition */;
+    } else {
+      accessFlags = 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0);
+      if (assignmentTargetKind === 2 /* Compound */) {
+        accessFlags |= 32 /* ExpressionPosition */;
+      }
+    }
     const indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node) || errorType;
     return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
   }

package/lib/typescript.d.ts

@@ -4215,7 +4215,7 @@ declare namespace ts {
         getSourceFile(): SourceFile;
         getChildCount(sourceFile?: SourceFile): number;
         getChildAt(index: number, sourceFile?: SourceFile): Node;
-        getChildren(sourceFile?: SourceFile): Node[];
+        getChildren(sourceFile?: SourceFile): readonly Node[];
         getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): number;
         getFullStart(): number;
         getEnd(): number;

package/lib/typescript.js

@@ -15916,6 +15916,10 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
       ],
       es2022: [
         "at"
+      ],
+      esnext: [
+        "isWellFormed",
+        "toWellFormed"
       ]
     })),
     StringConstructor: new Map(Object.entries({
@@ -29599,6 +29603,8 @@ function isSyntaxList(n) {
 // src/compiler/factory/nodeChildren.ts
 var nodeChildren = /* @__PURE__ */ new WeakMap();
 function getNodeChildren(node) {
+  if (!isNodeKind(node.kind))
+    return emptyArray;
   return nodeChildren.get(node);
 }
 function setNodeChildren(node, children) {
@@ -38888,6 +38894,7 @@ var libEntries = [
   ["esnext.object", "lib.esnext.object.d.ts"],
   ["esnext.array", "lib.esnext.array.d.ts"],
   ["esnext.regexp", "lib.esnext.regexp.d.ts"],
+  ["esnext.string", "lib.esnext.string.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -66041,37 +66048,7 @@ function createTypeChecker(host) {
     const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
     for (let i = 0; i < paramCount; i++) {
       const sourceType = i === restIndex ? getRestOrAnyTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
-      let targetType = i === restIndex ? getRestOrAnyTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
-      if (i === restIndex && targetType && sourceType && isTupleType(sourceType)) {
-        targetType = mapType(targetType, (t) => {
-          if (!isTupleType(t) || // When both sides are tuples of the same structure, we don't want to "propagate" types from elements of variable positions
-          // to the following positions as that would disallow signatures of the exact same structures when trailing fixed elements are involved:
-          //
-          // let fn: (...rest: [...string[], number]) => void = (...rest: [...string[], number]) => {}; // ok
-          //
-          // Since we want to allow contextual types to flow into paremeters, we don't need to differentiate between rest and variadic elements
-          // as that doesn't affect the contextual type of the parameter
-          isTupleTypeStructureMatching(sourceType, t, 2 /* MatchVariable */)) {
-            return t;
-          }
-          const elementTypes = [];
-          const elementFlags = [];
-          const sourceArity = getTypeReferenceArity(sourceType);
-          const targetArity = getTypeReferenceArity(t);
-          for (let i2 = 0; i2 < sourceArity; i2++) {
-            if (i2 >= targetArity) {
-              if (sourceType.target.elementFlags[i2] & 3 /* Fixed */) {
-                elementTypes.push(undefinedType);
-                elementFlags.push(sourceType.target.elementFlags[i2]);
-              }
-              continue;
-            }
-            elementTypes.push(getTupleElementType(t, i2));
-            elementFlags.push(sourceType.target.elementFlags[i2]);
-          }
-          return createTupleType(elementTypes, elementFlags);
-        });
-      }
+      const targetType = i === restIndex ? getRestOrAnyTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
       if (sourceType && targetType) {
         const sourceSig = checkMode & 3 /* Callback */ || isInstantiatedGenericParameter(source, i) ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
         const targetSig = checkMode & 3 /* Callback */ || isInstantiatedGenericParameter(target, i) ? void 0 : getSingleCallSignature(getNonNullableType(targetType));
@@ -69342,11 +69319,8 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function isTupleTypeStructureMatching(t1, t2, tupleStructureComparisonKind) {
-    return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f1, i) => {
-      const f2 = t2.target.elementFlags[i];
-      return f1 === f2 || !!(tupleStructureComparisonKind & 1 /* MatchFixed */ && f1 & 3 /* Fixed */ && f2 & 3 /* Fixed */) || !!(tupleStructureComparisonKind & 2 /* MatchVariable */ && f1 & 12 /* Variable */ && f2 & 12 /* Variable */);
-    });
+  function isTupleTypeStructureMatching(t1, t2) {
+    return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f, i) => (f & 12 /* Variable */) === (t2.target.elementFlags[i] & 12 /* Variable */));
   }
   function isZeroBigInt({ value }) {
     return value.base10Value === "0";
@@ -70587,7 +70561,7 @@ function createTypeChecker(host) {
             const targetArity = getTypeReferenceArity(target);
             const elementTypes = getTypeArguments(target);
             const elementFlags = target.target.elementFlags;
-            if (isTupleType(source) && isTupleTypeStructureMatching(source, target, 1 /* MatchFixed */)) {
+            if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
               for (let i = 0; i < targetArity; i++) {
                 inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
               }
@@ -76242,7 +76216,10 @@ function createTypeChecker(host) {
       if (indexInfo.isReadonly && (isAssignmentTarget(node) || isDeleteTarget(node))) {
         error2(node, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType));
       }
-      propType = compilerOptions.noUncheckedIndexedAccess && !isAssignmentTarget(node) ? getUnionType([indexInfo.type, missingType]) : indexInfo.type;
+      propType = indexInfo.type;
+      if (compilerOptions.noUncheckedIndexedAccess && getAssignmentTargetKind(node) !== 1 /* Definite */) {
+        propType = getUnionType([propType, missingType]);
+      }
       if (compilerOptions.noPropertyAccessFromIndexSignature && isPropertyAccessExpression(node)) {
         error2(right, Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, unescapeLeadingUnderscores(right.escapedText));
       }
@@ -76692,7 +76669,16 @@ function createTypeChecker(host) {
       return errorType;
     }
     const effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType;
-    const accessFlags = isAssignmentTarget(node) ? 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0) : 32 /* ExpressionPosition */;
+    const assignmentTargetKind = getAssignmentTargetKind(node);
+    let accessFlags;
+    if (assignmentTargetKind === 0 /* None */) {
+      accessFlags = 32 /* ExpressionPosition */;
+    } else {
+      accessFlags = 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0);
+      if (assignmentTargetKind === 2 /* Compound */) {
+        accessFlags |= 32 /* ExpressionPosition */;
+      }
+    }
     const indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node) || errorType;
     return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
   }
@@ -146539,9 +146525,6 @@ var NodeObject = class {
   }
 };
 function createChildren(node, sourceFile) {
-  if (!isNodeKind(node.kind)) {
-    return emptyArray;
-  }
   const children = [];
   if (isJSDocCommentContainingNode(node)) {
     node.forEachChild((child) => {
@@ -170632,9 +170615,6 @@ function getArgumentOrParameterListInfo(node, position, sourceFile, checker) {
     return void 0;
   const { list, argumentIndex } = info;
   const argumentCount = getArgumentCount(checker, list);
-  if (argumentIndex !== 0) {
-    Debug.assertLessThan(argumentIndex, argumentCount);
-  }
   const argumentsSpan = getApplicableSpanForArguments(list, sourceFile);
   return { list, argumentIndex, argumentCount, argumentsSpan };
 }
@@ -170913,9 +170893,6 @@ function createSignatureHelpItems(candidates, resolvedSignature, { isTypeParamet
     void 0
   ) : emptyArray;
   const items = map(candidates, (candidateSignature) => getSignatureHelpItem(candidateSignature, callTargetDisplayParts, isTypeParameterList, typeChecker, enclosingDeclaration, sourceFile));
-  if (argumentIndex !== 0) {
-    Debug.assertLessThan(argumentIndex, argumentCount);
-  }
   let selectedItemIndex = 0;
   let itemsSeen = 0;
   for (let i = 0; i < items.length; i++) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.5.0-pr-49218-53",
+  "version": "5.5.0-pr-58203-3",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [
@@ -111,5 +111,5 @@
     "node": "20.1.0",
     "npm": "8.19.4"
   },
-  "gitHead": "a6705551c8511c14e60cf14599775f5c622468a5"
+  "gitHead": "bccb4ae04ac260e4bb710389c6fc90ab7b59179d"
 }