typescript 5.3.0-dev.20230822 → 5.3.0-dev.20230824

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.3";
-      version = `${versionMajorMinor}.0-dev.20230822`;
+      version = `${versionMajorMinor}.0-dev.20230824`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -13329,402 +13329,6 @@ ${lanes.join("\n")}
     const emitNode = node.emitNode;
     return emitNode && emitNode.internalFlags || 0;
   }
-  function getScriptTargetFeatures() {
-    return new Map(Object.entries({
-      Array: new Map(Object.entries({
-        es2015: [
-          "find",
-          "findIndex",
-          "fill",
-          "copyWithin",
-          "entries",
-          "keys",
-          "values"
-        ],
-        es2016: [
-          "includes"
-        ],
-        es2019: [
-          "flat",
-          "flatMap"
-        ],
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Iterator: new Map(Object.entries({
-        es2015: emptyArray
-      })),
-      AsyncIterator: new Map(Object.entries({
-        es2015: emptyArray
-      })),
-      Atomics: new Map(Object.entries({
-        es2017: emptyArray
-      })),
-      SharedArrayBuffer: new Map(Object.entries({
-        es2017: emptyArray
-      })),
-      AsyncIterable: new Map(Object.entries({
-        es2018: emptyArray
-      })),
-      AsyncIterableIterator: new Map(Object.entries({
-        es2018: emptyArray
-      })),
-      AsyncGenerator: new Map(Object.entries({
-        es2018: emptyArray
-      })),
-      AsyncGeneratorFunction: new Map(Object.entries({
-        es2018: emptyArray
-      })),
-      RegExp: new Map(Object.entries({
-        es2015: [
-          "flags",
-          "sticky",
-          "unicode"
-        ],
-        es2018: [
-          "dotAll"
-        ]
-      })),
-      Reflect: new Map(Object.entries({
-        es2015: [
-          "apply",
-          "construct",
-          "defineProperty",
-          "deleteProperty",
-          "get",
-          " getOwnPropertyDescriptor",
-          "getPrototypeOf",
-          "has",
-          "isExtensible",
-          "ownKeys",
-          "preventExtensions",
-          "set",
-          "setPrototypeOf"
-        ]
-      })),
-      ArrayConstructor: new Map(Object.entries({
-        es2015: [
-          "from",
-          "of"
-        ]
-      })),
-      ObjectConstructor: new Map(Object.entries({
-        es2015: [
-          "assign",
-          "getOwnPropertySymbols",
-          "keys",
-          "is",
-          "setPrototypeOf"
-        ],
-        es2017: [
-          "values",
-          "entries",
-          "getOwnPropertyDescriptors"
-        ],
-        es2019: [
-          "fromEntries"
-        ],
-        es2022: [
-          "hasOwn"
-        ]
-      })),
-      NumberConstructor: new Map(Object.entries({
-        es2015: [
-          "isFinite",
-          "isInteger",
-          "isNaN",
-          "isSafeInteger",
-          "parseFloat",
-          "parseInt"
-        ]
-      })),
-      Math: new Map(Object.entries({
-        es2015: [
-          "clz32",
-          "imul",
-          "sign",
-          "log10",
-          "log2",
-          "log1p",
-          "expm1",
-          "cosh",
-          "sinh",
-          "tanh",
-          "acosh",
-          "asinh",
-          "atanh",
-          "hypot",
-          "trunc",
-          "fround",
-          "cbrt"
-        ]
-      })),
-      Map: new Map(Object.entries({
-        es2015: [
-          "entries",
-          "keys",
-          "values"
-        ]
-      })),
-      Set: new Map(Object.entries({
-        es2015: [
-          "entries",
-          "keys",
-          "values"
-        ]
-      })),
-      PromiseConstructor: new Map(Object.entries({
-        es2015: [
-          "all",
-          "race",
-          "reject",
-          "resolve"
-        ],
-        es2020: [
-          "allSettled"
-        ],
-        es2021: [
-          "any"
-        ]
-      })),
-      Symbol: new Map(Object.entries({
-        es2015: [
-          "for",
-          "keyFor"
-        ],
-        es2019: [
-          "description"
-        ]
-      })),
-      WeakMap: new Map(Object.entries({
-        es2015: [
-          "entries",
-          "keys",
-          "values"
-        ]
-      })),
-      WeakSet: new Map(Object.entries({
-        es2015: [
-          "entries",
-          "keys",
-          "values"
-        ]
-      })),
-      String: new Map(Object.entries({
-        es2015: [
-          "codePointAt",
-          "includes",
-          "endsWith",
-          "normalize",
-          "repeat",
-          "startsWith",
-          "anchor",
-          "big",
-          "blink",
-          "bold",
-          "fixed",
-          "fontcolor",
-          "fontsize",
-          "italics",
-          "link",
-          "small",
-          "strike",
-          "sub",
-          "sup"
-        ],
-        es2017: [
-          "padStart",
-          "padEnd"
-        ],
-        es2019: [
-          "trimStart",
-          "trimEnd",
-          "trimLeft",
-          "trimRight"
-        ],
-        es2020: [
-          "matchAll"
-        ],
-        es2021: [
-          "replaceAll"
-        ],
-        es2022: [
-          "at"
-        ]
-      })),
-      StringConstructor: new Map(Object.entries({
-        es2015: [
-          "fromCodePoint",
-          "raw"
-        ]
-      })),
-      DateTimeFormat: new Map(Object.entries({
-        es2017: [
-          "formatToParts"
-        ]
-      })),
-      Promise: new Map(Object.entries({
-        es2015: emptyArray,
-        es2018: [
-          "finally"
-        ]
-      })),
-      RegExpMatchArray: new Map(Object.entries({
-        es2018: [
-          "groups"
-        ]
-      })),
-      RegExpExecArray: new Map(Object.entries({
-        es2018: [
-          "groups"
-        ]
-      })),
-      Intl: new Map(Object.entries({
-        es2018: [
-          "PluralRules"
-        ]
-      })),
-      NumberFormat: new Map(Object.entries({
-        es2018: [
-          "formatToParts"
-        ]
-      })),
-      SymbolConstructor: new Map(Object.entries({
-        es2020: [
-          "matchAll"
-        ]
-      })),
-      DataView: new Map(Object.entries({
-        es2020: [
-          "setBigInt64",
-          "setBigUint64",
-          "getBigInt64",
-          "getBigUint64"
-        ]
-      })),
-      BigInt: new Map(Object.entries({
-        es2020: emptyArray
-      })),
-      RelativeTimeFormat: new Map(Object.entries({
-        es2020: [
-          "format",
-          "formatToParts",
-          "resolvedOptions"
-        ]
-      })),
-      Int8Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Uint8Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Uint8ClampedArray: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Int16Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Uint16Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Int32Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Uint32Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Float32Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Float64Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      BigInt64Array: new Map(Object.entries({
-        es2020: emptyArray,
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      BigUint64Array: new Map(Object.entries({
-        es2020: emptyArray,
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Error: new Map(Object.entries({
-        es2022: [
-          "cause"
-        ]
-      }))
-    }));
-  }
   function getLiteralText(node, sourceFile, flags) {
     if (sourceFile && canUseOriginalText(node, flags)) {
       return getSourceTextOfNodeFromSourceFile(sourceFile, node);
@@ -19303,7 +18907,7 @@ ${lanes.join("\n")}
     }
     return Debug.fail();
   }
-  var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashLibReferenceRegEx, fullTripleSlashAMDReferencePathRegEx, fullTripleSlashAMDModuleRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, objectAllocator, objectAllocatorPatchers, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, supportedTSImplementationExtensions, extensionsNotSupportingExtensionlessResolution, ModuleSpecifierEnding, extensionsToRemove, emptyFileSystemEntries;
+  var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, getScriptTargetFeatures, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashLibReferenceRegEx, fullTripleSlashAMDReferencePathRegEx, fullTripleSlashAMDModuleRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, objectAllocator, objectAllocatorPatchers, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, supportedTSImplementationExtensions, extensionsNotSupportingExtensionlessResolution, ModuleSpecifierEnding, extensionsToRemove, emptyFileSystemEntries;
   var init_utilities = __esm({
     "src/compiler/utilities.ts"() {
       "use strict";
@@ -19313,6 +18917,402 @@ ${lanes.join("\n")}
       defaultMaximumTruncationLength = 160;
       noTruncationMaximumTruncationLength = 1e6;
       stringWriter = createSingleLineStringWriter();
+      getScriptTargetFeatures = /* @__PURE__ */ memoize(
+        () => new Map(Object.entries({
+          Array: new Map(Object.entries({
+            es2015: [
+              "find",
+              "findIndex",
+              "fill",
+              "copyWithin",
+              "entries",
+              "keys",
+              "values"
+            ],
+            es2016: [
+              "includes"
+            ],
+            es2019: [
+              "flat",
+              "flatMap"
+            ],
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Iterator: new Map(Object.entries({
+            es2015: emptyArray
+          })),
+          AsyncIterator: new Map(Object.entries({
+            es2015: emptyArray
+          })),
+          Atomics: new Map(Object.entries({
+            es2017: emptyArray
+          })),
+          SharedArrayBuffer: new Map(Object.entries({
+            es2017: emptyArray
+          })),
+          AsyncIterable: new Map(Object.entries({
+            es2018: emptyArray
+          })),
+          AsyncIterableIterator: new Map(Object.entries({
+            es2018: emptyArray
+          })),
+          AsyncGenerator: new Map(Object.entries({
+            es2018: emptyArray
+          })),
+          AsyncGeneratorFunction: new Map(Object.entries({
+            es2018: emptyArray
+          })),
+          RegExp: new Map(Object.entries({
+            es2015: [
+              "flags",
+              "sticky",
+              "unicode"
+            ],
+            es2018: [
+              "dotAll"
+            ]
+          })),
+          Reflect: new Map(Object.entries({
+            es2015: [
+              "apply",
+              "construct",
+              "defineProperty",
+              "deleteProperty",
+              "get",
+              "getOwnPropertyDescriptor",
+              "getPrototypeOf",
+              "has",
+              "isExtensible",
+              "ownKeys",
+              "preventExtensions",
+              "set",
+              "setPrototypeOf"
+            ]
+          })),
+          ArrayConstructor: new Map(Object.entries({
+            es2015: [
+              "from",
+              "of"
+            ]
+          })),
+          ObjectConstructor: new Map(Object.entries({
+            es2015: [
+              "assign",
+              "getOwnPropertySymbols",
+              "keys",
+              "is",
+              "setPrototypeOf"
+            ],
+            es2017: [
+              "values",
+              "entries",
+              "getOwnPropertyDescriptors"
+            ],
+            es2019: [
+              "fromEntries"
+            ],
+            es2022: [
+              "hasOwn"
+            ]
+          })),
+          NumberConstructor: new Map(Object.entries({
+            es2015: [
+              "isFinite",
+              "isInteger",
+              "isNaN",
+              "isSafeInteger",
+              "parseFloat",
+              "parseInt"
+            ]
+          })),
+          Math: new Map(Object.entries({
+            es2015: [
+              "clz32",
+              "imul",
+              "sign",
+              "log10",
+              "log2",
+              "log1p",
+              "expm1",
+              "cosh",
+              "sinh",
+              "tanh",
+              "acosh",
+              "asinh",
+              "atanh",
+              "hypot",
+              "trunc",
+              "fround",
+              "cbrt"
+            ]
+          })),
+          Map: new Map(Object.entries({
+            es2015: [
+              "entries",
+              "keys",
+              "values"
+            ]
+          })),
+          Set: new Map(Object.entries({
+            es2015: [
+              "entries",
+              "keys",
+              "values"
+            ]
+          })),
+          PromiseConstructor: new Map(Object.entries({
+            es2015: [
+              "all",
+              "race",
+              "reject",
+              "resolve"
+            ],
+            es2020: [
+              "allSettled"
+            ],
+            es2021: [
+              "any"
+            ]
+          })),
+          Symbol: new Map(Object.entries({
+            es2015: [
+              "for",
+              "keyFor"
+            ],
+            es2019: [
+              "description"
+            ]
+          })),
+          WeakMap: new Map(Object.entries({
+            es2015: [
+              "entries",
+              "keys",
+              "values"
+            ]
+          })),
+          WeakSet: new Map(Object.entries({
+            es2015: [
+              "entries",
+              "keys",
+              "values"
+            ]
+          })),
+          String: new Map(Object.entries({
+            es2015: [
+              "codePointAt",
+              "includes",
+              "endsWith",
+              "normalize",
+              "repeat",
+              "startsWith",
+              "anchor",
+              "big",
+              "blink",
+              "bold",
+              "fixed",
+              "fontcolor",
+              "fontsize",
+              "italics",
+              "link",
+              "small",
+              "strike",
+              "sub",
+              "sup"
+            ],
+            es2017: [
+              "padStart",
+              "padEnd"
+            ],
+            es2019: [
+              "trimStart",
+              "trimEnd",
+              "trimLeft",
+              "trimRight"
+            ],
+            es2020: [
+              "matchAll"
+            ],
+            es2021: [
+              "replaceAll"
+            ],
+            es2022: [
+              "at"
+            ]
+          })),
+          StringConstructor: new Map(Object.entries({
+            es2015: [
+              "fromCodePoint",
+              "raw"
+            ]
+          })),
+          DateTimeFormat: new Map(Object.entries({
+            es2017: [
+              "formatToParts"
+            ]
+          })),
+          Promise: new Map(Object.entries({
+            es2015: emptyArray,
+            es2018: [
+              "finally"
+            ]
+          })),
+          RegExpMatchArray: new Map(Object.entries({
+            es2018: [
+              "groups"
+            ]
+          })),
+          RegExpExecArray: new Map(Object.entries({
+            es2018: [
+              "groups"
+            ]
+          })),
+          Intl: new Map(Object.entries({
+            es2018: [
+              "PluralRules"
+            ]
+          })),
+          NumberFormat: new Map(Object.entries({
+            es2018: [
+              "formatToParts"
+            ]
+          })),
+          SymbolConstructor: new Map(Object.entries({
+            es2020: [
+              "matchAll"
+            ]
+          })),
+          DataView: new Map(Object.entries({
+            es2020: [
+              "setBigInt64",
+              "setBigUint64",
+              "getBigInt64",
+              "getBigUint64"
+            ]
+          })),
+          BigInt: new Map(Object.entries({
+            es2020: emptyArray
+          })),
+          RelativeTimeFormat: new Map(Object.entries({
+            es2020: [
+              "format",
+              "formatToParts",
+              "resolvedOptions"
+            ]
+          })),
+          Int8Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Uint8Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Uint8ClampedArray: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Int16Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Uint16Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Int32Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Uint32Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Float32Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Float64Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          BigInt64Array: new Map(Object.entries({
+            es2020: emptyArray,
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          BigUint64Array: new Map(Object.entries({
+            es2020: emptyArray,
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Error: new Map(Object.entries({
+            es2022: [
+              "cause"
+            ]
+          }))
+        }))
+      );
       GetLiteralTextFlags = /* @__PURE__ */ ((GetLiteralTextFlags2) => {
         GetLiteralTextFlags2[GetLiteralTextFlags2["None"] = 0] = "None";
         GetLiteralTextFlags2[GetLiteralTextFlags2["NeverAsciiEscape"] = 1] = "NeverAsciiEscape";
@@ -51099,11 +51099,17 @@ ${lanes.join("\n")}
         const constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
         return typeParameterToDeclarationWithConstraint(type, context, constraintNode);
       }
-      function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
-        let parameterDeclaration = getDeclarationOfKind(parameterSymbol, 169 /* Parameter */);
-        if (!parameterDeclaration && !isTransientSymbol(parameterSymbol)) {
-          parameterDeclaration = getDeclarationOfKind(parameterSymbol, 348 /* JSDocParameterTag */);
+      function getEffectiveParameterDeclaration(parameterSymbol) {
+        const parameterDeclaration = getDeclarationOfKind(parameterSymbol, 169 /* Parameter */);
+        if (parameterDeclaration) {
+          return parameterDeclaration;
         }
+        if (!isTransientSymbol(parameterSymbol)) {
+          return getDeclarationOfKind(parameterSymbol, 348 /* JSDocParameterTag */);
+        }
+      }
+      function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
+        const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
         let parameterType = getTypeOfSymbol(parameterSymbol);
         if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
           parameterType = getOptionalType(parameterType);
@@ -51112,7 +51118,7 @@ ${lanes.join("\n")}
         const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
         const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
         const dotDotDotToken = isRest ? factory.createToken(26 /* DotDotDotToken */) : void 0;
-        const name = parameterDeclaration ? parameterDeclaration.name ? parameterDeclaration.name.kind === 80 /* Identifier */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name), 16777216 /* NoAsciiEscaping */) : parameterDeclaration.name.kind === 166 /* QualifiedName */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name.right), 16777216 /* NoAsciiEscaping */) : cloneBindingName(parameterDeclaration.name) : symbolName(parameterSymbol) : symbolName(parameterSymbol);
+        const name = parameterToParameterDeclarationName(parameterSymbol, parameterDeclaration, context);
         const isOptional = parameterDeclaration && isOptionalParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 16384 /* OptionalParameter */;
         const questionToken = isOptional ? factory.createToken(58 /* QuestionToken */) : void 0;
         const parameterNode = factory.createParameterDeclaration(
@@ -51126,6 +51132,9 @@ ${lanes.join("\n")}
         );
         context.approximateLength += symbolName(parameterSymbol).length + 3;
         return parameterNode;
+      }
+      function parameterToParameterDeclarationName(parameterSymbol, parameterDeclaration, context) {
+        return parameterDeclaration ? parameterDeclaration.name ? parameterDeclaration.name.kind === 80 /* Identifier */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name), 16777216 /* NoAsciiEscaping */) : parameterDeclaration.name.kind === 166 /* QualifiedName */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name.right), 16777216 /* NoAsciiEscaping */) : cloneBindingName(parameterDeclaration.name) : symbolName(parameterSymbol) : symbolName(parameterSymbol);
         function cloneBindingName(node) {
           return elideInitializerAndSetEmitFlags(node);
           function elideInitializerAndSetEmitFlags(node2) {
@@ -53106,6 +53115,21 @@ ${lanes.join("\n")}
             if (p.flags & 98304 /* Accessor */ && useAccessors) {
               const result = [];
               if (p.flags & 65536 /* SetAccessor */) {
+                const setter = p.declarations && forEach(p.declarations, (d) => {
+                  if (d.kind === 178 /* SetAccessor */) {
+                    return d;
+                  }
+                  if (isCallExpression(d) && isBindableObjectDefinePropertyCall(d)) {
+                    return forEach(d.arguments[2].properties, (propDecl) => {
+                      const id = getNameOfDeclaration(propDecl);
+                      if (!!id && isIdentifier(id) && idText(id) === "set") {
+                        return propDecl;
+                      }
+                    });
+                  }
+                });
+                Debug.assert(setter && isFunctionLikeDeclaration(setter));
+                const paramSymbol = getSignatureFromDeclaration(setter).parameters[0];
                 result.push(setTextRange(
                   factory.createSetAccessorDeclaration(
                     factory.createModifiersFromModifierFlags(flag),
@@ -53115,7 +53139,7 @@ ${lanes.join("\n")}
                       void 0,
                       /*dotDotDotToken*/
                       void 0,
-                      "arg",
+                      paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value",
                       /*questionToken*/
                       void 0,
                       isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled)
@@ -66465,12 +66489,14 @@ ${lanes.join("\n")}
       }
       function inferFromSignatures(source, target, kind) {
         const sourceSignatures = getSignaturesOfType(source, kind);
-        const targetSignatures = getSignaturesOfType(target, kind);
         const sourceLen = sourceSignatures.length;
-        const targetLen = targetSignatures.length;
-        const len = sourceLen < targetLen ? sourceLen : targetLen;
-        for (let i = 0; i < len; i++) {
-          inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
+        if (sourceLen > 0) {
+          const targetSignatures = getSignaturesOfType(target, kind);
+          const targetLen = targetSignatures.length;
+          for (let i = 0; i < targetLen; i++) {
+            const sourceIndex = Math.max(sourceLen - targetLen + i, 0);
+            inferFromSignature(getBaseSignature(sourceSignatures[sourceIndex]), getErasedSignature(targetSignatures[i]));
+          }
         }
       }
       function inferFromSignature(source, target) {
@@ -68006,7 +68032,7 @@ ${lanes.join("\n")}
         return void 0;
       }
       function getDiscriminantPropertyAccess(expr, computedType) {
-        const type = declaredType.flags & 1048576 /* Union */ ? declaredType : computedType;
+        const type = !(computedType.flags & 1048576 /* Union */) && declaredType.flags & 1048576 /* Union */ ? declaredType : computedType;
         if (type.flags & 1048576 /* Union */) {
           const access = getCandidateDiscriminantPropertyAccess(expr);
           if (access) {
@@ -163988,11 +164014,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     function isSignatureSupportingReturnAnnotation(node) {
       return isArrowFunction(node) || isFunctionExpression(node) || isFunctionDeclaration(node) || isMethodDeclaration(node) || isGetAccessorDeclaration(node);
     }
-    function addParameterHints(text, parameter, position, isFirstVariadicArgument, sourceFile) {
+    function addParameterHints(text, parameter, position, isFirstVariadicArgument) {
       let hintText = `${isFirstVariadicArgument ? "..." : ""}${text}`;
       let displayParts;
       if (shouldUseInteractiveInlayHints(preferences)) {
-        displayParts = [getNodeDisplayPart(hintText, parameter, sourceFile), { text: ":" }];
+        displayParts = [getNodeDisplayPart(hintText, parameter), { text: ":" }];
         hintText = "";
       } else {
         hintText += ":";
@@ -164064,7 +164090,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       if (!signature || !candidates.length) {
         return;
       }
-      const sourceFile = shouldUseInteractiveInlayHints(preferences) ? expr.getSourceFile() : void 0;
       let signatureParamPos = 0;
       for (const originalArg of args) {
         const arg = skipParentheses(originalArg);
@@ -164099,7 +164124,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           if (leadingCommentsContainsParameterName(arg, name)) {
             continue;
           }
-          addParameterHints(name, parameter, originalArg.getStart(), isFirstVariadicArgument, sourceFile);
+          addParameterHints(name, parameter, originalArg.getStart(), isFirstVariadicArgument);
         }
       }
     }
@@ -164235,7 +164260,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       return true;
     }
-    function getNodeDisplayPart(text, node, sourceFile) {
+    function getNodeDisplayPart(text, node) {
+      const sourceFile = node.getSourceFile();
       return {
         text,
         span: createTextSpanFromNode(node, sourceFile),
@@ -167123,11 +167149,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     if (documentation.length === 0 && isIdentifier(location) && symbol.valueDeclaration && isBindingElement(symbol.valueDeclaration)) {
       const declaration = symbol.valueDeclaration;
       const parent2 = declaration.parent;
-      if (isIdentifier(declaration.name) && isObjectBindingPattern(parent2)) {
-        const name = getTextOfIdentifierOrLiteral(declaration.name);
+      const name = declaration.propertyName || declaration.name;
+      if (isIdentifier(name) && isObjectBindingPattern(parent2)) {
+        const propertyName = getTextOfIdentifierOrLiteral(name);
         const objectType = typeChecker.getTypeAtLocation(parent2);
         documentation = firstDefined(objectType.isUnion() ? objectType.types : [objectType], (t) => {
-          const prop = t.getProperty(name);
+          const prop = t.getProperty(propertyName);
           return prop ? prop.getDocumentationComment(typeChecker) : void 0;
         }) || emptyArray;
       }
@@ -180978,14 +181005,22 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
             return {
               ...hint,
               position: scriptInfo.positionToLineOffset(position),
-              displayParts: displayParts == null ? void 0 : displayParts.map(({ text, span, file: file2 }) => ({
-                text,
-                span: span && {
-                  start: scriptInfo.positionToLineOffset(span.start),
-                  end: scriptInfo.positionToLineOffset(span.start + span.length),
-                  file: file2
+              displayParts: displayParts == null ? void 0 : displayParts.map(({ text, span, file: file2 }) => {
+                if (span) {
+                  Debug.assertIsDefined(file2, "Target file should be defined together with its span.");
+                  const scriptInfo2 = this.projectService.getScriptInfo(file2);
+                  return {
+                    text,
+                    span: {
+                      start: scriptInfo2.positionToLineOffset(span.start),
+                      end: scriptInfo2.positionToLineOffset(span.start + span.length),
+                      file: file2
+                    }
+                  };
+                } else {
+                  return { text };
                 }
-              }))
+              })
             };
           });
         }