@typescript-deploys/pr-build 5.0.0-pr-50431-13 → 5.0.0-pr-52836-22

package/lib/tsserver.js

@@ -1797,8 +1797,6 @@ __export(server_exports, {
   isWithStatement: () => isWithStatement,
   isWriteAccess: () => isWriteAccess,
   isWriteOnlyAccess: () => isWriteOnlyAccess,
-  isWriteOnlyUsage: () => isWriteOnlyUsage,
-  isWriteUsage: () => isWriteUsage,
   isYieldExpression: () => isYieldExpression,
   jsxModeNeedsExplicitImport: () => jsxModeNeedsExplicitImport,
   keywordPart: () => keywordPart,
@@ -2290,7 +2288,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20230217`;
+var version = `${versionMajorMinor}.0-insiders.20230218`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -11954,18 +11952,18 @@ function isIdentifierText(name, languageVersion, identifierVariant) {
   return true;
 }
 function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Standard */, textInitial, onError, start2, length2) {
-  let text = textInitial;
-  let pos;
-  let end;
-  let startPos;
-  let tokenPos;
-  let token;
-  let tokenValue;
-  let tokenFlags;
-  let commentDirectives;
-  let inJSDocType = 0;
+  var text = textInitial;
+  var pos;
+  var end;
+  var startPos;
+  var tokenPos;
+  var token;
+  var tokenValue;
+  var tokenFlags;
+  var commentDirectives;
+  var inJSDocType = 0;
   setText(text, start2, length2);
-  const scanner2 = {
+  var scanner2 = {
     getStartPos: () => startPos,
     getTextPos: () => pos,
     getToken: () => token,
@@ -19654,39 +19652,20 @@ function isWriteOnlyAccess(node) {
 function isWriteAccess(node) {
   return accessKind(node) !== 0 /* Read */;
 }
-function isWriteOnlyUsage(node) {
-  return accessKindForUsageChecks(node) === 1 /* Write */;
-}
-function isWriteUsage(node) {
-  return accessKindForUsageChecks(node) !== 0 /* Read */;
-}
-function accessKindForUsageChecks(node) {
-  const kind = accessKind(node);
-  const { parent: parent2 } = node;
-  switch (parent2 == null ? void 0 : parent2.kind) {
-    case 222 /* PostfixUnaryExpression */:
-    case 221 /* PrefixUnaryExpression */:
-    case 223 /* BinaryExpression */:
-      return kind === 2 /* ReadWrite */ ? writeOrReadWrite() : kind;
-    default:
-      return kind;
-  }
-  function writeOrReadWrite() {
-    return parent2.parent && walkUpParenthesizedExpressions(parent2.parent).kind === 241 /* ExpressionStatement */ ? 1 /* Write */ : 2 /* ReadWrite */;
-  }
-}
 function accessKind(node) {
   const { parent: parent2 } = node;
-  switch (parent2 == null ? void 0 : parent2.kind) {
+  if (!parent2)
+    return 0 /* Read */;
+  switch (parent2.kind) {
     case 214 /* ParenthesizedExpression */:
       return accessKind(parent2);
     case 222 /* PostfixUnaryExpression */:
     case 221 /* PrefixUnaryExpression */:
       const { operator } = parent2;
-      return operator === 45 /* PlusPlusToken */ || operator === 46 /* MinusMinusToken */ ? 2 /* ReadWrite */ : 0 /* Read */;
+      return operator === 45 /* PlusPlusToken */ || operator === 46 /* MinusMinusToken */ ? writeOrReadWrite() : 0 /* Read */;
     case 223 /* BinaryExpression */:
       const { left, operatorToken } = parent2;
-      return left === node && isAssignmentOperator(operatorToken.kind) ? operatorToken.kind === 63 /* EqualsToken */ ? 1 /* Write */ : 2 /* ReadWrite */ : 0 /* Read */;
+      return left === node && isAssignmentOperator(operatorToken.kind) ? operatorToken.kind === 63 /* EqualsToken */ ? 1 /* Write */ : writeOrReadWrite() : 0 /* Read */;
     case 208 /* PropertyAccessExpression */:
       return parent2.name !== node ? 0 /* Read */ : accessKind(parent2);
     case 299 /* PropertyAssignment */: {
@@ -19700,6 +19679,9 @@ function accessKind(node) {
     default:
       return 0 /* Read */;
   }
+  function writeOrReadWrite() {
+    return parent2.parent && walkUpParenthesizedExpressions(parent2.parent).kind === 241 /* ExpressionStatement */ ? 1 /* Write */ : 2 /* ReadWrite */;
+  }
 }
 function reverseAccessKind(a) {
   switch (a) {
@@ -30372,22 +30354,22 @@ function parseJSDocTypeExpressionForTests(content, start2, length2) {
 }
 var Parser;
 ((Parser2) => {
-  const scanner2 = createScanner(
+  var scanner2 = createScanner(
     99 /* Latest */,
     /*skipTrivia*/
     true
   );
-  const disallowInAndDecoratorContext = 4096 /* DisallowInContext */ | 16384 /* DecoratorContext */;
-  let NodeConstructor2;
-  let TokenConstructor2;
-  let IdentifierConstructor2;
-  let PrivateIdentifierConstructor2;
-  let SourceFileConstructor2;
+  var disallowInAndDecoratorContext = 4096 /* DisallowInContext */ | 16384 /* DecoratorContext */;
+  var NodeConstructor2;
+  var TokenConstructor2;
+  var IdentifierConstructor2;
+  var PrivateIdentifierConstructor2;
+  var SourceFileConstructor2;
   function countNode(node) {
     nodeCount++;
     return node;
   }
-  const baseNodeFactory = {
+  var baseNodeFactory = {
     createBaseSourceFileNode: (kind) => countNode(new SourceFileConstructor2(
       kind,
       /*pos*/
@@ -30424,25 +30406,25 @@ var Parser;
       0
     ))
   };
-  const factory2 = createNodeFactory(1 /* NoParenthesizerRules */ | 2 /* NoNodeConverters */ | 8 /* NoOriginalNode */, baseNodeFactory);
-  let fileName;
-  let sourceFlags;
-  let sourceText;
-  let languageVersion;
-  let scriptKind;
-  let languageVariant;
-  let parseDiagnostics;
-  let jsDocDiagnostics;
-  let syntaxCursor;
-  let currentToken;
-  let nodeCount;
-  let identifiers;
-  let identifierCount;
-  let parsingContext;
-  let notParenthesizedArrow;
-  let contextFlags;
-  let topLevel = true;
-  let parseErrorBeforeNextFinishedNode = false;
+  var factory2 = createNodeFactory(1 /* NoParenthesizerRules */ | 2 /* NoNodeConverters */ | 8 /* NoOriginalNode */, baseNodeFactory);
+  var fileName;
+  var sourceFlags;
+  var sourceText;
+  var languageVersion;
+  var scriptKind;
+  var languageVariant;
+  var parseDiagnostics;
+  var jsDocDiagnostics;
+  var syntaxCursor;
+  var currentToken;
+  var nodeCount;
+  var identifiers;
+  var identifierCount;
+  var parsingContext;
+  var notParenthesizedArrow;
+  var contextFlags;
+  var topLevel = true;
+  var parseErrorBeforeNextFinishedNode = false;
   function parseSourceFile(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes = false, scriptKind2, setExternalModuleIndicatorOverride) {
     var _a2;
     scriptKind2 = ensureScriptKind(fileName2, scriptKind2);
@@ -33949,13 +33931,9 @@ var Parser;
   function parseJsxClosingFragment(inExpressionContext) {
     const pos = getNodePos();
     parseExpected(30 /* LessThanSlashToken */);
-    if (tokenIsIdentifierOrKeyword(token())) {
-      parseErrorAtRange(parseJsxElementName(), Diagnostics.Expected_corresponding_closing_tag_for_JSX_fragment);
-    }
     if (parseExpected(
       31 /* GreaterThanToken */,
-      /*diagnostic*/
-      void 0,
+      Diagnostics.Expected_corresponding_closing_tag_for_JSX_fragment,
       /*shouldAdvance*/
       false
     )) {
@@ -51917,7 +51895,7 @@ function createTypeChecker(host) {
         return result;
       }
       function createAnonymousTypeNode(type2) {
-        var _a3;
+        var _a3, _b2;
         const typeId = type2.id;
         const symbol = type2.symbol;
         if (symbol) {
@@ -51943,6 +51921,20 @@ function createTypeChecker(host) {
             return visitAndTransformType(type2, createTypeNodeFromObjectType);
           }
         } else {
+          const isInstantiationExpressionType = !!(getObjectFlags(type2) & 8388608 /* InstantiationExpressionType */);
+          if (isInstantiationExpressionType) {
+            const instantiationExpressionType = type2;
+            if (isTypeQueryNode(instantiationExpressionType.node)) {
+              const typeNode = serializeExistingTypeNode(context, instantiationExpressionType.node);
+              if (typeNode) {
+                return typeNode;
+              }
+            }
+            if ((_b2 = context.visitedTypes) == null ? void 0 : _b2.has(typeId)) {
+              return createElidedInformationPlaceholder(context);
+            }
+            return visitAndTransformType(type2, createTypeNodeFromObjectType);
+          }
           return createTypeNodeFromObjectType(type2);
         }
         function shouldWriteTypeOfFunctionSymbol() {
@@ -52451,7 +52443,7 @@ function createTypeChecker(host) {
       );
     }
     function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
-      var _a2, _b, _c, _d;
+      var _a2, _b, _c, _d, _e;
       const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
       if (suppressAny)
         context.flags &= ~256 /* SuppressAnyReturnType */;
@@ -52468,6 +52460,39 @@ function createTypeChecker(host) {
         /*skipUnionExpanding*/
         true
       )[0];
+      let cleanup;
+      if (context.enclosingDeclaration && signature.declaration && signature.declaration !== context.enclosingDeclaration && !isInJSFile(signature.declaration) && some(expandedParams)) {
+        const existingFakeScope = getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration ? context.enclosingDeclaration : void 0;
+        Debug.assertOptionalNode(existingFakeScope, isBlock);
+        const locals = (_a2 = existingFakeScope == null ? void 0 : existingFakeScope.locals) != null ? _a2 : createSymbolTable();
+        let newLocals;
+        for (const param of expandedParams) {
+          if (!locals.has(param.escapedName)) {
+            newLocals = append(newLocals, param.escapedName);
+            locals.set(param.escapedName, param);
+          }
+        }
+        if (newLocals) {
+          let removeNewLocals2 = function() {
+            forEach(newLocals, (s) => locals.delete(s));
+          };
+          var removeNewLocals = removeNewLocals2;
+          if (existingFakeScope) {
+            cleanup = removeNewLocals2;
+          } else {
+            const fakeScope = parseNodeFactory.createBlock(emptyArray);
+            getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = true;
+            fakeScope.locals = locals;
+            const saveEnclosingDeclaration = context.enclosingDeclaration;
+            setParent(fakeScope, saveEnclosingDeclaration);
+            context.enclosingDeclaration = fakeScope;
+            cleanup = () => {
+              context.enclosingDeclaration = saveEnclosingDeclaration;
+              removeNewLocals2();
+            };
+          }
+        }
+      }
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 173 /* Constructor */, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
@@ -52493,11 +52518,11 @@ function createTypeChecker(host) {
         const flags = modifiersToFlags(modifiers);
         modifiers = factory.createModifiersFromModifierFlags(flags | 256 /* Abstract */);
       }
-      const node = kind === 176 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 177 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 170 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (_a2 = options == null ? void 0 : options.name) != null ? _a2 : factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 171 /* MethodDeclaration */ ? factory.createMethodDeclaration(
+      const node = kind === 176 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 177 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 170 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (_b = options == null ? void 0 : options.name) != null ? _b : factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 171 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
         /*asteriskToken*/
         void 0,
-        (_b = options == null ? void 0 : options.name) != null ? _b : factory.createIdentifier(""),
+        (_c = options == null ? void 0 : options.name) != null ? _c : factory.createIdentifier(""),
         /*questionToken*/
         void 0,
         typeParameters,
@@ -52512,14 +52537,14 @@ function createTypeChecker(host) {
         void 0
       ) : kind === 174 /* GetAccessor */ ? factory.createGetAccessorDeclaration(
         modifiers,
-        (_c = options == null ? void 0 : options.name) != null ? _c : factory.createIdentifier(""),
+        (_d = options == null ? void 0 : options.name) != null ? _d : factory.createIdentifier(""),
         parameters,
         returnTypeNode,
         /*body*/
         void 0
       ) : kind === 175 /* SetAccessor */ ? factory.createSetAccessorDeclaration(
         modifiers,
-        (_d = options == null ? void 0 : options.name) != null ? _d : factory.createIdentifier(""),
+        (_e = options == null ? void 0 : options.name) != null ? _e : factory.createIdentifier(""),
         parameters,
         /*body*/
         void 0
@@ -52554,6 +52579,7 @@ function createTypeChecker(host) {
       if (typeArguments) {
         node.typeArguments = factory.createNodeArray(typeArguments);
       }
+      cleanup == null ? void 0 : cleanup();
       return node;
     }
     function tryGetThisParameterDeclaration(signature, context) {
@@ -53168,9 +53194,12 @@ function createTypeChecker(host) {
     function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
       return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
     }
+    function getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration) {
+      return getNodeLinks(enclosingDeclaration).fakeScopeForSignatureDeclaration ? enclosingDeclaration.parent : enclosingDeclaration;
+    }
     function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
       if (!isErrorType(type) && enclosingDeclaration) {
-        const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration);
+        const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
           if (typeNodeIsEquivalentToType(existing, declWithExistingAnnotation, type) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
@@ -53202,7 +53231,8 @@ function createTypeChecker(host) {
     function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
       if (!isErrorType(type) && context.enclosingDeclaration) {
         const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
-        if (!!findAncestor(annotation, (n) => n === context.enclosingDeclaration) && annotation) {
+        const enclosingDeclarationIgnoringFakeScope = getEnclosingDeclarationIgnoringFakeScope(context.enclosingDeclaration);
+        if (!!findAncestor(annotation, (n) => n === enclosingDeclarationIgnoringFakeScope) && annotation) {
           const annotated = getTypeFromTypeNode(annotation);
           const thisInstantiated = annotated.flags & 262144 /* TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated;
           if (thisInstantiated === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
@@ -60964,31 +60994,21 @@ function createTypeChecker(host) {
     }
     return type;
     function addSpans(texts2, types2) {
-      const isTextsArray = isArray(texts2);
       for (let i = 0; i < types2.length; i++) {
         const t = types2[i];
-        const addText = isTextsArray ? texts2[i + 1] : texts2;
         if (t.flags & (2944 /* Literal */ | 65536 /* Null */ | 32768 /* Undefined */)) {
           text += getTemplateStringForType(t) || "";
-          text += addText;
-          if (!isTextsArray)
-            return true;
+          text += texts2[i + 1];
         } else if (t.flags & 134217728 /* TemplateLiteral */) {
           text += t.texts[0];
           if (!addSpans(t.texts, t.types))
             return false;
-          text += addText;
-          if (!isTextsArray)
-            return true;
-        } else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t)) {
+          text += texts2[i + 1];
+        } else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t) || t.flags & 2097152 /* Intersection */) {
           newTypes.push(t);
           newTexts.push(text);
-          text = addText;
-        } else if (t.flags & 2097152 /* Intersection */) {
-          const added = addSpans(texts2[i + 1], t.types);
-          if (!added)
-            return false;
-        } else if (isTextsArray) {
+          text = texts2[i + 1];
+        } else {
           return false;
         }
       }
@@ -61000,6 +61020,11 @@ function createTypeChecker(host) {
   }
   function createTemplateLiteralType(texts, types) {
     const type = createType(134217728 /* TemplateLiteral */);
+    type.objectFlags = getPropagatingFlagsOfTypes(
+      types,
+      /*excludeKinds*/
+      98304 /* Nullable */
+    );
     type.texts = texts;
     type.types = types;
     return type;
@@ -61314,7 +61339,7 @@ function createTypeChecker(host) {
     return !!(getGenericObjectFlags(type) & 8388608 /* IsGenericIndexType */);
   }
   function getGenericObjectFlags(type) {
-    if (type.flags & 3145728 /* UnionOrIntersection */) {
+    if (type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */)) {
       if (!(type.objectFlags & 2097152 /* IsGenericTypeComputed */)) {
         type.objectFlags |= 2097152 /* IsGenericTypeComputed */ | reduceLeft(type.types, (flags, t) => flags | getGenericObjectFlags(t), 0);
       }
@@ -61326,7 +61351,7 @@ function createTypeChecker(host) {
       }
       return type.objectFlags & 12582912 /* IsGenericType */;
     }
-    return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
+    return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
   }
   function getSimplifiedType(type, writing) {
     return type.flags & 8388608 /* IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) : type.flags & 16777216 /* Conditional */ ? getSimplifiedConditionalType(type, writing) : type;
@@ -66504,7 +66529,7 @@ function createTypeChecker(host) {
     const restType = getRestTypeOfTupleType(type);
     return restType && createArrayType(restType);
   }
-  function getElementTypeOfSliceOfTupleType(type, index, endSkipCount = 0, writing = false) {
+  function getElementTypeOfSliceOfTupleType(type, index, endSkipCount = 0, writing = false, noReductions = false) {
     const length2 = getTypeReferenceArity(type) - endSkipCount;
     if (index < length2) {
       const typeArguments = getTypeArguments(type);
@@ -66513,7 +66538,7 @@ function createTypeChecker(host) {
         const t = typeArguments[i];
         elementTypes.push(type.target.elementFlags[i] & 8 /* Variadic */ ? getIndexedAccessType(t, numberType) : t);
       }
-      return writing ? getIntersectionType(elementTypes) : getUnionType(elementTypes);
+      return writing ? getIntersectionType(elementTypes) : getUnionType(elementTypes, noReductions ? 0 /* None */ : 1 /* Literal */);
     }
     return void 0;
   }
@@ -67980,7 +68005,7 @@ function createTypeChecker(host) {
         111551 /* Value */ | 1048576 /* ExportValue */,
         getCannotFindNameDiagnosticForName(node),
         node,
-        !isWriteOnlyUsage(node),
+        !isWriteOnlyAccess(node),
         /*excludeGlobals*/
         false
       ) || unknownSymbol;
@@ -71100,9 +71125,18 @@ function createTypeChecker(host) {
           if (prop) {
             return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
           }
-          if (isTupleType(t)) {
-            const restType = getRestTypeOfTupleType(t);
-            if (restType && isNumericLiteralName(name) && +name >= 0) {
+          if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
+            const restType = getElementTypeOfSliceOfTupleType(
+              t,
+              t.target.fixedLength,
+              /*endSkipCount*/
+              0,
+              /*writing*/
+              false,
+              /*noReductions*/
+              true
+            );
+            if (restType) {
               return restType;
             }
           }
@@ -71149,9 +71183,18 @@ function createTypeChecker(host) {
     return void 0;
   }
   function getContextualTypeForElementExpression(arrayContextualType, index) {
-    return arrayContextualType && (getTypeOfPropertyOfContextualType(arrayContextualType, "" + index) || mapType(
+    return arrayContextualType && (index >= 0 && getTypeOfPropertyOfContextualType(arrayContextualType, "" + index) || mapType(
       arrayContextualType,
-      (t) => getIteratedTypeOrElementType(
+      (t) => isTupleType(t) ? getElementTypeOfSliceOfTupleType(
+        t,
+        0,
+        /*endSkipCount*/
+        0,
+        /*writing*/
+        false,
+        /*noReductions*/
+        true
+      ) : getIteratedTypeOrElementType(
         1 /* Element */,
         t,
         undefinedType,
@@ -71304,6 +71347,7 @@ function createTypeChecker(host) {
     return type;
   }
   function getContextualType2(node, contextFlags) {
+    var _a2, _b;
     if (node.flags & 33554432 /* InWithStatement */) {
       return void 0;
     }
@@ -71348,7 +71392,9 @@ function createTypeChecker(host) {
       case 206 /* ArrayLiteralExpression */: {
         const arrayLiteral = parent2;
         const type = getApparentTypeOfContextualType(arrayLiteral, contextFlags);
-        return getContextualTypeForElementExpression(type, indexOfNode(arrayLiteral.elements, node));
+        const spreadIndex = (_b = (_a2 = getNodeLinks(arrayLiteral)).firstSpreadIndex) != null ? _b : _a2.firstSpreadIndex = findIndex(arrayLiteral.elements, isSpreadElement);
+        const elementIndex = indexOfNode(arrayLiteral.elements, node);
+        return getContextualTypeForElementExpression(type, spreadIndex < 0 || elementIndex < spreadIndex ? elementIndex : -1);
       }
       case 224 /* ConditionalExpression */:
         return getContextualTypeForConditionalOperand(node, contextFlags);
@@ -72798,8 +72844,8 @@ function createTypeChecker(host) {
     }
     return nonNullType;
   }
-  function checkPropertyAccessExpression(node, checkMode, writeOnly) {
-    return node.flags & 32 /* OptionalChain */ ? checkPropertyAccessChain(node, checkMode) : checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullExpression(node.expression), node.name, checkMode, writeOnly);
+  function checkPropertyAccessExpression(node, checkMode) {
+    return node.flags & 32 /* OptionalChain */ ? checkPropertyAccessChain(node, checkMode) : checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullExpression(node.expression), node.name, checkMode);
   }
   function checkPropertyAccessChain(node, checkMode) {
     const leftType = checkExpression(node.expression);
@@ -72930,7 +72976,7 @@ function createTypeChecker(host) {
       false
     ) === getDeclaringConstructor(prop);
   }
-  function checkPropertyAccessExpressionOrQualifiedName(node, left, leftType, right, checkMode, writeOnly) {
+  function checkPropertyAccessExpressionOrQualifiedName(node, left, leftType, right, checkMode) {
     const parentSymbol = getNodeLinks(left).resolvedSymbol;
     const assignmentKind = getAssignmentTargetKind(node);
     const apparentType = getApparentType(assignmentKind !== 0 /* None */ || isMethodAccessForCall(node) ? getWidenedType(leftType) : leftType);
@@ -73029,12 +73075,13 @@ function createTypeChecker(host) {
       checkPropertyNotUsedBeforeDeclaration(prop, node, right);
       markPropertyAsReferenced(prop, node, isSelfTypeAccess(left, parentSymbol));
       getNodeLinks(node).resolvedSymbol = prop;
-      checkPropertyAccessibility(node, left.kind === 106 /* SuperKeyword */, isWriteAccess(node), apparentType, prop);
+      const writing = isWriteAccess(node);
+      checkPropertyAccessibility(node, left.kind === 106 /* SuperKeyword */, writing, apparentType, prop);
       if (isAssignmentToReadonlyEntity(node, prop, assignmentKind)) {
         error(right, Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, idText(right));
         return errorType;
       }
-      propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writeOnly || isWriteOnlyAccess(node) ? getWriteTypeOfSymbol(prop) : getTypeOfSymbol(prop);
+      propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writing ? getWriteTypeOfSymbol(prop) : getTypeOfSymbol(prop);
     }
     return getFlowTypeOfAccessExpression(node, prop, propType, right, checkMode);
   }
@@ -73350,7 +73397,7 @@ function createTypeChecker(host) {
     if (!hasPrivateModifier && !hasPrivateIdentifier) {
       return;
     }
-    if (nodeForCheckWriteOnly && isWriteOnlyUsage(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SetAccessor */)) {
+    if (nodeForCheckWriteOnly && isWriteOnlyAccess(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SetAccessor */)) {
       return;
     }
     if (isSelfTypeAccess2) {
@@ -77664,16 +77711,6 @@ function createTypeChecker(host) {
         addLazyDiagnostic(checkAssignmentOperatorWorker);
       }
       function checkAssignmentOperatorWorker() {
-        let assigneeType = leftType;
-        if (isCompoundAssignment(operatorToken.kind) && left.kind === 208 /* PropertyAccessExpression */) {
-          assigneeType = checkPropertyAccessExpression(
-            left,
-            /*checkMode*/
-            void 0,
-            /*writeOnly*/
-            true
-          );
-        }
         if (checkReferenceExpression(
           left,
           Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access,
@@ -77686,7 +77723,7 @@ function createTypeChecker(host) {
               headMessage = Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target;
             }
           }
-          checkTypeAssignableToAndOptionallyElaborate(valueType, assigneeType, left, right, headMessage);
+          checkTypeAssignableToAndOptionallyElaborate(valueType, leftType, left, right, headMessage);
         }
       }
     }
@@ -82456,20 +82493,19 @@ function createTypeChecker(host) {
       }
     }
   }
-  function getMemberOverrideModifierStatus(node, member) {
+  function getMemberOverrideModifierStatus(node, member, memberSymbol) {
     if (!member.name) {
       return 0 /* Ok */;
     }
-    const symbol = getSymbolOfDeclaration(node);
-    const type = getDeclaredTypeOfSymbol(symbol);
+    const classSymbol = getSymbolOfDeclaration(node);
+    const type = getDeclaredTypeOfSymbol(classSymbol);
     const typeWithThis = getTypeWithThisArgument(type);
-    const staticType = getTypeOfSymbol(symbol);
+    const staticType = getTypeOfSymbol(classSymbol);
     const baseTypeNode = getEffectiveBaseTypeNode(node);
     const baseTypes = baseTypeNode && getBaseTypes(type);
     const baseWithThis = (baseTypes == null ? void 0 : baseTypes.length) ? getTypeWithThisArgument(first(baseTypes), type.thisType) : void 0;
     const baseStaticType = getBaseConstructorTypeOfClass(type);
     const memberHasOverrideModifier = member.parent ? hasOverrideModifier(member) : hasSyntacticModifier(member, 16384 /* Override */);
-    const memberName = unescapeLeadingUnderscores(getTextOfPropertyName(member.name));
     return checkMemberForOverrideModifier(
       node,
       staticType,
@@ -82482,7 +82518,7 @@ function createTypeChecker(host) {
       isStatic(member),
       /* memberIsParameterProperty */
       false,
-      memberName
+      symbolName(memberSymbol)
     );
   }
   function getTargetSymbol(s) {
@@ -148269,6 +148305,7 @@ var SymbolOriginInfoKind = /* @__PURE__ */ ((SymbolOriginInfoKind2) => {
   SymbolOriginInfoKind2[SymbolOriginInfoKind2["TypeOnlyAlias"] = 64] = "TypeOnlyAlias";
   SymbolOriginInfoKind2[SymbolOriginInfoKind2["ObjectLiteralMethod"] = 128] = "ObjectLiteralMethod";
   SymbolOriginInfoKind2[SymbolOriginInfoKind2["Ignore"] = 256] = "Ignore";
+  SymbolOriginInfoKind2[SymbolOriginInfoKind2["ComputedPropertyName"] = 512] = "ComputedPropertyName";
   SymbolOriginInfoKind2[SymbolOriginInfoKind2["SymbolMemberNoExport"] = 2 /* SymbolMember */] = "SymbolMemberNoExport";
   SymbolOriginInfoKind2[SymbolOriginInfoKind2["SymbolMemberExport"] = 6] = "SymbolMemberExport";
   return SymbolOriginInfoKind2;
@@ -148286,7 +148323,7 @@ function originIsResolvedExport(origin) {
   return !!(origin && origin.kind === 32 /* ResolvedExport */);
 }
 function originIncludesSymbolName(origin) {
-  return originIsExport(origin) || originIsResolvedExport(origin);
+  return originIsExport(origin) || originIsResolvedExport(origin) || originIsComputedPropertyName(origin);
 }
 function originIsPackageJsonImport(origin) {
   return (originIsExport(origin) || originIsResolvedExport(origin)) && !!origin.isFromPackageJson;
@@ -148306,6 +148343,9 @@ function originIsObjectLiteralMethod(origin) {
 function originIsIgnore(origin) {
   return !!(origin && origin.kind & 256 /* Ignore */);
 }
+function originIsComputedPropertyName(origin) {
+  return !!(origin && origin.kind & 512 /* ComputedPropertyName */);
+}
 function resolvingModuleSpecifiers(logPrefix, host, resolver, program, position, preferences, isForImportStatementCompletion, isValidTypeOnlyUseSite, cb) {
   var _a2, _b, _c;
   const start2 = timestamp();
@@ -149032,7 +149072,7 @@ function getEntryForMemberCompletion(host, program, options, preferences, name,
       if (isAbstract) {
         requiredModifiers |= 256 /* Abstract */;
       }
-      if (isClassElement(node) && checker.getMemberOverrideModifierStatus(classLikeDeclaration, node) === 1 /* NeedsOverride */) {
+      if (isClassElement(node) && checker.getMemberOverrideModifierStatus(classLikeDeclaration, node, symbol) === 1 /* NeedsOverride */) {
         requiredModifiers |= 16384 /* Override */;
       }
       if (!completionNodes.length) {
@@ -149626,7 +149666,8 @@ function getCompletionEntryDetails(program, log, sourceFile, position, entryId,
     case "symbol": {
       const { symbol, location, contextToken: contextToken2, origin, previousToken: previousToken2 } = symbolCompletion;
       const { codeActions, sourceDisplay } = getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken2, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken2, formatContext, preferences, data, source, cancellationToken);
-      return createCompletionDetailsForSymbol(symbol, typeChecker, sourceFile, location, cancellationToken, codeActions, sourceDisplay);
+      const symbolName2 = originIsComputedPropertyName(origin) ? origin.symbolName : symbol.name;
+      return createCompletionDetailsForSymbol(symbol, symbolName2, typeChecker, sourceFile, location, cancellationToken, codeActions, sourceDisplay);
     }
     case "literal": {
       const { literal } = symbolCompletion;
@@ -149677,12 +149718,12 @@ function getCompletionEntryDetails(program, log, sourceFile, position, entryId,
 function createSimpleDetails(name, kind, kind2) {
   return createCompletionDetails(name, "" /* none */, kind, [displayPart(name, kind2)]);
 }
-function createCompletionDetailsForSymbol(symbol, checker, sourceFile, location, cancellationToken, codeActions, sourceDisplay) {
+function createCompletionDetailsForSymbol(symbol, name, checker, sourceFile, location, cancellationToken, codeActions, sourceDisplay) {
   const { displayParts, documentation, symbolKind, tags } = checker.runWithCancellationToken(
     cancellationToken,
     (checker2) => ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(checker2, symbol, sourceFile, location, location, 7 /* All */)
   );
-  return createCompletionDetails(symbol.name, ts_SymbolDisplay_exports.getSymbolModifiers(checker, symbol), symbolKind, displayParts, documentation, tags, codeActions, sourceDisplay);
+  return createCompletionDetails(name, ts_SymbolDisplay_exports.getSymbolModifiers(checker, symbol), symbolKind, displayParts, documentation, tags, codeActions, sourceDisplay);
 }
 function createCompletionDetails(name, kindModifiers, kind, displayParts, documentation, tags, codeActions, source) {
   return { name, kindModifiers, kind, displayParts, documentation, tags, codeActions, source, sourceDisplay: source };
@@ -150789,6 +150830,16 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         return classElementModifierFlags & 32 /* Static */ ? (type == null ? void 0 : type.symbol) && typeChecker.getPropertiesOfType(typeChecker.getTypeOfSymbolAtLocation(type.symbol, decl)) : type && typeChecker.getPropertiesOfType(type);
       });
       symbols = concatenate(symbols, filterClassMembersList(baseSymbols, decl.members, classElementModifierFlags));
+      forEach(symbols, (symbol, index) => {
+        const declaration = symbol == null ? void 0 : symbol.valueDeclaration;
+        if (declaration && isClassElement(declaration) && declaration.name && isComputedPropertyName(declaration.name)) {
+          const origin = {
+            kind: 512 /* ComputedPropertyName */,
+            symbolName: typeChecker.symbolToString(symbol)
+          };
+          symbolToOriginInfoMap[index] = origin;
+        }
+      });
     }
     return 1 /* Success */;
   }
@@ -151173,7 +151224,7 @@ function getCompletionEntryDisplayNameForSymbol(symbol, target, origin, kind, js
   }
   switch (kind) {
     case 3 /* MemberLike */:
-      return void 0;
+      return originIsComputedPropertyName(origin) ? { name: origin.symbolName, needsConvertPropertyAccess: false } : void 0;
     case 0 /* ObjectPropertyDeclaration */:
       return { name: JSON.stringify(name), needsConvertPropertyAccess: false };
     case 2 /* PropertyAccess */:
@@ -151765,7 +151816,7 @@ function stringLiteralCompletionDetails(name, location, completion, sourceFile,
     }
     case 1 /* Properties */: {
       const match = find(completion.symbols, (s) => s.name === name);
-      return match && createCompletionDetailsForSymbol(match, checker, sourceFile, location, cancellationToken);
+      return match && createCompletionDetailsForSymbol(match, match.name, checker, sourceFile, location, cancellationToken);
     }
     case 2 /* Types */:
       return find(completion.types, (t) => t.value === name) ? createCompletionDetails(name, "" /* none */, "string" /* string */, [textPart(name)]) : void 0;
@@ -169343,8 +169394,6 @@ __export(ts_exports3, {
   isWithStatement: () => isWithStatement,
   isWriteAccess: () => isWriteAccess,
   isWriteOnlyAccess: () => isWriteOnlyAccess,
-  isWriteOnlyUsage: () => isWriteOnlyUsage,
-  isWriteUsage: () => isWriteUsage,
   isYieldExpression: () => isYieldExpression,
   jsxModeNeedsExplicitImport: () => jsxModeNeedsExplicitImport,
   keywordPart: () => keywordPart,
@@ -183295,8 +183344,6 @@ start(initializeNodeSystem(), require("os").platform());
   isWithStatement,
   isWriteAccess,
   isWriteOnlyAccess,
-  isWriteOnlyUsage,
-  isWriteUsage,
   isYieldExpression,
   jsxModeNeedsExplicitImport,
   keywordPart,