Update package-lock.json

* Plain JS binder errors

Issue select errors from the binder in JS files that do not have checkJS
explicitly turned on or off. These errors mirror runtime checks done by
Javascript.

* Rest of plain JS binder errors

* address PR comments

* Only issue binder errors in plain JS.

Checker errors require requesting diagnostics, which stll needs to be
peformance tested.

This commit removes one cross-file duplicate declaration error in the tests.

* fix const lint

package-lock.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript",
-    "version": "4.5.0",
+    "version": "4.6.0",
     "lockfileVersion": 1,
     "requires": true,
     "dependencies": {
@@ -676,9 +676,9 @@
             "dev": true
         },
         "@types/node": {
-            "version": "16.11.6",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.6.tgz",
-            "integrity": "sha512-ua7PgUoeQFjmWPcoo9khiPum3Pd60k4/2ZGXt18sm2Slk0W0xZTqt5Y0Ny1NyBiN1EVQ/+FaF9NcY4Qe6rwk5w==",
+            "version": "16.11.10",
+            "resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.10.tgz",
+            "integrity": "sha512-3aRnHa1KlOEEhJ6+CvyHKK5vE9BcLGjtUpwvqYLRvYNQKMfabu3BwfJaA/SLW8dxe28LsNDjtHwePTuzn3gmOA==",
             "dev": true
         },
         "@types/node-fetch": {
@@ -6997,9 +6997,9 @@
             }
         },
         "source-map-support": {
-            "version": "0.5.20",
-            "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.20.tgz",
-            "integrity": "sha512-n1lZZ8Ve4ksRqizaBQgxXDgKwttHDhyfQjA6YZZn8+AroHbsIz+JjwxQDxbp+7y5OYCI8t1Yk7etjD9CRd2hIw==",
+            "version": "0.5.21",
+            "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+            "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
             "dev": true,
             "requires": {
                 "buffer-from": "^1.0.0",
@@ -8423,9 +8423,9 @@
             },
             "dependencies": {
                 "camelcase": {
-                    "version": "6.2.0",
-                    "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz",
-                    "integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==",
+                    "version": "6.2.1",
+                    "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.1.tgz",
+                    "integrity": "sha512-tVI4q5jjFV5CavAU8DXfza/TJcZutVKo/5Foskmsqcm0MsL91moHvwiGNnqaa2o6PF/7yT5ikDRcVcl8Rj6LCA==",
                     "dev": true
                 },
                 "decamelize": {

package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.5.0",
+    "version": "4.6.0",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [

scripts/build/projects.js

@@ -39,7 +39,7 @@ const execTsc = (lkg, ...args) =>
     exec(process.execPath,
          [resolve(findUpRoot(), lkg ? "./lib/tsc" : "./built/local/tsc"),
           "-b", ...args],
-         { hidePrompt: true })
+         { hidePrompt: true });
 
 const projectBuilder = new ProjectQueue((projects, lkg, force) => execTsc(lkg, ...(force ? ["--force"] : []), ...projects));
 

scripts/open-cherry-pick-pr.ts

@@ -33,9 +33,9 @@ async function main() {
 
     const inputPR = (await gh.pulls.get({ pull_number: +process.env.SOURCE_ISSUE, owner: "microsoft", repo: "TypeScript" })).data;
     let remoteName = "origin";
-    if (inputPR.base.repo.git_url !== `git:github.com/microsoft/TypeScript`) {
+    if (inputPR.base.repo.git_url !== `git:github.com/microsoft/TypeScript` && inputPR.base.repo.git_url !== `git://github.com/microsoft/TypeScript`) {
         runSequence([
-            ["git", ["remote", "add", "nonlocal", inputPR.base.repo.git_url]]
+            ["git", ["remote", "add", "nonlocal", inputPR.base.repo.git_url.replace(/^git:(?:\/\/)?/, "https://")]]
         ]);
         remoteName = "nonlocal";
     }

src/compiler/checker.ts

@@ -1016,6 +1016,22 @@ namespace ts {
         const builtinGlobals = createSymbolTable();
         builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
 
+        // Extensions suggested for path imports when module resolution is node12 or higher.
+        // The first element of each tuple is the extension a file has.
+        // The second element of each tuple is the extension that should be used in a path import.
+        // e.g. if we want to import file `foo.mts`, we should write `import {} from "./foo.mjs".
+        const suggestedExtensions: [string, string][] = [
+            [".mts", ".mjs"],
+            [".ts", ".js"],
+            [".cts", ".cjs"],
+            [".mjs", ".mjs"],
+            [".js", ".js"],
+            [".cjs", ".cjs"],
+            [".tsx", compilerOptions.jsx === JsxEmit.Preserve ? ".jsx" : ".js"],
+            [".jsx", ".jsx"],
+            [".json", ".json"],
+        ];
+
         initializeTypeChecker();
 
         return checker;
@@ -3443,7 +3459,7 @@ namespace ts {
                     (isModuleDeclaration(location) ? location : location.parent && isModuleDeclaration(location.parent) && location.parent.name === location ? location.parent : undefined)?.name ||
                     (isLiteralImportTypeNode(location) ? location : undefined)?.argument.literal;
             const mode = contextSpecifier && isStringLiteralLike(contextSpecifier) ? getModeForUsageLocation(currentSourceFile, contextSpecifier) : currentSourceFile.impliedNodeFormat;
-            const resolvedModule = getResolvedModule(currentSourceFile, moduleReference, mode)!; // TODO: GH#18217
+            const resolvedModule = getResolvedModule(currentSourceFile, moduleReference, mode);
             const resolutionDiagnostic = resolvedModule && getResolutionDiagnostic(compilerOptions, resolvedModule);
             const sourceFile = resolvedModule && !resolutionDiagnostic && host.getSourceFile(resolvedModule.resolvedFileName);
             if (sourceFile) {
@@ -3489,10 +3505,10 @@ namespace ts {
             if (resolvedModule && !resolutionExtensionIsTSOrJson(resolvedModule.extension) && resolutionDiagnostic === undefined || resolutionDiagnostic === Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type) {
                 if (isForAugmentation) {
                     const diag = Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented;
-                    error(errorNode, diag, moduleReference, resolvedModule.resolvedFileName);
+                    error(errorNode, diag, moduleReference, resolvedModule!.resolvedFileName);
                 }
                 else {
-                    errorOnImplicitAnyModule(/*isError*/ noImplicitAny && !!moduleNotFoundError, errorNode, resolvedModule, moduleReference);
+                    errorOnImplicitAnyModule(/*isError*/ noImplicitAny && !!moduleNotFoundError, errorNode, resolvedModule!, moduleReference);
                 }
                 // Failed imports and untyped modules are both treated in an untyped manner; only difference is whether we give a diagnostic first.
                 return undefined;
@@ -3513,6 +3529,10 @@ namespace ts {
                 }
                 else {
                     const tsExtension = tryExtractTSExtension(moduleReference);
+                    const isExtensionlessRelativePathImport = pathIsRelative(moduleReference) && !hasExtension(moduleReference);
+                    const moduleResolutionKind = getEmitModuleResolutionKind(compilerOptions);
+                    const resolutionIsNode12OrNext = moduleResolutionKind === ModuleResolutionKind.Node12 ||
+                        moduleResolutionKind === ModuleResolutionKind.NodeNext;
                     if (tsExtension) {
                         const diag = Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead;
                         const importSourceWithoutExtension = removeExtension(moduleReference, tsExtension);
@@ -3532,6 +3552,18 @@ namespace ts {
                         hasJsonModuleEmitEnabled(compilerOptions)) {
                         error(errorNode, Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference);
                     }
+                    else if (mode === ModuleKind.ESNext && resolutionIsNode12OrNext && isExtensionlessRelativePathImport) {
+                        const absoluteRef = getNormalizedAbsolutePath(moduleReference, getDirectoryPath(currentSourceFile.path));
+                        const suggestedExt = suggestedExtensions.find(([actualExt, _importExt]) => host.fileExists(absoluteRef + actualExt))?.[1];
+                        if (suggestedExt) {
+                            error(errorNode,
+                                Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Did_you_mean_0,
+                                moduleReference + suggestedExt);
+                        }
+                        else {
+                            error(errorNode, Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Consider_adding_an_extension_to_the_import_path);
+                        }
+                    }
                     else {
                         error(errorNode, moduleNotFoundError, moduleReference);
                     }
@@ -5625,8 +5657,8 @@ namespace ts {
                 const expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
                 // If the expanded parameter list had a variadic in a non-trailing position, don't expand it
                 const parameters = (some(expandedParams, p => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & CheckFlags.RestParameter)) ? signature.parameters : expandedParams).map(parameter => symbolToParameterDeclaration(parameter, context, kind === SyntaxKind.Constructor, options?.privateSymbolVisitor, options?.bundledImports));
-                if (signature.thisParameter) {
-                    const thisParameter = symbolToParameterDeclaration(signature.thisParameter, context);
+                const thisParameter = tryGetThisParameterDeclaration(signature, context);
+                if (thisParameter) {
                     parameters.unshift(thisParameter);
                 }
 
@@ -5681,6 +5713,25 @@ namespace ts {
                 return node;
             }
 
+            function tryGetThisParameterDeclaration(signature: Signature, context: NodeBuilderContext) {
+                if (signature.thisParameter) {
+                    return symbolToParameterDeclaration(signature.thisParameter, context);
+                }
+                if (signature.declaration) {
+                    const thisTag = getJSDocThisTag(signature.declaration);
+                    if (thisTag && thisTag.typeExpression) {
+                        return factory.createParameterDeclaration(
+                            /* decorators */ undefined,
+                            /* modifiers */ undefined,
+                            /* dotDotDotToken */ undefined,
+                            "this",
+                            /* questionToken */ undefined,
+                            typeToTypeNodeHelper(getTypeFromTypeNode(thisTag.typeExpression), context)
+                        );
+                    }
+                }
+            }
+
             function typeParameterToDeclarationWithConstraint(type: TypeParameter, context: NodeBuilderContext, constraintNode: TypeNode | undefined): TypeParameterDeclaration {
                 const savedContextFlags = context.flags;
                 context.flags &= ~NodeBuilderFlags.WriteTypeParametersInQualifiedName; // Avoids potential infinite loop when building for a claimspace with a generic
@@ -6172,12 +6223,8 @@ namespace ts {
                             firstChar = symbolName.charCodeAt(0);
                         }
                         let expression: Expression | undefined;
-                        if (isSingleOrDoubleQuote(firstChar)) {
-                            expression = factory.createStringLiteral(
-                                symbolName
-                                    .substring(1, symbolName.length - 1)
-                                    .replace(/\\./g, s => s.substring(1)),
-                                firstChar === CharacterCodes.singleQuote);
+                        if (isSingleOrDoubleQuote(firstChar) && !(symbol.flags & SymbolFlags.EnumMember)) {
+                           expression = factory.createStringLiteral(stripQuotes(symbolName).replace(/\\./g, s => s.substring(1)), firstChar === CharacterCodes.singleQuote);
                         }
                         else if (("" + +symbolName) === symbolName) {
                             expression = factory.createNumericLiteral(+symbolName);
@@ -8512,12 +8559,16 @@ namespace ts {
 
         /** Return the inferred type for a binding element */
         function getTypeForBindingElement(declaration: BindingElement): Type | undefined {
-            const pattern = declaration.parent;
-            let parentType = getTypeForBindingElementParent(pattern.parent);
-            // If no type or an any type was inferred for parent, infer that for the binding element
-            if (!parentType || isTypeAny(parentType)) {
+            const parentType = getTypeForBindingElementParent(declaration.parent.parent);
+            return parentType && getBindingElementTypeFromParentType(declaration, parentType);
+        }
+
+        function getBindingElementTypeFromParentType(declaration: BindingElement, parentType: Type): Type {
+            // If an any type was inferred for parent, infer that for the binding element
+            if (isTypeAny(parentType)) {
                 return parentType;
             }
+            const pattern = declaration.parent;
             // Relax null check on ambient destructuring parameters, since the parameters have no implementation and are just documentation
             if (strictNullChecks && declaration.flags & NodeFlags.Ambient && isParameterDeclaration(declaration)) {
                 parentType = getNonNullableType(parentType);
@@ -14121,6 +14172,7 @@ namespace ts {
             // We ignore 'never' types in unions
             if (!(flags & TypeFlags.Never)) {
                 includes |= flags & TypeFlags.IncludesMask;
+                if (flags & TypeFlags.Instantiable) includes |= TypeFlags.IncludesInstantiable;
                 if (type === wildcardType) includes |= TypeFlags.IncludesWildcard;
                 if (!strictNullChecks && flags & TypeFlags.Nullable) {
                     if (!(getObjectFlags(type) & ObjectFlags.ContainsWideningType)) includes |= TypeFlags.IncludesNonWideningType;
@@ -15976,7 +16028,7 @@ namespace ts {
                         const declarations = concatenate(leftProp.declarations, rightProp.declarations);
                         const flags = SymbolFlags.Property | (leftProp.flags & SymbolFlags.Optional);
                         const result = createSymbol(flags, leftProp.escapedName);
-                        result.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)]);
+                        result.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)], UnionReduction.Subtype);
                         result.leftSpread = leftProp;
                         result.rightSpread = rightProp;
                         result.declarations = declarations;
@@ -16572,7 +16624,8 @@ namespace ts {
                         if (t.flags & (TypeFlags.AnyOrUnknown | TypeFlags.InstantiableNonPrimitive | TypeFlags.Object | TypeFlags.Intersection) && t !== wildcardType && !isErrorType(t)) {
                             if (!type.declaration.nameType) {
                                 let constraint;
-                                if (isArrayType(t) || (t.flags & TypeFlags.Any) && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, or(isArrayType, isTupleType))) {
+                                if (isArrayType(t) || t.flags & TypeFlags.Any && findResolutionCycleStartIndex(typeVariable, TypeSystemPropertyName.ImmediateBaseConstraint) < 0 &&
+                                    (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, or(isArrayType, isTupleType))) {
                                     return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
                                 }
                                 if (isGenericTupleType(t)) {
@@ -17770,7 +17823,7 @@ namespace ts {
                 if (source.flags & TypeFlags.Singleton) return true;
             }
             if (source.flags & TypeFlags.Object && target.flags & TypeFlags.Object) {
-                const related = relation.get(getRelationKey(source, target, IntersectionState.None, relation));
+                const related = relation.get(getRelationKey(source, target, IntersectionState.None, relation, /*ignoreConstraints*/ false));
                 if (related !== undefined) {
                     return !!(related & RelationComparisonResult.Succeeded);
                 }
@@ -18670,7 +18723,8 @@ namespace ts {
                 if (overflow) {
                     return Ternary.False;
                 }
-                const id = getRelationKey(source, target, intersectionState | (inPropertyCheck ? IntersectionState.InPropertyCheck : 0), relation);
+                const keyIntersectionState = intersectionState | (inPropertyCheck ? IntersectionState.InPropertyCheck : 0);
+                const id = getRelationKey(source, target, keyIntersectionState, relation, /*ingnoreConstraints*/ false);
                 const entry = relation.get(id);
                 if (entry !== undefined) {
                     if (reportErrors && entry & RelationComparisonResult.Failed && !(entry & RelationComparisonResult.Reported)) {
@@ -18697,16 +18751,13 @@ namespace ts {
                     targetStack = [];
                 }
                 else {
-                    // generate a key where all type parameter id positions are replaced with unconstrained type parameter ids
-                    // this isn't perfect - nested type references passed as type arguments will muck up the indexes and thus
-                    // prevent finding matches- but it should hit up the common cases
-                    const broadestEquivalentId = id.split(",").map(i => i.replace(/-\d+/g, (_match, offset: number) => {
-                        const index = length(id.slice(0, offset).match(/[-=]/g) || undefined);
-                        return `=${index}`;
-                    })).join(",");
+                    // A key that starts with "*" is an indication that we have type references that reference constrained
+                    // type parameters. For such keys we also check against the key we would have gotten if all type parameters
+                    // were unconstrained.
+                    const broadestEquivalentId = id.startsWith("*") ? getRelationKey(source, target, keyIntersectionState, relation, /*ignoreConstraints*/ true) : undefined;
                     for (let i = 0; i < maybeCount; i++) {
                         // If source and target are already being compared, consider them related with assumptions
-                        if (id === maybeKeys[i] || broadestEquivalentId === maybeKeys[i]) {
+                        if (id === maybeKeys[i] || broadestEquivalentId && broadestEquivalentId === maybeKeys[i]) {
                             return Ternary.Maybe;
                         }
                     }
@@ -19013,7 +19064,7 @@ namespace ts {
                         originalErrorInfo = undefined;
                     }
                 }
-                else if (isGenericMappedType(target)) {
+                else if (isGenericMappedType(target) && relation !== identityRelation) {
                     // Check if source type `S` is related to target type `{ [P in Q]: T }` or `{ [P in Q as R]: T}`.
                     const keysRemapped = !!target.declaration.nameType;
                     const templateType = getTemplateTypeFromMappedType(target);
@@ -20261,47 +20312,55 @@ namespace ts {
             return isNonDeferredTypeReference(type) && some(getTypeArguments(type), t => !!(t.flags & TypeFlags.TypeParameter) || isTypeReferenceWithGenericArguments(t));
         }
 
-        /**
-         * getTypeReferenceId(A<T, number, U>) returns "111=0-12=1"
-         *   where A.id=111 and number.id=12
-         */
-        function getTypeReferenceId(type: TypeReference, typeParameters: Type[], depth = 0) {
-            let result = "" + type.target.id;
-            for (const t of getTypeArguments(type)) {
-                if (isUnconstrainedTypeParameter(t)) {
-                    let index = typeParameters.indexOf(t);
-                    if (index < 0) {
-                        index = typeParameters.length;
-                        typeParameters.push(t);
+        function getGenericTypeReferenceRelationKey(source: TypeReference, target: TypeReference, postFix: string, ignoreConstraints: boolean) {
+            const typeParameters: Type[] = [];
+            let constraintMarker = "";
+            const sourceId = getTypeReferenceId(source, 0);
+            const targetId = getTypeReferenceId(target, 0);
+            return `${constraintMarker}${sourceId},${targetId}${postFix}`;
+            // getTypeReferenceId(A<T, number, U>) returns "111=0-12=1"
+            // where A.id=111 and number.id=12
+            function getTypeReferenceId(type: TypeReference, depth = 0) {
+                let result = "" + type.target.id;
+                for (const t of getTypeArguments(type)) {
+                    if (t.flags & TypeFlags.TypeParameter) {
+                        if (ignoreConstraints || isUnconstrainedTypeParameter(t)) {
+                            let index = typeParameters.indexOf(t);
+                            if (index < 0) {
+                                index = typeParameters.length;
+                                typeParameters.push(t);
+                            }
+                            result += "=" + index;
+                            continue;
+                        }
+                        // We mark type references that reference constrained type parameters such that we know to obtain
+                        // and look for a "broadest equivalent key" in the cache.
+                        constraintMarker = "*";
+                    }
+                    else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
+                        result += "<" + getTypeReferenceId(t as TypeReference, depth + 1) + ">";
+                        continue;
                     }
-                    result += "=" + index;
-                }
-                else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
-                    result += "<" + getTypeReferenceId(t as TypeReference, typeParameters, depth + 1) + ">";
-                }
-                else {
                     result += "-" + t.id;
                 }
+                return result;
             }
-            return result;
         }
 
         /**
          * To improve caching, the relation key for two generic types uses the target's id plus ids of the type parameters.
          * For other cases, the types ids are used.
          */
-        function getRelationKey(source: Type, target: Type, intersectionState: IntersectionState, relation: ESMap<string, RelationComparisonResult>) {
+        function getRelationKey(source: Type, target: Type, intersectionState: IntersectionState, relation: ESMap<string, RelationComparisonResult>, ignoreConstraints: boolean) {
             if (relation === identityRelation && source.id > target.id) {
                 const temp = source;
                 source = target;
                 target = temp;
             }
             const postFix = intersectionState ? ":" + intersectionState : "";
-            if (isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target)) {
-                const typeParameters: Type[] = [];
-                return getTypeReferenceId(source as TypeReference, typeParameters) + "," + getTypeReferenceId(target as TypeReference, typeParameters) + postFix;
-            }
-            return source.id + "," + target.id + postFix;
+            return isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target) ?
+                getGenericTypeReferenceRelationKey(source as TypeReference, target as TypeReference, postFix, ignoreConstraints) :
+                `${source.id},${target.id}${postFix}`;
         }
 
         // Invoke the callback for each underlying property symbol of the given symbol and return the first
@@ -20355,27 +20414,34 @@ namespace ts {
         }
 
         // Return true if the given type is deeply nested. We consider this to be the case when structural type comparisons
-        // for 5 or more occurrences or instantiations of the type have been recorded on the given stack. It is possible,
+        // for maxDepth or more occurrences or instantiations of the type have been recorded on the given stack. It is possible,
         // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely
-        // expanding. Effectively, we will generate a false positive when two types are structurally equal to at least 5
+        // expanding. Effectively, we will generate a false positive when two types are structurally equal to at least maxDepth
         // levels, but unequal at some level beyond that.
-        // In addition, this will also detect when an indexed access has been chained off of 5 or more times (which is essentially
-        // the dual of the structural comparison), and likewise mark the type as deeply nested, potentially adding false positives
-        // for finite but deeply expanding indexed accesses (eg, for `Q[P1][P2][P3][P4][P5]`).
-        // It also detects when a recursive type reference has expanded 5 or more times, eg, if the true branch of
+        // In addition, this will also detect when an indexed access has been chained off of maxDepth more times (which is
+        // essentially the dual of the structural comparison), and likewise mark the type as deeply nested, potentially adding
+        // false positives for finite but deeply expanding indexed accesses (eg, for `Q[P1][P2][P3][P4][P5]`).
+        // It also detects when a recursive type reference has expanded maxDepth or more times, e.g. if the true branch of
         // `type A<T> = null extends T ? [A<NonNullable<T>>] : [T]`
-        // has expanded into `[A<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>>>>>>]`
-        // in such cases we need to terminate the expansion, and we do so here.
-        function isDeeplyNestedType(type: Type, stack: Type[], depth: number, maxDepth = 5): boolean {
+        // has expanded into `[A<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>>>>>>]`. In such cases we need
+        // to terminate the expansion, and we do so here.
+        function isDeeplyNestedType(type: Type, stack: Type[], depth: number, maxDepth = 3): boolean {
             if (depth >= maxDepth) {
                 const identity = getRecursionIdentity(type);
                 let count = 0;
+                let lastTypeId = 0;
                 for (let i = 0; i < depth; i++) {
-                    if (getRecursionIdentity(stack[i]) === identity) {
-                        count++;
-                        if (count >= maxDepth) {
-                            return true;
+                    const t = stack[i];
+                    if (getRecursionIdentity(t) === identity) {
+                        // We only count occurrences with a higher type id than the previous occurrence, since higher
+                        // type ids are an indicator of newer instantiations caused by recursion.
+                        if (t.id >= lastTypeId) {
+                            count++;
+                            if (count >= maxDepth) {
+                                return true;
+                            }
                         }
+                        lastTypeId = t.id;
                     }
                 }
             }
@@ -21170,9 +21236,10 @@ namespace ts {
                         (isCallSignatureDeclaration(param.parent) || isMethodSignature(param.parent) || isFunctionTypeNode(param.parent)) &&
                         param.parent.parameters.indexOf(param) > -1 &&
                         (resolveName(param, param.name.escapedText, SymbolFlags.Type, undefined, param.name.escapedText, /*isUse*/ true) ||
-                         param.name.originalKeywordKind && isTypeNodeKind(param.name.originalKeywordKind))) {
+                        param.name.originalKeywordKind && isTypeNodeKind(param.name.originalKeywordKind))) {
                         const newName = "arg" + param.parent.parameters.indexOf(param);
-                        errorOrSuggestion(noImplicitAny, declaration, Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, declarationNameToString(param.name));
+                        const typeName = declarationNameToString(param.name) + (param.dotDotDotToken ? "[]" : "");
+                        errorOrSuggestion(noImplicitAny, declaration, Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, typeName);
                         return;
                     }
                     diagnostic = (declaration as ParameterDeclaration).dotDotDotToken ?
@@ -22586,30 +22653,6 @@ namespace ts {
             return false;
         }
 
-        function getPropertyAccess(expr: Expression) {
-            if (isAccessExpression(expr)) {
-                return expr;
-            }
-            if (isIdentifier(expr)) {
-                const symbol = getResolvedSymbol(expr);
-                if (isConstVariable(symbol)) {
-                    const declaration = symbol.valueDeclaration!;
-                    // Given 'const x = obj.kind', allow 'x' as an alias for 'obj.kind'
-                    if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer)) {
-                        return declaration.initializer;
-                    }
-                    // Given 'const { kind: x } = obj', allow 'x' as an alias for 'obj.kind'
-                    if (isBindingElement(declaration) && !declaration.initializer) {
-                        const parent = declaration.parent.parent;
-                        if (isVariableDeclaration(parent) && !parent.type && parent.initializer && (isIdentifier(parent.initializer) || isAccessExpression(parent.initializer))) {
-                            return declaration;
-                        }
-                    }
-                }
-            }
-            return undefined;
-        }
-
         function getAccessedPropertyName(access: AccessExpression | BindingElement): __String | undefined {
             let propertyName;
             return access.kind === SyntaxKind.PropertyAccessExpression ? access.name.escapedText :
@@ -23579,19 +23622,19 @@ namespace ts {
             return false;
         }
 
-        function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node) {
+        function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node, flowNode = reference.flowNode) {
             let key: string | undefined;
             let isKeySet = false;
             let flowDepth = 0;
             if (flowAnalysisDisabled) {
                 return errorType;
             }
-            if (!reference.flowNode) {
+            if (!flowNode) {
                 return declaredType;
             }
             flowInvocationCount++;
             const sharedFlowStart = sharedFlowCount;
-            const evolvedType = getTypeFromFlowType(getTypeAtFlowNode(reference.flowNode));
+            const evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode));
             sharedFlowCount = sharedFlowStart;
             // When the reference is 'x' in an 'x.length', 'x.push(value)', 'x.unshift(value)' or x[n] = value' operation,
             // we give type 'any[]' to 'x' instead of using the type determined by control flow analysis such that operations
@@ -24035,13 +24078,58 @@ namespace ts {
                 return result;
             }
 
+            function getCandidateDiscriminantPropertyAccess(expr: Expression) {
+                if (isBindingPattern(reference)) {
+                    // When the reference is a binding pattern, we are narrowing a pesudo-reference in getNarrowedTypeOfSymbol.
+                    // An identifier for a destructuring variable declared in the same binding pattern is a candidate.
+                    if (isIdentifier(expr)) {
+                        const symbol = getResolvedSymbol(expr);
+                        const declaration = symbol.valueDeclaration;
+                        if (declaration && isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && reference === declaration.parent) {
+                            return declaration;
+                        }
+                    }
+                }
+                else if (isAccessExpression(expr)) {
+                    // An access expression is a candidate if the reference matches the left hand expression.
+                    if (isMatchingReference(reference, expr.expression)) {
+                        return expr;
+                    }
+                }
+                else if (isIdentifier(expr)) {
+                    const symbol = getResolvedSymbol(expr);
+                    if (isConstVariable(symbol)) {
+                        const declaration = symbol.valueDeclaration!;
+                        // Given 'const x = obj.kind', allow 'x' as an alias for 'obj.kind'
+                        if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer) &&
+                            isMatchingReference(reference, declaration.initializer.expression)) {
+                            return declaration.initializer;
+                        }
+                        // Given 'const { kind: x } = obj', allow 'x' as an alias for 'obj.kind'
+                        if (isBindingElement(declaration) && !declaration.initializer) {
+                            const parent = declaration.parent.parent;
+                            if (isVariableDeclaration(parent) && !parent.type && parent.initializer && (isIdentifier(parent.initializer) || isAccessExpression(parent.initializer)) &&
+                                isMatchingReference(reference, parent.initializer)) {
+                                return declaration;
+                            }
+                        }
+                    }
+                }
+                return undefined;
+            }
+
             function getDiscriminantPropertyAccess(expr: Expression, computedType: Type) {
-                let access, name;
                 const type = declaredType.flags & TypeFlags.Union ? declaredType : computedType;
-                return type.flags & TypeFlags.Union && (access = getPropertyAccess(expr)) && (name = getAccessedPropertyName(access)) &&
-                    isMatchingReference(reference, isAccessExpression(access) ? access.expression : access.parent.parent.initializer!) &&
-                    isDiscriminantProperty(type, name) ?
-                    access : undefined;
+                if (type.flags & TypeFlags.Union) {
+                    const access = getCandidateDiscriminantPropertyAccess(expr);
+                    if (access) {
+                        const name = getAccessedPropertyName(access);
+                        if (name && isDiscriminantProperty(type, name)) {
+                            return access;
+                        }
+                    }
+                }
+                return undefined;
             }
 
             function narrowTypeByDiscriminant(type: Type, access: AccessExpression | BindingElement, narrowType: (t: Type) => Type): Type {
@@ -24854,6 +24942,50 @@ namespace ts {
             }
         }
 
+        function getNarrowedTypeOfSymbol(symbol: Symbol, location: Identifier) {
+            // If we have a non-rest binding element with no initializer declared as a const variable or a const-like
+            // parameter (a parameter for which there are no assignments in the function body), and if the parent type
+            // for the destructuring is a union type, one or more of the binding elements may represent discriminant
+            // properties, and we want the effects of conditional checks on such discriminants to affect the types of
+            // other binding elements from the same destructuring. Consider:
+            //
+            //   type Action =
+            //       | { kind: 'A', payload: number }
+            //       | { kind: 'B', payload: string };
+            //
+            //   function f1({ kind, payload }: Action) {
+            //       if (kind === 'A') {
+            //           payload.toFixed();
+            //       }
+            //       if (kind === 'B') {
+            //           payload.toUpperCase();
+            //       }
+            //   }
+            //
+            // Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use
+            // the binding pattern AST instance for '{ kind, payload }' as a pseudo-reference and narrow this reference
+            // as if it occurred in the specified location. We then recompute the narrowed binding element type by
+            // destructuring from the narrowed parent type.
+            const declaration = symbol.valueDeclaration;
+            if (declaration && isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
+                const parent = declaration.parent.parent;
+                if (parent.kind === SyntaxKind.VariableDeclaration && getCombinedNodeFlags(declaration) & NodeFlags.Const || parent.kind === SyntaxKind.Parameter) {
+                    const links = getNodeLinks(location);
+                    if (!(links.flags & NodeCheckFlags.InCheckIdentifier)) {
+                        links.flags |= NodeCheckFlags.InCheckIdentifier;
+                        const parentType = getTypeForBindingElementParent(parent);
+                        links.flags &= ~NodeCheckFlags.InCheckIdentifier;
+                        if (parentType && parentType.flags & TypeFlags.Union && !(parent.kind === SyntaxKind.Parameter && isSymbolAssigned(symbol))) {
+                            const pattern = declaration.parent;
+                            const narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, /*flowContainer*/ undefined, location.flowNode);
+                            return getBindingElementTypeFromParentType(declaration, narrowedType);
+                        }
+                    }
+                }
+            }
+            return getTypeOfSymbol(symbol);
+        }
+
         function checkIdentifier(node: Identifier, checkMode: CheckMode | undefined): Type {
             const symbol = getResolvedSymbol(node);
             if (symbol === unknownSymbol) {
@@ -24937,7 +25069,7 @@ namespace ts {
 
             checkNestedBlockScopedBinding(node, symbol);
 
-            let type = getTypeOfSymbol(localOrExportSymbol);
+            let type = getNarrowedTypeOfSymbol(localOrExportSymbol, node);
             const assignmentKind = getAssignmentTargetKind(node);
 
             if (assignmentKind) {
@@ -26075,12 +26207,12 @@ namespace ts {
             return !!(getCheckFlags(symbol) & CheckFlags.Mapped && !(symbol as MappedSymbol).type && findResolutionCycleStartIndex(symbol, TypeSystemPropertyName.Type) >= 0);
         }
 
-        function getTypeOfPropertyOfContextualType(type: Type, name: __String) {
+        function getTypeOfPropertyOfContextualType(type: Type, name: __String, nameType?: Type) {
             return mapType(type, t => {
                 if (isGenericMappedType(t)) {
                     const constraint = getConstraintTypeFromMappedType(t);
                     const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-                    const propertyNameType = getStringLiteralType(unescapeLeadingUnderscores(name));
+                    const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
                     if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
                         return substituteIndexedMappedType(t, propertyNameType);
                     }
@@ -26096,7 +26228,7 @@ namespace ts {
                             return restType;
                         }
                     }
-                    return findApplicableIndexInfo(getIndexInfosOfStructuredType(t), getStringLiteralType(unescapeLeadingUnderscores(name)))?.type;
+                    return findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))?.type;
                 }
                 return undefined;
             }, /*noReductions*/ true);
@@ -26126,7 +26258,8 @@ namespace ts {
                     // For a (non-symbol) computed property, there is no reason to look up the name
                     // in the type. It will just be "__computed", which does not appear in any
                     // SymbolTable.
-                    return getTypeOfPropertyOfContextualType(type, getSymbolOfNode(element).escapedName);
+                    const symbol = getSymbolOfNode(element);
+                    return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType);
                 }
                 if (element.name) {
                     const nameType = getLiteralTypeFromPropertyName(element.name);
@@ -34696,7 +34829,8 @@ namespace ts {
         function getTypeArgumentConstraint(node: TypeNode): Type | undefined {
             const typeReferenceNode = tryCast(node.parent, isTypeReferenceType);
             if (!typeReferenceNode) return undefined;
-            const typeParameters = getTypeParametersForTypeReference(typeReferenceNode)!; // TODO: GH#18217
+            const typeParameters = getTypeParametersForTypeReference(typeReferenceNode);
+            if (!typeParameters) return undefined;
             const constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments!.indexOf(node)]);
             return constraint && instantiateType(constraint, createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReferenceNode, typeParameters)));
         }
@@ -39646,8 +39780,12 @@ namespace ts {
 
         function checkAssertClause(declaration: ImportDeclaration | ExportDeclaration) {
             if (declaration.assertClause) {
-                if (moduleKind !== ModuleKind.ESNext) {
-                    return grammarErrorOnNode(declaration.assertClause, Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext);
+                const mode = (moduleKind === ModuleKind.NodeNext) && declaration.moduleSpecifier && getUsageModeForExpression(declaration.moduleSpecifier);
+                if (mode !== ModuleKind.ESNext && moduleKind !== ModuleKind.ESNext) {
+                    return grammarErrorOnNode(declaration.assertClause,
+                        moduleKind === ModuleKind.NodeNext
+                            ? Diagnostics.Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls
+                            : Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext);
                 }
 
                 if (isImportDeclaration(declaration) ? declaration.importClause?.isTypeOnly : declaration.isTypeOnly) {
@@ -40284,9 +40422,8 @@ namespace ts {
             const enclosingFile = getSourceFileOfNode(node);
             const links = getNodeLinks(enclosingFile);
             if (!(links.flags & NodeCheckFlags.TypeChecked)) {
-                links.deferredNodes = links.deferredNodes || new Map();
-                const id = getNodeId(node);
-                links.deferredNodes.set(id, node);
+                links.deferredNodes ||= new Set();
+                links.deferredNodes.add(node);
             }
         }
 
@@ -41466,7 +41603,7 @@ namespace ts {
             if (!symbol) {
                 return false;
             }
-            const target = resolveAlias(symbol);
+            const target = getExportSymbolOfValueSymbolIfExported(resolveAlias(symbol));
             if (target === unknownSymbol) {
                 return true;
             }
@@ -42939,8 +43076,7 @@ namespace ts {
 
                 // Modifiers are never allowed on properties except for 'async' on a method declaration
                 if (prop.modifiers) {
-                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-                    for (const mod of prop.modifiers!) { // TODO: GH#19955
+                    for (const mod of prop.modifiers) {
                         if (mod.kind !== SyntaxKind.AsyncKeyword || prop.kind !== SyntaxKind.MethodDeclaration) {
                             grammarErrorOnNode(mod, Diagnostics._0_modifier_cannot_be_used_here, getTextOfNode(mod));
                         }
@@ -43857,13 +43993,13 @@ namespace ts {
             }
 
             const nodeArguments = node.arguments;
-            if (moduleKind !== ModuleKind.ESNext) {
+            if (moduleKind !== ModuleKind.ESNext && moduleKind !== ModuleKind.NodeNext) {
                 // We are allowed trailing comma after proposal-import-assertions.
                 checkGrammarForDisallowedTrailingComma(nodeArguments);
 
                 if (nodeArguments.length > 1) {
                     const assertionArgument = nodeArguments[1];
-                    return grammarErrorOnNode(assertionArgument, Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext);
+                    return grammarErrorOnNode(assertionArgument, Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext);
                 }
             }
 

src/compiler/commandLineParser.ts

@@ -29,6 +29,7 @@ namespace ts {
         ["es2019", "lib.es2019.d.ts"],
         ["es2020", "lib.es2020.d.ts"],
         ["es2021", "lib.es2021.d.ts"],
+        ["es2022", "lib.es2022.d.ts"],
         ["esnext", "lib.esnext.d.ts"],
         // Host only
         ["dom", "lib.dom.d.ts"],
@@ -72,12 +73,16 @@ namespace ts {
         ["es2021.string", "lib.es2021.string.d.ts"],
         ["es2021.weakref", "lib.es2021.weakref.d.ts"],
         ["es2021.intl", "lib.es2021.intl.d.ts"],
-        ["esnext.array", "lib.es2019.array.d.ts"],
+        ["es2022.array", "lib.es2022.array.d.ts"],
+        ["es2022.error", "lib.es2022.error.d.ts"],
+        ["es2022.object", "lib.es2022.object.d.ts"],
+        ["es2022.string", "lib.es2022.string.d.ts"],
+        ["esnext.array", "lib.es2022.array.d.ts"],
         ["esnext.symbol", "lib.es2019.symbol.d.ts"],
         ["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
         ["esnext.intl", "lib.esnext.intl.d.ts"],
         ["esnext.bigint", "lib.es2020.bigint.d.ts"],
-        ["esnext.string", "lib.es2021.string.d.ts"],
+        ["esnext.string", "lib.es2022.string.d.ts"],
         ["esnext.promise", "lib.es2021.promise.d.ts"],
         ["esnext.weakref", "lib.es2021.weakref.d.ts"]
     ];
@@ -314,6 +319,7 @@ namespace ts {
             es2019: ScriptTarget.ES2019,
             es2020: ScriptTarget.ES2020,
             es2021: ScriptTarget.ES2021,
+            es2022: ScriptTarget.ES2022,
             esnext: ScriptTarget.ESNext,
         })),
         affectsSourceFile: true,

src/compiler/core.ts

@@ -23,34 +23,6 @@ namespace ts {
     export const emptyMap: ReadonlyESMap<never, never> = new Map<never, never>();
     export const emptySet: ReadonlySet<never> = new Set<never>();
 
-    /**
-     * Create a new map.
-     * @deprecated Use `new Map()` instead.
-     */
-    export function createMap<K, V>(): ESMap<K, V>;
-    export function createMap<T>(): ESMap<string, T>;
-    export function createMap<K, V>(): ESMap<K, V> {
-        return new Map<K, V>();
-    }
-
-    /**
-     * Create a new map from a template object is provided, the map will copy entries from it.
-     * @deprecated Use `new Map(getEntries(template))` instead.
-     */
-    export function createMapFromTemplate<T>(template: MapLike<T>): ESMap<string, T> {
-        const map: ESMap<string, T> = new Map<string, T>();
-
-        // Copies keys/values from template. Note that for..in will not throw if
-        // template is undefined, and instead will just exit the loop.
-        for (const key in template) {
-            if (hasOwnProperty.call(template, key)) {
-                map.set(key, template[key]);
-            }
-        }
-
-        return map;
-    }
-
     export function length(array: readonly any[] | undefined): number {
         return array ? array.length : 0;
     }

src/compiler/corePublic.ts

@@ -1,7 +1,7 @@
 namespace ts {
     // WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values.
     // If changing the text in this section, be sure to test `configurePrerelease` too.
-    export const versionMajorMinor = "4.5";
+    export const versionMajorMinor = "4.6";
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types

src/compiler/debug.ts

@@ -171,12 +171,6 @@ namespace ts {
             return value;
         }
 
-        /**
-         * @deprecated Use `checkDefined` to check whether a value is defined inline. Use `assertIsDefined` to check whether
-         * a value is defined at the statement level.
-         */
-        export const assertDefined = checkDefined;
-
         export function assertEachIsDefined<T extends Node>(value: NodeArray<T>, message?: string, stackCrawlMark?: AnyFunction): asserts value is NodeArray<T>;
         export function assertEachIsDefined<T>(value: readonly T[], message?: string, stackCrawlMark?: AnyFunction): asserts value is readonly NonNullable<T>[];
         export function assertEachIsDefined<T>(value: readonly T[], message?: string, stackCrawlMark?: AnyFunction) {
@@ -190,12 +184,6 @@ namespace ts {
             return value;
         }
 
-        /**
-         * @deprecated Use `checkEachDefined` to check whether the elements of an array are defined inline. Use `assertEachIsDefined` to check whether
-         * the elements of an array are defined at the statement level.
-         */
-        export const assertEachDefined = checkEachDefined;
-
         export function assertNever(member: never, message = "Illegal value:", stackCrawlMark?: AnyFunction): never {
             const detail = typeof member === "object" && hasProperty(member, "kind") && hasProperty(member, "pos") && formatSyntaxKind ? "SyntaxKind: " + formatSyntaxKind((member as Node).kind) : JSON.stringify(member);
             return fail(`${message} ${detail}`, stackCrawlMark || assertNever);

src/compiler/diagnosticMessages.json

@@ -924,7 +924,7 @@
         "category": "Error",
         "code": 1323
     },
-    "Dynamic imports only support a second argument when the '--module' option is set to 'esnext'.": {
+    "Dynamic imports only support a second argument when the '--module' option is set to 'esnext' or 'nodenext'.": {
         "category": "Error",
         "code": 1324
     },
@@ -3333,7 +3333,7 @@
         "category": "Error",
         "code": 2820
     },
-    "Import assertions are only supported when the '--module' option is set to 'esnext'.": {
+    "Import assertions are only supported when the '--module' option is set to 'esnext' or 'nodenext'.": {
         "category": "Error",
         "code": 2821
     },
@@ -3345,6 +3345,18 @@
         "category": "Error",
         "code": 2833
     },
+    "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Consider adding an extension to the import path.": {
+        "category": "Error",
+        "code": 2834
+    },
+    "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Did you mean '{0}'?": {
+        "category": "Error",
+        "code": 2835
+    },
+    "Import assertions are not allowed on statements that transpile to commonjs 'require' calls.": {
+        "category": "Error",
+        "code": 2836
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
@@ -3770,6 +3782,11 @@
         "category": "Error",
         "code": 4123
     },
+    "Compiler option '{0}' of value '{1}' is unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'.": {
+        "category": "Error",
+        "code": 4124
+    },
+
     "The current host does not support the '{0}' option.": {
         "category": "Error",
         "code": 5001
@@ -6420,6 +6437,11 @@
         "category": "Message",
         "code": 90053
     },
+    "Includes imports of types referenced by '{0}'": {
+        "category": "Message",
+        "code": 90054
+    },
+
     "Convert function to an ES2015 class": {
         "category": "Message",
         "code": 95001

src/compiler/emitter.ts

@@ -1604,6 +1604,7 @@ namespace ts {
                         return emitJSDocSignature(node as JSDocSignature);
                     case SyntaxKind.JSDocTag:
                     case SyntaxKind.JSDocClassTag:
+                    case SyntaxKind.JSDocOverrideTag:
                         return emitJSDocSimpleTag(node as JSDocTag);
                     case SyntaxKind.JSDocAugmentsTag:
                     case SyntaxKind.JSDocImplementsTag:
@@ -1616,7 +1617,6 @@ namespace ts {
                     case SyntaxKind.JSDocPrivateTag:
                     case SyntaxKind.JSDocProtectedTag:
                     case SyntaxKind.JSDocReadonlyTag:
-                    case SyntaxKind.JSDocOverrideTag:
                         return;
                     case SyntaxKind.JSDocCallbackTag:
                         return emitJSDocCallbackTag(node as JSDocCallbackTag);

src/compiler/factory/nodeFactory.ts

@@ -6387,7 +6387,7 @@ namespace ts {
             sourceMapText = mapTextOrStripInternal as string;
         }
         const node = oldFileOfCurrentEmit ?
-            parseOldFileOfCurrentEmit(Debug.assertDefined(bundleFileInfo)) :
+            parseOldFileOfCurrentEmit(Debug.checkDefined(bundleFileInfo)) :
             parseUnparsedSourceFile(bundleFileInfo, stripInternal, length);
         node.fileName = fileName;
         node.sourceMapPath = sourceMapPath;
@@ -6587,13 +6587,13 @@ namespace ts {
             };
             node.javascriptPath = declarationTextOrJavascriptPath;
             node.javascriptMapPath = javascriptMapPath;
-            node.declarationPath = Debug.assertDefined(javascriptMapTextOrDeclarationPath);
+            node.declarationPath = Debug.checkDefined(javascriptMapTextOrDeclarationPath);
             node.declarationMapPath = declarationMapPath;
             node.buildInfoPath = declarationMapTextOrBuildInfoPath;
             Object.defineProperties(node, {
                 javascriptText: { get() { return definedTextGetter(declarationTextOrJavascriptPath); } },
                 javascriptMapText: { get() { return textGetter(javascriptMapPath); } }, // TODO:: if there is inline sourceMap in jsFile, use that
-                declarationText: { get() { return definedTextGetter(Debug.assertDefined(javascriptMapTextOrDeclarationPath)); } },
+                declarationText: { get() { return definedTextGetter(Debug.checkDefined(javascriptMapTextOrDeclarationPath)); } },
                 declarationMapText: { get() { return textGetter(declarationMapPath); } }, // TODO:: if there is inline sourceMap in dtsFile, use that
                 buildInfo: { get() { return getAndCacheBuildInfo(() => textGetter(declarationMapTextOrBuildInfoPath)); } }
             });

src/compiler/moduleSpecifiers.ts

@@ -707,13 +707,15 @@ namespace ts.moduleSpecifiers {
             if (host.fileExists(packageJsonPath)) {
                 const packageJsonContent = JSON.parse(host.readFile!(packageJsonPath)!);
                 // TODO: Inject `require` or `import` condition based on the intended import mode
-                const fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, packageJsonContent.name, packageJsonContent.exports, ["node", "types"]) : undefined;
-                if (fromExports) {
-                    const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
-                    return { ...withJsExtension, verbatimFromExports: true };
-                }
-                if (packageJsonContent.exports) {
-                    return { moduleFileToTry: path, blockedByExports: true };
+                if (getEmitModuleResolutionKind(options) === ModuleResolutionKind.Node12 || getEmitModuleResolutionKind(options) === ModuleResolutionKind.NodeNext) {
+                    const fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, packageJsonContent.name, packageJsonContent.exports, ["node", "types"]) : undefined;
+                    if (fromExports) {
+                        const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
+                        return { ...withJsExtension, verbatimFromExports: true };
+                    }
+                    if (packageJsonContent.exports) {
+                        return { moduleFileToTry: path, blockedByExports: true };
+                    }
                 }
                 const versionPaths = packageJsonContent.typesVersions
                     ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions)

src/compiler/program.ts

@@ -818,6 +818,25 @@ namespace ts {
         }
     }
 
+    /** @internal */
+    export const plainJSErrors: Set<number> = new Set([
+        Diagnostics.Cannot_redeclare_block_scoped_variable_0.code,
+        Diagnostics.A_module_cannot_have_multiple_default_exports.code,
+        Diagnostics.Another_export_default_is_here.code,
+        Diagnostics.The_first_export_default_is_here.code,
+        Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module.code,
+        Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode.code,
+        Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here.code,
+        Diagnostics.constructor_is_a_reserved_word.code,
+        Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode.code,
+        Diagnostics.Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode.code,
+        Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode.code,
+        Diagnostics.Invalid_use_of_0_in_strict_mode.code,
+        Diagnostics.A_label_is_not_allowed_here.code,
+        Diagnostics.Octal_literals_are_not_allowed_in_strict_mode.code,
+        Diagnostics.with_statements_are_not_allowed_in_strict_mode.code,
+    ]);
+
     /**
      * Determine if source file needs to be re-created even if its text hasn't changed
      */
@@ -1577,6 +1596,7 @@ namespace ts {
                 newSourceFile.originalFileName = oldSourceFile.originalFileName;
                 newSourceFile.resolvedPath = oldSourceFile.resolvedPath;
                 newSourceFile.fileName = oldSourceFile.fileName;
+                newSourceFile.impliedNodeFormat = oldSourceFile.impliedNodeFormat;
 
                 const packageName = oldProgram.sourceFileToPackageName.get(oldSourceFile.path);
                 if (packageName !== undefined) {
@@ -1674,8 +1694,8 @@ namespace ts {
                 const typesReferenceDirectives = map(newSourceFile.typeReferenceDirectives, ref => toFileNameLowerCase(ref.fileName));
                 const typeReferenceResolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFile);
                 // ensure that types resolutions are still correct
-                const typeReferenceEesolutionsChanged = hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, oldSourceFile, typeDirectiveIsEqualTo);
-                if (typeReferenceEesolutionsChanged) {
+                const typeReferenceResolutionsChanged = hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, oldSourceFile, typeDirectiveIsEqualTo);
+                if (typeReferenceResolutionsChanged) {
                     structureIsReused = StructureIsReused.SafeModules;
                     newSourceFile.resolvedTypeReferenceDirectiveNames = zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions);
                 }
@@ -2004,15 +2024,24 @@ namespace ts {
 
                 Debug.assert(!!sourceFile.bindDiagnostics);
 
-                const isCheckJs = isCheckJsEnabledForFile(sourceFile, options);
+                const isJs = sourceFile.scriptKind === ScriptKind.JS || sourceFile.scriptKind === ScriptKind.JSX;
+                const isCheckJs = isJs && isCheckJsEnabledForFile(sourceFile, options);
+                const isPlainJs = isJs && !sourceFile.checkJsDirective && options.checkJs === undefined;
                 const isTsNoCheck = !!sourceFile.checkJsDirective && sourceFile.checkJsDirective.enabled === false;
-                // By default, only type-check .ts, .tsx, 'Deferred' and 'External' files (external files are added by plugins)
-                const includeBindAndCheckDiagnostics = !isTsNoCheck && (sourceFile.scriptKind === ScriptKind.TS || sourceFile.scriptKind === ScriptKind.TSX
-                    || sourceFile.scriptKind === ScriptKind.External || isCheckJs || sourceFile.scriptKind === ScriptKind.Deferred);
-                const bindDiagnostics: readonly Diagnostic[] = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : emptyArray;
-                const checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : emptyArray;
 
-                return getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : undefined);
+                // By default, only type-check .ts, .tsx, Deferred, plain JS, checked JS and External
+                // - plain JS: .js files with no // ts-check and checkJs: undefined
+                // - check JS: .js files with either // ts-check or checkJs: true
+                // - external: files that are added by plugins
+                const includeBindAndCheckDiagnostics = !isTsNoCheck && (sourceFile.scriptKind === ScriptKind.TS || sourceFile.scriptKind === ScriptKind.TSX
+                        || sourceFile.scriptKind === ScriptKind.External || isPlainJs || isCheckJs || sourceFile.scriptKind === ScriptKind.Deferred);
+                let bindDiagnostics: readonly Diagnostic[] = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : emptyArray;
+                const checkDiagnostics = includeBindAndCheckDiagnostics && !isPlainJs ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : emptyArray;
+                if (isPlainJs) {
+                    bindDiagnostics = filter(bindDiagnostics, d => plainJSErrors.has(d.code));
+                }
+                // skip ts-expect-error errors in plain JS files, and skip JSDoc errors except in checked JS
+                return getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics && !isPlainJs, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : undefined);
             });
         }
 
@@ -3160,6 +3189,21 @@ namespace ts {
         }
 
         function verifyCompilerOptions() {
+            const isNightly = stringContains(version, "-dev") || stringContains(version, "-insiders");
+            if (!isNightly) {
+                if (getEmitModuleKind(options) === ModuleKind.Node12) {
+                    createOptionValueDiagnostic("module", Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "module", "node12");
+                }
+                else if (getEmitModuleKind(options) === ModuleKind.NodeNext) {
+                    createOptionValueDiagnostic("module", Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "module", "nodenext");
+                }
+                else if (getEmitModuleResolutionKind(options) === ModuleResolutionKind.Node12) {
+                    createOptionValueDiagnostic("moduleResolution", Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "moduleResolution", "node12");
+                }
+                else if (getEmitModuleResolutionKind(options) === ModuleResolutionKind.NodeNext) {
+                    createOptionValueDiagnostic("moduleResolution", Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "moduleResolution", "nodenext");
+                }
+            }
             if (options.strictPropertyInitialization && !getStrictOptionValue(options, "strictNullChecks")) {
                 createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "strictPropertyInitialization", "strictNullChecks");
             }
@@ -3696,8 +3740,8 @@ namespace ts {
             createDiagnosticForOption(/*onKey*/ true, option1, option2, message, option1, option2, option3);
         }
 
-        function createOptionValueDiagnostic(option1: string, message: DiagnosticMessage, arg0?: string) {
-            createDiagnosticForOption(/*onKey*/ false, option1, /*option2*/ undefined, message, arg0);
+        function createOptionValueDiagnostic(option1: string, message: DiagnosticMessage, arg0?: string, arg1?: string) {
+            createDiagnosticForOption(/*onKey*/ false, option1, /*option2*/ undefined, message, arg0, arg1);
         }
 
         function createDiagnosticForReference(sourceFile: JsonSourceFile | undefined, index: number, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number) {

src/compiler/resolutionCache.ts

@@ -66,6 +66,7 @@ namespace ts {
         getCurrentProgram(): Program | undefined;
         fileIsOpen(filePath: Path): boolean;
         getCompilerHost?(): CompilerHost | undefined;
+        onDiscoveredSymlink?(): void;
     }
 
     interface DirectoryWatchesOfFailedLookup {
@@ -431,6 +432,9 @@ namespace ts {
                     else {
                         resolution = loader(name, containingFile, compilerOptions, resolutionHost.getCompilerHost?.() || resolutionHost, redirectedReference, containingSourceFile);
                         perDirectoryResolution.set(name, mode, resolution);
+                        if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {
+                            resolutionHost.onDiscoveredSymlink();
+                        }
                     }
                     resolutionsInFile.set(name, mode, resolution);
                     watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName);
@@ -615,7 +619,7 @@ namespace ts {
         ) {
             if (resolution.refCount) {
                 resolution.refCount++;
-                Debug.assertDefined(resolution.files);
+                Debug.assertIsDefined(resolution.files);
             }
             else {
                 resolution.refCount = 1;
@@ -692,7 +696,7 @@ namespace ts {
             filePath: Path,
             getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>,
         ) {
-            unorderedRemoveItem(Debug.assertDefined(resolution.files), filePath);
+            unorderedRemoveItem(Debug.checkDefined(resolution.files), filePath);
             resolution.refCount!--;
             if (resolution.refCount) {
                 return;
@@ -794,7 +798,7 @@ namespace ts {
             for (const resolution of resolutions) {
                 if (resolution.isInvalidated || !canInvalidate(resolution)) continue;
                 resolution.isInvalidated = invalidated = true;
-                for (const containingFilePath of Debug.assertDefined(resolution.files)) {
+                for (const containingFilePath of Debug.checkDefined(resolution.files)) {
                     (filesWithInvalidatedResolutions || (filesWithInvalidatedResolutions = new Set())).add(containingFilePath);
                     // When its a file with inferred types resolution, invalidate type reference directive resolution
                     hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || endsWith(containingFilePath, inferredTypesContainingFile);
@@ -965,4 +969,11 @@ namespace ts {
             return dirPath === rootPath || canWatchDirectory(dirPath);
         }
     }
+
+    function resolutionIsSymlink(resolution: ResolutionWithFailedLookupLocations) {
+        return !!(
+            (resolution as ResolvedModuleWithFailedLookupLocations).resolvedModule?.originalPath ||
+            (resolution as ResolvedTypeReferenceDirectiveWithFailedLookupLocations).resolvedTypeReferenceDirective?.originalPath
+        );
+    }
 }

src/compiler/scanner.ts

@@ -2374,6 +2374,7 @@ namespace ts {
                     tokenValue = tokenValue.slice(0, -1);
                     pos--;
                 }
+                return getIdentifierToken();
             }
             return token;
         }

src/compiler/sys.ts

@@ -1625,7 +1625,6 @@ namespace ts {
                         sysLog(`sysLog:: ${fileOrDirectory}:: Defaulting to fsWatchFile`);
                         return watchPresentFileSystemEntryWithFsWatchFile();
                     }
-
                     try {
                         const presentWatcher = _fs.watch(
                             fileOrDirectory,
@@ -1804,7 +1803,7 @@ namespace ts {
             }
 
             function readDirectory(path: string, extensions?: readonly string[], excludes?: readonly string[], includes?: readonly string[], depth?: number): string[] {
-                return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath, directoryExists);
+                return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
             }
 
             function fileSystemEntryExists(path: string, entryKind: FileSystemEntryKind): boolean {

src/compiler/transformers/es2018.ts

@@ -282,7 +282,7 @@ namespace ts {
         function visitYieldExpression(node: YieldExpression) {
             if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) {
                 if (node.asteriskToken) {
-                    const expression = visitNode(Debug.assertDefined(node.expression), visitor, isExpression);
+                    const expression = visitNode(Debug.checkDefined(node.expression), visitor, isExpression);
 
                     return setOriginalNode(
                         setTextRange(

src/compiler/transformers/jsx.ts

@@ -26,12 +26,12 @@ namespace ts {
             return currentFileState.filenameDeclaration.name;
         }
 
-        function getJsxFactoryCalleePrimitive(childrenLength: number): "jsx" | "jsxs" | "jsxDEV" {
-            return compilerOptions.jsx === JsxEmit.ReactJSXDev ? "jsxDEV" : childrenLength > 1 ? "jsxs" : "jsx";
+        function getJsxFactoryCalleePrimitive(isStaticChildren: boolean): "jsx" | "jsxs" | "jsxDEV" {
+            return compilerOptions.jsx === JsxEmit.ReactJSXDev ? "jsxDEV" : isStaticChildren ? "jsxs" : "jsx";
         }
 
-        function getJsxFactoryCallee(childrenLength: number) {
-            const type = getJsxFactoryCalleePrimitive(childrenLength);
+        function getJsxFactoryCallee(isStaticChildren: boolean) {
+            const type = getJsxFactoryCalleePrimitive(isStaticChildren);
             return getImplicitImportForName(type);
         }
 
@@ -48,11 +48,11 @@ namespace ts {
                 return existing.name;
             }
             if (!currentFileState.utilizedImplicitRuntimeImports) {
-                currentFileState.utilizedImplicitRuntimeImports = createMap();
+                currentFileState.utilizedImplicitRuntimeImports = new Map();
             }
             let specifierSourceImports = currentFileState.utilizedImplicitRuntimeImports.get(importSource);
             if (!specifierSourceImports) {
-                specifierSourceImports = createMap();
+                specifierSourceImports = new Map();
                 currentFileState.utilizedImplicitRuntimeImports.set(importSource, specifierSourceImports);
             }
             const generatedName = factory.createUniqueName(`_${name}`, GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel | GeneratedIdentifierFlags.AllowNameSubstitution);
@@ -206,7 +206,7 @@ namespace ts {
 
         function convertJsxChildrenToChildrenPropAssignment(children: readonly JsxChild[]) {
             const nonWhitespaceChildren = getSemanticJsxChildren(children);
-            if (length(nonWhitespaceChildren) === 1) {
+            if (length(nonWhitespaceChildren) === 1 && !(nonWhitespaceChildren[0] as JsxExpression).dotDotDotToken) {
                 const result = transformJsxChildToExpression(nonWhitespaceChildren[0]);
                 return result && factory.createPropertyAssignment("children", result);
             }
@@ -221,16 +221,33 @@ namespace ts {
             const attrs = keyAttr ? filter(node.attributes.properties, p => p !== keyAttr) : node.attributes.properties;
             const objectProperties = length(attrs) ? transformJsxAttributesToObjectProps(attrs, childrenProp) :
                 factory.createObjectLiteralExpression(childrenProp ? [childrenProp] : emptyArray); // When there are no attributes, React wants {}
-            return visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, length(getSemanticJsxChildren(children || emptyArray)), isChild, location);
+            return visitJsxOpeningLikeElementOrFragmentJSX(
+                tagName,
+                objectProperties,
+                keyAttr,
+                children || emptyArray,
+                isChild,
+                location
+            );
         }
 
-        function visitJsxOpeningLikeElementOrFragmentJSX(tagName: Expression, objectProperties: Expression, keyAttr: JsxAttribute | undefined, childrenLength: number, isChild: boolean, location: TextRange) {
+        function visitJsxOpeningLikeElementOrFragmentJSX(
+            tagName: Expression,
+            objectProperties: Expression,
+            keyAttr: JsxAttribute | undefined,
+            children: readonly JsxChild[],
+            isChild: boolean,
+            location: TextRange
+        ) {
+            const nonWhitespaceChildren = getSemanticJsxChildren(children);
+            const isStaticChildren =
+                length(nonWhitespaceChildren) > 1 || !!(nonWhitespaceChildren[0] as JsxExpression)?.dotDotDotToken;
             const args: Expression[] = [tagName, objectProperties, !keyAttr ? factory.createVoidZero() : transformJsxAttributeInitializer(keyAttr.initializer)];
             if (compilerOptions.jsx === JsxEmit.ReactJSXDev) {
                 const originalFile = getOriginalNode(currentSourceFile);
                 if (originalFile && isSourceFile(originalFile)) {
                     // isStaticChildren development flag
-                    args.push(childrenLength > 1 ? factory.createTrue() : factory.createFalse());
+                    args.push(isStaticChildren ? factory.createTrue() : factory.createFalse());
                     // __source development flag
                     const lineCol = getLineAndCharacterOfPosition(originalFile, location.pos);
                     args.push(factory.createObjectLiteralExpression([
@@ -242,7 +259,10 @@ namespace ts {
                     args.push(factory.createThis());
                 }
             }
-            const element = setTextRange(factory.createCallExpression(getJsxFactoryCallee(childrenLength), /*typeArguments*/ undefined, args), location);
+            const element = setTextRange(
+                factory.createCallExpression(getJsxFactoryCallee(isStaticChildren), /*typeArguments*/ undefined, args),
+                location
+            );
 
             if (isChild) {
                 startOnNewLine(element);
@@ -294,7 +314,7 @@ namespace ts {
                 getImplicitJsxFragmentReference(),
                 childrenProps || factory.createObjectLiteralExpression([]),
                 /*keyAttr*/ undefined,
-                length(getSemanticJsxChildren(children)),
+                children,
                 isChild,
                 location
             );

src/compiler/types.ts

@@ -1609,7 +1609,7 @@ namespace ts {
     export interface TypePredicateNode extends TypeNode {
         readonly kind: SyntaxKind.TypePredicate;
         readonly parent: SignatureDeclaration | JSDocTypeExpression;
-        readonly assertsModifier?: AssertsToken;
+        readonly assertsModifier?: AssertsKeyword;
         readonly parameterName: Identifier | ThisTypeNode;
         readonly type?: TypeNode;
     }
@@ -1702,7 +1702,7 @@ namespace ts {
 
     export interface MappedTypeNode extends TypeNode, Declaration {
         readonly kind: SyntaxKind.MappedType;
-        readonly readonlyToken?: ReadonlyToken | PlusToken | MinusToken;
+        readonly readonlyToken?: ReadonlyKeyword | PlusToken | MinusToken;
         readonly typeParameter: TypeParameterDeclaration;
         readonly nameType?: TypeNode;
         readonly questionToken?: QuestionToken | PlusToken | MinusToken;
@@ -2756,7 +2756,7 @@ namespace ts {
 
     export interface ForOfStatement extends IterationStatement {
         readonly kind: SyntaxKind.ForOfStatement;
-        readonly awaitModifier?: AwaitKeywordToken;
+        readonly awaitModifier?: AwaitKeyword;
         readonly initializer: ForInitializer;
         readonly expression: Expression;
     }
@@ -5083,6 +5083,7 @@ namespace ts {
         ConstructorReferenceInClass              = 0x02000000,  // Binding to a class constructor inside of the class's body.
         ContainsClassWithPrivateIdentifiers      = 0x04000000,  // Marked on all block-scoped containers containing a class with private identifiers.
         ContainsSuperPropertyInStaticInitializer = 0x08000000,  // Marked on all block-scoped containers containing a static initializer with 'super.x' or 'super[x]'.
+        InCheckIdentifier                        = 0x10000000,
     }
 
     /* @internal */
@@ -5106,7 +5107,7 @@ namespace ts {
         jsxNamespace?: Symbol | false;      // Resolved jsx namespace symbol for this node
         jsxImplicitImportContainer?: Symbol | false; // Resolved module symbol the implicit jsx import of this file should refer to
         contextFreeType?: Type;             // Cached context-free type used by the first pass of inference; used when a function's return is partially contextually sensitive
-        deferredNodes?: ESMap<NodeId, Node>; // Set of nodes whose checking has been deferred
+        deferredNodes?: Set<Node>;          // Set of nodes whose checking has been deferred
         capturedBlockScopeBindings?: Symbol[]; // Block-scoped bindings captured beneath this part of an IterationStatement
         outerTypeParameters?: TypeParameter[]; // Outer type parameters of anonymous object type
         isExhaustive?: boolean;             // Is node an exhaustive switch statement
@@ -5187,8 +5188,6 @@ namespace ts {
         // 'Narrowable' types are types where narrowing actually narrows.
         // This *should* be every type other than null, undefined, void, and never
         Narrowable = Any | Unknown | StructuredOrInstantiable | StringLike | NumberLike | BigIntLike | BooleanLike | ESSymbol | UniqueESSymbol | NonPrimitive,
-        /* @internal */
-        NotPrimitiveUnion = Any | Unknown | Enum | Void | Never | Object | Intersection | Instantiable,
         // The following flags are aggregated during union and intersection type construction
         /* @internal */
         IncludesMask = Any | Unknown | Primitive | Never | Object | Union | Intersection | NonPrimitive | TemplateLiteral,
@@ -5201,6 +5200,10 @@ namespace ts {
         IncludesWildcard = IndexedAccess,
         /* @internal */
         IncludesEmptyObject = Conditional,
+        /* @internal */
+        IncludesInstantiable = Substitution,
+        /* @internal */
+        NotPrimitiveUnion = Any | Unknown | Enum | Void | Never | Object | Intersection | IncludesInstantiable,
     }
 
     export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
@@ -5992,7 +5995,7 @@ namespace ts {
     export enum ModuleResolutionKind {
         Classic  = 1,
         NodeJs   = 2,
-        // Starting with node12, node's module resolver has significant departures from tranditional cjs resolution
+        // Starting with node12, node's module resolver has significant departures from traditional cjs resolution
         // to better support ecmascript modules and their use within node - more features are still being added, so
         // we can expect it to change over time, and as such, offer both a `NodeNext` moving resolution target, and a `Node12`
         // version-anchored resolution target
@@ -6265,6 +6268,7 @@ namespace ts {
         ES2019 = 6,
         ES2020 = 7,
         ES2021 = 8,
+        ES2022 = 9,
         ESNext = 99,
         JSON = 100,
         Latest = ESNext,
@@ -6722,15 +6726,16 @@ namespace ts {
         ContainsTypeScript = 1 << 0,
         ContainsJsx = 1 << 1,
         ContainsESNext = 1 << 2,
-        ContainsES2021 = 1 << 3,
-        ContainsES2020 = 1 << 4,
-        ContainsES2019 = 1 << 5,
-        ContainsES2018 = 1 << 6,
-        ContainsES2017 = 1 << 7,
-        ContainsES2016 = 1 << 8,
-        ContainsES2015 = 1 << 9,
-        ContainsGenerator = 1 << 10,
-        ContainsDestructuringAssignment = 1 << 11,
+        ContainsES2022 = 1 << 3,
+        ContainsES2021 = 1 << 4,
+        ContainsES2020 = 1 << 5,
+        ContainsES2019 = 1 << 6,
+        ContainsES2018 = 1 << 7,
+        ContainsES2017 = 1 << 8,
+        ContainsES2016 = 1 << 9,
+        ContainsES2015 = 1 << 10,
+        ContainsGenerator = 1 << 11,
+        ContainsDestructuringAssignment = 1 << 12,
 
         // Markers
         // - Flags used to indicate that a subtree contains a specific transformation.
@@ -6759,6 +6764,7 @@ namespace ts {
         AssertTypeScript = ContainsTypeScript,
         AssertJsx = ContainsJsx,
         AssertESNext = ContainsESNext,
+        AssertES2022 = ContainsES2022,
         AssertES2021 = ContainsES2021,
         AssertES2020 = ContainsES2020,
         AssertES2019 = ContainsES2019,

src/compiler/utilities.ts

@@ -20,21 +20,6 @@ namespace ts {
         return undefined;
     }
 
-    /**
-     * Create a new escaped identifier map.
-     * @deprecated Use `new Map<__String, T>()` instead.
-     */
-    export function createUnderscoreEscapedMap<T>(): UnderscoreEscapedMap<T> {
-        return new Map<__String, T>();
-    }
-
-    /**
-     * @deprecated Use `!!map?.size` instead
-     */
-    export function hasEntries(map: ReadonlyCollection<any> | undefined): map is ReadonlyCollection<any> {
-        return !!map && !!map.size;
-    }
-
     export function createSymbolTable(symbols?: readonly Symbol[]): SymbolTable {
         const result = new Map<__String, Symbol>();
         if (symbols) {
@@ -606,6 +591,7 @@ namespace ts {
                 AsyncIterableIterator: emptyArray,
                 AsyncGenerator: emptyArray,
                 AsyncGeneratorFunction: emptyArray,
+                NumberFormat: ["formatToParts"]
             },
             es2019: {
                 Array: ["flat", "flatMap"],
@@ -627,8 +613,21 @@ namespace ts {
                 PromiseConstructor: ["any"],
                 String: ["replaceAll"]
             },
-            esnext: {
-                NumberFormat: ["formatToParts"]
+            es2022: {
+                Array: ["at"],
+                String: ["at"],
+                Int8Array: ["at"],
+                Uint8Array: ["at"],
+                Uint8ClampedArray: ["at"],
+                Int16Array: ["at"],
+                Uint16Array: ["at"],
+                Int32Array: ["at"],
+                Uint32Array: ["at"],
+                Float32Array: ["at"],
+                Float64Array: ["at"],
+                BigInt64Array: ["at"],
+                BigUint64Array: ["at"],
+                ObjectConstructor: ["hasOwn"]
             }
         };
     }
@@ -6615,7 +6614,7 @@ namespace ts {
             includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
             includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
             excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-            basePaths: getBasePaths(absolutePath, includes, useCaseSensitiveFileNames)
+            basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
         };
     }
 
@@ -6624,7 +6623,7 @@ namespace ts {
     }
 
     /** @param path directory of the tsconfig.json */
-    export function matchFiles(path: string, extensions: readonly string[] | undefined, excludes: readonly string[] | undefined, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getFileSystemEntries: (path: string) => FileSystemEntries, realpath: (path: string) => string, directoryExists: (path: string) => boolean): string[] {
+    export function matchFiles(path: string, extensions: readonly string[] | undefined, excludes: readonly string[] | undefined, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getFileSystemEntries: (path: string) => FileSystemEntries, realpath: (path: string) => string): string[] {
         path = normalizePath(path);
         currentDirectory = normalizePath(currentDirectory);
 
@@ -6639,22 +6638,20 @@ namespace ts {
         const results: string[][] = includeFileRegexes ? includeFileRegexes.map(() => []) : [[]];
         const visited = new Map<string, true>();
         const toCanonical = createGetCanonicalFileName(useCaseSensitiveFileNames);
-        for (const absoluteBasePath of patterns.basePaths) {
-            if (directoryExists(absoluteBasePath)) {
-                visitDirectory(absoluteBasePath, depth);
-            }
+        for (const basePath of patterns.basePaths) {
+            visitDirectory(basePath, combinePaths(currentDirectory, basePath), depth);
         }
 
         return flatten(results);
 
-        function visitDirectory(absolutePath: string, depth: number | undefined) {
+        function visitDirectory(path: string, absolutePath: string, depth: number | undefined) {
             const canonicalPath = toCanonical(realpath(absolutePath));
             if (visited.has(canonicalPath)) return;
             visited.set(canonicalPath, true);
-            const { files, directories } = getFileSystemEntries(absolutePath);
+            const { files, directories } = getFileSystemEntries(path);
 
             for (const current of sort<string>(files, compareStringsCaseSensitive)) {
-                const name = combinePaths(absolutePath, current);
+                const name = combinePaths(path, current);
                 const absoluteName = combinePaths(absolutePath, current);
                 if (extensions && !fileExtensionIsOneOf(name, extensions)) continue;
                 if (excludeRegex && excludeRegex.test(absoluteName)) continue;
@@ -6677,10 +6674,11 @@ namespace ts {
             }
 
             for (const current of sort<string>(directories, compareStringsCaseSensitive)) {
+                const name = combinePaths(path, current);
                 const absoluteName = combinePaths(absolutePath, current);
                 if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
                     (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    visitDirectory(absoluteName, depth);
+                    visitDirectory(name, absoluteName, depth);
                 }
             }
         }
@@ -6688,11 +6686,10 @@ namespace ts {
 
     /**
      * Computes the unique non-wildcard base paths amongst the provided include patterns.
-     * @returns Absolute directory paths
      */
-    function getBasePaths(absoluteTsconfigPath: string, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean): string[] {
+    function getBasePaths(path: string, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean): string[] {
         // Storage for our results in the form of literal paths (e.g. the paths as written by the user).
-        const basePaths: string[] = [absoluteTsconfigPath];
+        const basePaths: string[] = [path];
 
         if (includes) {
             // Storage for literal base paths amongst the include patterns.
@@ -6700,9 +6697,9 @@ namespace ts {
             for (const include of includes) {
                 // We also need to check the relative paths by converting them to absolute and normalizing
                 // in case they escape the base path (e.g "..\somedirectory")
-                const absoluteIncludePath: string = isRootedDiskPath(include) ? include : normalizePath(combinePaths(absoluteTsconfigPath, include));
+                const absolute: string = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path, include));
                 // Append the literal and canonical candidate base paths.
-                includeBasePaths.push(getIncludeBasePath(absoluteIncludePath));
+                includeBasePaths.push(getIncludeBasePath(absolute));
             }
 
             // Sort the offsets array using either the literal or canonical path representations.
@@ -6711,7 +6708,7 @@ namespace ts {
             // Iterate over each include base path and include unique base paths that are not a
             // subpath of an existing base path
             for (const includeBasePath of includeBasePaths) {
-                if (every(basePaths, basePath => !containsPath(basePath, includeBasePath, absoluteTsconfigPath, !useCaseSensitiveFileNames))) {
+                if (every(basePaths, basePath => !containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames))) {
                     basePaths.push(includeBasePath);
                 }
             }
@@ -6982,18 +6979,6 @@ namespace ts {
         return { min, max };
     }
 
-    /** @deprecated Use `ReadonlySet<TNode>` instead. */
-    export type ReadonlyNodeSet<TNode extends Node> = ReadonlySet<TNode>;
-
-    /** @deprecated Use `Set<TNode>` instead. */
-    export type NodeSet<TNode extends Node> = Set<TNode>;
-
-    /** @deprecated Use `ReadonlyMap<TNode, TValue>` instead. */
-    export type ReadonlyNodeMap<TNode extends Node, TValue> = ReadonlyESMap<TNode, TValue>;
-
-    /** @deprecated Use `Map<TNode, TValue>` instead. */
-    export type NodeMap<TNode extends Node, TValue> = ESMap<TNode, TValue>;
-
     export function rangeOfNode(node: Node): TextRange {
         return { pos: getTokenPosOfNode(node), end: node.end };
     }

src/compiler/utilitiesPublic.ts

@@ -14,6 +14,8 @@ namespace ts {
         switch (getEmitScriptTarget(options)) {
             case ScriptTarget.ESNext:
                 return "lib.esnext.full.d.ts";
+            case ScriptTarget.ES2022:
+                return "lib.es2022.full.d.ts";
             case ScriptTarget.ES2021:
                 return "lib.es2021.full.d.ts";
             case ScriptTarget.ES2020:

src/compiler/watchUtilities.ts

@@ -184,7 +184,7 @@ namespace ts {
             const rootResult = tryReadDirectory(rootDir, rootDirPath);
             let rootSymLinkResult: FileSystemEntries | undefined;
             if (rootResult !== undefined) {
-                return matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath, directoryExists);
+                return matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath);
             }
             return host.readDirectory!(rootDir, extensions, excludes, includes, depth);
 

src/harness/fakesHosts.ts

@@ -95,7 +95,7 @@ namespace fakes {
         }
 
         public readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[] {
-            return ts.matchFiles(path, extensions, exclude, include, this.useCaseSensitiveFileNames, this.getCurrentDirectory(), depth, path => this.getAccessibleFileSystemEntries(path), path => this.realpath(path), path => this.directoryExists(path));
+            return ts.matchFiles(path, extensions, exclude, include, this.useCaseSensitiveFileNames, this.getCurrentDirectory(), depth, path => this.getAccessibleFileSystemEntries(path), path => this.realpath(path));
         }
 
         public getAccessibleFileSystemEntries(path: string): ts.FileSystemEntries {

src/harness/findUpDir.ts

@@ -1,11 +1,11 @@
-namespace findUpDir {
-    import { join, resolve, dirname } from "path";
-    import { existsSync } from "fs";
+namespace Utils {
+    const { join, resolve, dirname } = require("path") as typeof import("path");
+    const { existsSync } = require("fs") as typeof import("fs");
 
     // search directories upward to avoid hard-wired paths based on the
     // build tree (same as scripts/build/findUpDir.js)
 
-    export function findUpFile(name: string) {
+    export function findUpFile(name: string): string {
         let dir = __dirname;
         while (true) {
             const fullPath = join(dir, name);

src/harness/fourslashImpl.ts

@@ -637,7 +637,8 @@ namespace FourSlash {
             ts.forEachKey(this.inputFiles, fileName => {
                 if (!ts.isAnySupportedFileExtension(fileName)
                     || Harness.getConfigNameFromFileName(fileName)
-                    || !ts.getAllowJSCompilerOption(this.getProgram().getCompilerOptions()) && !ts.resolutionExtensionIsTSOrJson(ts.extensionFromPath(fileName))
+                    // Can't get a Program in Server tests
+                    || this.testType !== FourSlashTestType.Server && !ts.getAllowJSCompilerOption(this.getProgram().getCompilerOptions()) && !ts.resolutionExtensionIsTSOrJson(ts.extensionFromPath(fileName))
                     || ts.getBaseFileName(fileName) === "package.json") return;
                 const errors = this.getDiagnostics(fileName).filter(e => e.category !== ts.DiagnosticCategory.Suggestion);
                 if (errors.length) {
@@ -942,7 +943,7 @@ namespace FourSlash {
             expected = typeof expected === "string" ? { name: expected } : expected;
 
             if (actual.insertText !== expected.insertText) {
-                this.raiseError(`Expected completion insert text to be ${expected.insertText}, got ${actual.insertText}`);
+                this.raiseError(`Completion insert text did not match: ${showTextDiff(expected.insertText || "", actual.insertText || "")}`);
             }
             const convertedReplacementSpan = expected.replacementSpan && ts.createTextSpanFromRange(expected.replacementSpan);
             if (convertedReplacementSpan?.length) {

src/harness/harnessIO.ts

@@ -41,6 +41,7 @@ namespace Harness {
     export const virtualFileSystemRoot = "/";
 
     function createNodeIO(): IO {
+        const workspaceRoot = Utils.findUpRoot();
         let fs: any, pathModule: any;
         if (require) {
             fs = require("fs");
@@ -154,7 +155,7 @@ namespace Harness {
             log: s => console.log(s),
             args: () => ts.sys.args,
             getExecutingFilePath: () => ts.sys.getExecutingFilePath(),
-            getWorkspaceRoot: () => vpath.resolve(__dirname, "../.."),
+            getWorkspaceRoot: () => workspaceRoot,
             exit: exitCode => ts.sys.exit(exitCode),
             readDirectory: (path, extension, exclude, include, depth) => ts.sys.readDirectory(path, extension, exclude, include, depth),
             getAccessibleFileSystemEntries,

src/harness/tsconfig.json

@@ -28,6 +28,7 @@
         "evaluatorImpl.ts",
         "fakesHosts.ts",
         "client.ts",
+        "findUpDir.ts",
 
         "runnerbase.ts",
         "sourceMapRecorder.ts",

src/harness/virtualFileSystemWithWatch.ts

@@ -922,7 +922,7 @@ interface Array<T> { length: number; [n: number]: T; }`
                     });
                 }
                 return { directories, files };
-            }, path => this.realpath(path), path => this.directoryExists(path));
+            }, path => this.realpath(path));
         }
 
         createHash(s: string): string {

src/lib/es2020.intl.d.ts

@@ -200,7 +200,7 @@ declare namespace Intl {
     interface NumberFormatOptions {
         compactDisplay?: "short" | "long" | undefined;
         notation?: "standard" | "scientific" | "engineering" | "compact" | undefined;
-        signDisplay?: "auto" | "never" | "always" | undefined;
+        signDisplay?: "auto" | "never" | "always" | "exceptZero" | undefined;
         unit?: string | undefined;
         unitDisplay?: "short" | "long" | "narrow" | undefined;
     }
@@ -208,7 +208,7 @@ declare namespace Intl {
     interface ResolvedNumberFormatOptions {
         compactDisplay?: "short" | "long";
         notation?: "standard" | "scientific" | "engineering" | "compact";
-        signDisplay?: "auto" | "never" | "always";
+        signDisplay?: "auto" | "never" | "always" | "exceptZero";
         unit?: string;
         unitDisplay?: "short" | "long" | "narrow";
     }

src/lib/es2022.array.d.ts

@@ -0,0 +1,103 @@
+interface Array<T> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): T | undefined;
+}
+
+interface ReadonlyArray<T> {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): T | undefined;
+}
+
+interface Int8Array {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+
+interface Uint8Array {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+
+interface Uint8ClampedArray {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+
+interface Int16Array {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+
+interface Uint16Array {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+
+interface Int32Array {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+
+interface Uint32Array {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+
+interface Float32Array {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+
+interface Float64Array {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): number | undefined;
+}
+
+interface BigInt64Array {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): bigint | undefined;
+}
+
+interface BigUint64Array {
+    /**
+     * Returns the item located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): bigint | undefined;
+}

src/lib/es2022.d.ts

@@ -0,0 +1,5 @@
+/// <reference lib="es2021" />
+/// <reference lib="es2022.array" />
+/// <reference lib="es2022.error" />
+/// <reference lib="es2022.object" />
+/// <reference lib="es2022.string" />

src/lib/es2022.error.d.ts

@@ -0,0 +1,8 @@
+interface ErrorOptions {
+  cause?: Error;
+}
+
+interface ErrorConstructor {
+  new(message?: string, options?: ErrorOptions): Error;
+  (message?: string, options?: ErrorOptions): Error;
+}

src/lib/es2022.full.d.ts

@@ -0,0 +1,5 @@
+/// <reference lib="es2022" />
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
+/// <reference lib="scripthost" />
+/// <reference lib="dom.iterable" />

src/lib/es2022.object.d.ts

@@ -0,0 +1,8 @@
+interface Object {
+    /**
+     * Determines whether an object has a property with the specified name.
+     * @param o An object.
+     * @param v A property name.
+     */
+    hasOwn(o: object, v: PropertyKey): boolean;
+}

src/lib/es2022.string.d.ts

@@ -0,0 +1,7 @@
+interface String {
+    /**
+     * Returns a new String consisting of the single UTF-16 code unit located at the specified index.
+     * @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
+     */
+    at(index: number): string | undefined;
+}

src/lib/es5.d.ts

@@ -96,7 +96,7 @@ interface PropertyDescriptor {
 }
 
 interface PropertyDescriptorMap {
-    [s: string]: PropertyDescriptor;
+    [key: PropertyKey]: PropertyDescriptor;
 }
 
 interface Object {

src/lib/esnext.d.ts

@@ -1,2 +1,2 @@
-/// <reference lib="es2021" />
+/// <reference lib="es2022" />
 /// <reference lib="esnext.intl" />

src/lib/libs.json

@@ -9,6 +9,7 @@
         "es2019",
         "es2020",
         "es2021",
+        "es2022",
         "esnext",
         // Host only
         "dom.generated",
@@ -52,6 +53,10 @@
         "es2021.promise",
         "es2021.weakref",
         "es2021.intl",
+        "es2022.array",
+        "es2022.error",
+        "es2022.object",
+        "es2022.string",
         "esnext.intl",
         // Default libraries
         "es5.full",
@@ -62,6 +67,7 @@
         "es2019.full",
         "es2020.full",
         "es2021.full",
+        "es2022.full",
         "esnext.full"
     ],
     "paths": {

src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl

@@ -7764,6 +7764,15 @@
         </Str>
         <Disp Icon="Str" />
       </Item>
+      <Item ItemId=";JSON_imports_are_experimental_in_ES_module_mode_imports_7062" ItemType="0" PsrId="306" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[JSON imports are experimental in ES module mode imports.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[JSON 导入在 ES 模块模式导入中是实验性的。]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
       <Item ItemId=";JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000" ItemType="0" PsrId="306" Leaf="true">
         <Str Cat="Text">
           <Val><![CDATA[JSX attributes must only be assigned a non-empty 'expression'.]]></Val>

src/loc/lcl/csy/diagnosticMessages/diagnosticMessages.generated.json.lcl

@@ -7773,6 +7773,15 @@
         </Str>
         <Disp Icon="Str" />
       </Item>
+      <Item ItemId=";JSON_imports_are_experimental_in_ES_module_mode_imports_7062" ItemType="0" PsrId="306" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[JSON imports are experimental in ES module mode imports.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Importy JSON jsou v importech režimu modulu ES experimentální.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
       <Item ItemId=";JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000" ItemType="0" PsrId="306" Leaf="true">
         <Str Cat="Text">
           <Val><![CDATA[JSX attributes must only be assigned a non-empty 'expression'.]]></Val>

src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl

@@ -7761,6 +7761,15 @@
         </Str>
         <Disp Icon="Str" />
       </Item>
+      <Item ItemId=";JSON_imports_are_experimental_in_ES_module_mode_imports_7062" ItemType="0" PsrId="306" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[JSON imports are experimental in ES module mode imports.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[JSON-Importe sind experimentell in Importen im ES-Modulmodus.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
       <Item ItemId=";JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000" ItemType="0" PsrId="306" Leaf="true">
         <Str Cat="Text">
           <Val><![CDATA[JSX attributes must only be assigned a non-empty 'expression'.]]></Val>

src/loc/lcl/fra/diagnosticMessages/diagnosticMessages.generated.json.lcl

@@ -7776,6 +7776,15 @@
         </Str>
         <Disp Icon="Str" />
       </Item>
+      <Item ItemId=";JSON_imports_are_experimental_in_ES_module_mode_imports_7062" ItemType="0" PsrId="306" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[JSON imports are experimental in ES module mode imports.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Les importations JSON sont expérimentales dans les importations en mode module ES.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
       <Item ItemId=";JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000" ItemType="0" PsrId="306" Leaf="true">
         <Str Cat="Text">
           <Val><![CDATA[JSX attributes must only be assigned a non-empty 'expression'.]]></Val>

src/loc/lcl/ita/diagnosticMessages/diagnosticMessages.generated.json.lcl

@@ -7764,6 +7764,15 @@
         </Str>
         <Disp Icon="Str" />
       </Item>
+      <Item ItemId=";JSON_imports_are_experimental_in_ES_module_mode_imports_7062" ItemType="0" PsrId="306" Leaf="true">
+        <Str Cat="Text">
+          <Val><![CDATA[JSON imports are experimental in ES module mode imports.]]></Val>
+          <Tgt Cat="Text" Stat="Loc" Orig="New">
+            <Val><![CDATA[Le importazioni JSON sono sperimentali nelle importazioni in modalità modulo ES.]]></Val>
+          </Tgt>
+        </Str>
+        <Disp Icon="Str" />
+      </Item>
       <Item ItemId=";JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000" ItemType="0" PsrId="306" Leaf="true">
         <Str Cat="Text">
           <Val><![CDATA[JSX attributes must only be assigned a non-empty 'expression'.]]></Val>

src/server/editorServices.ts

@@ -49,24 +49,23 @@ namespace ts.server {
         readonly data: ProjectInfoTelemetryEventData;
     }
 
-    /*
-     * __GDPR__
-     * "projectInfo" : {
-     *      "${include}": ["${TypeScriptCommonProperties}"],
-     *      "projectId": { "classification": "EndUserPseudonymizedInformation", "purpose": "FeatureInsight", "endpoint": "ProjectId" },
-     *      "fileStats": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "compilerOptions": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "extends": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "files": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "include": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "exclude": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "compileOnSave": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "typeAcquisition": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "configFileName": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "projectType": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "languageServiceEnabled": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *      "version": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
-     * }
+    /* __GDPR__
+        "projectInfo" : {
+            "${include}": ["${TypeScriptCommonProperties}"],
+            "projectId": { "classification": "EndUserPseudonymizedInformation", "purpose": "FeatureInsight", "endpoint": "ProjectId" },
+            "fileStats": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "compilerOptions": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "extends": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "files": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "include": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "exclude": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "compileOnSave": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "typeAcquisition": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "configFileName": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "projectType": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "languageServiceEnabled": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "version": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+        }
      */
     export interface ProjectInfoTelemetryEventData {
         /** Cryptographically secure hash of project file location. */

src/server/project.ts

@@ -1031,6 +1031,11 @@ namespace ts.server {
             }
         }
 
+        /* @internal */
+        onDiscoveredSymlink() {
+            this.hasAddedOrRemovedSymlinks = true;
+        }
+
         /**
          * Updates set of files that contribute to this project
          * @returns: true if set of files in the project stays the same and false - otherwise.
@@ -1939,15 +1944,15 @@ namespace ts.server {
                 for (const resolution of resolutions) {
                     if (!resolution.resolvedFileName) continue;
                     const { resolvedFileName, originalPath } = resolution;
+                    if (originalPath) {
+                        symlinkCache.setSymlinkedDirectoryFromSymlinkedFile(originalPath, resolvedFileName);
+                    }
                     if (!program.getSourceFile(resolvedFileName) && (!originalPath || !program.getSourceFile(originalPath))) {
                         rootNames = append(rootNames, resolvedFileName);
                         // Avoid creating a large project that would significantly slow down time to editor interactivity
                         if (dependencySelection === PackageJsonAutoImportPreference.Auto && rootNames.length > this.maxDependencies) {
                             return ts.emptyArray;
                         }
-                        if (originalPath) {
-                            symlinkCache.setSymlinkedDirectoryFromSymlinkedFile(originalPath, resolvedFileName);
-                        }
                     }
                 }
             }

src/server/protocol.ts

@@ -3199,14 +3199,32 @@ namespace ts.server.protocol {
         payload: TypingsInstalledTelemetryEventPayload;
     }
 
-    /*
-     * __GDPR__
-     * "typingsinstalled" : {
-     *     "${include}": ["${TypeScriptCommonProperties}"],
-     *     "installedPackages": { "classification": "PublicNonPersonalData", "purpose": "FeatureInsight" },
-     *     "installSuccess": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-     *     "typingsInstallerVersion": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
-     * }
+    // A __GDPR__FRAGMENT__ has no meaning until it is ${include}d by a __GDPR__ comment, at which point
+    // the included properties are effectively inlined into the __GDPR__ declaration.  In this case, for
+    // example, any __GDPR__ comment including the TypeScriptCommonProperties will be updated with an
+    // additional version property with the classification below.  Obviously, the purpose of such a construct
+    // is to reduce duplication and keep multiple use sites consistent (e.g. by making sure that all reflect
+    // any newly added TypeScriptCommonProperties).  Unfortunately, the system has limits - in particular,
+    // these reusable __GDPR__FRAGMENT__s are not accessible across repo boundaries.  Therefore, even though
+    // the code for adding the common properties (i.e. version), along with the corresponding __GDPR__FRAGMENT__,
+    // lives in the VS Code repo (see https://github.com/microsoft/vscode/blob/main/extensions/typescript-language-features/src/utils/telemetry.ts)
+    // we have to duplicate it here.  It would be nice to keep them in sync, but the only likely failure mode
+    // is adding a property to the VS Code repro but not here and the only consequence would be having that
+    // property suppressed on the events (i.e. __GDPT__ comments) in this repo that reference the out-of-date
+    // local __GDPR__FRAGMENT__.
+    /* __GDPR__FRAGMENT__
+        "TypeScriptCommonProperties" : {
+            "version" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+        }
+    */
+
+    /* __GDPR__
+        "typingsinstalled" : {
+            "${include}": ["${TypeScriptCommonProperties}"],
+            "installedPackages": { "classification": "PublicNonPersonalData", "purpose": "FeatureInsight" },
+            "installSuccess": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+            "typingsInstallerVersion": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+        }
      */
     export interface TypingsInstalledTelemetryEventPayload {
         /**
@@ -3516,6 +3534,7 @@ namespace ts.server.protocol {
         ES2019 = "ES2019",
         ES2020 = "ES2020",
         ES2021 = "ES2021",
+        ES2022 = "ES2022",
         ESNext = "ESNext"
     }
 

src/server/session.ts

@@ -2112,7 +2112,7 @@ namespace ts.server {
         private getFullNavigateToItems(args: protocol.NavtoRequestArgs): CombineOutputResult<NavigateToItem> {
             const { currentFileOnly, searchValue, maxResultCount, projectFileName } = args;
             if (currentFileOnly) {
-                Debug.assertDefined(args.file);
+                Debug.assertIsDefined(args.file);
                 const { file, project } = this.getFileAndProject(args as protocol.FileRequestArgs);
                 return [{ project, result: project.getLanguageService().getNavigateToItems(searchValue, maxResultCount, file) }];
             }

src/services/codeFixProvider.ts

@@ -3,13 +3,6 @@ namespace ts.codefix {
     const errorCodeToFixes = createMultiMap<CodeFixRegistration>();
     const fixIdToRegistration = new Map<string, CodeFixRegistration>();
 
-    export type DiagnosticAndArguments = DiagnosticMessage | [DiagnosticMessage, string] | [DiagnosticMessage, string, string];
-    function diagnosticToString(diag: DiagnosticAndArguments): string {
-        return isArray(diag)
-            ? formatStringFromArgs(getLocaleSpecificMessage(diag[0]), diag.slice(1) as readonly string[])
-            : getLocaleSpecificMessage(diag);
-    }
-
     export function createCodeFixActionWithoutFixAll(fixName: string, changes: FileTextChanges[], description: DiagnosticAndArguments) {
         return createCodeFixActionWorker(fixName, diagnosticToString(description), changes, /*fixId*/ undefined, /*fixAllDescription*/ undefined);
     }

src/services/codefixes/addNameToNamelessParameter.ts

@@ -14,24 +14,24 @@ namespace ts.codefix {
 
     function makeChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, pos: number) {
         const token = getTokenAtPosition(sourceFile, pos);
-        if (!isIdentifier(token)) {
-            return Debug.fail("add-name-to-nameless-parameter operates on identifiers, but got a " + Debug.formatSyntaxKind(token.kind));
-        }
         const param = token.parent;
         if (!isParameter(param)) {
             return Debug.fail("Tried to add a parameter name to a non-parameter: " + Debug.formatSyntaxKind(token.kind));
         }
+
         const i = param.parent.parameters.indexOf(param);
         Debug.assert(!param.type, "Tried to add a parameter name to a parameter that already had one.");
         Debug.assert(i > -1, "Parameter not found in parent parameter list.");
+
+        const typeNode = factory.createTypeReferenceNode(param.name as Identifier, /*typeArguments*/ undefined);
         const replacement = factory.createParameterDeclaration(
             /*decorators*/ undefined,
             param.modifiers,
             param.dotDotDotToken,
             "arg" + i,
             param.questionToken,
-            factory.createTypeReferenceNode(token, /*typeArguments*/ undefined),
+            param.dotDotDotToken ? factory.createArrayTypeNode(typeNode) : typeNode,
             param.initializer);
-        changeTracker.replaceNode(sourceFile, token, replacement);
+        changeTracker.replaceNode(sourceFile, param, replacement);
     }
 }

src/services/codefixes/convertToEsModule.ts

@@ -408,9 +408,7 @@ namespace ts.codefix {
                 const importSpecifiers = mapAllOrFail(name.elements, e =>
                     e.dotDotDotToken || e.initializer || e.propertyName && !isIdentifier(e.propertyName) || !isIdentifier(e.name)
                         ? undefined
-                        // (TODO: GH#18217)
-                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-                        : makeImportSpecifier(e.propertyName && (e.propertyName as Identifier).text, e.name.text));
+                        : makeImportSpecifier(e.propertyName && e.propertyName.text, e.name.text));
                 if (importSpecifiers) {
                     return convertedImports([makeImport(/*name*/ undefined, importSpecifiers, moduleSpecifier, quotePreference)]);
                 }

src/services/codefixes/fixImplicitThis.ts

@@ -26,9 +26,9 @@ namespace ts.codefix {
         if (!isFunctionDeclaration(fn) && !isFunctionExpression(fn)) return undefined;
 
         if (!isSourceFile(getThisContainer(fn, /*includeArrowFunctions*/ false))) { // 'this' is defined outside, convert to arrow function
-            const fnKeyword = Debug.assertDefined(findChildOfKind(fn, SyntaxKind.FunctionKeyword, sourceFile));
+            const fnKeyword = Debug.checkDefined(findChildOfKind(fn, SyntaxKind.FunctionKeyword, sourceFile));
             const { name } = fn;
-            const body = Debug.assertDefined(fn.body); // Should be defined because the function contained a 'this' expression
+            const body = Debug.checkDefined(fn.body); // Should be defined because the function contained a 'this' expression
             if (isFunctionExpression(fn)) {
                 if (name && FindAllReferences.Core.isSymbolReferencedInFile(name, checker, sourceFile, body)) {
                     // Function expression references itself. To fix we would have to extract it to a const.

src/services/codefixes/fixOverrideModifier.ts

@@ -17,37 +17,81 @@ namespace ts.codefix {
         Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code,
         Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code,
         Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code,
-        Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code
+        Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code,
+        Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code,
+        Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code,
+        Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code,
+        Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code,
     ];
 
-    const errorCodeFixIdMap: Record<number, [DiagnosticMessage, string | undefined, DiagnosticMessage | undefined]> = {
-        [Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code]: [
-            Diagnostics.Add_override_modifier, fixAddOverrideId, Diagnostics.Add_all_missing_override_modifiers,
-        ],
-        [Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code]: [
-            Diagnostics.Remove_override_modifier, fixRemoveOverrideId, Diagnostics.Remove_all_unnecessary_override_modifiers
-        ],
-        [Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code]: [
-            Diagnostics.Add_override_modifier, fixAddOverrideId, Diagnostics.Add_all_missing_override_modifiers,
-        ],
-        [Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code]: [
-            Diagnostics.Add_override_modifier, fixAddOverrideId, Diagnostics.Remove_all_unnecessary_override_modifiers
-        ],
-        [Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code]: [
-            Diagnostics.Remove_override_modifier, fixRemoveOverrideId, Diagnostics.Remove_all_unnecessary_override_modifiers
-        ]
+    interface ErrorCodeFixInfo {
+        descriptions: DiagnosticMessage;
+        fixId?: string | undefined;
+        fixAllDescriptions?: DiagnosticMessage | undefined;
+    }
+
+    const errorCodeFixIdMap: Record<number, ErrorCodeFixInfo> = {
+        // case #1:
+        [Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code]: {
+            descriptions: Diagnostics.Add_override_modifier,
+            fixId: fixAddOverrideId,
+            fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers,
+        },
+        [Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code]: {
+            descriptions: Diagnostics.Add_override_modifier,
+            fixId: fixAddOverrideId,
+            fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers
+        },
+        // case #2:
+        [Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code]: {
+            descriptions: Diagnostics.Remove_override_modifier,
+            fixId: fixRemoveOverrideId,
+            fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers,
+        },
+        [Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code]: {
+            descriptions: Diagnostics.Remove_override_modifier,
+            fixId: fixRemoveOverrideId,
+            fixAllDescriptions: Diagnostics.Remove_override_modifier
+        },
+        // case #3:
+        [Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code]: {
+            descriptions: Diagnostics.Add_override_modifier,
+            fixId: fixAddOverrideId,
+            fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers,
+        },
+        [Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code]: {
+            descriptions: Diagnostics.Add_override_modifier,
+            fixId: fixAddOverrideId,
+            fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers,
+        },
+        // case #4:
+        [Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code]: {
+            descriptions: Diagnostics.Add_override_modifier,
+            fixId: fixAddOverrideId,
+            fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers,
+        },
+        // case #5:
+        [Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code]: {
+            descriptions: Diagnostics.Remove_override_modifier,
+            fixId: fixRemoveOverrideId,
+            fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers,
+        },
+        [Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code]: {
+            descriptions: Diagnostics.Remove_override_modifier,
+            fixId: fixRemoveOverrideId,
+            fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers,
+        }
     };
 
     registerCodeFix({
         errorCodes,
         getCodeActions: context => {
-            const { errorCode, span, sourceFile } = context;
+            const { errorCode, span } = context;
 
             const info = errorCodeFixIdMap[errorCode];
             if (!info) return emptyArray;
 
-            const [ descriptions, fixId, fixAllDescriptions ] = info;
-            if (isSourceFileJS(sourceFile)) return emptyArray;
+            const { descriptions, fixId, fixAllDescriptions } = info;
             const changes = textChanges.ChangeTracker.with(context, changes => dispatchChanges(changes, context, errorCode, span.start));
 
             return [
@@ -57,9 +101,9 @@ namespace ts.codefix {
         fixIds: [fixName, fixAddOverrideId, fixRemoveOverrideId],
         getAllCodeActions: context =>
             codeFixAll(context, errorCodes, (changes, diag) => {
-                const { code, start, file } = diag;
+                const { code, start } = diag;
                 const info = errorCodeFixIdMap[code];
-                if (!info || info[1] !== context.fixId || isSourceFileJS(file)) {
+                if (!info || info.fixId !== context.fixId) {
                     return;
                 }
 
@@ -74,11 +118,15 @@ namespace ts.codefix {
         pos: number) {
         switch (errorCode) {
             case Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code:
+            case Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code:
             case Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code:
             case Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code:
+            case Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code:
                 return doAddOverrideModifierChange(changeTracker, context.sourceFile, pos);
             case Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code:
+            case Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code:
             case Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code:
+            case Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code:
                 return doRemoveOverrideModifierChange(changeTracker, context.sourceFile, pos);
             default:
                 Debug.fail("Unexpected error code: " + errorCode);
@@ -87,6 +135,10 @@ namespace ts.codefix {
 
     function doAddOverrideModifierChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, pos: number) {
         const classElement = findContainerClassElementLike(sourceFile, pos);
+        if (isSourceFileJS(sourceFile)) {
+            changeTracker.addJSDocTags(sourceFile, classElement, [factory.createJSDocOverrideTag(factory.createIdentifier("override"))]);
+            return;
+        }
         const modifiers = classElement.modifiers || emptyArray;
         const staticModifier = find(modifiers, isStaticModifier);
         const abstractModifier = find(modifiers, isAbstractModifier);
@@ -101,6 +153,10 @@ namespace ts.codefix {
 
     function doRemoveOverrideModifierChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, pos: number) {
         const classElement = findContainerClassElementLike(sourceFile, pos);
+        if (isSourceFileJS(sourceFile)) {
+            changeTracker.filterJSDocTags(sourceFile, classElement, not(isJSDocOverrideTag));
+            return;
+        }
         const overrideModifier = classElement.modifiers && find(classElement.modifiers, modifier => modifier.kind === SyntaxKind.OverrideKeyword);
         Debug.assertIsDefined(overrideModifier);
 

src/services/codefixes/helpers.ts

@@ -37,6 +37,12 @@ namespace ts.codefix {
 
     type AddNode = PropertyDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | MethodDeclaration | FunctionExpression | ArrowFunction;
 
+    export const enum PreserveOptionalFlags {
+        Method  = 1 << 0,
+        Property = 1 << 1,
+        All     = Method | Property
+    }
+
     /**
      * `addClassElement` will not be called if we can't figure out a representation for `symbol` in `enclosingDeclaration`.
      * @param body If defined, this will be the body of the member node passed to `addClassElement`. Otherwise, the body will default to a stub.
@@ -50,6 +56,7 @@ namespace ts.codefix {
         importAdder: ImportAdder | undefined,
         addClassElement: (node: AddNode) => void,
         body: Block | undefined,
+        preserveOptional = PreserveOptionalFlags.All,
         isAmbient = false,
     ): void {
         const declarations = symbol.getDeclarations();
@@ -83,7 +90,7 @@ namespace ts.codefix {
                     /*decorators*/ undefined,
                     modifiers,
                     name,
-                    optional ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
+                    optional && (preserveOptional & PreserveOptionalFlags.Property) ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
                     typeNode,
                     /*initializer*/ undefined));
                 break;
@@ -158,14 +165,14 @@ namespace ts.codefix {
                     }
                     else {
                         Debug.assert(declarations.length === signatures.length, "Declarations and signatures should match count");
-                        addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference, body));
+                        addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional && !!(preserveOptional & PreserveOptionalFlags.Method), modifiers, quotePreference, body));
                     }
                 }
                 break;
         }
 
         function outputMethod(quotePreference: QuotePreference, signature: Signature, modifiers: NodeArray<Modifier> | undefined, name: PropertyName, body?: Block): void {
-            const method = createSignatureDeclarationFromSignature(SyntaxKind.MethodDeclaration, context, quotePreference, signature, body, name, modifiers, optional, enclosingDeclaration, importAdder);
+            const method = createSignatureDeclarationFromSignature(SyntaxKind.MethodDeclaration, context, quotePreference, signature, body, name, modifiers, optional && !!(preserveOptional & PreserveOptionalFlags.Method), enclosingDeclaration, importAdder);
             if (method) addClassElement(method);
         }
     }

src/services/codefixes/importFixes.ts

@@ -33,6 +33,7 @@ namespace ts.codefix {
     });
 
     export interface ImportAdder {
+        hasFixes(): boolean;
         addImportFromDiagnostic: (diagnostic: DiagnosticWithLocation, context: CodeFixContextBase) => void;
         addImportFromExportedSymbol: (exportedSymbol: Symbol, isValidTypeOnlyUseSite?: boolean) => void;
         writeFixes: (changeTracker: textChanges.ChangeTracker) => void;
@@ -59,7 +60,7 @@ namespace ts.codefix {
         type NewImportsKey = `${0 | 1}|${string}`;
         /** Use `getNewImportEntry` for access */
         const newImports = new Map<NewImportsKey, Mutable<ImportsCollection & { useRequire: boolean }>>();
-        return { addImportFromDiagnostic, addImportFromExportedSymbol, writeFixes };
+        return { addImportFromDiagnostic, addImportFromExportedSymbol, writeFixes, hasFixes };
 
         function addImportFromDiagnostic(diagnostic: DiagnosticWithLocation, context: CodeFixContextBase) {
             const info = getFixesInfo(context, diagnostic.code, diagnostic.start, useAutoImportProvider);
@@ -217,6 +218,10 @@ namespace ts.codefix {
                 insertImports(changeTracker, sourceFile, newDeclarations, /*blankLineBetween*/ true);
             }
         }
+
+        function hasFixes() {
+            return addToNamespace.length > 0 || importType.length > 0 || addToExisting.size > 0 || newImports.size > 0;
+        }
     }
 
     // Sorted with the preferred fix coming first.

src/services/codefixes/inferFromUsage.ts

@@ -131,7 +131,7 @@ namespace ts.codefix {
                     if (typeNode) {
                         // Note that the codefix will never fire with an existing `@type` tag, so there is no need to merge tags
                         const typeTag = factory.createJSDocTypeTag(/*tagName*/ undefined, factory.createJSDocTypeExpression(typeNode), /*comment*/ undefined);
-                        addJSDocTags(changes, sourceFile, cast(parent.parent.parent, isExpressionStatement), [typeTag]);
+                        changes.addJSDocTags(sourceFile, cast(parent.parent.parent, isExpressionStatement), [typeTag]);
                     }
                     importAdder.writeFixes(changes);
                     return parent;
@@ -271,7 +271,7 @@ namespace ts.codefix {
     }
 
     function annotateJSDocThis(changes: textChanges.ChangeTracker, sourceFile: SourceFile, containingFunction: SignatureDeclaration, typeNode: TypeNode) {
-        addJSDocTags(changes, sourceFile, containingFunction, [
+        changes.addJSDocTags(sourceFile, containingFunction, [
             factory.createJSDocThisTag(/*tagName*/ undefined, factory.createJSDocTypeExpression(typeNode)),
         ]);
     }
@@ -311,7 +311,7 @@ namespace ts.codefix {
                 }
                 const typeExpression = factory.createJSDocTypeExpression(typeNode);
                 const typeTag = isGetAccessorDeclaration(declaration) ? factory.createJSDocReturnTag(/*tagName*/ undefined, typeExpression, /*comment*/ undefined) : factory.createJSDocTypeTag(/*tagName*/ undefined, typeExpression, /*comment*/ undefined);
-                addJSDocTags(changes, sourceFile, parent, [typeTag]);
+                changes.addJSDocTags(sourceFile, parent, [typeTag]);
             }
             else if (!tryReplaceImportTypeNodeWithAutoImport(typeNode, declaration, sourceFile, changes, importAdder, getEmitScriptTarget(program.getCompilerOptions()))) {
                 changes.tryInsertTypeAnnotation(sourceFile, declaration, typeNode);
@@ -378,46 +378,7 @@ namespace ts.codefix {
         else {
             const paramTags = map(inferences, ({ name, typeNode, isOptional }) =>
                 factory.createJSDocParameterTag(/*tagName*/ undefined, name, /*isBracketed*/ !!isOptional, factory.createJSDocTypeExpression(typeNode), /* isNameFirst */ false, /*comment*/ undefined));
-            addJSDocTags(changes, sourceFile, signature, paramTags);
-        }
-    }
-
-    export function addJSDocTags(changes: textChanges.ChangeTracker, sourceFile: SourceFile, parent: HasJSDoc, newTags: readonly JSDocTag[]): void {
-        const comments = flatMap(parent.jsDoc, j => typeof j.comment === "string" ? factory.createJSDocText(j.comment) : j.comment) as JSDocComment[];
-        const oldTags = flatMapToMutable(parent.jsDoc, j => j.tags);
-        const unmergedNewTags = newTags.filter(newTag => !oldTags || !oldTags.some((tag, i) => {
-            const merged = tryMergeJsdocTags(tag, newTag);
-            if (merged) oldTags[i] = merged;
-            return !!merged;
-        }));
-        const tag = factory.createJSDocComment(factory.createNodeArray(intersperse(comments, factory.createJSDocText("\n"))), factory.createNodeArray([...(oldTags || emptyArray), ...unmergedNewTags]));
-        const jsDocNode = parent.kind === SyntaxKind.ArrowFunction ? getJsDocNodeForArrowFunction(parent) : parent;
-        jsDocNode.jsDoc = parent.jsDoc;
-        jsDocNode.jsDocCache = parent.jsDocCache;
-        changes.insertJsdocCommentBefore(sourceFile, jsDocNode, tag);
-    }
-
-    function getJsDocNodeForArrowFunction(signature: ArrowFunction): HasJSDoc {
-        if (signature.parent.kind === SyntaxKind.PropertyDeclaration) {
-            return signature.parent as HasJSDoc;
-        }
-        return signature.parent.parent as HasJSDoc;
-    }
-
-    function tryMergeJsdocTags(oldTag: JSDocTag, newTag: JSDocTag): JSDocTag | undefined {
-        if (oldTag.kind !== newTag.kind) {
-            return undefined;
-        }
-        switch (oldTag.kind) {
-            case SyntaxKind.JSDocParameterTag: {
-                const oldParam = oldTag as JSDocParameterTag;
-                const newParam = newTag as JSDocParameterTag;
-                return isIdentifier(oldParam.name) && isIdentifier(newParam.name) && oldParam.name.escapedText === newParam.name.escapedText
-                    ? factory.createJSDocParameterTag(/*tagName*/ undefined, newParam.name, /*isBracketed*/ false, newParam.typeExpression, newParam.isNameFirst, oldParam.comment)
-                    : undefined;
-            }
-            case SyntaxKind.JSDocReturnTag:
-                return factory.createJSDocReturnTag(/*tagName*/ undefined, (newTag as JSDocReturnTag).typeExpression, oldTag.comment);
+            changes.addJSDocTags(sourceFile, signature, paramTags);
         }
     }
 
@@ -1000,13 +961,25 @@ namespace ts.codefix {
             if (usage.numberIndex) {
                 types.push(checker.createArrayType(combineFromUsage(usage.numberIndex)));
             }
-            if (usage.properties?.size || usage.calls?.length || usage.constructs?.length || usage.stringIndex) {
+            if (usage.properties?.size || usage.constructs?.length || usage.stringIndex) {
                 types.push(inferStructuralType(usage));
             }
 
-            types.push(...(usage.candidateTypes || []).map(t => checker.getBaseTypeOfLiteralType(t)));
-            types.push(...inferNamedTypesFromProperties(usage));
+            const candidateTypes = (usage.candidateTypes || []).map(t => checker.getBaseTypeOfLiteralType(t));
+            const callsType = usage.calls?.length ? inferStructuralType(usage) : undefined;
+            if (callsType && candidateTypes) {
+                types.push(checker.getUnionType([callsType, ...candidateTypes], UnionReduction.Subtype));
+            }
+            else {
+                if (callsType) {
+                    types.push(callsType);
+                }
+                if (length(candidateTypes)) {
+                    types.push(...candidateTypes);
+                }
+            }
 
+            types.push(...inferNamedTypesFromProperties(usage));
             return types;
         }
 

src/services/completions.ts

@@ -57,7 +57,9 @@ namespace ts.Completions {
      */
     export enum CompletionSource {
         /** Completions that require `this.` insertion text */
-        ThisProperty = "ThisProperty/"
+        ThisProperty = "ThisProperty/",
+        /** Auto-import that comes attached to a class member snippet */
+        ClassMemberSnippet = "ClassMemberSnippet/",
     }
 
     const enum SymbolOriginInfoKind {
@@ -641,6 +643,7 @@ namespace ts.Completions {
         let replacementSpan = getReplacementSpanForContextToken(replacementToken);
         let data: CompletionEntryData | undefined;
         let isSnippet: true | undefined;
+        let source = getSourceFromOrigin(origin);
         let sourceDisplay;
         let hasAction;
 
@@ -702,7 +705,12 @@ namespace ts.Completions {
             preferences.includeCompletionsWithInsertText &&
             completionKind === CompletionKind.MemberLike &&
             isClassLikeMemberCompletion(symbol, location)) {
-            ({ insertText, isSnippet } = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken));
+            let importAdder;
+            ({ insertText, isSnippet, importAdder } = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken));
+            if (importAdder?.hasFixes()) {
+                hasAction = true;
+                source = CompletionSource.ClassMemberSnippet;
+            }
         }
 
         const kind = SymbolDisplay.getSymbolKind(typeChecker, symbol, location);
@@ -730,10 +738,6 @@ namespace ts.Completions {
                 insertText = `${escapeSnippetText(name)}={$1}`;
                 isSnippet = true;
             }
-
-            if (isSnippet) {
-                replacementSpan = createTextSpanFromNode(location, sourceFile);
-            }
         }
 
         if (insertText !== undefined && !preferences.includeCompletionsWithInsertText) {
@@ -758,7 +762,7 @@ namespace ts.Completions {
             kind,
             kindModifiers: SymbolDisplay.getSymbolModifiers(typeChecker, symbol),
             sortText,
-            source: getSourceFromOrigin(origin),
+            source,
             hasAction: hasAction ? true : undefined,
             isRecommended: isRecommendedCompletionMatch(symbol, recommendedCompletion, typeChecker) || undefined,
             insertText,
@@ -828,7 +832,7 @@ namespace ts.Completions {
         symbol: Symbol,
         location: Node,
         contextToken: Node | undefined,
-    ): { insertText: string, isSnippet?: true } {
+    ): { insertText: string, isSnippet?: true, importAdder?: codefix.ImportAdder } {
         const classLikeDeclaration = findAncestor(location, isClassLike);
         if (!classLikeDeclaration) {
             return { insertText: name };
@@ -843,21 +847,20 @@ namespace ts.Completions {
             removeComments: true,
             module: options.module,
             target: options.target,
-            omitTrailingSemicolon: true,
+            omitTrailingSemicolon: false,
             newLine: getNewLineKind(getNewLineCharacter(options, maybeBind(host, host.getNewLine))),
         });
         const importAdder = codefix.createImportAdder(sourceFile, program, preferences, host);
 
         let body;
-        let tabstopStart = 1;
         if (preferences.includeCompletionsWithSnippetText) {
             isSnippet = true;
-            // We are adding a final tabstop (i.e. $0) in the body of the suggested member, if it has one.
+            // We are adding a tabstop (i.e. `$0`) in the body of the suggested member,
+            // if it has one, so that the cursor ends up in the body once the completion is inserted.
             // Note: this assumes we won't have more than one body in the completion nodes, which should be the case.
-            const emptyStatement1 = factory.createExpressionStatement(factory.createIdentifier(""));
-            setSnippetElement(emptyStatement1, { kind: SnippetKind.TabStop, order: 1 });
-            tabstopStart = 2;
-            body = factory.createBlock([emptyStatement1], /* multiline */ true);
+            const emptyStatement = factory.createExpressionStatement(factory.createIdentifier(""));
+            setSnippetElement(emptyStatement, { kind: SnippetKind.TabStop, order: 0 });
+            body = factory.createBlock([emptyStatement], /* multiline */ true);
         }
         else {
             body = factory.createBlock([], /* multiline */ true);
@@ -888,7 +891,7 @@ namespace ts.Completions {
             node => {
                 let requiredModifiers = ModifierFlags.None;
                 if (isAbstract) {
-                        requiredModifiers |= ModifierFlags.Abstract;
+                    requiredModifiers |= ModifierFlags.Abstract;
                 }
                 if (isClassElement(node)
                     && checker.getMemberOverrideModifierStatus(classLikeDeclaration, node) === MemberOverrideStatus.NeedsOverride) {
@@ -912,16 +915,17 @@ namespace ts.Completions {
                 completionNodes.push(node);
             },
             body,
+            codefix.PreserveOptionalFlags.Property,
             isAbstract);
 
         if (completionNodes.length) {
-            if (preferences.includeCompletionsWithSnippetText) {
-                addSnippets(completionNodes, tabstopStart);
-            }
-            insertText = printer.printSnippetList(ListFormat.MultiLine, factory.createNodeArray(completionNodes), sourceFile);
+            insertText = printer.printSnippetList(
+                ListFormat.MultiLine | ListFormat.NoTrailingNewLine,
+                factory.createNodeArray(completionNodes),
+                sourceFile);
         }
 
-        return { insertText, isSnippet };
+        return { insertText, isSnippet, importAdder };
     }
 
     function getPresentModifiers(contextToken: Node): ModifierFlags {
@@ -965,35 +969,6 @@ namespace ts.Completions {
         return undefined;
     }
 
-    function addSnippets(nodes: Node[], orderStart: number): void {
-        let order = orderStart;
-        for (const node of nodes) {
-            addSnippetsWorker(node, /*parent*/ undefined);
-        }
-
-        function addSnippetsWorker(node: Node, parent: Node | undefined) {
-            if (isVariableLike(node) && node.kind === SyntaxKind.Parameter) {
-                // Placeholder
-                setSnippetElement(node.name, { kind: SnippetKind.Placeholder, order });
-                order += 1;
-                if (node.type) {
-                    setSnippetElement(node.type, { kind: SnippetKind.Placeholder, order });
-                    order += 1;
-                }
-            }
-            else if (isTypeNode(node) && parent && isFunctionLikeDeclaration(parent)) {
-                setSnippetElement(node, { kind: SnippetKind.Placeholder, order });
-                order += 1;
-            }
-            else if (isTypeParameterDeclaration(node) && parent && isFunctionLikeDeclaration(parent)) {
-                setSnippetElement(node, { kind: SnippetKind.Placeholder, order });
-                order += 1;
-            }
-
-            forEachChild(node, child => addSnippetsWorker(child, node));
-        }
-    }
-
     function createSnippetPrinter(
         printerOptions: PrinterOptions,
     ) {
@@ -1297,6 +1272,7 @@ namespace ts.Completions {
         location: Node;
         origin: SymbolOriginInfo | SymbolOriginInfoExport | SymbolOriginInfoResolvedExport | undefined;
         previousToken: Node | undefined;
+        contextToken: Node | undefined;
         readonly isJsxInitializer: IsJsxInitializer;
         readonly isTypeOnlyLocation: boolean;
     }
@@ -1312,11 +1288,13 @@ namespace ts.Completions {
         if (entryId.data) {
             const autoImport = getAutoImportSymbolFromCompletionEntryData(entryId.name, entryId.data, program, host);
             if (autoImport) {
+                const { contextToken, previousToken } = getRelevantTokens(position, sourceFile);
                 return {
                     type: "symbol",
                     symbol: autoImport.symbol,
                     location: getTouchingPropertyName(sourceFile, position),
-                    previousToken: findPrecedingToken(position, sourceFile, /*startNode*/ undefined)!,
+                    previousToken,
+                    contextToken,
                     isJsxInitializer: false,
                     isTypeOnlyLocation: false,
                     origin: autoImport.origin,
@@ -1333,7 +1311,7 @@ namespace ts.Completions {
             return { type: "request", request: completionData };
         }
 
-        const { symbols, literals, location, completionKind, symbolToOriginInfoMap, previousToken, isJsxInitializer, isTypeOnlyLocation } = completionData;
+        const { symbols, literals, location, completionKind, symbolToOriginInfoMap, contextToken, previousToken, isJsxInitializer, isTypeOnlyLocation } = completionData;
 
         const literal = find(literals, l => completionNameForLiteral(sourceFile, preferences, l) === entryId.name);
         if (literal !== undefined) return { type: "literal", literal };
@@ -1345,8 +1323,8 @@ namespace ts.Completions {
         return firstDefined(symbols, (symbol, index): SymbolCompletion | undefined => {
             const origin = symbolToOriginInfoMap[index];
             const info = getCompletionEntryDisplayNameForSymbol(symbol, getEmitScriptTarget(compilerOptions), origin, completionKind, completionData.isJsxIdentifierExpected);
-            return info && info.name === entryId.name && getSourceFromOrigin(origin) === entryId.source
-                ? { type: "symbol" as const, symbol, location, origin, previousToken, isJsxInitializer, isTypeOnlyLocation }
+            return info && info.name === entryId.name && (entryId.source === CompletionSource.ClassMemberSnippet && symbol.flags & SymbolFlags.ClassMember || getSourceFromOrigin(origin) === entryId.source)
+                ? { type: "symbol" as const, symbol, location, origin, contextToken, previousToken, isJsxInitializer, isTypeOnlyLocation }
                 : undefined;
         }) || { type: "none" };
     }
@@ -1370,7 +1348,7 @@ namespace ts.Completions {
     ): CompletionEntryDetails | undefined {
         const typeChecker = program.getTypeChecker();
         const compilerOptions = program.getCompilerOptions();
-        const { name } = entryId;
+        const { name, source, data } = entryId;
 
         const contextToken = findPrecedingToken(position, sourceFile);
         if (isInString(sourceFile, position, contextToken)) {
@@ -1396,8 +1374,8 @@ namespace ts.Completions {
                 }
             }
             case "symbol": {
-                const { symbol, location, origin, previousToken } = symbolCompletion;
-                const { codeActions, sourceDisplay } = getCompletionEntryCodeActionsAndSourceDisplay(origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, entryId.data);
+                const { symbol, location, contextToken, origin, previousToken } = symbolCompletion;
+                const { codeActions, sourceDisplay } = getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source);
                 return createCompletionDetailsForSymbol(symbol, typeChecker, sourceFile, location, cancellationToken, codeActions, sourceDisplay); // TODO: GH#18217
             }
             case "literal": {
@@ -1433,6 +1411,9 @@ namespace ts.Completions {
         readonly sourceDisplay: SymbolDisplayPart[] | undefined;
     }
     function getCompletionEntryCodeActionsAndSourceDisplay(
+        name: string,
+        location: Node,
+        contextToken: Node | undefined,
         origin: SymbolOriginInfo | SymbolOriginInfoExport | SymbolOriginInfoResolvedExport | undefined,
         symbol: Symbol,
         program: Program,
@@ -1444,6 +1425,7 @@ namespace ts.Completions {
         formatContext: formatting.FormatContext,
         preferences: UserPreferences,
         data: CompletionEntryData | undefined,
+        source: string | undefined,
     ): CodeActionsAndSourceDisplay {
         if (data?.moduleSpecifier) {
             const { contextToken, previousToken } = getRelevantTokens(position, sourceFile);
@@ -1453,6 +1435,30 @@ namespace ts.Completions {
             }
         }
 
+        if (source === CompletionSource.ClassMemberSnippet) {
+            const { importAdder } = getEntryForMemberCompletion(
+                host,
+                program,
+                compilerOptions,
+                preferences,
+                name,
+                symbol,
+                location,
+                contextToken);
+            if (importAdder) {
+                const changes = textChanges.ChangeTracker.with(
+                    { host, formatContext, preferences },
+                    importAdder.writeFixes);
+                return {
+                    sourceDisplay: undefined,
+                    codeActions: [{
+                        changes,
+                        description: diagnosticToString([Diagnostics.Includes_imports_of_types_referenced_by_0, name]),
+                    }],
+                };
+            }
+        }
+
         if (!origin || !(originIsExport(origin) || originIsResolvedExport(origin))) {
             return { codeActions: undefined, sourceDisplay: undefined };
         }
@@ -3519,6 +3525,7 @@ namespace ts.Completions {
         // function f<T>(x: T) {}
         // f({ abc/**/: "" }) // `abc` is a member of `T` but only because it declares itself
         function hasDeclarationOtherThanSelf(member: Symbol) {
+            if (!length(member.declarations)) return true;
             return some(member.declarations, decl => decl.parent !== obj);
         }
     }
@@ -3882,5 +3889,6 @@ namespace ts.Completions {
         }
         return charCode;
     }
+
 }
 

src/services/findAllReferences.ts

@@ -1323,7 +1323,7 @@ namespace ts.FindAllReferences {
             if (!symbol) return undefined;
             for (const token of getPossibleSymbolReferenceNodes(sourceFile, symbol.name, searchContainer)) {
                 if (!isIdentifier(token) || token === definition || token.escapedText !== definition.escapedText) continue;
-                const referenceSymbol: Symbol = checker.getSymbolAtLocation(token)!; // See GH#19955 for why the type annotation is necessary
+                const referenceSymbol = checker.getSymbolAtLocation(token)!;
                 if (referenceSymbol === symbol
                     || checker.getShorthandAssignmentValueSymbol(token.parent) === symbol
                     || isExportSpecifier(token.parent) && getLocalSymbolForExportSpecifier(token, referenceSymbol, token.parent, checker) === symbol) {
@@ -2021,7 +2021,8 @@ namespace ts.FindAllReferences {
                             }
                         }
                         else {
-                            return nodeEntry(ref, EntryKind.StringLiteral);
+                            return isNoSubstitutionTemplateLiteral(ref) && !rangeIsOnSingleLine(ref, sourceFile) ? undefined :
+                                nodeEntry(ref, EntryKind.StringLiteral);
                         }
                     }
                 });

src/services/goToDefinition.ts

@@ -198,14 +198,17 @@ namespace ts.GoToDefinition {
             return undefined;
         }
 
-        const symbol = typeChecker.getSymbolAtLocation(node);
+        const symbol = getSymbol(node, typeChecker);
         if (!symbol) return undefined;
 
         const typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
         const returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
         const fromReturnType = returnType && definitionFromType(returnType, typeChecker, node);
         // If a function returns 'void' or some other type with no definition, just return the function definition.
-        return fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node);
+        const typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node);
+        return typeDefinitions.length ? typeDefinitions
+            : !(symbol.flags & SymbolFlags.Value) && symbol.flags & SymbolFlags.Type ? getDefinitionFromSymbol(typeChecker, skipAlias(symbol, typeChecker), node)
+            : undefined;
     }
 
     function definitionFromType(type: Type, checker: TypeChecker, node: Node): readonly DefinitionInfo[] {

src/services/outliningElementsCollector.ts

@@ -34,7 +34,7 @@ namespace ts.OutliningElementsCollector {
             if (depthRemaining === 0) return;
             cancellationToken.throwIfCancellationRequested();
 
-            if (isDeclaration(n) || isVariableStatement(n) || isReturnStatement(n) || n.kind === SyntaxKind.EndOfFileToken) {
+            if (isDeclaration(n) || isVariableStatement(n) || isReturnStatement(n) || isCallOrNewExpression(n) || n.kind === SyntaxKind.EndOfFileToken) {
                 addOutliningForLeadingCommentsForNode(n, sourceFile, cancellationToken, out);
             }
 

src/services/refactors/extractSymbol.ts

@@ -314,8 +314,7 @@ namespace ts.refactor.extractSymbol {
                 return { errors: [createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
             }
             const statements: Statement[] = [];
-            const start2 = start; // TODO: GH#18217 Need to alias `start` to get this to compile. See https://github.com/Microsoft/TypeScript/issues/19955#issuecomment-344118248
-            for (const statement of (start2.parent as BlockLike).statements) {
+            for (const statement of start.parent.statements) {
                 if (statement === start || statements.length) {
                     const errors = checkNode(statement);
                     if (errors) {
@@ -364,10 +363,11 @@ namespace ts.refactor.extractSymbol {
                     return node.expression;
                 }
             }
-            else if (isVariableStatement(node)) {
+            else if (isVariableStatement(node) || isVariableDeclarationList(node)) {
+                const declarations = isVariableStatement(node) ? node.declarationList.declarations : node.declarations;
                 let numInitializers = 0;
                 let lastInitializer: Expression | undefined;
-                for (const declaration of node.declarationList.declarations) {
+                for (const declaration of declarations) {
                     if (declaration.initializer) {
                         numInitializers++;
                         lastInitializer = declaration.initializer;
@@ -383,7 +383,6 @@ namespace ts.refactor.extractSymbol {
                     return node.initializer;
                 }
             }
-
             return node;
         }
 

src/services/services.ts

@@ -599,10 +599,11 @@ namespace ts {
     }
 
     function findBaseOfDeclaration<T>(checker: TypeChecker, declaration: Declaration, cb: (symbol: Symbol) => T[] | undefined): T[] | undefined {
+        if (hasStaticModifier(declaration)) return;
+
         const classOrInterfaceDeclaration = declaration.parent?.kind === SyntaxKind.Constructor ? declaration.parent.parent : declaration.parent;
-        if (!classOrInterfaceDeclaration) {
-            return;
-        }
+        if (!classOrInterfaceDeclaration) return;
+
         return firstDefined(getAllSuperTypeNodes(classOrInterfaceDeclaration), superTypeNode => {
             const symbol = checker.getPropertyOfType(checker.getTypeAtLocation(superTypeNode), declaration.symbol.name);
             return symbol ? cb(symbol) : undefined;

src/services/textChanges.ts

@@ -494,6 +494,27 @@ namespace ts.textChanges {
             this.insertNodeAt(sourceFile, fnStart, tag, { preserveLeadingWhitespace: false, suffix: this.newLineCharacter + indent });
         }
 
+        public addJSDocTags(sourceFile: SourceFile, parent: HasJSDoc, newTags: readonly JSDocTag[]): void {
+            const comments = flatMap(parent.jsDoc, j => typeof j.comment === "string" ? factory.createJSDocText(j.comment) : j.comment) as JSDocComment[];
+            const oldTags = flatMapToMutable(parent.jsDoc, j => j.tags);
+            const unmergedNewTags = newTags.filter(newTag => !oldTags.some((tag, i) => {
+                const merged = tryMergeJsdocTags(tag, newTag);
+                if (merged) oldTags[i] = merged;
+                return !!merged;
+            }));
+            const tag = factory.createJSDocComment(factory.createNodeArray(intersperse(comments, factory.createJSDocText("\n"))), factory.createNodeArray([...oldTags, ...unmergedNewTags]));
+            const host = updateJSDocHost(parent);
+            this.insertJsdocCommentBefore(sourceFile, host, tag);
+        }
+
+        public filterJSDocTags(sourceFile: SourceFile, parent: HasJSDoc, predicate: (tag: JSDocTag) => boolean): void {
+            const comments = flatMap(parent.jsDoc, j => typeof j.comment === "string" ? factory.createJSDocText(j.comment) : j.comment) as JSDocComment[];
+            const oldTags = flatMapToMutable(parent.jsDoc, j => j.tags);
+            const tag = factory.createJSDocComment(factory.createNodeArray(intersperse(comments, factory.createJSDocText("\n"))), factory.createNodeArray([...(filter(oldTags, predicate) || emptyArray)]));
+            const host = updateJSDocHost(parent);
+            this.insertJsdocCommentBefore(sourceFile, host, tag);
+        }
+
         public replaceRangeWithText(sourceFile: SourceFile, range: TextRange, text: string): void {
             this.changes.push({ kind: ChangeKind.Text, sourceFile, range, text });
         }
@@ -920,6 +941,35 @@ namespace ts.textChanges {
         }
     }
 
+    function updateJSDocHost(parent: HasJSDoc): HasJSDoc {
+        if (parent.kind !== SyntaxKind.ArrowFunction) {
+            return parent;
+        }
+        const jsDocNode = parent.parent.kind === SyntaxKind.PropertyDeclaration ?
+            parent.parent as HasJSDoc :
+            parent.parent.parent as HasJSDoc;
+        jsDocNode.jsDoc = parent.jsDoc;
+        jsDocNode.jsDocCache = parent.jsDocCache;
+        return jsDocNode;
+    }
+
+    function tryMergeJsdocTags(oldTag: JSDocTag, newTag: JSDocTag): JSDocTag | undefined {
+        if (oldTag.kind !== newTag.kind) {
+            return undefined;
+        }
+        switch (oldTag.kind) {
+            case SyntaxKind.JSDocParameterTag: {
+                const oldParam = oldTag as JSDocParameterTag;
+                const newParam = newTag as JSDocParameterTag;
+                return isIdentifier(oldParam.name) && isIdentifier(newParam.name) && oldParam.name.escapedText === newParam.name.escapedText
+                    ? factory.createJSDocParameterTag(/*tagName*/ undefined, newParam.name, /*isBracketed*/ false, newParam.typeExpression, newParam.isNameFirst, oldParam.comment)
+                    : undefined;
+            }
+            case SyntaxKind.JSDocReturnTag:
+                return factory.createJSDocReturnTag(/*tagName*/ undefined, (newTag as JSDocReturnTag).typeExpression, oldTag.comment);
+        }
+    }
+
     // find first non-whitespace position in the leading trivia of the node
     function startPositionToDeleteNodeInList(sourceFile: SourceFile, node: Node): number {
         return skipTrivia(sourceFile.text, getAdjustedStartPosition(sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.IncludeAll }), /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);

src/services/utilities.ts

@@ -3283,5 +3283,12 @@ namespace ts {
         return newLineCharacter === "\n" ? NewLineKind.LineFeed : NewLineKind.CarriageReturnLineFeed;
     }
 
+    export type DiagnosticAndArguments = DiagnosticMessage | [DiagnosticMessage, string] | [DiagnosticMessage, string, string];
+    export function diagnosticToString(diag: DiagnosticAndArguments): string {
+        return isArray(diag)
+            ? formatStringFromArgs(getLocaleSpecificMessage(diag[0]), diag.slice(1) as readonly string[])
+            : getLocaleSpecificMessage(diag);
+    }
+
     // #endregion
 }

src/testRunner/parallel/host.ts

@@ -14,7 +14,7 @@ namespace Harness.Parallel.Host {
         const { statSync } = require("fs") as typeof import("fs");
 
         // NOTE: paths for module and types for FailedTestReporter _do not_ line up due to our use of --outFile for run.js
-        const FailedTestReporter = require(path.resolve(__dirname, "../../scripts/failed-tests")) as typeof import("../../../scripts/failed-tests");
+        const FailedTestReporter = require(Utils.findUpFile("scripts/failed-tests.js")) as typeof import("../../../scripts/failed-tests");
 
         const perfdataFileNameFragment = ".parallelperf";
         const perfData = readSavedPerfData(configOption);

src/testRunner/unittests/config/commandLineParsing.ts

@@ -211,7 +211,7 @@ namespace ts {
                         start: undefined,
                         length: undefined,
                     }, {
-                        messageText: "Argument for '--target' option must be: 'es3', 'es5', 'es6', 'es2015', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'esnext'.",
+                        messageText: "Argument for '--target' option must be: 'es3', 'es5', 'es6', 'es2015', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'es2022', 'esnext'.",
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
 

src/testRunner/unittests/publicApi.ts

@@ -182,34 +182,3 @@ describe("unittests:: Public APIs:: getChild* methods on EndOfFileToken with JSD
     assert.equal(endOfFileToken.getChildCount(), 1);
     assert.notEqual(endOfFileToken.getChildAt(0), /*expected*/ undefined);
 });
-
-describe("unittests:: Public APIs:: sys", () => {
-    it("readDirectory", () => {
-        // #45990, testing passing a non-absolute path
-        // `sys.readDirectory` is just `matchFiles` plugged into the real FS
-        const read = ts.matchFiles(
-            /*path*/ "",
-            /*extensions*/ [".ts", ".tsx"],
-            /*excludes*/ ["node_modules", "dist"],
-            /*includes*/ ["**/*"],
-            /*useCaseSensitiveFileNames*/ true,
-            /*currentDirectory*/ "/",
-            /*depth*/ undefined,
-            /*getFileSystemEntries*/ path => {
-                switch (path) {
-                    case "/": return { directories: [], files: ["file.ts"] };
-                    default: return { directories: [], files: [] };
-                }
-            },
-            /*realpath*/ ts.identity,
-            /*directoryExists*/ path => {
-                switch (path) {
-                    case "/": return true;
-                    default: return false;
-                }
-            }
-        );
-
-        assert.deepEqual(read, ["/file.ts"]);
-    });
-});

src/testRunner/unittests/services/extract/ranges.ts

@@ -191,7 +191,7 @@ namespace ts {
             testExtractRange("extractRange28", `[#|return [$|1|];|]`);
 
             // For statements
-            testExtractRange("extractRange29", `for ([#|var i = 1|]; i < 2; i++) {}`);
+            testExtractRange("extractRange29", `for ([#|var i = [$|1|]|]; i < 2; i++) {}`);
             testExtractRange("extractRange30", `for (var i = [#|[$|1|]|]; i < 2; i++) {}`);
         });
 

src/testRunner/unittests/tsserver/autoImportProvider.ts

@@ -326,7 +326,7 @@ namespace ts.projectSystem {
         };
 
         function updateFile(path: string, newText: string) {
-            Debug.assertDefined(files.find(f => f.path === path));
+            Debug.assertIsDefined(files.find(f => f.path === path));
             session.executeCommandSeq<protocol.ApplyChangedToOpenFilesRequest>({
                 command: protocol.CommandTypes.ApplyChangedToOpenFiles,
                 arguments: {
@@ -339,7 +339,7 @@ namespace ts.projectSystem {
         }
 
         function findAllReferences(file: string, line: number, offset: number) {
-            Debug.assertDefined(files.find(f => f.path === file));
+            Debug.assertIsDefined(files.find(f => f.path === file));
             session.executeCommandSeq<protocol.ReferencesRequest>({
                 command: protocol.CommandTypes.References,
                 arguments: {

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -14,7 +14,7 @@ and limitations under the License.
 ***************************************************************************** */
 
 declare namespace ts {
-    const versionMajorMinor = "4.5";
+    const versionMajorMinor = "4.6";
     /** The version of the TypeScript compiler release */
     const version: string;
     /**
@@ -897,7 +897,7 @@ declare namespace ts {
     export interface TypePredicateNode extends TypeNode {
         readonly kind: SyntaxKind.TypePredicate;
         readonly parent: SignatureDeclaration | JSDocTypeExpression;
-        readonly assertsModifier?: AssertsToken;
+        readonly assertsModifier?: AssertsKeyword;
         readonly parameterName: Identifier | ThisTypeNode;
         readonly type?: TypeNode;
     }
@@ -968,7 +968,7 @@ declare namespace ts {
     }
     export interface MappedTypeNode extends TypeNode, Declaration {
         readonly kind: SyntaxKind.MappedType;
-        readonly readonlyToken?: ReadonlyToken | PlusToken | MinusToken;
+        readonly readonlyToken?: ReadonlyKeyword | PlusToken | MinusToken;
         readonly typeParameter: TypeParameterDeclaration;
         readonly nameType?: TypeNode;
         readonly questionToken?: QuestionToken | PlusToken | MinusToken;
@@ -1465,7 +1465,7 @@ declare namespace ts {
     }
     export interface ForOfStatement extends IterationStatement {
         readonly kind: SyntaxKind.ForOfStatement;
-        readonly awaitModifier?: AwaitKeywordToken;
+        readonly awaitModifier?: AwaitKeyword;
         readonly initializer: ForInitializer;
         readonly expression: Expression;
     }
@@ -3078,6 +3078,7 @@ declare namespace ts {
         ES2019 = 6,
         ES2020 = 7,
         ES2021 = 8,
+        ES2022 = 9,
         ESNext = 99,
         JSON = 100,
         Latest = 99
@@ -9666,6 +9667,7 @@ declare namespace ts.server.protocol {
         ES2019 = "ES2019",
         ES2020 = "ES2020",
         ES2021 = "ES2021",
+        ES2022 = "ES2022",
         ESNext = "ESNext"
     }
     enum ClassificationType {

tests/baselines/reference/api/typescript.d.ts

@@ -14,7 +14,7 @@ and limitations under the License.
 ***************************************************************************** */
 
 declare namespace ts {
-    const versionMajorMinor = "4.5";
+    const versionMajorMinor = "4.6";
     /** The version of the TypeScript compiler release */
     const version: string;
     /**
@@ -897,7 +897,7 @@ declare namespace ts {
     export interface TypePredicateNode extends TypeNode {
         readonly kind: SyntaxKind.TypePredicate;
         readonly parent: SignatureDeclaration | JSDocTypeExpression;
-        readonly assertsModifier?: AssertsToken;
+        readonly assertsModifier?: AssertsKeyword;
         readonly parameterName: Identifier | ThisTypeNode;
         readonly type?: TypeNode;
     }
@@ -968,7 +968,7 @@ declare namespace ts {
     }
     export interface MappedTypeNode extends TypeNode, Declaration {
         readonly kind: SyntaxKind.MappedType;
-        readonly readonlyToken?: ReadonlyToken | PlusToken | MinusToken;
+        readonly readonlyToken?: ReadonlyKeyword | PlusToken | MinusToken;
         readonly typeParameter: TypeParameterDeclaration;
         readonly nameType?: TypeNode;
         readonly questionToken?: QuestionToken | PlusToken | MinusToken;
@@ -1465,7 +1465,7 @@ declare namespace ts {
     }
     export interface ForOfStatement extends IterationStatement {
         readonly kind: SyntaxKind.ForOfStatement;
-        readonly awaitModifier?: AwaitKeywordToken;
+        readonly awaitModifier?: AwaitKeyword;
         readonly initializer: ForInitializer;
         readonly expression: Expression;
     }
@@ -3078,6 +3078,7 @@ declare namespace ts {
         ES2019 = 6,
         ES2020 = 7,
         ES2021 = 8,
+        ES2022 = 9,
         ESNext = 99,
         JSON = 100,
         Latest = 99

tests/baselines/reference/argumentsReferenceInConstructor4_Js.errors.txt

@@ -0,0 +1,46 @@
+/a.js(18,9): error TS1210: Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of 'arguments'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode.
+
+
+==== /a.js (1 errors) ====
+    class A {
+    	/**
+    	 * Constructor
+    	 *
+    	 * @param {object} [foo={}]
+    	 */
+    	constructor(foo = {}) {
+    		const key = "bar";
+    
+    		/**
+    		 * @type object
+    		 */
+    		this.foo = foo;
+    
+    		/**
+    		 * @type object
+    		 */
+    		const arguments = this.arguments;
+    		      ~~~~~~~~~
+!!! error TS1210: Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of 'arguments'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode.
+    
+    		/**
+    		 * @type object
+    		 */
+    		this.bar = arguments.bar;
+    
+    		/**
+    		 * @type object
+    		 */
+    		this.baz = arguments[key];
+    
+    		/**
+    		 * @type object
+    		 */
+    		this.options = arguments;
+    	}
+    
+    	get arguments() {
+    		return { bar: {} };
+    	}
+    }
+    

tests/baselines/reference/argumentsReferenceInMethod4_Js.errors.txt

@@ -0,0 +1,44 @@
+/a.js(16,9): error TS1210: Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of 'arguments'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode.
+
+
+==== /a.js (1 errors) ====
+    class A {
+    	/**
+    	 * @param {object} [foo={}]
+    	 */
+    	m(foo = {}) {
+    		const key = "bar";
+    
+    		/**
+    		 * @type object
+    		 */
+    		this.foo = foo;
+    
+    		/**
+    		 * @type object
+    		 */
+    		const arguments = this.arguments;
+    		      ~~~~~~~~~
+!!! error TS1210: Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of 'arguments'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode.
+    
+    		/**
+    		 * @type object
+    		 */
+    		this.bar = arguments.bar;
+    
+    		/**
+    		 * @type object
+    		 */
+    		this.baz = arguments[key];
+    
+    		/**
+    		 * @type object
+    		 */
+    		this.options = arguments;
+    	}
+    
+    	get arguments() {
+    		return { bar: {} };
+    	}
+    }
+    

tests/baselines/reference/callChainWithSuper(target=es2022).js

@@ -0,0 +1,18 @@
+//// [callChainWithSuper.ts]
+// GH#34952
+class Base { method?() {} }
+class Derived extends Base {
+    method1() { return super.method?.(); }
+    method2() { return super["method"]?.(); }
+}
+
+//// [callChainWithSuper.js]
+"use strict";
+// GH#34952
+class Base {
+    method() { }
+}
+class Derived extends Base {
+    method1() { return super.method?.(); }
+    method2() { return super["method"]?.(); }
+}

tests/baselines/reference/callWithSpread4.symbols

@@ -30,7 +30,7 @@ declare const pli: {
 
     (streams: ReadonlyArray<R | W | RW>): Promise<void>;
 >streams : Symbol(streams, Decl(callWithSpread4.ts, 5, 5))
->ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es2019.array.d.ts, --, --))
+>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --), Decl(lib.es2019.array.d.ts, --, --) ... and 1 more)
 >R : Symbol(R, Decl(callWithSpread4.ts, 0, 0))
 >W : Symbol(W, Decl(callWithSpread4.ts, 0, 22))
 >RW : Symbol(RW, Decl(callWithSpread4.ts, 1, 22))
@@ -43,7 +43,7 @@ declare const pli: {
 >RW : Symbol(RW, Decl(callWithSpread4.ts, 1, 22))
 >W : Symbol(W, Decl(callWithSpread4.ts, 0, 22))
 >streams : Symbol(streams, Decl(callWithSpread4.ts, 6, 23))
->Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 2 more)
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 3 more)
 >RW : Symbol(RW, Decl(callWithSpread4.ts, 1, 22))
 >W : Symbol(W, Decl(callWithSpread4.ts, 0, 22))
 >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --))

tests/baselines/reference/contextuallyTypedSymbolNamedProperties.js

@@ -0,0 +1,53 @@
+//// [contextuallyTypedSymbolNamedProperties.ts]
+// Repros from #43628
+
+const A = Symbol("A");
+const B = Symbol("B");
+
+type Action =
+    | {type: typeof A, data: string}
+    | {type: typeof B, data: number}
+
+declare const ab: Action;
+
+declare function f<T extends { type: string | symbol }>(action: T, blah: { [K in T['type']]: (p: K) => void }): any;
+
+f(ab, {
+    [A]: ap => { ap.description },
+    [B]: bp => { bp.description },
+})
+
+const x: { [sym: symbol]: (p: string) => void } = { [A]: s => s.length };
+
+
+//// [contextuallyTypedSymbolNamedProperties.js]
+"use strict";
+// Repros from #43628
+const A = Symbol("A");
+const B = Symbol("B");
+f(ab, {
+    [A]: ap => { ap.description; },
+    [B]: bp => { bp.description; },
+});
+const x = { [A]: s => s.length };
+
+
+//// [contextuallyTypedSymbolNamedProperties.d.ts]
+declare const A: unique symbol;
+declare const B: unique symbol;
+declare type Action = {
+    type: typeof A;
+    data: string;
+} | {
+    type: typeof B;
+    data: number;
+};
+declare const ab: Action;
+declare function f<T extends {
+    type: string | symbol;
+}>(action: T, blah: {
+    [K in T['type']]: (p: K) => void;
+}): any;
+declare const x: {
+    [sym: symbol]: (p: string) => void;
+};

tests/baselines/reference/contextuallyTypedSymbolNamedProperties.symbols

@@ -0,0 +1,73 @@
+=== tests/cases/compiler/contextuallyTypedSymbolNamedProperties.ts ===
+// Repros from #43628
+
+const A = Symbol("A");
+>A : Symbol(A, Decl(contextuallyTypedSymbolNamedProperties.ts, 2, 5))
+>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --))
+
+const B = Symbol("B");
+>B : Symbol(B, Decl(contextuallyTypedSymbolNamedProperties.ts, 3, 5))
+>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --))
+
+type Action =
+>Action : Symbol(Action, Decl(contextuallyTypedSymbolNamedProperties.ts, 3, 22))
+
+    | {type: typeof A, data: string}
+>type : Symbol(type, Decl(contextuallyTypedSymbolNamedProperties.ts, 6, 7))
+>A : Symbol(A, Decl(contextuallyTypedSymbolNamedProperties.ts, 2, 5))
+>data : Symbol(data, Decl(contextuallyTypedSymbolNamedProperties.ts, 6, 22))
+
+    | {type: typeof B, data: number}
+>type : Symbol(type, Decl(contextuallyTypedSymbolNamedProperties.ts, 7, 7))
+>B : Symbol(B, Decl(contextuallyTypedSymbolNamedProperties.ts, 3, 5))
+>data : Symbol(data, Decl(contextuallyTypedSymbolNamedProperties.ts, 7, 22))
+
+declare const ab: Action;
+>ab : Symbol(ab, Decl(contextuallyTypedSymbolNamedProperties.ts, 9, 13))
+>Action : Symbol(Action, Decl(contextuallyTypedSymbolNamedProperties.ts, 3, 22))
+
+declare function f<T extends { type: string | symbol }>(action: T, blah: { [K in T['type']]: (p: K) => void }): any;
+>f : Symbol(f, Decl(contextuallyTypedSymbolNamedProperties.ts, 9, 25))
+>T : Symbol(T, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 19))
+>type : Symbol(type, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 30))
+>action : Symbol(action, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 56))
+>T : Symbol(T, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 19))
+>blah : Symbol(blah, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 66))
+>K : Symbol(K, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 76))
+>T : Symbol(T, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 19))
+>p : Symbol(p, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 94))
+>K : Symbol(K, Decl(contextuallyTypedSymbolNamedProperties.ts, 11, 76))
+
+f(ab, {
+>f : Symbol(f, Decl(contextuallyTypedSymbolNamedProperties.ts, 9, 25))
+>ab : Symbol(ab, Decl(contextuallyTypedSymbolNamedProperties.ts, 9, 13))
+
+    [A]: ap => { ap.description },
+>[A] : Symbol([A], Decl(contextuallyTypedSymbolNamedProperties.ts, 13, 7))
+>A : Symbol(A, Decl(contextuallyTypedSymbolNamedProperties.ts, 2, 5))
+>ap : Symbol(ap, Decl(contextuallyTypedSymbolNamedProperties.ts, 14, 8))
+>ap.description : Symbol(Symbol.description, Decl(lib.es2019.symbol.d.ts, --, --))
+>ap : Symbol(ap, Decl(contextuallyTypedSymbolNamedProperties.ts, 14, 8))
+>description : Symbol(Symbol.description, Decl(lib.es2019.symbol.d.ts, --, --))
+
+    [B]: bp => { bp.description },
+>[B] : Symbol([B], Decl(contextuallyTypedSymbolNamedProperties.ts, 14, 34))
+>B : Symbol(B, Decl(contextuallyTypedSymbolNamedProperties.ts, 3, 5))
+>bp : Symbol(bp, Decl(contextuallyTypedSymbolNamedProperties.ts, 15, 8))
+>bp.description : Symbol(Symbol.description, Decl(lib.es2019.symbol.d.ts, --, --))
+>bp : Symbol(bp, Decl(contextuallyTypedSymbolNamedProperties.ts, 15, 8))
+>description : Symbol(Symbol.description, Decl(lib.es2019.symbol.d.ts, --, --))
+
+})
+
+const x: { [sym: symbol]: (p: string) => void } = { [A]: s => s.length };
+>x : Symbol(x, Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 5))
+>sym : Symbol(sym, Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 12))
+>p : Symbol(p, Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 27))
+>[A] : Symbol([A], Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 51))
+>A : Symbol(A, Decl(contextuallyTypedSymbolNamedProperties.ts, 2, 5))
+>s : Symbol(s, Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 56))
+>s.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>s : Symbol(s, Decl(contextuallyTypedSymbolNamedProperties.ts, 18, 56))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+

tests/baselines/reference/contextuallyTypedSymbolNamedProperties.types

@@ -0,0 +1,77 @@
+=== tests/cases/compiler/contextuallyTypedSymbolNamedProperties.ts ===
+// Repros from #43628
+
+const A = Symbol("A");
+>A : unique symbol
+>Symbol("A") : unique symbol
+>Symbol : SymbolConstructor
+>"A" : "A"
+
+const B = Symbol("B");
+>B : unique symbol
+>Symbol("B") : unique symbol
+>Symbol : SymbolConstructor
+>"B" : "B"
+
+type Action =
+>Action : Action
+
+    | {type: typeof A, data: string}
+>type : unique symbol
+>A : unique symbol
+>data : string
+
+    | {type: typeof B, data: number}
+>type : unique symbol
+>B : unique symbol
+>data : number
+
+declare const ab: Action;
+>ab : Action
+
+declare function f<T extends { type: string | symbol }>(action: T, blah: { [K in T['type']]: (p: K) => void }): any;
+>f : <T extends { type: string | symbol; }>(action: T, blah: { [K in T["type"]]: (p: K) => void; }) => any
+>type : string | symbol
+>action : T
+>blah : { [K in T["type"]]: (p: K) => void; }
+>p : K
+
+f(ab, {
+>f(ab, {    [A]: ap => { ap.description },    [B]: bp => { bp.description },}) : any
+>f : <T extends { type: string | symbol; }>(action: T, blah: { [K in T["type"]]: (p: K) => void; }) => any
+>ab : Action
+>{    [A]: ap => { ap.description },    [B]: bp => { bp.description },} : { [A]: (ap: unique symbol) => void; [B]: (bp: unique symbol) => void; }
+
+    [A]: ap => { ap.description },
+>[A] : (ap: unique symbol) => void
+>A : unique symbol
+>ap => { ap.description } : (ap: unique symbol) => void
+>ap : unique symbol
+>ap.description : string | undefined
+>ap : unique symbol
+>description : string | undefined
+
+    [B]: bp => { bp.description },
+>[B] : (bp: unique symbol) => void
+>B : unique symbol
+>bp => { bp.description } : (bp: unique symbol) => void
+>bp : unique symbol
+>bp.description : string | undefined
+>bp : unique symbol
+>description : string | undefined
+
+})
+
+const x: { [sym: symbol]: (p: string) => void } = { [A]: s => s.length };
+>x : { [sym: symbol]: (p: string) => void; }
+>sym : symbol
+>p : string
+>{ [A]: s => s.length } : { [A]: (s: string) => number; }
+>[A] : (s: string) => number
+>A : unique symbol
+>s => s.length : (s: string) => number
+>s : string
+>s.length : number
+>s : string
+>length : number
+

tests/baselines/reference/controlFlowAliasing.errors.txt

@@ -28,15 +28,11 @@ tests/cases/conformance/controlFlow/controlFlowAliasing.ts(232,13): error TS2322
   Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/controlFlow/controlFlowAliasing.ts(233,13): error TS2322: Type 'string | number' is not assignable to type 'string'.
   Type 'number' is not assignable to type 'string'.
-tests/cases/conformance/controlFlow/controlFlowAliasing.ts(267,13): error TS2322: Type 'string | number' is not assignable to type 'string'.
-  Type 'number' is not assignable to type 'string'.
-tests/cases/conformance/controlFlow/controlFlowAliasing.ts(270,13): error TS2322: Type 'string | number' is not assignable to type 'number'.
-  Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/controlFlow/controlFlowAliasing.ts(280,5): error TS2448: Block-scoped variable 'a' used before its declaration.
 tests/cases/conformance/controlFlow/controlFlowAliasing.ts(280,5): error TS2454: Variable 'a' is used before being assigned.
 
 
-==== tests/cases/conformance/controlFlow/controlFlowAliasing.ts (19 errors) ====
+==== tests/cases/conformance/controlFlow/controlFlowAliasing.ts (17 errors) ====
     // Narrowing by aliased conditional expressions
     
     function f10(x: string | number) {
@@ -349,15 +345,9 @@ tests/cases/conformance/controlFlow/controlFlowAliasing.ts(280,5): error TS2454:
     function foo({ kind, payload }: Data) {
         if (kind === 'str') {
             let t: string = payload;
-                ~
-!!! error TS2322: Type 'string | number' is not assignable to type 'string'.
-!!! error TS2322:   Type 'number' is not assignable to type 'string'.
         }
         else {
             let t: number = payload;
-                ~
-!!! error TS2322: Type 'string | number' is not assignable to type 'number'.
-!!! error TS2322:   Type 'string' is not assignable to type 'number'.
         }
     }
     

tests/baselines/reference/controlFlowAliasing.types

@@ -888,12 +888,12 @@ function foo({ kind, payload }: Data) {
 
         let t: string = payload;
 >t : string
->payload : string | number
+>payload : string
     }
     else {
         let t: number = payload;
 >t : number
->payload : string | number
+>payload : number
     }
 }
 

tests/baselines/reference/defaultNamedExportWithType1.js

@@ -0,0 +1,9 @@
+//// [defaultNamedExportWithType1.ts]
+type Foo = number;
+export const Foo = 1;
+export default Foo;
+
+
+//// [defaultNamedExportWithType1.js]
+export const Foo = 1;
+export default Foo;

tests/baselines/reference/defaultNamedExportWithType1.symbols

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/defaultNamedExportWithType1.ts ===
+type Foo = number;
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType1.ts, 0, 0), Decl(defaultNamedExportWithType1.ts, 1, 12))
+
+export const Foo = 1;
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType1.ts, 1, 12))
+
+export default Foo;
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType1.ts, 0, 0), Decl(defaultNamedExportWithType1.ts, 1, 12))
+

tests/baselines/reference/defaultNamedExportWithType1.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/defaultNamedExportWithType1.ts ===
+type Foo = number;
+>Foo : number
+
+export const Foo = 1;
+>Foo : 1
+>1 : 1
+
+export default Foo;
+>Foo : number
+

tests/baselines/reference/defaultNamedExportWithType2.js

@@ -0,0 +1,9 @@
+//// [defaultNamedExportWithType2.ts]
+type Foo = number;
+const Foo = 1;
+export default Foo;
+
+
+//// [defaultNamedExportWithType2.js]
+const Foo = 1;
+export default Foo;

tests/baselines/reference/defaultNamedExportWithType2.symbols

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/defaultNamedExportWithType2.ts ===
+type Foo = number;
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType2.ts, 0, 0), Decl(defaultNamedExportWithType2.ts, 1, 5))
+
+const Foo = 1;
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType2.ts, 0, 0), Decl(defaultNamedExportWithType2.ts, 1, 5))
+
+export default Foo;
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType2.ts, 0, 0), Decl(defaultNamedExportWithType2.ts, 1, 5))
+

tests/baselines/reference/defaultNamedExportWithType2.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/defaultNamedExportWithType2.ts ===
+type Foo = number;
+>Foo : number
+
+const Foo = 1;
+>Foo : 1
+>1 : 1
+
+export default Foo;
+>Foo : number
+

tests/baselines/reference/defaultNamedExportWithType3.js

@@ -0,0 +1,9 @@
+//// [defaultNamedExportWithType3.ts]
+interface Foo {}
+export const Foo = {};
+export default Foo;
+
+
+//// [defaultNamedExportWithType3.js]
+export const Foo = {};
+export default Foo;

tests/baselines/reference/defaultNamedExportWithType3.symbols

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/defaultNamedExportWithType3.ts ===
+interface Foo {}
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType3.ts, 0, 0), Decl(defaultNamedExportWithType3.ts, 1, 12))
+
+export const Foo = {};
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType3.ts, 1, 12))
+
+export default Foo;
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType3.ts, 0, 0), Decl(defaultNamedExportWithType3.ts, 1, 12))
+

tests/baselines/reference/defaultNamedExportWithType3.types

@@ -0,0 +1,9 @@
+=== tests/cases/compiler/defaultNamedExportWithType3.ts ===
+interface Foo {}
+export const Foo = {};
+>Foo : {}
+>{} : {}
+
+export default Foo;
+>Foo : Foo
+

tests/baselines/reference/defaultNamedExportWithType4.js

@@ -0,0 +1,9 @@
+//// [defaultNamedExportWithType4.ts]
+interface Foo {}
+const Foo = {};
+export default Foo;
+
+
+//// [defaultNamedExportWithType4.js]
+const Foo = {};
+export default Foo;

tests/baselines/reference/defaultNamedExportWithType4.symbols

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/defaultNamedExportWithType4.ts ===
+interface Foo {}
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType4.ts, 0, 0), Decl(defaultNamedExportWithType4.ts, 1, 5))
+
+const Foo = {};
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType4.ts, 0, 0), Decl(defaultNamedExportWithType4.ts, 1, 5))
+
+export default Foo;
+>Foo : Symbol(Foo, Decl(defaultNamedExportWithType4.ts, 0, 0), Decl(defaultNamedExportWithType4.ts, 1, 5))
+

tests/baselines/reference/defaultNamedExportWithType4.types

@@ -0,0 +1,9 @@
+=== tests/cases/compiler/defaultNamedExportWithType4.ts ===
+interface Foo {}
+const Foo = {};
+>Foo : {}
+>{} : {}
+
+export default Foo;
+>Foo : Foo
+

tests/baselines/reference/dependentDestructuredVariables.js

@@ -0,0 +1,336 @@
+//// [dependentDestructuredVariables.ts]
+type Action =
+    | { kind: 'A', payload: number }
+    | { kind: 'B', payload: string };
+
+function f10({ kind, payload }: Action) {
+    if (kind === 'A') {
+        payload.toFixed();
+    }
+    if (kind === 'B') {
+        payload.toUpperCase();
+    }
+}
+
+function f11(action: Action) {
+    const { kind, payload } = action;
+    if (kind === 'A') {
+        payload.toFixed();
+    }
+    if (kind === 'B') {
+        payload.toUpperCase();
+    }
+}
+
+function f12({ kind, payload }: Action) {
+    switch (kind) {
+        case 'A':
+            payload.toFixed();
+            break;
+        case 'B':
+            payload.toUpperCase();
+            break;
+        default:
+            payload;  // never
+    }
+}
+
+type Action2 =
+    | { kind: 'A', payload: number | undefined }
+    | { kind: 'B', payload: string | undefined };
+
+function f20({ kind, payload }: Action2) {
+    if (payload) {
+        if (kind === 'A') {
+            payload.toFixed();
+        }
+        if (kind === 'B') {
+            payload.toUpperCase();
+        }
+    }
+}
+
+function f21(action: Action2) {
+    const { kind, payload } = action;
+    if (payload) {
+        if (kind === 'A') {
+            payload.toFixed();
+        }
+        if (kind === 'B') {
+            payload.toUpperCase();
+        }
+    }
+}
+
+function f22(action: Action2) {
+    if (action.payload) {
+        const { kind, payload } = action;
+        if (kind === 'A') {
+            payload.toFixed();
+        }
+        if (kind === 'B') {
+            payload.toUpperCase();
+        }
+    }
+}
+
+function f23({ kind, payload }: Action2) {
+    if (payload) {
+        switch (kind) {
+            case 'A':
+                payload.toFixed();
+                break;
+            case 'B':
+                payload.toUpperCase();
+                break;
+            default:
+                payload;  // never
+        }
+    }
+}
+
+type Foo =
+    | { kind: 'A', isA: true }
+    | { kind: 'B', isA: false }
+    | { kind: 'C', isA: false };
+
+function f30({ kind, isA }: Foo) {
+    if (kind === 'A') {
+        isA;   // true
+    }
+    if (kind === 'B') {
+        isA;   // false
+    }
+    if (kind === 'C') {
+        isA;   // false
+    }
+    if (isA) {
+        kind;  // 'A'
+    }
+    else {
+        kind;  // 'B' | 'C'
+    }
+}
+
+// Repro from #35283
+
+interface A<T> { variant: 'a', value: T }
+
+interface B<T> { variant: 'b', value: Array<T> }
+
+type AB<T> = A<T> | B<T>;
+
+declare function printValue<T>(t: T): void;
+
+declare function printValueList<T>(t: Array<T>): void;
+
+function unrefined1<T>(ab: AB<T>): void {
+    const { variant, value } = ab;
+    if (variant === 'a') {
+        printValue<T>(value);
+    }
+    else {
+        printValueList<T>(value);
+    }
+}
+
+// Repro from #38020
+
+type Action3 =
+    | {type: 'add', payload: { toAdd: number } }
+    | {type: 'remove', payload: { toRemove: number } };
+
+const reducerBroken = (state: number, { type, payload }: Action3) => {
+    switch (type) {
+        case 'add':
+            return state + payload.toAdd;
+        case 'remove':
+            return state - payload.toRemove;
+    }
+}
+
+// Repro from #46143
+
+declare var it: Iterator<number>;
+const { value, done } = it.next();
+if (!done) {
+    value;  // number
+}
+
+
+//// [dependentDestructuredVariables.js]
+"use strict";
+function f10({ kind, payload }) {
+    if (kind === 'A') {
+        payload.toFixed();
+    }
+    if (kind === 'B') {
+        payload.toUpperCase();
+    }
+}
+function f11(action) {
+    const { kind, payload } = action;
+    if (kind === 'A') {
+        payload.toFixed();
+    }
+    if (kind === 'B') {
+        payload.toUpperCase();
+    }
+}
+function f12({ kind, payload }) {
+    switch (kind) {
+        case 'A':
+            payload.toFixed();
+            break;
+        case 'B':
+            payload.toUpperCase();
+            break;
+        default:
+            payload; // never
+    }
+}
+function f20({ kind, payload }) {
+    if (payload) {
+        if (kind === 'A') {
+            payload.toFixed();
+        }
+        if (kind === 'B') {
+            payload.toUpperCase();
+        }
+    }
+}
+function f21(action) {
+    const { kind, payload } = action;
+    if (payload) {
+        if (kind === 'A') {
+            payload.toFixed();
+        }
+        if (kind === 'B') {
+            payload.toUpperCase();
+        }
+    }
+}
+function f22(action) {
+    if (action.payload) {
+        const { kind, payload } = action;
+        if (kind === 'A') {
+            payload.toFixed();
+        }
+        if (kind === 'B') {
+            payload.toUpperCase();
+        }
+    }
+}
+function f23({ kind, payload }) {
+    if (payload) {
+        switch (kind) {
+            case 'A':
+                payload.toFixed();
+                break;
+            case 'B':
+                payload.toUpperCase();
+                break;
+            default:
+                payload; // never
+        }
+    }
+}
+function f30({ kind, isA }) {
+    if (kind === 'A') {
+        isA; // true
+    }
+    if (kind === 'B') {
+        isA; // false
+    }
+    if (kind === 'C') {
+        isA; // false
+    }
+    if (isA) {
+        kind; // 'A'
+    }
+    else {
+        kind; // 'B' | 'C'
+    }
+}
+function unrefined1(ab) {
+    const { variant, value } = ab;
+    if (variant === 'a') {
+        printValue(value);
+    }
+    else {
+        printValueList(value);
+    }
+}
+const reducerBroken = (state, { type, payload }) => {
+    switch (type) {
+        case 'add':
+            return state + payload.toAdd;
+        case 'remove':
+            return state - payload.toRemove;
+    }
+};
+const { value, done } = it.next();
+if (!done) {
+    value; // number
+}
+
+
+//// [dependentDestructuredVariables.d.ts]
+declare type Action = {
+    kind: 'A';
+    payload: number;
+} | {
+    kind: 'B';
+    payload: string;
+};
+declare function f10({ kind, payload }: Action): void;
+declare function f11(action: Action): void;
+declare function f12({ kind, payload }: Action): void;
+declare type Action2 = {
+    kind: 'A';
+    payload: number | undefined;
+} | {
+    kind: 'B';
+    payload: string | undefined;
+};
+declare function f20({ kind, payload }: Action2): void;
+declare function f21(action: Action2): void;
+declare function f22(action: Action2): void;
+declare function f23({ kind, payload }: Action2): void;
+declare type Foo = {
+    kind: 'A';
+    isA: true;
+} | {
+    kind: 'B';
+    isA: false;
+} | {
+    kind: 'C';
+    isA: false;
+};
+declare function f30({ kind, isA }: Foo): void;
+interface A<T> {
+    variant: 'a';
+    value: T;
+}
+interface B<T> {
+    variant: 'b';
+    value: Array<T>;
+}
+declare type AB<T> = A<T> | B<T>;
+declare function printValue<T>(t: T): void;
+declare function printValueList<T>(t: Array<T>): void;
+declare function unrefined1<T>(ab: AB<T>): void;
+declare type Action3 = {
+    type: 'add';
+    payload: {
+        toAdd: number;
+    };
+} | {
+    type: 'remove';
+    payload: {
+        toRemove: number;
+    };
+};
+declare const reducerBroken: (state: number, { type, payload }: Action3) => number;
+declare var it: Iterator<number>;
+declare const value: any, done: boolean | undefined;

tests/baselines/reference/dependentDestructuredVariables.symbols

@@ -0,0 +1,409 @@
+=== tests/cases/conformance/controlFlow/dependentDestructuredVariables.ts ===
+type Action =
+>Action : Symbol(Action, Decl(dependentDestructuredVariables.ts, 0, 0))
+
+    | { kind: 'A', payload: number }
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 1, 7))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 1, 18))
+
+    | { kind: 'B', payload: string };
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 2, 7))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 2, 18))
+
+function f10({ kind, payload }: Action) {
+>f10 : Symbol(f10, Decl(dependentDestructuredVariables.ts, 2, 37))
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 4, 14))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 4, 20))
+>Action : Symbol(Action, Decl(dependentDestructuredVariables.ts, 0, 0))
+
+    if (kind === 'A') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 4, 14))
+
+        payload.toFixed();
+>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 4, 20))
+>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+    }
+    if (kind === 'B') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 4, 14))
+
+        payload.toUpperCase();
+>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 4, 20))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+    }
+}
+
+function f11(action: Action) {
+>f11 : Symbol(f11, Decl(dependentDestructuredVariables.ts, 11, 1))
+>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 13, 13))
+>Action : Symbol(Action, Decl(dependentDestructuredVariables.ts, 0, 0))
+
+    const { kind, payload } = action;
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 14, 11))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 14, 17))
+>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 13, 13))
+
+    if (kind === 'A') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 14, 11))
+
+        payload.toFixed();
+>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 14, 17))
+>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+    }
+    if (kind === 'B') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 14, 11))
+
+        payload.toUpperCase();
+>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 14, 17))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+    }
+}
+
+function f12({ kind, payload }: Action) {
+>f12 : Symbol(f12, Decl(dependentDestructuredVariables.ts, 21, 1))
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 23, 14))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 23, 20))
+>Action : Symbol(Action, Decl(dependentDestructuredVariables.ts, 0, 0))
+
+    switch (kind) {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 23, 14))
+
+        case 'A':
+            payload.toFixed();
+>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 23, 20))
+>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+
+            break;
+        case 'B':
+            payload.toUpperCase();
+>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 23, 20))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+
+            break;
+        default:
+            payload;  // never
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 23, 20))
+    }
+}
+
+type Action2 =
+>Action2 : Symbol(Action2, Decl(dependentDestructuredVariables.ts, 34, 1))
+
+    | { kind: 'A', payload: number | undefined }
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 37, 7))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 37, 18))
+
+    | { kind: 'B', payload: string | undefined };
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 38, 7))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 38, 18))
+
+function f20({ kind, payload }: Action2) {
+>f20 : Symbol(f20, Decl(dependentDestructuredVariables.ts, 38, 49))
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 40, 14))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 40, 20))
+>Action2 : Symbol(Action2, Decl(dependentDestructuredVariables.ts, 34, 1))
+
+    if (payload) {
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 40, 20))
+
+        if (kind === 'A') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 40, 14))
+
+            payload.toFixed();
+>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 40, 20))
+>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+        }
+        if (kind === 'B') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 40, 14))
+
+            payload.toUpperCase();
+>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 40, 20))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+        }
+    }
+}
+
+function f21(action: Action2) {
+>f21 : Symbol(f21, Decl(dependentDestructuredVariables.ts, 49, 1))
+>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 51, 13))
+>Action2 : Symbol(Action2, Decl(dependentDestructuredVariables.ts, 34, 1))
+
+    const { kind, payload } = action;
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 52, 11))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 52, 17))
+>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 51, 13))
+
+    if (payload) {
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 52, 17))
+
+        if (kind === 'A') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 52, 11))
+
+            payload.toFixed();
+>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 52, 17))
+>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+        }
+        if (kind === 'B') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 52, 11))
+
+            payload.toUpperCase();
+>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 52, 17))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+        }
+    }
+}
+
+function f22(action: Action2) {
+>f22 : Symbol(f22, Decl(dependentDestructuredVariables.ts, 61, 1))
+>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 63, 13))
+>Action2 : Symbol(Action2, Decl(dependentDestructuredVariables.ts, 34, 1))
+
+    if (action.payload) {
+>action.payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 37, 18), Decl(dependentDestructuredVariables.ts, 38, 18))
+>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 63, 13))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 37, 18), Decl(dependentDestructuredVariables.ts, 38, 18))
+
+        const { kind, payload } = action;
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 65, 15))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 65, 21))
+>action : Symbol(action, Decl(dependentDestructuredVariables.ts, 63, 13))
+
+        if (kind === 'A') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 65, 15))
+
+            payload.toFixed();
+>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 65, 21))
+>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+        }
+        if (kind === 'B') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 65, 15))
+
+            payload.toUpperCase();
+>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 65, 21))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+        }
+    }
+}
+
+function f23({ kind, payload }: Action2) {
+>f23 : Symbol(f23, Decl(dependentDestructuredVariables.ts, 73, 1))
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 75, 14))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 75, 20))
+>Action2 : Symbol(Action2, Decl(dependentDestructuredVariables.ts, 34, 1))
+
+    if (payload) {
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 75, 20))
+
+        switch (kind) {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 75, 14))
+
+            case 'A':
+                payload.toFixed();
+>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 75, 20))
+>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --))
+
+                break;
+            case 'B':
+                payload.toUpperCase();
+>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 75, 20))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --))
+
+                break;
+            default:
+                payload;  // never
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 75, 20))
+        }
+    }
+}
+
+type Foo =
+>Foo : Symbol(Foo, Decl(dependentDestructuredVariables.ts, 88, 1))
+
+    | { kind: 'A', isA: true }
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 91, 7))
+>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 91, 18))
+
+    | { kind: 'B', isA: false }
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 92, 7))
+>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 92, 18))
+
+    | { kind: 'C', isA: false };
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 93, 7))
+>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 93, 18))
+
+function f30({ kind, isA }: Foo) {
+>f30 : Symbol(f30, Decl(dependentDestructuredVariables.ts, 93, 32))
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
+>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 95, 20))
+>Foo : Symbol(Foo, Decl(dependentDestructuredVariables.ts, 88, 1))
+
+    if (kind === 'A') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
+
+        isA;   // true
+>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 95, 20))
+    }
+    if (kind === 'B') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
+
+        isA;   // false
+>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 95, 20))
+    }
+    if (kind === 'C') {
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
+
+        isA;   // false
+>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 95, 20))
+    }
+    if (isA) {
+>isA : Symbol(isA, Decl(dependentDestructuredVariables.ts, 95, 20))
+
+        kind;  // 'A'
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
+    }
+    else {
+        kind;  // 'B' | 'C'
+>kind : Symbol(kind, Decl(dependentDestructuredVariables.ts, 95, 14))
+    }
+}
+
+// Repro from #35283
+
+interface A<T> { variant: 'a', value: T }
+>A : Symbol(A, Decl(dependentDestructuredVariables.ts, 111, 1))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 115, 12))
+>variant : Symbol(A.variant, Decl(dependentDestructuredVariables.ts, 115, 16))
+>value : Symbol(A.value, Decl(dependentDestructuredVariables.ts, 115, 30))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 115, 12))
+
+interface B<T> { variant: 'b', value: Array<T> }
+>B : Symbol(B, Decl(dependentDestructuredVariables.ts, 115, 41))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 117, 12))
+>variant : Symbol(B.variant, Decl(dependentDestructuredVariables.ts, 117, 16))
+>value : Symbol(B.value, Decl(dependentDestructuredVariables.ts, 117, 30))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 117, 12))
+
+type AB<T> = A<T> | B<T>;
+>AB : Symbol(AB, Decl(dependentDestructuredVariables.ts, 117, 48))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 119, 8))
+>A : Symbol(A, Decl(dependentDestructuredVariables.ts, 111, 1))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 119, 8))
+>B : Symbol(B, Decl(dependentDestructuredVariables.ts, 115, 41))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 119, 8))
+
+declare function printValue<T>(t: T): void;
+>printValue : Symbol(printValue, Decl(dependentDestructuredVariables.ts, 119, 25))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 121, 28))
+>t : Symbol(t, Decl(dependentDestructuredVariables.ts, 121, 31))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 121, 28))
+
+declare function printValueList<T>(t: Array<T>): void;
+>printValueList : Symbol(printValueList, Decl(dependentDestructuredVariables.ts, 121, 43))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 123, 32))
+>t : Symbol(t, Decl(dependentDestructuredVariables.ts, 123, 35))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 123, 32))
+
+function unrefined1<T>(ab: AB<T>): void {
+>unrefined1 : Symbol(unrefined1, Decl(dependentDestructuredVariables.ts, 123, 54))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 125, 20))
+>ab : Symbol(ab, Decl(dependentDestructuredVariables.ts, 125, 23))
+>AB : Symbol(AB, Decl(dependentDestructuredVariables.ts, 117, 48))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 125, 20))
+
+    const { variant, value } = ab;
+>variant : Symbol(variant, Decl(dependentDestructuredVariables.ts, 126, 11))
+>value : Symbol(value, Decl(dependentDestructuredVariables.ts, 126, 20))
+>ab : Symbol(ab, Decl(dependentDestructuredVariables.ts, 125, 23))
+
+    if (variant === 'a') {
+>variant : Symbol(variant, Decl(dependentDestructuredVariables.ts, 126, 11))
+
+        printValue<T>(value);
+>printValue : Symbol(printValue, Decl(dependentDestructuredVariables.ts, 119, 25))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 125, 20))
+>value : Symbol(value, Decl(dependentDestructuredVariables.ts, 126, 20))
+    }
+    else {
+        printValueList<T>(value);
+>printValueList : Symbol(printValueList, Decl(dependentDestructuredVariables.ts, 121, 43))
+>T : Symbol(T, Decl(dependentDestructuredVariables.ts, 125, 20))
+>value : Symbol(value, Decl(dependentDestructuredVariables.ts, 126, 20))
+    }
+}
+
+// Repro from #38020
+
+type Action3 =
+>Action3 : Symbol(Action3, Decl(dependentDestructuredVariables.ts, 133, 1))
+
+    | {type: 'add', payload: { toAdd: number } }
+>type : Symbol(type, Decl(dependentDestructuredVariables.ts, 138, 7))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 138, 19))
+>toAdd : Symbol(toAdd, Decl(dependentDestructuredVariables.ts, 138, 30))
+
+    | {type: 'remove', payload: { toRemove: number } };
+>type : Symbol(type, Decl(dependentDestructuredVariables.ts, 139, 7))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 139, 22))
+>toRemove : Symbol(toRemove, Decl(dependentDestructuredVariables.ts, 139, 33))
+
+const reducerBroken = (state: number, { type, payload }: Action3) => {
+>reducerBroken : Symbol(reducerBroken, Decl(dependentDestructuredVariables.ts, 141, 5))
+>state : Symbol(state, Decl(dependentDestructuredVariables.ts, 141, 23))
+>type : Symbol(type, Decl(dependentDestructuredVariables.ts, 141, 39))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 141, 45))
+>Action3 : Symbol(Action3, Decl(dependentDestructuredVariables.ts, 133, 1))
+
+    switch (type) {
+>type : Symbol(type, Decl(dependentDestructuredVariables.ts, 141, 39))
+
+        case 'add':
+            return state + payload.toAdd;
+>state : Symbol(state, Decl(dependentDestructuredVariables.ts, 141, 23))
+>payload.toAdd : Symbol(toAdd, Decl(dependentDestructuredVariables.ts, 138, 30))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 141, 45))
+>toAdd : Symbol(toAdd, Decl(dependentDestructuredVariables.ts, 138, 30))
+
+        case 'remove':
+            return state - payload.toRemove;
+>state : Symbol(state, Decl(dependentDestructuredVariables.ts, 141, 23))
+>payload.toRemove : Symbol(toRemove, Decl(dependentDestructuredVariables.ts, 139, 33))
+>payload : Symbol(payload, Decl(dependentDestructuredVariables.ts, 141, 45))
+>toRemove : Symbol(toRemove, Decl(dependentDestructuredVariables.ts, 139, 33))
+    }
+}
+
+// Repro from #46143
+
+declare var it: Iterator<number>;
+>it : Symbol(it, Decl(dependentDestructuredVariables.ts, 152, 11))
+>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+
+const { value, done } = it.next();
+>value : Symbol(value, Decl(dependentDestructuredVariables.ts, 153, 7))
+>done : Symbol(done, Decl(dependentDestructuredVariables.ts, 153, 14))
+>it.next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --))
+>it : Symbol(it, Decl(dependentDestructuredVariables.ts, 152, 11))
+>next : Symbol(Iterator.next, Decl(lib.es2015.iterable.d.ts, --, --))
+
+if (!done) {
+>done : Symbol(done, Decl(dependentDestructuredVariables.ts, 153, 14))
+
+    value;  // number
+>value : Symbol(value, Decl(dependentDestructuredVariables.ts, 153, 7))
+}
+

tests/baselines/reference/dependentDestructuredVariables.types

@@ -0,0 +1,441 @@
+=== tests/cases/conformance/controlFlow/dependentDestructuredVariables.ts ===
+type Action =
+>Action : Action
+
+    | { kind: 'A', payload: number }
+>kind : "A"
+>payload : number
+
+    | { kind: 'B', payload: string };
+>kind : "B"
+>payload : string
+
+function f10({ kind, payload }: Action) {
+>f10 : ({ kind, payload }: Action) => void
+>kind : "A" | "B"
+>payload : string | number
+
+    if (kind === 'A') {
+>kind === 'A' : boolean
+>kind : "A" | "B"
+>'A' : "A"
+
+        payload.toFixed();
+>payload.toFixed() : string
+>payload.toFixed : (fractionDigits?: number | undefined) => string
+>payload : number
+>toFixed : (fractionDigits?: number | undefined) => string
+    }
+    if (kind === 'B') {
+>kind === 'B' : boolean
+>kind : "A" | "B"
+>'B' : "B"
+
+        payload.toUpperCase();
+>payload.toUpperCase() : string
+>payload.toUpperCase : () => string
+>payload : string
+>toUpperCase : () => string
+    }
+}
+
+function f11(action: Action) {
+>f11 : (action: Action) => void
+>action : Action
+
+    const { kind, payload } = action;
+>kind : "A" | "B"
+>payload : string | number
+>action : Action
+
+    if (kind === 'A') {
+>kind === 'A' : boolean
+>kind : "A" | "B"
+>'A' : "A"
+
+        payload.toFixed();
+>payload.toFixed() : string
+>payload.toFixed : (fractionDigits?: number | undefined) => string
+>payload : number
+>toFixed : (fractionDigits?: number | undefined) => string
+    }
+    if (kind === 'B') {
+>kind === 'B' : boolean
+>kind : "A" | "B"
+>'B' : "B"
+
+        payload.toUpperCase();
+>payload.toUpperCase() : string
+>payload.toUpperCase : () => string
+>payload : string
+>toUpperCase : () => string
+    }
+}
+
+function f12({ kind, payload }: Action) {
+>f12 : ({ kind, payload }: Action) => void
+>kind : "A" | "B"
+>payload : string | number
+
+    switch (kind) {
+>kind : "A" | "B"
+
+        case 'A':
+>'A' : "A"
+
+            payload.toFixed();
+>payload.toFixed() : string
+>payload.toFixed : (fractionDigits?: number | undefined) => string
+>payload : number
+>toFixed : (fractionDigits?: number | undefined) => string
+
+            break;
+        case 'B':
+>'B' : "B"
+
+            payload.toUpperCase();
+>payload.toUpperCase() : string
+>payload.toUpperCase : () => string
+>payload : string
+>toUpperCase : () => string
+
+            break;
+        default:
+            payload;  // never
+>payload : never
+    }
+}
+
+type Action2 =
+>Action2 : Action2
+
+    | { kind: 'A', payload: number | undefined }
+>kind : "A"
+>payload : number | undefined
+
+    | { kind: 'B', payload: string | undefined };
+>kind : "B"
+>payload : string | undefined
+
+function f20({ kind, payload }: Action2) {
+>f20 : ({ kind, payload }: Action2) => void
+>kind : "A" | "B"
+>payload : string | number | undefined
+
+    if (payload) {
+>payload : string | number | undefined
+
+        if (kind === 'A') {
+>kind === 'A' : boolean
+>kind : "A" | "B"
+>'A' : "A"
+
+            payload.toFixed();
+>payload.toFixed() : string
+>payload.toFixed : (fractionDigits?: number | undefined) => string
+>payload : number
+>toFixed : (fractionDigits?: number | undefined) => string
+        }
+        if (kind === 'B') {
+>kind === 'B' : boolean
+>kind : "A" | "B"
+>'B' : "B"
+
+            payload.toUpperCase();
+>payload.toUpperCase() : string
+>payload.toUpperCase : () => string
+>payload : string
+>toUpperCase : () => string
+        }
+    }
+}
+
+function f21(action: Action2) {
+>f21 : (action: Action2) => void
+>action : Action2
+
+    const { kind, payload } = action;
+>kind : "A" | "B"
+>payload : string | number | undefined
+>action : Action2
+
+    if (payload) {
+>payload : string | number | undefined
+
+        if (kind === 'A') {
+>kind === 'A' : boolean
+>kind : "A" | "B"
+>'A' : "A"
+
+            payload.toFixed();
+>payload.toFixed() : string
+>payload.toFixed : (fractionDigits?: number | undefined) => string
+>payload : number
+>toFixed : (fractionDigits?: number | undefined) => string
+        }
+        if (kind === 'B') {
+>kind === 'B' : boolean
+>kind : "A" | "B"
+>'B' : "B"
+
+            payload.toUpperCase();
+>payload.toUpperCase() : string
+>payload.toUpperCase : () => string
+>payload : string
+>toUpperCase : () => string
+        }
+    }
+}
+
+function f22(action: Action2) {
+>f22 : (action: Action2) => void
+>action : Action2
+
+    if (action.payload) {
+>action.payload : string | number | undefined
+>action : Action2
+>payload : string | number | undefined
+
+        const { kind, payload } = action;
+>kind : "A" | "B"
+>payload : string | number
+>action : Action2
+
+        if (kind === 'A') {
+>kind === 'A' : boolean
+>kind : "A" | "B"
+>'A' : "A"
+
+            payload.toFixed();
+>payload.toFixed() : string
+>payload.toFixed : (fractionDigits?: number | undefined) => string
+>payload : number
+>toFixed : (fractionDigits?: number | undefined) => string
+        }
+        if (kind === 'B') {
+>kind === 'B' : boolean
+>kind : "A" | "B"
+>'B' : "B"
+
+            payload.toUpperCase();
+>payload.toUpperCase() : string
+>payload.toUpperCase : () => string
+>payload : string
+>toUpperCase : () => string
+        }
+    }
+}
+
+function f23({ kind, payload }: Action2) {
+>f23 : ({ kind, payload }: Action2) => void
+>kind : "A" | "B"
+>payload : string | number | undefined
+
+    if (payload) {
+>payload : string | number | undefined
+
+        switch (kind) {
+>kind : "A" | "B"
+
+            case 'A':
+>'A' : "A"
+
+                payload.toFixed();
+>payload.toFixed() : string
+>payload.toFixed : (fractionDigits?: number | undefined) => string
+>payload : number
+>toFixed : (fractionDigits?: number | undefined) => string
+
+                break;
+            case 'B':
+>'B' : "B"
+
+                payload.toUpperCase();
+>payload.toUpperCase() : string
+>payload.toUpperCase : () => string
+>payload : string
+>toUpperCase : () => string
+
+                break;
+            default:
+                payload;  // never
+>payload : never
+        }
+    }
+}
+
+type Foo =
+>Foo : Foo
+
+    | { kind: 'A', isA: true }
+>kind : "A"
+>isA : true
+>true : true
+
+    | { kind: 'B', isA: false }
+>kind : "B"
+>isA : false
+>false : false
+
+    | { kind: 'C', isA: false };
+>kind : "C"
+>isA : false
+>false : false
+
+function f30({ kind, isA }: Foo) {
+>f30 : ({ kind, isA }: Foo) => void
+>kind : "A" | "B" | "C"
+>isA : boolean
+
+    if (kind === 'A') {
+>kind === 'A' : boolean
+>kind : "A" | "B" | "C"
+>'A' : "A"
+
+        isA;   // true
+>isA : true
+    }
+    if (kind === 'B') {
+>kind === 'B' : boolean
+>kind : "A" | "B" | "C"
+>'B' : "B"
+
+        isA;   // false
+>isA : false
+    }
+    if (kind === 'C') {
+>kind === 'C' : boolean
+>kind : "A" | "B" | "C"
+>'C' : "C"
+
+        isA;   // false
+>isA : false
+    }
+    if (isA) {
+>isA : boolean
+
+        kind;  // 'A'
+>kind : "A"
+    }
+    else {
+        kind;  // 'B' | 'C'
+>kind : "B" | "C"
+    }
+}
+
+// Repro from #35283
+
+interface A<T> { variant: 'a', value: T }
+>variant : "a"
+>value : T
+
+interface B<T> { variant: 'b', value: Array<T> }
+>variant : "b"
+>value : T[]
+
+type AB<T> = A<T> | B<T>;
+>AB : AB<T>
+
+declare function printValue<T>(t: T): void;
+>printValue : <T>(t: T) => void
+>t : T
+
+declare function printValueList<T>(t: Array<T>): void;
+>printValueList : <T>(t: Array<T>) => void
+>t : T[]
+
+function unrefined1<T>(ab: AB<T>): void {
+>unrefined1 : <T>(ab: AB<T>) => void
+>ab : AB<T>
+
+    const { variant, value } = ab;
+>variant : "a" | "b"
+>value : T | T[]
+>ab : AB<T>
+
+    if (variant === 'a') {
+>variant === 'a' : boolean
+>variant : "a" | "b"
+>'a' : "a"
+
+        printValue<T>(value);
+>printValue<T>(value) : void
+>printValue : <T>(t: T) => void
+>value : T
+    }
+    else {
+        printValueList<T>(value);
+>printValueList<T>(value) : void
+>printValueList : <T>(t: T[]) => void
+>value : T[]
+    }
+}
+
+// Repro from #38020
+
+type Action3 =
+>Action3 : Action3
+
+    | {type: 'add', payload: { toAdd: number } }
+>type : "add"
+>payload : { toAdd: number; }
+>toAdd : number
+
+    | {type: 'remove', payload: { toRemove: number } };
+>type : "remove"
+>payload : { toRemove: number; }
+>toRemove : number
+
+const reducerBroken = (state: number, { type, payload }: Action3) => {
+>reducerBroken : (state: number, { type, payload }: Action3) => number
+>(state: number, { type, payload }: Action3) => {    switch (type) {        case 'add':            return state + payload.toAdd;        case 'remove':            return state - payload.toRemove;    }} : (state: number, { type, payload }: Action3) => number
+>state : number
+>type : "add" | "remove"
+>payload : { toAdd: number; } | { toRemove: number; }
+
+    switch (type) {
+>type : "add" | "remove"
+
+        case 'add':
+>'add' : "add"
+
+            return state + payload.toAdd;
+>state + payload.toAdd : number
+>state : number
+>payload.toAdd : number
+>payload : { toAdd: number; }
+>toAdd : number
+
+        case 'remove':
+>'remove' : "remove"
+
+            return state - payload.toRemove;
+>state - payload.toRemove : number
+>state : number
+>payload.toRemove : number
+>payload : { toRemove: number; }
+>toRemove : number
+    }
+}
+
+// Repro from #46143
+
+declare var it: Iterator<number>;
+>it : Iterator<number, any, undefined>
+
+const { value, done } = it.next();
+>value : any
+>done : boolean | undefined
+>it.next() : IteratorResult<number, any>
+>it.next : (...args: [] | [undefined]) => IteratorResult<number, any>
+>it : Iterator<number, any, undefined>
+>next : (...args: [] | [undefined]) => IteratorResult<number, any>
+
+if (!done) {
+>!done : boolean
+>done : boolean | undefined
+
+    value;  // number
+>value : number
+}
+

tests/baselines/reference/doYouNeedToChangeYourTargetLibraryES2016Plus.errors.txt

@@ -16,7 +16,7 @@ tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(20,27): err
 tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(21,35): error TS2583: Cannot find name 'AsyncGeneratorFunction'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
 tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(22,26): error TS2583: Cannot find name 'AsyncIterable'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
 tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(23,34): error TS2583: Cannot find name 'AsyncIterableIterator'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
-tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(24,70): error TS2550: Property 'formatToParts' does not exist on type 'NumberFormat'. Do you need to change your target library? Try changing the 'lib' compiler option to 'esnext' or later.
+tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(24,70): error TS2550: Property 'formatToParts' does not exist on type 'NumberFormat'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
 tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(27,26): error TS2550: Property 'flat' does not exist on type 'undefined[]'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2019' or later.
 tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(28,29): error TS2550: Property 'flatMap' does not exist on type 'undefined[]'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2019' or later.
 tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(29,49): error TS2550: Property 'fromEntries' does not exist on type 'ObjectConstructor'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2019' or later.
@@ -95,7 +95,7 @@ tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts(44,33): err
 !!! error TS2583: Cannot find name 'AsyncIterableIterator'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
     const testNumberFormatFormatToParts = new Intl.NumberFormat("en-US").formatToParts();
                                                                          ~~~~~~~~~~~~~
-!!! error TS2550: Property 'formatToParts' does not exist on type 'NumberFormat'. Do you need to change your target library? Try changing the 'lib' compiler option to 'esnext' or later.
+!!! error TS2550: Property 'formatToParts' does not exist on type 'NumberFormat'. Do you need to change your target library? Try changing the 'lib' compiler option to 'es2018' or later.
     
     // es2019
     const testArrayFlat = [].flat();

tests/baselines/reference/duplicateVarsAcrossFileBoundaries.js

@@ -43,6 +43,7 @@ var x = 0;
 var y = "";
 var z = 0;
 //// [duplicateVarsAcrossFileBoundaries_4.js]
+var p = P;
 var q;
 //// [duplicateVarsAcrossFileBoundaries_5.js]
 var p;

tests/baselines/reference/enumWithUnicodeEscape1.symbols

@@ -3,6 +3,6 @@ enum E {
 >E : Symbol(E, Decl(enumWithUnicodeEscape1.ts, 0, 0))
 
   'gold \u2730'
->'gold \u2730' : Symbol(E['gold u2730'], Decl(enumWithUnicodeEscape1.ts, 0, 8))
+>'gold \u2730' : Symbol(E['gold \u2730'], Decl(enumWithUnicodeEscape1.ts, 0, 8))
 }
 

tests/baselines/reference/errorCause(target=es2021).errors.txt

@@ -0,0 +1,8 @@
+tests/cases/compiler/errorCause.ts(1,18): error TS2554: Expected 0-1 arguments, but got 2.
+
+
+==== tests/cases/compiler/errorCause.ts (1 errors) ====
+    new Error("foo", { cause: new Error("bar") });
+                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2554: Expected 0-1 arguments, but got 2.
+    

tests/baselines/reference/errorCause(target=es2021).js

@@ -0,0 +1,6 @@
+//// [errorCause.ts]
+new Error("foo", { cause: new Error("bar") });
+
+
+//// [errorCause.js]
+new Error("foo", { cause: new Error("bar") });