@typescript-deploys/pr-build 5.2.0-pr-54781-9 → 5.2.0-pr-52493-8

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.2";
-var version = `${versionMajorMinor}.0-insiders.20230626`;
+var version = `${versionMajorMinor}.0-insiders.20230627`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6212,7 +6212,6 @@ var Diagnostics = {
   This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0: diag(2343, 1 /* Error */, "This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_ve_2343", "This syntax requires an imported helper named '{1}' which does not exist in '{0}'. Consider upgrading your version of '{0}'."),
   Type_0_does_not_satisfy_the_constraint_1: diag(2344, 1 /* Error */, "Type_0_does_not_satisfy_the_constraint_1_2344", "Type '{0}' does not satisfy the constraint '{1}'."),
   Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: diag(2345, 1 /* Error */, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_2345", "Argument of type '{0}' is not assignable to parameter of type '{1}'."),
-  Call_target_does_not_contain_any_signatures: diag(2346, 1 /* Error */, "Call_target_does_not_contain_any_signatures_2346", "Call target does not contain any signatures."),
   Untyped_function_calls_may_not_accept_type_arguments: diag(2347, 1 /* Error */, "Untyped_function_calls_may_not_accept_type_arguments_2347", "Untyped function calls may not accept type arguments."),
   Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: diag(2348, 1 /* Error */, "Value_of_type_0_is_not_callable_Did_you_mean_to_include_new_2348", "Value of type '{0}' is not callable. Did you mean to include 'new'?"),
   This_expression_is_not_callable: diag(2349, 1 /* Error */, "This_expression_is_not_callable_2349", "This expression is not callable."),
@@ -6822,7 +6821,6 @@ var Diagnostics = {
   Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0: diag(5081, 1 /* Error */, "Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0_5081", "Cannot find a tsconfig.json file at the current directory: {0}."),
   _0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1: diag(5082, 1 /* Error */, "_0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1_5082", "'{0}' could be instantiated with an arbitrary type which could be unrelated to '{1}'."),
   Cannot_read_file_0: diag(5083, 1 /* Error */, "Cannot_read_file_0_5083", "Cannot read file '{0}'."),
-  Tuple_members_must_all_have_names_or_all_not_have_names: diag(5084, 1 /* Error */, "Tuple_members_must_all_have_names_or_all_not_have_names_5084", "Tuple members must all have names or all not have names."),
   A_tuple_member_cannot_be_both_optional_and_rest: diag(5085, 1 /* Error */, "A_tuple_member_cannot_be_both_optional_and_rest_5085", "A tuple member cannot be both optional and rest."),
   A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type: diag(5086, 1 /* Error */, "A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_c_5086", "A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type."),
   A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type: diag(5087, 1 /* Error */, "A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type_5087", "A labeled tuple element is declared as rest with a '...' before the name, rather than before the type."),
@@ -7748,6 +7746,7 @@ var Diagnostics = {
   Inline_variable: diag(95184, 3 /* Message */, "Inline_variable_95184", "Inline variable"),
   Could_not_find_variable_to_inline: diag(95185, 3 /* Message */, "Could_not_find_variable_to_inline_95185", "Could not find variable to inline."),
   Variables_with_multiple_declarations_cannot_be_inlined: diag(95186, 3 /* Message */, "Variables_with_multiple_declarations_cannot_be_inlined_95186", "Variables with multiple declarations cannot be inlined."),
+  Add_missing_comma_for_object_member_completion_0: diag(95187, 3 /* Message */, "Add_missing_comma_for_object_member_completion_0_95187", "Add missing comma for object member completion '{0}'."),
   No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, 1 /* Error */, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
   Classes_may_not_have_a_field_named_constructor: diag(18006, 1 /* Error */, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
   JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, 1 /* Error */, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -13288,8 +13287,8 @@ function isInExpressionContext(node) {
       return forStatement.initializer === node && forStatement.initializer.kind !== 261 /* VariableDeclarationList */ || forStatement.condition === node || forStatement.incrementor === node;
     case 249 /* ForInStatement */:
     case 250 /* ForOfStatement */:
-      const forInStatement = parent;
-      return forInStatement.initializer === node && forInStatement.initializer.kind !== 261 /* VariableDeclarationList */ || forInStatement.expression === node;
+      const forInOrOfStatement = parent;
+      return forInOrOfStatement.initializer === node && forInOrOfStatement.initializer.kind !== 261 /* VariableDeclarationList */ || forInOrOfStatement.expression === node;
     case 216 /* TypeAssertionExpression */:
     case 234 /* AsExpression */:
       return node === parent.expression;
@@ -13950,20 +13949,23 @@ function getTypeParameterFromJsDoc(node) {
   const { typeParameters } = node.parent.parent.parent;
   return typeParameters && find(typeParameters, (p) => p.name.escapedText === name);
 }
-function getAssignmentTargetKind(node) {
+function getAssignmentTarget(node) {
   let parent = node.parent;
   while (true) {
     switch (parent.kind) {
       case 226 /* BinaryExpression */:
-        const binaryOperator = parent.operatorToken.kind;
-        return isAssignmentOperator(binaryOperator) && parent.left === node ? binaryOperator === 64 /* EqualsToken */ || isLogicalOrCoalescingAssignmentOperator(binaryOperator) ? 1 /* Definite */ : 2 /* Compound */ : 0 /* None */;
+        const binaryExpression = parent;
+        const binaryOperator = binaryExpression.operatorToken.kind;
+        return isAssignmentOperator(binaryOperator) && binaryExpression.left === node ? binaryExpression : void 0;
       case 224 /* PrefixUnaryExpression */:
       case 225 /* PostfixUnaryExpression */:
-        const unaryOperator = parent.operator;
-        return unaryOperator === 46 /* PlusPlusToken */ || unaryOperator === 47 /* MinusMinusToken */ ? 2 /* Compound */ : 0 /* None */;
+        const unaryExpression = parent;
+        const unaryOperator = unaryExpression.operator;
+        return unaryOperator === 46 /* PlusPlusToken */ || unaryOperator === 47 /* MinusMinusToken */ ? unaryExpression : void 0;
       case 249 /* ForInStatement */:
       case 250 /* ForOfStatement */:
-        return parent.initializer === node ? 1 /* Definite */ : 0 /* None */;
+        const forInOrOfStatement = parent;
+        return forInOrOfStatement.initializer === node ? forInOrOfStatement : void 0;
       case 217 /* ParenthesizedExpression */:
       case 209 /* ArrayLiteralExpression */:
       case 230 /* SpreadElement */:
@@ -13975,24 +13977,53 @@ function getAssignmentTargetKind(node) {
         break;
       case 304 /* ShorthandPropertyAssignment */:
         if (parent.name !== node) {
-          return 0 /* None */;
+          return void 0;
         }
         node = parent.parent;
         break;
       case 303 /* PropertyAssignment */:
         if (parent.name === node) {
-          return 0 /* None */;
+          return void 0;
         }
         node = parent.parent;
         break;
       default:
-        return 0 /* None */;
+        return void 0;
     }
     parent = node.parent;
   }
 }
+function getAssignmentTargetKind(node) {
+  const target = getAssignmentTarget(node);
+  if (!target) {
+    return 0 /* None */;
+  }
+  switch (target.kind) {
+    case 226 /* BinaryExpression */:
+      const binaryOperator = target.operatorToken.kind;
+      return binaryOperator === 64 /* EqualsToken */ || isLogicalOrCoalescingAssignmentOperator(binaryOperator) ? 1 /* Definite */ : 2 /* Compound */;
+    case 224 /* PrefixUnaryExpression */:
+    case 225 /* PostfixUnaryExpression */:
+      return 2 /* Compound */;
+    case 249 /* ForInStatement */:
+    case 250 /* ForOfStatement */:
+      return 1 /* Definite */;
+  }
+}
 function isAssignmentTarget(node) {
-  return getAssignmentTargetKind(node) !== 0 /* None */;
+  return !!getAssignmentTarget(node);
+}
+function isCompoundLikeAssignment(assignment) {
+  const right = skipParentheses(assignment.right);
+  return right.kind === 226 /* BinaryExpression */ && isShiftOperatorOrHigher(right.operatorToken.kind);
+}
+function isInCompoundLikeAssignment(node) {
+  const target = getAssignmentTarget(node);
+  return !!target && isAssignmentExpression(
+    target,
+    /*excludeCompoundAssignment*/
+    true
+  ) && isCompoundLikeAssignment(target);
 }
 function isNodeWithPossibleHoistedDeclaration(node) {
   switch (node.kind) {
@@ -47964,19 +47995,18 @@ function createTypeChecker(host) {
             const arity = getTypeReferenceArity(type2);
             const tupleConstituentNodes = mapToTypeNodes(typeArguments.slice(0, arity), context);
             if (tupleConstituentNodes) {
-              if (type2.target.labeledElementDeclarations) {
-                for (let i = 0; i < tupleConstituentNodes.length; i++) {
-                  const flags = type2.target.elementFlags[i];
+              const { labeledElementDeclarations } = type2.target;
+              for (let i = 0; i < tupleConstituentNodes.length; i++) {
+                const flags = type2.target.elementFlags[i];
+                const labeledElementDeclaration = labeledElementDeclarations == null ? void 0 : labeledElementDeclarations[i];
+                if (labeledElementDeclaration) {
                   tupleConstituentNodes[i] = factory.createNamedTupleMember(
                     flags & 12 /* Variable */ ? factory.createToken(26 /* DotDotDotToken */) : void 0,
-                    factory.createIdentifier(unescapeLeadingUnderscores(getTupleElementLabel(type2.target.labeledElementDeclarations[i]))),
+                    factory.createIdentifier(unescapeLeadingUnderscores(getTupleElementLabel(labeledElementDeclaration))),
                     flags & 2 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
                     flags & 4 /* Rest */ ? factory.createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i]
                   );
-                }
-              } else {
-                for (let i = 0; i < Math.min(arity, tupleConstituentNodes.length); i++) {
-                  const flags = type2.target.elementFlags[i];
+                } else {
                   tupleConstituentNodes[i] = flags & 12 /* Variable */ ? factory.createRestTypeNode(flags & 4 /* Rest */ ? factory.createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i]) : flags & 2 /* Optional */ ? factory.createOptionalTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i];
                 }
               }
@@ -53088,17 +53118,18 @@ function createTypeChecker(host) {
   function getExpandedParameters(sig, skipUnionExpanding) {
     if (signatureHasRestParameter(sig)) {
       const restIndex = sig.parameters.length - 1;
+      const restName = sig.parameters[restIndex].escapedName;
       const restType = getTypeOfSymbol(sig.parameters[restIndex]);
       if (isTupleType(restType)) {
-        return [expandSignatureParametersWithTupleMembers(restType, restIndex)];
+        return [expandSignatureParametersWithTupleMembers(restType, restIndex, restName)];
       } else if (!skipUnionExpanding && restType.flags & 1048576 /* Union */ && every(restType.types, isTupleType)) {
-        return map(restType.types, (t) => expandSignatureParametersWithTupleMembers(t, restIndex));
+        return map(restType.types, (t) => expandSignatureParametersWithTupleMembers(t, restIndex, restName));
       }
     }
     return [sig.parameters];
-    function expandSignatureParametersWithTupleMembers(restType, restIndex) {
-      const elementTypes = getElementTypes(restType);
-      const associatedNames = getUniqAssociatedNamesFromTupleType(restType);
+    function expandSignatureParametersWithTupleMembers(restType, restIndex, restName) {
+      const elementTypes = getTypeArguments(restType);
+      const associatedNames = getUniqAssociatedNamesFromTupleType(restType, restName);
       const restParams = map(elementTypes, (t, i) => {
         const name = associatedNames && associatedNames[i] ? associatedNames[i] : getParameterNameAtPosition(sig, restIndex + i, restType);
         const flags = restType.target.elementFlags[i];
@@ -53109,10 +53140,10 @@ function createTypeChecker(host) {
       });
       return concatenate(sig.parameters.slice(0, restIndex), restParams);
     }
-    function getUniqAssociatedNamesFromTupleType(type) {
+    function getUniqAssociatedNamesFromTupleType(type, restName) {
       const associatedNamesMap = /* @__PURE__ */ new Map();
-      return map(type.target.labeledElementDeclarations, (labeledElement) => {
-        const name = getTupleElementLabel(labeledElement);
+      return map(type.target.labeledElementDeclarations, (labeledElement, i) => {
+        const name = getTupleElementLabel(labeledElement, i, restName);
         const prevCounter = associatedNamesMap.get(name);
         if (prevCounter === void 0) {
           associatedNamesMap.set(name, 1);
@@ -56046,13 +56077,10 @@ function createTypeChecker(host) {
       return readonly ? globalReadonlyArrayType : globalArrayType;
     }
     const elementFlags = map(node.elements, getTupleElementFlags);
-    const missingName = some(node.elements, (e) => e.kind !== 202 /* NamedTupleMember */);
-    return getTupleTargetType(
-      elementFlags,
-      readonly,
-      /*associatedNames*/
-      missingName ? void 0 : node.elements
-    );
+    return getTupleTargetType(elementFlags, readonly, map(node.elements, memberIfLabeledElementDeclaration));
+  }
+  function memberIfLabeledElementDeclaration(member) {
+    return isNamedTupleMember(member) || isParameter(member) ? member : void 0;
   }
   function isDeferredTypeReferenceNode(node, hasDefaultTypeArguments) {
     return !!getAliasSymbolForTypeNode(node) || isResolvedByTypeAlias(node) && (node.kind === 188 /* ArrayType */ ? mayResolveTypeAlias(node.elementType) : node.kind === 189 /* TupleType */ ? some(node.elements, mayResolveTypeAlias) : hasDefaultTypeArguments || some(node.typeArguments, mayResolveTypeAlias));
@@ -56127,7 +56155,7 @@ function createTypeChecker(host) {
   function isReadonlyTypeOperator(node) {
     return isTypeOperatorNode(node) && node.operator === 148 /* ReadonlyKeyword */;
   }
-  function createTupleType(elementTypes, elementFlags, readonly = false, namedMemberDeclarations) {
+  function createTupleType(elementTypes, elementFlags, readonly = false, namedMemberDeclarations = []) {
     const tupleTarget = getTupleTargetType(elementFlags || map(elementTypes, (_) => 1 /* Required */), readonly, namedMemberDeclarations);
     return tupleTarget === emptyGenericType ? emptyObjectType : elementTypes.length ? createNormalizedTypeReference(tupleTarget, elementTypes) : tupleTarget;
   }
@@ -56135,7 +56163,8 @@ function createTypeChecker(host) {
     if (elementFlags.length === 1 && elementFlags[0] & 4 /* Rest */) {
       return readonly ? globalReadonlyArrayType : globalArrayType;
     }
-    const key = map(elementFlags, (f) => f & 1 /* Required */ ? "#" : f & 2 /* Optional */ ? "?" : f & 4 /* Rest */ ? "." : "*").join() + (readonly ? "R" : "") + (namedMemberDeclarations && namedMemberDeclarations.length ? "," + map(namedMemberDeclarations, getNodeId).join(",") : "");
+    const memberIds = mapDefined(namedMemberDeclarations, (node) => node ? getNodeId(node) : void 0);
+    const key = map(elementFlags, (f) => f & 1 /* Required */ ? "#" : f & 2 /* Optional */ ? "?" : f & 4 /* Rest */ ? "." : "*").join() + (readonly ? "R" : "") + (memberIds.length ? "," + memberIds.join(",") : "");
     let type = tupleTypes.get(key);
     if (!type) {
       tupleTypes.set(key, type = createTupleTargetType(elementFlags, readonly, namedMemberDeclarations));
@@ -56217,7 +56246,7 @@ function createTypeChecker(host) {
     }
     const expandedTypes = [];
     const expandedFlags = [];
-    let expandedDeclarations = [];
+    const expandedDeclarations = [];
     let lastRequiredIndex = -1;
     let firstRestIndex = -1;
     let lastOptionalOrRestIndex = -1;
@@ -56255,7 +56284,7 @@ function createTypeChecker(host) {
       ));
       expandedTypes.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);
       expandedFlags.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);
-      expandedDeclarations == null ? void 0 : expandedDeclarations.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);
+      expandedDeclarations.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);
     }
     const tupleTarget = getTupleTargetType(expandedFlags, target.readonly, expandedDeclarations);
     return tupleTarget === emptyGenericType ? emptyObjectType : expandedFlags.length ? createTypeReference(tupleTarget, expandedTypes) : tupleTarget;
@@ -56275,11 +56304,7 @@ function createTypeChecker(host) {
         true
       ) : type);
       expandedFlags.push(flags);
-      if (expandedDeclarations && declaration) {
-        expandedDeclarations.push(declaration);
-      } else {
-        expandedDeclarations = void 0;
-      }
+      expandedDeclarations.push(declaration);
     }
   }
   function sliceTupleType(type, index, endSkipCount = 0) {
@@ -65178,10 +65203,11 @@ function createTypeChecker(host) {
           const assignedType = getWidenedLiteralType(getInitialOrAssignedType(flow));
           return isTypeAssignableTo(assignedType, declaredType) ? assignedType : anyArrayType;
         }
-        if (declaredType.flags & 1048576 /* Union */) {
-          return getAssignmentReducedType(declaredType, getInitialOrAssignedType(flow));
+        const t = isInCompoundLikeAssignment(node) ? getBaseTypeOfLiteralType(declaredType) : declaredType;
+        if (t.flags & 1048576 /* Union */) {
+          return getAssignmentReducedType(t, getInitialOrAssignedType(flow));
         }
-        return declaredType;
+        return t;
       }
       if (containsMatchingReference(reference, node)) {
         if (!isReachableFlowNode(flow)) {
@@ -66310,7 +66336,7 @@ function createTypeChecker(host) {
     const isAlias = localOrExportSymbol.flags & 2097152 /* Alias */;
     if (localOrExportSymbol.flags & 3 /* Variable */) {
       if (assignmentKind === 1 /* Definite */) {
-        return type;
+        return isInCompoundLikeAssignment(node) ? getBaseTypeOfLiteralType(type) : type;
       }
     } else if (isAlias) {
       declaration = getDeclarationOfAliasSymbol(symbol);
@@ -66637,17 +66663,14 @@ function createTypeChecker(host) {
     }
   }
   function getTypeForThisExpressionFromJSDoc(node) {
-    const jsdocType = getJSDocType(node);
-    if (jsdocType && jsdocType.kind === 324 /* JSDocFunctionType */) {
-      const jsDocFunctionType = jsdocType;
-      if (jsDocFunctionType.parameters.length > 0 && jsDocFunctionType.parameters[0].name && jsDocFunctionType.parameters[0].name.escapedText === "this" /* This */) {
-        return getTypeFromTypeNode(jsDocFunctionType.parameters[0].type);
-      }
-    }
     const thisTag = getJSDocThisTag(node);
     if (thisTag && thisTag.typeExpression) {
       return getTypeFromTypeNode(thisTag.typeExpression);
     }
+    const signature = getSignatureOfTypeTag(node);
+    if (signature) {
+      return getThisTypeOfSignature(signature);
+    }
   }
   function isInConstructorArgumentInitializer(node, constructorDecl) {
     return !!findAncestor(node, (n) => isFunctionLikeDeclaration(n) ? "quit" : n.kind === 169 /* Parameter */ && n.parent === constructorDecl);
@@ -70549,12 +70572,7 @@ function createTypeChecker(host) {
     }
     const candidates = candidatesOutArray || [];
     reorderCandidates(signatures, candidates, callChainFlags);
-    if (!candidates.length) {
-      if (reportErrors2) {
-        diagnostics.add(getDiagnosticForCallNode(node, Diagnostics.Call_target_does_not_contain_any_signatures));
-      }
-      return resolveErrorCall(node);
-    }
+    Debug.assert(candidates.length, "Revert #54442 and add a testcase with whatever triggered this");
     const args = getEffectiveCallArguments(node);
     const isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
     let argCheckMode = !isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive) ? 4 /* SkipContextSensitive */ : 0 /* Normal */;
@@ -72006,7 +72024,10 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function getTupleElementLabel(d) {
+  function getTupleElementLabel(d, index, restParameterName = "arg") {
+    if (!d) {
+      return `${restParameterName}_${index}`;
+    }
     Debug.assert(isIdentifier(d.name));
     return d.name.escapedText;
   }
@@ -72020,7 +72041,7 @@ function createTypeChecker(host) {
     if (isTupleType(restType)) {
       const associatedNames = restType.target.labeledElementDeclarations;
       const index = pos - paramCount;
-      return associatedNames && getTupleElementLabel(associatedNames[index]) || restParameter.escapedName + "_" + index;
+      return getTupleElementLabel(associatedNames == null ? void 0 : associatedNames[index], index, restParameter.escapedName);
     }
     return restParameter.escapedName;
   }
@@ -75375,12 +75396,7 @@ function createTypeChecker(host) {
     const elementTypes = node.elements;
     let seenOptionalElement = false;
     let seenRestElement = false;
-    const hasNamedElement = some(elementTypes, isNamedTupleMember);
     for (const e of elementTypes) {
-      if (e.kind !== 202 /* NamedTupleMember */ && hasNamedElement) {
-        grammarErrorOnNode(e, Diagnostics.Tuple_members_must_all_have_names_or_all_not_have_names);
-        break;
-      }
       const flags = getTupleElementFlags(e);
       if (flags & 8 /* Variadic */) {
         const type = getTypeFromTypeNode(e.type);