typescript 5.2.0-dev.20230612 → 5.2.0-dev.20230614

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.2";
-      version = `${versionMajorMinor}.0-dev.20230612`;
+      version = `${versionMajorMinor}.0-dev.20230614`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -9032,6 +9032,9 @@ ${lanes.join("\n")}
         Use_type_0: diag(95181, 3 /* Message */, "Use_type_0_95181", "Use 'type {0}'"),
         Fix_all_with_type_only_imports: diag(95182, 3 /* Message */, "Fix_all_with_type_only_imports_95182", "Fix all with type-only imports"),
         Cannot_move_statements_to_the_selected_file: diag(95183, 3 /* Message */, "Cannot_move_statements_to_the_selected_file_95183", "Cannot move statements to the selected file"),
+        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."),
         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?"),
@@ -45389,14 +45392,25 @@ ${lanes.join("\n")}
       getTypeOfPropertyOfContextualType,
       getFullyQualifiedName,
       getResolvedSignature: (node, candidatesOutArray, argumentCount) => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0 /* Normal */),
-      getResolvedSignatureForStringLiteralCompletions: (call, editingArgument, candidatesOutArray) => runWithInferenceBlockedFromSourceNode(editingArgument, () => getResolvedSignatureWorker(
-        call,
-        candidatesOutArray,
-        /*argumentCount*/
-        void 0,
-        64 /* IsForStringLiteralArgumentCompletions */
-      )),
-      getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => runWithoutResolvedSignatureCaching(node, () => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 32 /* IsForSignatureHelp */)),
+      getResolvedSignatureForStringLiteralCompletions: (call, editingArgument, candidatesOutArray, checkMode = 32 /* IsForStringLiteralArgumentCompletions */) => {
+        if (checkMode & 32 /* IsForStringLiteralArgumentCompletions */) {
+          return runWithInferenceBlockedFromSourceNode(editingArgument, () => getResolvedSignatureWorker(
+            call,
+            candidatesOutArray,
+            /*argumentCount*/
+            void 0,
+            checkMode & ~32 /* IsForStringLiteralArgumentCompletions */
+          ));
+        }
+        return runWithoutResolvedSignatureCaching(editingArgument, () => getResolvedSignatureWorker(
+          call,
+          candidatesOutArray,
+          /*argumentCount*/
+          void 0,
+          checkMode & ~32 /* IsForStringLiteralArgumentCompletions */
+        ));
+      },
+      getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => runWithoutResolvedSignatureCaching(node, () => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* IsForSignatureHelp */)),
       getExpandedParameters,
       hasEffectiveRestParameter,
       containsArgumentsReference,
@@ -53222,9 +53236,15 @@ ${lanes.join("\n")}
       const prop = getPropertyOfType(type, name);
       return prop ? getTypeOfSymbol(prop) : void 0;
     }
-    function getTypeOfPropertyOrIndexSignature(type, name) {
+    function getTypeOfPropertyOrIndexSignature(type, name, addOptionalityToIndex) {
       var _a;
-      return getTypeOfPropertyOfType(type, name) || ((_a = getApplicableIndexInfoForName(type, name)) == null ? void 0 : _a.type) || unknownType;
+      let propType;
+      return getTypeOfPropertyOfType(type, name) || (propType = (_a = getApplicableIndexInfoForName(type, name)) == null ? void 0 : _a.type) && addOptionality(
+        propType,
+        /*isProperty*/
+        true,
+        addOptionalityToIndex
+      ) || unknownType;
     }
     function isTypeAny(type) {
       return type && (type.flags & 1 /* Any */) !== 0;
@@ -53351,7 +53371,7 @@ ${lanes.join("\n")}
       return type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */) ? "" + type.value : void 0;
     }
     function getTypeForBindingElement(declaration) {
-      const checkMode = declaration.dotDotDotToken ? 128 /* RestBindingElement */ : 0 /* Normal */;
+      const checkMode = declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
       const parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
       return parentType && getBindingElementTypeFromParentType(declaration, parentType);
     }
@@ -55108,19 +55128,13 @@ ${lanes.join("\n")}
       if (getObjectFlags(type) & 4 /* Reference */) {
         const target = type.target;
         const typeArguments = getTypeArguments(type);
-        if (length(target.typeParameters) === length(typeArguments)) {
-          const ref = createTypeReference(target, concatenate(typeArguments, [thisArgument || target.thisType]));
-          return needApparentType ? getApparentType(ref) : ref;
-        }
+        return length(target.typeParameters) === length(typeArguments) ? createTypeReference(target, concatenate(typeArguments, [thisArgument || target.thisType])) : type;
       } else if (type.flags & 2097152 /* Intersection */) {
         const types = sameMap(type.types, (t) => getTypeWithThisArgument(t, thisArgument, needApparentType));
         return types !== type.types ? getIntersectionType(types) : type;
       }
       return needApparentType ? getApparentType(type) : type;
     }
-    function getThisArgument(type) {
-      return getObjectFlags(type) & 4 /* Reference */ && length(getTypeArguments(type)) > getTypeReferenceArity(type) ? last(getTypeArguments(type)) : type;
-    }
     function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
       let mapper;
       let members;
@@ -56186,7 +56200,7 @@ ${lanes.join("\n")}
         return type.resolvedBaseConstraint;
       }
       const stack = [];
-      return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), getThisArgument(type));
+      return type.resolvedBaseConstraint = getImmediateBaseConstraint(type);
       function getImmediateBaseConstraint(t) {
         if (!t.immediateBaseConstraint) {
           if (!pushTypeResolution(t, 4 /* ImmediateBaseConstraint */)) {
@@ -56278,18 +56292,18 @@ ${lanes.join("\n")}
         }
         if (isGenericTupleType(t)) {
           const newElements = map(getElementTypes(t), (v, i) => {
-            const constraint = t.target.elementFlags[i] & 8 /* Variadic */ && getBaseConstraint(v) || v;
-            return constraint && everyType(constraint, (c) => isArrayOrTupleType(c) && !isGenericTupleType(c)) ? constraint : v;
+            const constraint = v.flags & 262144 /* TypeParameter */ && t.target.elementFlags[i] & 8 /* Variadic */ && getBaseConstraint(v) || v;
+            return constraint !== v && everyType(constraint, (c) => isArrayOrTupleType(c) && !isGenericTupleType(c)) ? constraint : v;
           });
           return createTupleType(newElements, t.target.elementFlags, t.target.readonly, t.target.labeledElementDeclarations);
         }
         return t;
       }
     }
-    function getApparentTypeOfIntersectionType(type) {
+    function getApparentTypeOfIntersectionType(type, thisArgument) {
       return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(
         type,
-        type,
+        thisArgument,
         /*needApparentType*/
         true
       ));
@@ -56340,8 +56354,9 @@ ${lanes.join("\n")}
       return !!(type.flags & 8388608 /* IndexedAccess */ && getObjectFlags(objectType = type.objectType) & 32 /* Mapped */ && !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) && !(getMappedTypeModifiers(objectType) & 8 /* ExcludeOptional */) && !objectType.declaration.nameType);
     }
     function getApparentType(type) {
-      const t = !(type.flags & 465829888 /* Instantiable */) ? type : getBaseConstraintOfType(type) || unknownType;
-      return getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) : t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) : t.flags & 402653316 /* StringLike */ ? globalStringType : t.flags & 296 /* NumberLike */ ? globalNumberType : t.flags & 2112 /* BigIntLike */ ? getGlobalBigIntType() : t.flags & 528 /* BooleanLike */ ? globalBooleanType : t.flags & 12288 /* ESSymbolLike */ ? getGlobalESSymbolType() : t.flags & 67108864 /* NonPrimitive */ ? emptyObjectType : t.flags & 4194304 /* Index */ ? keyofConstraintType : t.flags & 2 /* Unknown */ && !strictNullChecks ? emptyObjectType : t;
+      const t = type.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(type) || unknownType : type;
+      const objectFlags = getObjectFlags(t);
+      return objectFlags & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) : objectFlags & 4 /* Reference */ && t !== type ? getTypeWithThisArgument(t, type) : t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t, type) : t.flags & 402653316 /* StringLike */ ? globalStringType : t.flags & 296 /* NumberLike */ ? globalNumberType : t.flags & 2112 /* BigIntLike */ ? getGlobalBigIntType() : t.flags & 528 /* BooleanLike */ ? globalBooleanType : t.flags & 12288 /* ESSymbolLike */ ? getGlobalESSymbolType() : t.flags & 67108864 /* NonPrimitive */ ? emptyObjectType : t.flags & 4194304 /* Index */ ? keyofConstraintType : t.flags & 2 /* Unknown */ && !strictNullChecks ? emptyObjectType : t;
     }
     function getReducedApparentType(type) {
       return getReducedType(getApparentType(getReducedType(type)));
@@ -63170,7 +63185,7 @@ ${lanes.join("\n")}
             return 3 /* Maybe */;
           }
           const c = target2;
-          if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
+          if (!c.root.inferTypeParameters && !isDistributionDependent(c.root) && !(source2.flags & 16777216 /* Conditional */ && source2.root === c.root)) {
             const skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
             const skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
             if (result2 = skipTrue ? -1 /* True */ : isRelatedTo(
@@ -64231,7 +64246,12 @@ ${lanes.join("\n")}
         let matched = false;
         for (let i = 0; i < types.length; i++) {
           if (include[i]) {
-            const targetType = getTypeOfPropertyOfType(types[i], propertyName);
+            const targetType = getTypeOfPropertyOrIndexSignature(
+              types[i],
+              propertyName,
+              /*addOptionalityToIndex*/
+              true
+            );
             if (targetType && related(getDiscriminatingType(), targetType)) {
               matched = true;
             } else {
@@ -66162,7 +66182,7 @@ ${lanes.join("\n")}
         const constraint = getConstraintOfTypeParameter(inference.typeParameter);
         if (constraint) {
           const instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
-          if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
+          if (!inferredType || inferredType === wildcardType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
             inference.inferredType = fallbackType && context.compareTypes(fallbackType, getTypeWithThisArgument(instantiatedConstraint, fallbackType)) ? fallbackType : instantiatedConstraint;
           }
         }
@@ -67629,7 +67649,12 @@ ${lanes.join("\n")}
         propType = removeNullable && optionalChain ? getOptionalType(propType) : propType;
         const narrowedPropType = narrowType2(propType);
         return filterType(type, (t) => {
-          const discriminantType = getTypeOfPropertyOrIndexSignature(t, propName);
+          const discriminantType = getTypeOfPropertyOrIndexSignature(
+            t,
+            propName,
+            /*addOptionalityToIndex*/
+            false
+          );
           return !(discriminantType.flags & 131072 /* Never */) && !(narrowedPropType.flags & 131072 /* Never */) && areTypesComparable(narrowedPropType, discriminantType);
         });
       }
@@ -68256,7 +68281,7 @@ ${lanes.join("\n")}
       return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithoutNullableConstraint) : !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
     }
     function hasContextualTypeWithNoGenericTypes(node, checkMode) {
-      const contextualType = (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) && !((isJsxOpeningElement(node.parent) || isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) && (checkMode && checkMode & 128 /* RestBindingElement */ ? getContextualType2(node, 8 /* SkipBindingPatterns */) : getContextualType2(
+      const contextualType = (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) && !((isJsxOpeningElement(node.parent) || isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) && (checkMode && checkMode & 64 /* RestBindingElement */ ? getContextualType2(node, 8 /* SkipBindingPatterns */) : getContextualType2(
         node,
         /*contextFlags*/
         void 0
@@ -68903,6 +68928,25 @@ ${lanes.join("\n")}
         return t.flags & 2097152 /* Intersection */ ? forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t);
       });
     }
+    function getThisTypeOfObjectLiteralFromContextualType(containingLiteral, contextualType) {
+      let literal = containingLiteral;
+      let type = contextualType;
+      while (type) {
+        const thisType = getThisTypeFromContextualType(type);
+        if (thisType) {
+          return thisType;
+        }
+        if (literal.parent.kind !== 302 /* PropertyAssignment */) {
+          break;
+        }
+        literal = literal.parent.parent;
+        type = getApparentTypeOfContextualType(
+          literal,
+          /*contextFlags*/
+          void 0
+        );
+      }
+    }
     function getContextualThisParameterType(func) {
       if (func.kind === 218 /* ArrowFunction */) {
         return void 0;
@@ -68925,22 +68969,9 @@ ${lanes.join("\n")}
             /*contextFlags*/
             void 0
           );
-          let literal = containingLiteral;
-          let type = contextualType;
-          while (type) {
-            const thisType = getThisTypeFromContextualType(type);
-            if (thisType) {
-              return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral)));
-            }
-            if (literal.parent.kind !== 302 /* PropertyAssignment */) {
-              break;
-            }
-            literal = literal.parent.parent;
-            type = getApparentTypeOfContextualType(
-              literal,
-              /*contextFlags*/
-              void 0
-            );
+          const thisType = getThisTypeOfObjectLiteralFromContextualType(containingLiteral, contextualType);
+          if (thisType) {
+            return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral)));
           }
           return getWidenedType(contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral));
         }
@@ -69013,7 +69044,7 @@ ${lanes.join("\n")}
     function getContextualTypeForBindingElement(declaration, contextFlags) {
       const parent2 = declaration.parent.parent;
       const name = declaration.propertyName || declaration.name;
-      const parentType = getContextualTypeForVariableLikeDeclaration(parent2, contextFlags) || parent2.kind !== 207 /* BindingElement */ && parent2.initializer && checkDeclarationInitializer(parent2, declaration.dotDotDotToken ? 128 /* RestBindingElement */ : 0 /* Normal */);
+      const parentType = getContextualTypeForVariableLikeDeclaration(parent2, contextFlags) || parent2.kind !== 207 /* BindingElement */ && parent2.initializer && checkDeclarationInitializer(parent2, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
       if (!parentType || isBindingPattern(name) || isComputedNonLiteralName(name))
         return void 0;
       if (parent2.name.kind === 206 /* ArrayBindingPattern */) {
@@ -70062,9 +70093,7 @@ ${lanes.join("\n")}
           elementTypes.push(undefinedOrMissingType);
           elementFlags.push(2 /* Optional */);
         } else {
-          const shouldAddAsIntraExpressionInferenceSite = inTupleContext && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & (4 /* SkipContextSensitive */ | 16 /* SkipAddingIntraExpressionSites */)) && isContextSensitive(e);
-          const elementCheckMode = (checkMode || 0 /* Normal */) | (shouldAddAsIntraExpressionInferenceSite ? 16 /* SkipAddingIntraExpressionSites */ : 0);
-          const type = checkExpressionForMutableLocation(e, elementCheckMode, forceTuple);
+          const type = checkExpressionForMutableLocation(e, checkMode, forceTuple);
           elementTypes.push(addOptionality(
             type,
             /*isProperty*/
@@ -70072,7 +70101,7 @@ ${lanes.join("\n")}
             hasOmittedExpression
           ));
           elementFlags.push(hasOmittedExpression ? 2 /* Optional */ : 1 /* Required */);
-          if (shouldAddAsIntraExpressionInferenceSite) {
+          if (inTupleContext && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(e)) {
             const inferenceContext = getInferenceContext(node);
             Debug.assert(inferenceContext);
             addIntraExpressionInferenceSite(inferenceContext, e, type);
@@ -70213,13 +70242,11 @@ ${lanes.join("\n")}
         let member = getSymbolOfDeclaration(memberDecl);
         const computedNameType = memberDecl.name && memberDecl.name.kind === 166 /* ComputedPropertyName */ ? checkComputedPropertyName(memberDecl.name) : void 0;
         if (memberDecl.kind === 302 /* PropertyAssignment */ || memberDecl.kind === 303 /* ShorthandPropertyAssignment */ || isObjectLiteralMethod(memberDecl)) {
-          const shouldAddAsIntraExpressionInferenceSite = contextualType && checkMode & 2 /* Inferential */ && !(checkMode & (4 /* SkipContextSensitive */ | 16 /* SkipAddingIntraExpressionSites */)) && (memberDecl.kind === 302 /* PropertyAssignment */ || memberDecl.kind === 173 /* MethodDeclaration */) && isContextSensitive(memberDecl);
-          const propCheckMode = checkMode | (shouldAddAsIntraExpressionInferenceSite ? 16 /* SkipAddingIntraExpressionSites */ : 0);
-          let type = memberDecl.kind === 302 /* PropertyAssignment */ ? checkPropertyAssignment(memberDecl, propCheckMode) : (
+          let type = memberDecl.kind === 302 /* PropertyAssignment */ ? checkPropertyAssignment(memberDecl, checkMode) : (
             // avoid resolving the left side of the ShorthandPropertyAssignment outside of the destructuring
             // for error recovery purposes. For example, if a user wrote `{ a = 100 }` instead of `{ a: 100 }`.
             // we don't want to say "could not find 'a'".
-            memberDecl.kind === 303 /* ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, propCheckMode) : checkObjectLiteralMethod(memberDecl, propCheckMode)
+            memberDecl.kind === 303 /* ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, checkMode) : checkObjectLiteralMethod(memberDecl, checkMode)
           );
           if (isInJavascript) {
             const jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl);
@@ -70263,7 +70290,7 @@ ${lanes.join("\n")}
           prop.links.target = member;
           member = prop;
           allPropertiesTable == null ? void 0 : allPropertiesTable.set(prop.escapedName, prop);
-          if (shouldAddAsIntraExpressionInferenceSite) {
+          if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && (memberDecl.kind === 302 /* PropertyAssignment */ || memberDecl.kind === 173 /* MethodDeclaration */) && isContextSensitive(memberDecl)) {
             const inferenceContext = getInferenceContext(node);
             Debug.assert(inferenceContext);
             const inferenceNode = memberDecl.kind === 302 /* PropertyAssignment */ ? memberDecl.initializer : memberDecl;
@@ -70436,9 +70463,7 @@ ${lanes.join("\n")}
       for (const attributeDecl of attributes.properties) {
         const member = attributeDecl.symbol;
         if (isJsxAttribute(attributeDecl)) {
-          const shouldAddAsIntraExpressionInferenceSite = contextualType && checkMode & 2 /* Inferential */ && !(checkMode & (4 /* SkipContextSensitive */ | 16 /* SkipAddingIntraExpressionSites */)) && isContextSensitive(attributeDecl);
-          const attributeCheckMode = checkMode | (shouldAddAsIntraExpressionInferenceSite ? 16 /* SkipAddingIntraExpressionSites */ : 0);
-          const exprType = checkJsxAttribute(attributeDecl, attributeCheckMode);
+          const exprType = checkJsxAttribute(attributeDecl, checkMode);
           objectFlags |= getObjectFlags(exprType) & 458752 /* PropagatingFlags */;
           const attributeSymbol = createSymbol(4 /* Property */ | member.flags, member.escapedName);
           attributeSymbol.declarations = member.declarations;
@@ -70459,7 +70484,7 @@ ${lanes.join("\n")}
               addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText);
             }
           }
-          if (shouldAddAsIntraExpressionInferenceSite) {
+          if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(attributeDecl)) {
             const inferenceContext = getInferenceContext(attributes);
             Debug.assert(inferenceContext);
             const inferenceNode = attributeDecl.initializer.expression;
@@ -72077,7 +72102,7 @@ ${lanes.join("\n")}
       }
       for (let i = 0; i < argCount; i++) {
         const arg = args[i];
-        if (arg.kind !== 231 /* OmittedExpression */ && !(checkMode & 64 /* IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) {
+        if (arg.kind !== 231 /* OmittedExpression */) {
           const paramType = getTypeAtPosition(signature, i);
           if (couldContainTypeVariables(paramType)) {
             const argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
@@ -72690,12 +72715,11 @@ ${lanes.join("\n")}
       const args = getEffectiveCallArguments(node);
       const isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
       let argCheckMode = !isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive) ? 4 /* SkipContextSensitive */ : 0 /* Normal */;
-      argCheckMode |= checkMode & 64 /* IsForStringLiteralArgumentCompletions */;
       let candidatesForArgumentError;
       let candidateForArgumentArityError;
       let candidateForTypeArgumentError;
       let result;
-      const signatureHelpTrailingComma = !!(checkMode & 32 /* IsForSignatureHelp */) && node.kind === 212 /* CallExpression */ && node.arguments.hasTrailingComma;
+      const signatureHelpTrailingComma = !!(checkMode & 16 /* IsForSignatureHelp */) && node.kind === 212 /* CallExpression */ && node.arguments.hasTrailingComma;
       if (candidates.length > 1) {
         result = chooseOverload(candidates, subtypeRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
       }
@@ -72914,7 +72938,7 @@ ${lanes.join("\n")}
             continue;
           }
           if (argCheckMode) {
-            argCheckMode = checkMode & 64 /* IsForStringLiteralArgumentCompletions */;
+            argCheckMode = 0 /* Normal */;
             if (inferenceContext) {
               const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
               checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
@@ -75992,8 +76016,9 @@ ${lanes.join("\n")}
         case 36 /* ExclamationEqualsToken */:
         case 37 /* EqualsEqualsEqualsToken */:
         case 38 /* ExclamationEqualsEqualsToken */:
-          if (!(checkMode && checkMode & 256 /* TypeOnly */)) {
-            if (isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) {
+          if (!(checkMode && checkMode & 128 /* TypeOnly */)) {
+            if ((isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) && // only report for === and !== in JS, not == or !=
+            (!isInJSFile(left) || (operator === 37 /* EqualsEqualsEqualsToken */ || operator === 38 /* ExclamationEqualsEqualsToken */))) {
               const eqType = operator === 35 /* EqualsEqualsToken */ || operator === 37 /* EqualsEqualsEqualsToken */;
               error2(errorNode, Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true");
             }
@@ -76651,7 +76676,7 @@ ${lanes.join("\n")}
         }
       }
       const startInvocationCount = flowInvocationCount;
-      const type = checkExpression(node, 256 /* TypeOnly */);
+      const type = checkExpression(node, 128 /* TypeOnly */);
       if (flowInvocationCount !== startInvocationCount) {
         const cache = flowTypeCache || (flowTypeCache = []);
         cache[getNodeId(node)] = type;
@@ -76766,7 +76791,7 @@ ${lanes.join("\n")}
           return nullWideningType;
         case 15 /* NoSubstitutionTemplateLiteral */:
         case 11 /* StringLiteral */:
-          return hasSkipDirectInferenceFlag(node) ? anyType : getFreshTypeOfLiteralType(getStringLiteralType(node.text));
+          return hasSkipDirectInferenceFlag(node) ? wildcardType : getFreshTypeOfLiteralType(getStringLiteralType(node.text));
         case 9 /* NumericLiteral */:
           checkGrammarNumericLiteral(node);
           return getFreshTypeOfLiteralType(getNumberLiteralType(+node.text));
@@ -79122,7 +79147,7 @@ ${lanes.join("\n")}
           checkComputedPropertyName(node.propertyName);
         }
         const parent2 = node.parent.parent;
-        const parentCheckMode = node.dotDotDotToken ? 128 /* RestBindingElement */ : 0 /* Normal */;
+        const parentCheckMode = node.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
         const parentType = getTypeForBindingElementParent(parent2, parentCheckMode);
         const name = node.propertyName || node.name;
         if (parentType && !isBindingPattern(name)) {
@@ -82712,7 +82737,7 @@ ${lanes.join("\n")}
               /*contextFlags*/
               void 0
             );
-            const type = contextualType && getThisTypeFromContextualType(contextualType);
+            const type = getThisTypeOfObjectLiteralFromContextualType(containingLiteral, contextualType);
             return type && !isTypeAny(type);
           }
         }
@@ -85858,11 +85883,10 @@ ${lanes.join("\n")}
         CheckMode3[CheckMode3["Inferential"] = 2] = "Inferential";
         CheckMode3[CheckMode3["SkipContextSensitive"] = 4] = "SkipContextSensitive";
         CheckMode3[CheckMode3["SkipGenericFunctions"] = 8] = "SkipGenericFunctions";
-        CheckMode3[CheckMode3["SkipAddingIntraExpressionSites"] = 16] = "SkipAddingIntraExpressionSites";
-        CheckMode3[CheckMode3["IsForSignatureHelp"] = 32] = "IsForSignatureHelp";
-        CheckMode3[CheckMode3["IsForStringLiteralArgumentCompletions"] = 64] = "IsForStringLiteralArgumentCompletions";
-        CheckMode3[CheckMode3["RestBindingElement"] = 128] = "RestBindingElement";
-        CheckMode3[CheckMode3["TypeOnly"] = 256] = "TypeOnly";
+        CheckMode3[CheckMode3["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
+        CheckMode3[CheckMode3["IsForStringLiteralArgumentCompletions"] = 32] = "IsForStringLiteralArgumentCompletions";
+        CheckMode3[CheckMode3["RestBindingElement"] = 64] = "RestBindingElement";
+        CheckMode3[CheckMode3["TypeOnly"] = 128] = "TypeOnly";
         return CheckMode3;
       })(CheckMode || {});
       SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
@@ -120027,7 +120051,9 @@ ${lanes.join("\n")}
         Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations.code,
         Diagnostics.Class_constructor_may_not_be_a_generator.code,
         Diagnostics.Class_constructor_may_not_be_an_accessor.code,
-        Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code
+        Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
+        // Type errors
+        Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value.code
       ]);
       emitSkippedWithNoDiagnostics = { diagnostics: emptyArray, sourceMaps: void 0, emittedFiles: void 0, emitSkipped: true };
     }
@@ -134051,8 +134077,8 @@ ${lanes.join("\n")}
       return context.cancellationToken && context.cancellationToken.isCancellationRequested() || !((_a = refactor.kinds) == null ? void 0 : _a.some((kind) => refactorKindBeginsWith(kind, context.kind))) ? void 0 : refactor.getAvailableActions(context, includeInteractiveActions);
     }));
   }
-  function getEditsForRefactor(context, refactorName13, actionName2, interactiveRefactorArguments) {
-    const refactor = refactors.get(refactorName13);
+  function getEditsForRefactor(context, refactorName14, actionName2, interactiveRefactorArguments) {
+    const refactor = refactors.get(refactorName14);
     return refactor && refactor.getEditsForAction(context, actionName2, interactiveRefactorArguments);
   }
   var refactors;
@@ -134858,6 +134884,155 @@ ${lanes.join("\n")}
     }
   });
 
+  // src/services/refactors/inlineVariable.ts
+  function getInliningInfo(file, startPosition, tryWithReferenceToken, program) {
+    var _a, _b;
+    const checker = program.getTypeChecker();
+    const token = getTouchingPropertyName(file, startPosition);
+    const parent2 = token.parent;
+    if (!isIdentifier(token)) {
+      return void 0;
+    }
+    if (isInitializedVariable(parent2) && isVariableDeclarationInVariableStatement(parent2)) {
+      if (((_a = checker.getMergedSymbol(parent2.symbol).declarations) == null ? void 0 : _a.length) !== 1) {
+        return { error: getLocaleSpecificMessage(Diagnostics.Variables_with_multiple_declarations_cannot_be_inlined) };
+      }
+      if (isDeclarationExported(parent2)) {
+        return void 0;
+      }
+      const references = getReferenceNodes(parent2, checker, file);
+      return references && { references, declaration: parent2, replacement: parent2.initializer };
+    }
+    if (tryWithReferenceToken) {
+      let definition = checker.resolveName(
+        token.text,
+        token,
+        111551 /* Value */,
+        /*excludeGlobals*/
+        false
+      );
+      definition = definition && checker.getMergedSymbol(definition);
+      if (((_b = definition == null ? void 0 : definition.declarations) == null ? void 0 : _b.length) !== 1) {
+        return { error: getLocaleSpecificMessage(Diagnostics.Variables_with_multiple_declarations_cannot_be_inlined) };
+      }
+      const declaration = definition.declarations[0];
+      if (!isInitializedVariable(declaration) || !isVariableDeclarationInVariableStatement(declaration) || !isIdentifier(declaration.name)) {
+        return void 0;
+      }
+      if (isDeclarationExported(declaration)) {
+        return void 0;
+      }
+      const references = getReferenceNodes(declaration, checker, file);
+      return references && { references, declaration, replacement: declaration.initializer };
+    }
+    return { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_variable_to_inline) };
+  }
+  function isDeclarationExported(declaration) {
+    const variableStatement = cast(declaration.parent.parent, isVariableStatement);
+    return some(variableStatement.modifiers, isExportModifier);
+  }
+  function getReferenceNodes(declaration, checker, file) {
+    const references = [];
+    const cannotInline = ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(declaration.name, checker, file, (ref) => {
+      if (ts_FindAllReferences_exports.isWriteAccessForReference(ref)) {
+        return true;
+      }
+      if (isExportSpecifier(ref.parent) || isExportAssignment(ref.parent)) {
+        return true;
+      }
+      if (isTypeQueryNode(ref.parent)) {
+        return true;
+      }
+      if (textRangeContainsPositionInclusive(declaration, ref.pos)) {
+        return true;
+      }
+      references.push(ref);
+    });
+    return references.length === 0 || cannotInline ? void 0 : references;
+  }
+  function getReplacementExpression(reference, replacement) {
+    replacement = getSynthesizedDeepClone(replacement);
+    const { parent: parent2 } = reference;
+    if (isExpression(parent2) && (getExpressionPrecedence(replacement) < getExpressionPrecedence(parent2) || needsParentheses(parent2))) {
+      return factory.createParenthesizedExpression(replacement);
+    }
+    if (isFunctionLike(replacement) && isCallLikeExpression(parent2)) {
+      return factory.createParenthesizedExpression(replacement);
+    }
+    return replacement;
+  }
+  var refactorName4, refactorDescription, inlineVariableAction;
+  var init_inlineVariable = __esm({
+    "src/services/refactors/inlineVariable.ts"() {
+      "use strict";
+      init_ts4();
+      init_ts_refactor();
+      refactorName4 = "Inline variable";
+      refactorDescription = getLocaleSpecificMessage(Diagnostics.Inline_variable);
+      inlineVariableAction = {
+        name: refactorName4,
+        description: refactorDescription,
+        kind: "refactor.inline.variable"
+      };
+      registerRefactor(refactorName4, {
+        kinds: [inlineVariableAction.kind],
+        getAvailableActions(context) {
+          const {
+            file,
+            program,
+            preferences,
+            startPosition,
+            triggerReason
+          } = context;
+          const info = getInliningInfo(file, startPosition, triggerReason === "invoked", program);
+          if (!info) {
+            return emptyArray;
+          }
+          if (!ts_refactor_exports.isRefactorErrorInfo(info)) {
+            return [{
+              name: refactorName4,
+              description: refactorDescription,
+              actions: [inlineVariableAction]
+            }];
+          }
+          if (preferences.provideRefactorNotApplicableReason) {
+            return [{
+              name: refactorName4,
+              description: refactorDescription,
+              actions: [{
+                ...inlineVariableAction,
+                notApplicableReason: info.error
+              }]
+            }];
+          }
+          return emptyArray;
+        },
+        getEditsForAction(context, actionName2) {
+          Debug.assert(actionName2 === refactorName4, "Unexpected refactor invoked");
+          const { file, program, startPosition } = context;
+          const info = getInliningInfo(
+            file,
+            startPosition,
+            /*tryWithReferenceToken*/
+            true,
+            program
+          );
+          if (!info || ts_refactor_exports.isRefactorErrorInfo(info)) {
+            return void 0;
+          }
+          const { references, declaration, replacement } = info;
+          const edits = ts_textChanges_exports.ChangeTracker.with(context, (tracker) => {
+            for (const node of references) {
+              tracker.replaceNode(file, node, getReplacementExpression(node, replacement));
+            }
+            tracker.delete(file, declaration);
+          });
+          return { edits };
+        }
+      });
+    }
+  });
+
   // src/services/refactors/moveToNewFile.ts
   function doChange3(oldFile, program, toMove, changes, host, preferences, context) {
     const checker = program.getTypeChecker();
@@ -134939,29 +135114,29 @@ ${lanes.join("\n")}
     append(copiedOldImports, makeImportOrRequire(oldFile, oldFileDefault, oldFileNamedImports, getBaseFileName(oldFile.fileName), program, host, useEsModuleSyntax, quotePreference));
     return copiedOldImports;
   }
-  var refactorName4, description, moveToNewFileAction;
+  var refactorName5, description, moveToNewFileAction;
   var init_moveToNewFile = __esm({
     "src/services/refactors/moveToNewFile.ts"() {
       "use strict";
       init_ts4();
       init_ts_refactor();
-      refactorName4 = "Move to a new file";
+      refactorName5 = "Move to a new file";
       description = getLocaleSpecificMessage(Diagnostics.Move_to_a_new_file);
       moveToNewFileAction = {
-        name: refactorName4,
+        name: refactorName5,
         description,
         kind: "refactor.move.newFile"
       };
-      registerRefactor(refactorName4, {
+      registerRefactor(refactorName5, {
         kinds: [moveToNewFileAction.kind],
         getAvailableActions: function getRefactorActionsToMoveToNewFile(context) {
           const statements = getStatementsToMove(context);
           if (context.preferences.allowTextChangesInNewFiles && statements) {
-            return [{ name: refactorName4, description, actions: [moveToNewFileAction] }];
+            return [{ name: refactorName5, description, actions: [moveToNewFileAction] }];
           }
           if (context.preferences.provideRefactorNotApplicableReason) {
             return [{
-              name: refactorName4,
+              name: refactorName5,
               description,
               actions: [{ ...moveToNewFileAction, notApplicableReason: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_statement_or_statements) }]
             }];
@@ -134969,7 +135144,7 @@ ${lanes.join("\n")}
           return emptyArray;
         },
         getEditsForAction: function getRefactorEditsToMoveToNewFile(context, actionName2) {
-          Debug.assert(actionName2 === refactorName4, "Wrong refactor invoked");
+          Debug.assert(actionName2 === refactorName5, "Wrong refactor invoked");
           const statements = Debug.checkDefined(getStatementsToMove(context));
           const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange3(context.file, context.program, statements, t, context.host, context.preferences, context));
           return { edits, renameFilename: void 0, renameLocation: void 0 };
@@ -135887,8 +136062,8 @@ ${lanes.join("\n")}
     if (!info)
       return emptyArray;
     return [{
-      name: refactorName5,
-      description: refactorDescription,
+      name: refactorName6,
+      description: refactorDescription2,
       actions: [functionOverloadAction]
     }];
   }
@@ -136079,20 +136254,20 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     return signatureDecls;
   }
-  var refactorName5, refactorDescription, functionOverloadAction;
+  var refactorName6, refactorDescription2, functionOverloadAction;
   var init_convertOverloadListToSingleSignature = __esm({
     "src/services/refactors/convertOverloadListToSingleSignature.ts"() {
       "use strict";
       init_ts4();
       init_ts_refactor();
-      refactorName5 = "Convert overload list to single signature";
-      refactorDescription = getLocaleSpecificMessage(Diagnostics.Convert_overload_list_to_single_signature);
+      refactorName6 = "Convert overload list to single signature";
+      refactorDescription2 = getLocaleSpecificMessage(Diagnostics.Convert_overload_list_to_single_signature);
       functionOverloadAction = {
-        name: refactorName5,
-        description: refactorDescription,
+        name: refactorName6,
+        description: refactorDescription2,
         kind: "refactor.rewrite.function.overloadList"
       };
-      registerRefactor(refactorName5, {
+      registerRefactor(refactorName6, {
         kinds: [functionOverloadAction.kind],
         getEditsForAction: getRefactorEditsToConvertOverloadsToOneSignature,
         getAvailableActions: getRefactorActionsToConvertOverloadsToOneSignature
@@ -136108,8 +136283,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       return emptyArray;
     if (!isRefactorErrorInfo(info)) {
       return [{
-        name: refactorName6,
-        description: refactorDescription2,
+        name: refactorName7,
+        description: refactorDescription3,
         actions: [
           info.addBraces ? addBracesAction : removeBracesAction
         ]
@@ -136117,8 +136292,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     if (context.preferences.provideRefactorNotApplicableReason) {
       return [{
-        name: refactorName6,
-        description: refactorDescription2,
+        name: refactorName7,
+        description: refactorDescription3,
         actions: [
           { ...addBracesAction, notApplicableReason: info.error },
           { ...removeBracesAction, notApplicableReason: info.error }
@@ -136209,14 +136384,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     return void 0;
   }
-  var refactorName6, refactorDescription2, addBracesAction, removeBracesAction;
+  var refactorName7, refactorDescription3, addBracesAction, removeBracesAction;
   var init_addOrRemoveBracesToArrowFunction = __esm({
     "src/services/refactors/addOrRemoveBracesToArrowFunction.ts"() {
       "use strict";
       init_ts4();
       init_ts_refactor();
-      refactorName6 = "Add or remove braces in an arrow function";
-      refactorDescription2 = getLocaleSpecificMessage(Diagnostics.Add_or_remove_braces_in_an_arrow_function);
+      refactorName7 = "Add or remove braces in an arrow function";
+      refactorDescription3 = getLocaleSpecificMessage(Diagnostics.Add_or_remove_braces_in_an_arrow_function);
       addBracesAction = {
         name: "Add braces to arrow function",
         description: getLocaleSpecificMessage(Diagnostics.Add_braces_to_arrow_function),
@@ -136227,7 +136402,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         description: getLocaleSpecificMessage(Diagnostics.Remove_braces_from_arrow_function),
         kind: "refactor.rewrite.arrow.braces.remove"
       };
-      registerRefactor(refactorName6, {
+      registerRefactor(refactorName7, {
         kinds: [removeBracesAction.kind],
         getEditsForAction: getRefactorEditsToRemoveFunctionBraces,
         getAvailableActions: getRefactorActionsToRemoveFunctionBraces
@@ -136279,8 +136454,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
     }
     return [{
-      name: refactorName7,
-      description: refactorDescription3,
+      name: refactorName8,
+      description: refactorDescription4,
       actions: possibleActions.length === 0 && context.preferences.provideRefactorNotApplicableReason ? errors : possibleActions
     }];
   }
@@ -136440,14 +136615,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   function isFunctionReferencedInFile(sourceFile, typeChecker, node) {
     return !!node.name && ts_FindAllReferences_exports.Core.isSymbolReferencedInFile(node.name, typeChecker, sourceFile);
   }
-  var refactorName7, refactorDescription3, toAnonymousFunctionAction, toNamedFunctionAction, toArrowFunctionAction;
+  var refactorName8, refactorDescription4, toAnonymousFunctionAction, toNamedFunctionAction, toArrowFunctionAction;
   var init_convertArrowFunctionOrFunctionExpression = __esm({
     "src/services/refactors/convertArrowFunctionOrFunctionExpression.ts"() {
       "use strict";
       init_ts4();
       init_ts_refactor();
-      refactorName7 = "Convert arrow function or function expression";
-      refactorDescription3 = getLocaleSpecificMessage(Diagnostics.Convert_arrow_function_or_function_expression);
+      refactorName8 = "Convert arrow function or function expression";
+      refactorDescription4 = getLocaleSpecificMessage(Diagnostics.Convert_arrow_function_or_function_expression);
       toAnonymousFunctionAction = {
         name: "Convert to anonymous function",
         description: getLocaleSpecificMessage(Diagnostics.Convert_to_anonymous_function),
@@ -136463,7 +136638,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         description: getLocaleSpecificMessage(Diagnostics.Convert_to_arrow_function),
         kind: "refactor.rewrite.function.arrow"
       };
-      registerRefactor(refactorName7, {
+      registerRefactor(refactorName8, {
         kinds: [
           toAnonymousFunctionAction.kind,
           toNamedFunctionAction.kind,
@@ -136494,13 +136669,13 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     if (!functionDeclaration)
       return emptyArray;
     return [{
-      name: refactorName8,
-      description: refactorDescription4,
+      name: refactorName9,
+      description: refactorDescription5,
       actions: [toDestructuredAction]
     }];
   }
   function getRefactorEditsToConvertParametersToDestructuredObject(context, actionName2) {
-    Debug.assert(actionName2 === refactorName8, "Unexpected action name");
+    Debug.assert(actionName2 === refactorName9, "Unexpected action name");
     const { file, startPosition, program, cancellationToken, host } = context;
     const functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, program.getTypeChecker());
     if (!functionDeclaration || !cancellationToken)
@@ -137010,21 +137185,21 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return Debug.assertNever(functionDeclaration, `Unexpected function declaration kind ${functionDeclaration.kind}`);
     }
   }
-  var refactorName8, minimumParameterLength, refactorDescription4, toDestructuredAction;
+  var refactorName9, minimumParameterLength, refactorDescription5, toDestructuredAction;
   var init_convertParamsToDestructuredObject = __esm({
     "src/services/refactors/convertParamsToDestructuredObject.ts"() {
       "use strict";
       init_ts4();
       init_ts_refactor();
-      refactorName8 = "Convert parameters to destructured object";
+      refactorName9 = "Convert parameters to destructured object";
       minimumParameterLength = 1;
-      refactorDescription4 = getLocaleSpecificMessage(Diagnostics.Convert_parameters_to_destructured_object);
+      refactorDescription5 = getLocaleSpecificMessage(Diagnostics.Convert_parameters_to_destructured_object);
       toDestructuredAction = {
-        name: refactorName8,
-        description: refactorDescription4,
+        name: refactorName9,
+        description: refactorDescription5,
         kind: "refactor.rewrite.parameters.toDestructured"
       };
-      registerRefactor(refactorName8, {
+      registerRefactor(refactorName9, {
         kinds: [toDestructuredAction.kind],
         getEditsForAction: getRefactorEditsToConvertParametersToDestructuredObject,
         getAvailableActions: getRefactorActionsToConvertParametersToDestructuredObject
@@ -137046,7 +137221,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     const { file, startPosition } = context;
     const node = getNodeOrParentOfParentheses(file, startPosition);
     const maybeBinary = getParentBinaryExpression(node);
-    const refactorInfo = { name: refactorName9, description: refactorDescription5, actions: [] };
+    const refactorInfo = { name: refactorName10, description: refactorDescription6, actions: [] };
     if (isBinaryExpression(maybeBinary) && treeToArray(maybeBinary).isValidConcatenation) {
       refactorInfo.actions.push(convertStringAction);
       return [refactorInfo];
@@ -137072,7 +137247,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     const { file, startPosition } = context;
     const node = getNodeOrParentOfParentheses(file, startPosition);
     switch (actionName2) {
-      case refactorDescription5:
+      case refactorDescription6:
         return { edits: getEditsForToTemplateLiteral(context, node) };
       default:
         return Debug.fail("invalid action");
@@ -137223,20 +137398,20 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     return node;
   }
-  var refactorName9, refactorDescription5, convertStringAction, copyTrailingOperatorComments, copyCommentFromMultiNode;
+  var refactorName10, refactorDescription6, convertStringAction, copyTrailingOperatorComments, copyCommentFromMultiNode;
   var init_convertStringOrTemplateLiteral = __esm({
     "src/services/refactors/convertStringOrTemplateLiteral.ts"() {
       "use strict";
       init_ts4();
       init_ts_refactor();
-      refactorName9 = "Convert to template string";
-      refactorDescription5 = getLocaleSpecificMessage(Diagnostics.Convert_to_template_string);
+      refactorName10 = "Convert to template string";
+      refactorDescription6 = getLocaleSpecificMessage(Diagnostics.Convert_to_template_string);
       convertStringAction = {
-        name: refactorName9,
-        description: refactorDescription5,
+        name: refactorName10,
+        description: refactorDescription6,
         kind: "refactor.rewrite.string"
       };
-      registerRefactor(refactorName9, {
+      registerRefactor(refactorName10, {
         kinds: [convertStringAction.kind],
         getEditsForAction: getRefactorEditsToConvertToTemplateString,
         getAvailableActions: getRefactorActionsToConvertToTemplateString
@@ -137286,14 +137461,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       return emptyArray;
     if (!isRefactorErrorInfo(info)) {
       return [{
-        name: refactorName10,
+        name: refactorName11,
         description: convertToOptionalChainExpressionMessage,
         actions: [toOptionalChainAction]
       }];
     }
     if (context.preferences.provideRefactorNotApplicableReason) {
       return [{
-        name: refactorName10,
+        name: refactorName11,
         description: convertToOptionalChainExpressionMessage,
         actions: [{ ...toOptionalChainAction, notApplicableReason: info.error }]
       }];
@@ -137477,20 +137652,20 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
     }
   }
-  var refactorName10, convertToOptionalChainExpressionMessage, toOptionalChainAction;
+  var refactorName11, convertToOptionalChainExpressionMessage, toOptionalChainAction;
   var init_convertToOptionalChainExpression = __esm({
     "src/services/refactors/convertToOptionalChainExpression.ts"() {
       "use strict";
       init_ts4();
       init_ts_refactor();
-      refactorName10 = "Convert to optional chain expression";
+      refactorName11 = "Convert to optional chain expression";
       convertToOptionalChainExpressionMessage = getLocaleSpecificMessage(Diagnostics.Convert_to_optional_chain_expression);
       toOptionalChainAction = {
-        name: refactorName10,
+        name: refactorName11,
         description: convertToOptionalChainExpressionMessage,
         kind: "refactor.rewrite.expression.optionalChain"
       };
-      registerRefactor(refactorName10, {
+      registerRefactor(refactorName11, {
         kinds: [toOptionalChainAction.kind],
         getEditsForAction: getRefactorEditsToConvertToOptionalChain,
         getAvailableActions: getRefactorActionsToConvertToOptionalChain
@@ -137519,14 +137694,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       const errors = [];
       if (refactorKindBeginsWith(extractFunctionAction.kind, requestedRefactor)) {
         errors.push({
-          name: refactorName11,
+          name: refactorName12,
           description: extractFunctionAction.description,
           actions: [{ ...extractFunctionAction, notApplicableReason: getStringError(rangeToExtract.errors) }]
         });
       }
       if (refactorKindBeginsWith(extractConstantAction.kind, requestedRefactor)) {
         errors.push({
-          name: refactorName11,
+          name: refactorName12,
           description: extractConstantAction.description,
           actions: [{ ...extractConstantAction, notApplicableReason: getStringError(rangeToExtract.errors) }]
         });
@@ -137590,26 +137765,26 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     const infos = [];
     if (functionActions.length) {
       infos.push({
-        name: refactorName11,
+        name: refactorName12,
         description: getLocaleSpecificMessage(Diagnostics.Extract_function),
         actions: functionActions
       });
     } else if (context.preferences.provideRefactorNotApplicableReason && innermostErrorFunctionAction) {
       infos.push({
-        name: refactorName11,
+        name: refactorName12,
         description: getLocaleSpecificMessage(Diagnostics.Extract_function),
         actions: [innermostErrorFunctionAction]
       });
     }
     if (constantActions.length) {
       infos.push({
-        name: refactorName11,
+        name: refactorName12,
         description: getLocaleSpecificMessage(Diagnostics.Extract_constant),
         actions: constantActions
       });
     } else if (context.preferences.provideRefactorNotApplicableReason && innermostErrorConstantAction) {
       infos.push({
-        name: refactorName11,
+        name: refactorName12,
         description: getLocaleSpecificMessage(Diagnostics.Extract_constant),
         actions: [innermostErrorConstantAction]
       });
@@ -139040,13 +139215,13 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   function isStringLiteralJsxAttribute(node) {
     return isStringLiteral(node) && node.parent && isJsxAttribute(node.parent);
   }
-  var refactorName11, extractConstantAction, extractFunctionAction, Messages, RangeFacts;
+  var refactorName12, extractConstantAction, extractFunctionAction, Messages, RangeFacts;
   var init_extractSymbol = __esm({
     "src/services/refactors/extractSymbol.ts"() {
       "use strict";
       init_ts4();
       init_ts_refactor();
-      refactorName11 = "Extract Symbol";
+      refactorName12 = "Extract Symbol";
       extractConstantAction = {
         name: "Extract Constant",
         description: getLocaleSpecificMessage(Diagnostics.Extract_constant),
@@ -139057,7 +139232,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         description: getLocaleSpecificMessage(Diagnostics.Extract_function),
         kind: "refactor.extract.function"
       };
-      registerRefactor(refactorName11, {
+      registerRefactor(refactorName12, {
         kinds: [
           extractConstantAction.kind,
           extractFunctionAction.kind
@@ -139208,15 +139383,15 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       return emptyArray;
     if (!isRefactorErrorInfo(info)) {
       return [{
-        name: refactorName12,
-        description: refactorDescription6,
+        name: refactorName13,
+        description: refactorDescription7,
         actions: [inferReturnTypeAction]
       }];
     }
     if (context.preferences.provideRefactorNotApplicableReason) {
       return [{
-        name: refactorName12,
-        description: refactorDescription6,
+        name: refactorName13,
+        description: refactorDescription7,
         actions: [{ ...inferReturnTypeAction, notApplicableReason: info.error }]
       }];
     }
@@ -139275,20 +139450,20 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       return typeChecker.getReturnTypeOfSignature(signature);
     }
   }
-  var refactorName12, refactorDescription6, inferReturnTypeAction;
+  var refactorName13, refactorDescription7, inferReturnTypeAction;
   var init_inferFunctionReturnType = __esm({
     "src/services/refactors/inferFunctionReturnType.ts"() {
       "use strict";
       init_ts4();
       init_ts_refactor();
-      refactorName12 = "Infer function return type";
-      refactorDescription6 = getLocaleSpecificMessage(Diagnostics.Infer_function_return_type);
+      refactorName13 = "Infer function return type";
+      refactorDescription7 = getLocaleSpecificMessage(Diagnostics.Infer_function_return_type);
       inferReturnTypeAction = {
-        name: refactorName12,
-        description: refactorDescription6,
+        name: refactorName13,
+        description: refactorDescription7,
         kind: "refactor.rewrite.function.returnType"
       };
-      registerRefactor(refactorName12, {
+      registerRefactor(refactorName13, {
         kinds: [inferReturnTypeAction.kind],
         getEditsForAction: getRefactorEditsToInferReturnType,
         getAvailableActions: getRefactorActionsToInferReturnType
@@ -139349,6 +139524,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       init_convertImport();
       init_extractType();
       init_helpers();
+      init_inlineVariable();
       init_moveToNewFile();
       init_moveToFile();
       init_ts_refactor_addOrRemoveBracesToArrowFunction();
@@ -140887,10 +141063,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       const newFileName = createNewFileName(sourceFile, program, getRefactorContext(sourceFile, positionOrRange, preferences, emptyOptions), host);
       return { newFileName, files };
     }
-    function getEditsForRefactor2(fileName, formatOptions, positionOrRange, refactorName13, actionName2, preferences = emptyOptions, interactiveRefactorArguments) {
+    function getEditsForRefactor2(fileName, formatOptions, positionOrRange, refactorName14, actionName2, preferences = emptyOptions, interactiveRefactorArguments) {
       synchronizeHostData();
       const file = getValidSourceFile(fileName);
-      return ts_refactor_exports.getEditsForRefactor(getRefactorContext(file, positionOrRange, preferences, formatOptions), refactorName13, actionName2, interactiveRefactorArguments);
+      return ts_refactor_exports.getEditsForRefactor(getRefactorContext(file, positionOrRange, preferences, formatOptions), refactorName14, actionName2, interactiveRefactorArguments);
     }
     function toLineColumnOffset(fileName, position) {
       if (position === 0) {
@@ -158264,7 +158440,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       case 290 /* JsxAttribute */:
         if (!isRequireCallArgument(node) && !isImportCall(parent2)) {
           const argumentInfo = ts_SignatureHelp_exports.getArgumentInfoForCompletions(parent2.kind === 290 /* JsxAttribute */ ? parent2.parent : node, position, sourceFile);
-          return argumentInfo && getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) || fromContextualType();
+          return argumentInfo && (getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) || getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker, 0 /* Normal */)) || fromContextualType(0 /* None */);
         }
       case 271 /* ImportDeclaration */:
       case 277 /* ExportDeclaration */:
@@ -158333,12 +158509,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   function getAlreadyUsedTypesInStringLiteralUnion(union, current) {
     return mapDefined(union.types, (type) => type !== current && isLiteralTypeNode(type) && isStringLiteral(type.literal) ? type.literal.text : void 0);
   }
-  function getStringLiteralCompletionsFromSignature(call, arg, argumentInfo, checker) {
+  function getStringLiteralCompletionsFromSignature(call, arg, argumentInfo, checker, checkMode = 32 /* IsForStringLiteralArgumentCompletions */) {
     let isNewIdentifier = false;
     const uniques = /* @__PURE__ */ new Map();
     const candidates = [];
     const editingArgument = isJsxOpeningLikeElement(call) ? Debug.checkDefined(findAncestor(arg.parent, isJsxAttribute)) : arg;
-    checker.getResolvedSignatureForStringLiteralCompletions(call, editingArgument, candidates);
+    checker.getResolvedSignatureForStringLiteralCompletions(call, editingArgument, candidates, checkMode);
     const types = flatMap(candidates, (candidate) => {
       if (!signatureHasRestParameter(candidate) && argumentInfo.argumentCount > candidate.parameters.length)
         return;
@@ -161457,6 +161633,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     getTextSpanOfEntry: () => getTextSpanOfEntry,
     isContextWithStartAndEndNode: () => isContextWithStartAndEndNode,
     isDeclarationOfSymbol: () => isDeclarationOfSymbol,
+    isWriteAccessForReference: () => isWriteAccessForReference,
     nodeEntry: () => nodeEntry,
     toContextSpan: () => toContextSpan,
     toHighlightSpan: () => toHighlightSpan,
@@ -169663,9 +169840,9 @@ ${options.prefix}` : "\n" : options.prefix
       init_ts5();
       init_deprecate();
       addObjectAllocatorPatcher((objectAllocator2) => {
-        const Identifier74 = objectAllocator2.getIdentifierConstructor();
-        if (!hasProperty(Identifier74.prototype, "originalKeywordKind")) {
-          Object.defineProperty(Identifier74.prototype, "originalKeywordKind", {
+        const Identifier75 = objectAllocator2.getIdentifierConstructor();
+        if (!hasProperty(Identifier75.prototype, "originalKeywordKind")) {
+          Object.defineProperty(Identifier75.prototype, "originalKeywordKind", {
             get: deprecate(function() {
               return identifierToKeywordKind(this);
             }, {
@@ -169677,8 +169854,8 @@ ${options.prefix}` : "\n" : options.prefix
             })
           });
         }
-        if (!hasProperty(Identifier74.prototype, "isInJSDocNamespace")) {
-          Object.defineProperty(Identifier74.prototype, "isInJSDocNamespace", {
+        if (!hasProperty(Identifier75.prototype, "isInJSDocNamespace")) {
+          Object.defineProperty(Identifier75.prototype, "isInJSDocNamespace", {
             get: deprecate(function() {
               return this.flags & 2048 /* IdentifierIsInJSDocNamespace */ ? true : void 0;
             }, {