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

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-insiders.20230217`;
+      version = `${versionMajorMinor}.0-insiders.20230218`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -9616,18 +9616,18 @@ ${lanes.join("\n")}
     return true;
   }
   function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Standard */, textInitial, onError, start, 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, start, length2);
-    const scanner2 = {
+    var scanner2 = {
       getStartPos: () => startPos,
       getTextPos: () => pos,
       getToken: () => token,
@@ -17391,39 +17391,20 @@ ${lanes.join("\n")}
   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 */: {
@@ -17437,6 +17418,9 @@ ${lanes.join("\n")}
       default:
         return 0 /* Read */;
     }
+    function writeOrReadWrite() {
+      return parent2.parent && walkUpParenthesizedExpressions(parent2.parent).kind === 241 /* ExpressionStatement */ ? 1 /* Write */ : 2 /* ReadWrite */;
+    }
   }
   function reverseAccessKind(a) {
     switch (a) {
@@ -28480,22 +28464,22 @@ ${lanes.join("\n")}
         [356 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression
       };
       ((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*/
@@ -28532,25 +28516,25 @@ ${lanes.join("\n")}
             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);
@@ -32057,13 +32041,9 @@ ${lanes.join("\n")}
         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
           )) {
@@ -49723,7 +49703,7 @@ ${lanes.join("\n")}
           return result;
         }
         function createAnonymousTypeNode(type2) {
-          var _a3;
+          var _a3, _b2;
           const typeId = type2.id;
           const symbol = type2.symbol;
           if (symbol) {
@@ -49749,6 +49729,20 @@ ${lanes.join("\n")}
               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() {
@@ -50257,7 +50251,7 @@ ${lanes.join("\n")}
         );
       }
       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 */;
@@ -50274,6 +50268,39 @@ ${lanes.join("\n")}
           /*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) {
@@ -50299,11 +50326,11 @@ ${lanes.join("\n")}
           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,
@@ -50318,14 +50345,14 @@ ${lanes.join("\n")}
           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
@@ -50360,6 +50387,7 @@ ${lanes.join("\n")}
         if (typeArguments) {
           node.typeArguments = factory.createNodeArray(typeArguments);
         }
+        cleanup == null ? void 0 : cleanup();
         return node;
       }
       function tryGetThisParameterDeclaration(signature, context) {
@@ -50974,9 +51002,12 @@ ${lanes.join("\n")}
       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)) {
@@ -51008,7 +51039,8 @@ ${lanes.join("\n")}
       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)) {
@@ -58770,31 +58802,21 @@ ${lanes.join("\n")}
       }
       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;
           }
         }
@@ -65786,7 +65808,7 @@ ${lanes.join("\n")}
           111551 /* Value */ | 1048576 /* ExportValue */,
           getCannotFindNameDiagnosticForName(node),
           node,
-          !isWriteOnlyUsage(node),
+          !isWriteOnlyAccess(node),
           /*excludeGlobals*/
           false
         ) || unknownSymbol;
@@ -70604,8 +70626,8 @@ ${lanes.join("\n")}
       }
       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);
@@ -70736,7 +70758,7 @@ ${lanes.join("\n")}
         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);
@@ -70835,12 +70857,13 @@ ${lanes.join("\n")}
         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);
     }
@@ -71156,7 +71179,7 @@ ${lanes.join("\n")}
       if (!hasPrivateModifier && !hasPrivateIdentifier) {
         return;
       }
-      if (nodeForCheckWriteOnly && isWriteOnlyUsage(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SetAccessor */)) {
+      if (nodeForCheckWriteOnly && isWriteOnlyAccess(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SetAccessor */)) {
         return;
       }
       if (isSelfTypeAccess2) {
@@ -75470,16 +75493,6 @@ ${lanes.join("\n")}
           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,
@@ -75492,7 +75505,7 @@ ${lanes.join("\n")}
                 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);
           }
         }
       }
@@ -80262,20 +80275,19 @@ ${lanes.join("\n")}
         }
       }
     }
-    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,
@@ -80288,7 +80300,7 @@ ${lanes.join("\n")}
         isStatic(member),
         /* memberIsParameterProperty */
         false,
-        memberName
+        symbolName(memberSymbol)
       );
     }
     function getTargetSymbol(s) {
@@ -147352,7 +147364,7 @@ ${lanes.join("\n")}
     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;
@@ -147372,6 +147384,9 @@ ${lanes.join("\n")}
   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 start = timestamp();
@@ -148098,7 +148113,7 @@ ${lanes.join("\n")}
         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) {
@@ -148692,7 +148707,8 @@ ${lanes.join("\n")}
       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;
@@ -148743,12 +148759,12 @@ ${lanes.join("\n")}
   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 };
@@ -149846,6 +149862,16 @@ ${lanes.join("\n")}
           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 */;
     }
@@ -150230,7 +150256,7 @@ ${lanes.join("\n")}
     }
     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 */:
@@ -150738,6 +150764,7 @@ ${lanes.join("\n")}
         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;
@@ -150873,7 +150900,7 @@ ${lanes.join("\n")}
       }
       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;
@@ -169108,8 +169135,6 @@ ${options.prefix}` : "\n" : options.prefix
     isWithStatement: () => isWithStatement,
     isWriteAccess: () => isWriteAccess,
     isWriteOnlyAccess: () => isWriteOnlyAccess,
-    isWriteOnlyUsage: () => isWriteOnlyUsage,
-    isWriteUsage: () => isWriteUsage,
     isYieldExpression: () => isYieldExpression,
     jsxModeNeedsExplicitImport: () => jsxModeNeedsExplicitImport,
     keywordPart: () => keywordPart,