typescript 4.6.0-dev.20211102 → 4.6.0-dev.20211103

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // 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
-    ts.version = ts.versionMajorMinor + ".0-dev.20211102";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211103";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4800,6 +4800,7 @@ var ts;
         NodeCheckFlags[NodeCheckFlags["ConstructorReferenceInClass"] = 33554432] = "ConstructorReferenceInClass";
         NodeCheckFlags[NodeCheckFlags["ContainsClassWithPrivateIdentifiers"] = 67108864] = "ContainsClassWithPrivateIdentifiers";
         NodeCheckFlags[NodeCheckFlags["ContainsSuperPropertyInStaticInitializer"] = 134217728] = "ContainsSuperPropertyInStaticInitializer";
+        NodeCheckFlags[NodeCheckFlags["InCheckIdentifier"] = 268435456] = "InCheckIdentifier";
     })(NodeCheckFlags = ts.NodeCheckFlags || (ts.NodeCheckFlags = {}));
     var TypeFlags;
     (function (TypeFlags) {
@@ -4873,8 +4874,6 @@ var ts;
         // 'Narrowable' types are types where narrowing actually narrows.
         // This *should* be every type other than null, undefined, void, and never
         TypeFlags[TypeFlags["Narrowable"] = 536624127] = "Narrowable";
-        /* @internal */
-        TypeFlags[TypeFlags["NotPrimitiveUnion"] = 468598819] = "NotPrimitiveUnion";
         // The following flags are aggregated during union and intersection type construction
         /* @internal */
         TypeFlags[TypeFlags["IncludesMask"] = 205258751] = "IncludesMask";
@@ -4887,6 +4886,10 @@ var ts;
         TypeFlags[TypeFlags["IncludesWildcard"] = 8388608] = "IncludesWildcard";
         /* @internal */
         TypeFlags[TypeFlags["IncludesEmptyObject"] = 16777216] = "IncludesEmptyObject";
+        /* @internal */
+        TypeFlags[TypeFlags["IncludesInstantiable"] = 33554432] = "IncludesInstantiable";
+        /* @internal */
+        TypeFlags[TypeFlags["NotPrimitiveUnion"] = 36323363] = "NotPrimitiveUnion";
     })(TypeFlags = ts.TypeFlags || (ts.TypeFlags = {}));
     // Types included in TypeFlags.ObjectFlagsType have an objectFlags property. Some ObjectFlags
     // are specific to certain types and reuse the same bit position. Those ObjectFlags require a check
@@ -8101,7 +8104,7 @@ var ts;
         Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1321, ts.DiagnosticCategory.Error, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."),
         Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1322, ts.DiagnosticCategory.Error, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."),
         Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node12', or 'nodenext'."),
-        Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_1324", "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: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext' or 'nodenext'."),
         Argument_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."),
         Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments."),
         String_literal_with_double_quotes_expected: diag(1327, ts.DiagnosticCategory.Error, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."),
@@ -8701,11 +8704,12 @@ var ts;
         Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers: diag(2818, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializer_2818", "Duplicate identifier '{0}'. Compiler reserves name '{1}' when emitting 'super' references in static initializers."),
         Namespace_name_cannot_be_0: diag(2819, ts.DiagnosticCategory.Error, "Namespace_name_cannot_be_0_2819", "Namespace name cannot be '{0}'."),
         Type_0_is_not_assignable_to_type_1_Did_you_mean_2: diag(2820, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_Did_you_mean_2_2820", "Type '{0}' is not assignable to type '{1}'. Did you mean '{2}'?"),
-        Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext: diag(2821, ts.DiagnosticCategory.Error, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_2821", "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: diag(2821, ts.DiagnosticCategory.Error, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext_2821", "Import assertions are only supported when the '--module' option is set to 'esnext' or 'nodenext'."),
         Import_assertions_cannot_be_used_with_type_only_imports_or_exports: diag(2822, ts.DiagnosticCategory.Error, "Import_assertions_cannot_be_used_with_type_only_imports_or_exports_2822", "Import assertions cannot be used with type-only imports or exports."),
         Cannot_find_namespace_0_Did_you_mean_1: diag(2833, ts.DiagnosticCategory.Error, "Cannot_find_namespace_0_Did_you_mean_1_2833", "Cannot find namespace '{0}'. Did you mean '{1}'?"),
         Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Consider_adding_an_extension_to_the_import_path: diag(2834, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2834", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Consider adding an extension to the import path."),
         Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Did_you_mean_0: diag(2835, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Did you mean '{0}'?"),
+        Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls: diag(2836, ts.DiagnosticCategory.Error, "Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls_2836", "Import assertions are not allowed on statements that transpile to commonjs 'require' calls."),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -11732,6 +11736,7 @@ var ts;
                     tokenValue = tokenValue.slice(0, -1);
                     pos--;
                 }
+                return getIdentifierToken();
             }
             return token;
         }
@@ -54118,12 +54123,15 @@ var ts;
         }
         /** Return the inferred type for a binding element */
         function getTypeForBindingElement(declaration) {
-            var pattern = declaration.parent;
-            var 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)) {
+            var parentType = getTypeForBindingElementParent(declaration.parent.parent);
+            return parentType && getBindingElementTypeFromParentType(declaration, parentType);
+        }
+        function getBindingElementTypeFromParentType(declaration, parentType) {
+            // If an any type was inferred for parent, infer that for the binding element
+            if (isTypeAny(parentType)) {
                 return parentType;
             }
+            var pattern = declaration.parent;
             // Relax null check on ambient destructuring parameters, since the parameters have no implementation and are just documentation
             if (strictNullChecks && declaration.flags & 8388608 /* Ambient */ && ts.isParameterDeclaration(declaration)) {
                 parentType = getNonNullableType(parentType);
@@ -59335,6 +59343,8 @@ var ts;
             // We ignore 'never' types in unions
             if (!(flags & 131072 /* Never */)) {
                 includes |= flags & 205258751 /* IncludesMask */;
+                if (flags & 465829888 /* Instantiable */)
+                    includes |= 33554432 /* IncludesInstantiable */;
                 if (type === wildcardType)
                     includes |= 8388608 /* IncludesWildcard */;
                 if (!strictNullChecks && flags & 98304 /* Nullable */) {
@@ -59548,7 +59558,7 @@ var ts;
                     origin = createOriginUnionOrIntersectionType(1048576 /* Union */, reducedTypes);
                 }
             }
-            var objectFlags = (includes & 468598819 /* NotPrimitiveUnion */ ? 0 : 65536 /* PrimitiveUnion */) |
+            var objectFlags = (includes & 36323363 /* NotPrimitiveUnion */ ? 0 : 65536 /* PrimitiveUnion */) |
                 (includes & 2097152 /* Intersection */ ? 33554432 /* ContainsIntersections */ : 0);
             return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
         }
@@ -62743,7 +62753,7 @@ var ts;
                     return true;
             }
             if (source.flags & 524288 /* Object */ && target.flags & 524288 /* Object */) {
-                var related = relation.get(getRelationKey(source, target, 0 /* None */, relation));
+                var related = relation.get(getRelationKey(source, target, 0 /* None */, relation, /*ignoreConstraints*/ false));
                 if (related !== undefined) {
                     return !!(related & 1 /* Succeeded */);
                 }
@@ -63592,7 +63602,8 @@ var ts;
                 if (overflow) {
                     return 0 /* False */;
                 }
-                var id = getRelationKey(source, target, intersectionState | (inPropertyCheck ? 16 /* InPropertyCheck */ : 0), relation);
+                var keyIntersectionState = intersectionState | (inPropertyCheck ? 16 /* InPropertyCheck */ : 0);
+                var id = getRelationKey(source, target, keyIntersectionState, relation, /*ingnoreConstraints*/ false);
                 var entry = relation.get(id);
                 if (entry !== undefined) {
                     if (reportErrors && entry & 2 /* Failed */ && !(entry & 4 /* Reported */)) {
@@ -63619,16 +63630,13 @@ var 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
-                    var broadestEquivalentId = id.split(",").map(function (i) { return i.replace(/-\d+/g, function (_match, offset) {
-                        var index = ts.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.
+                    var broadestEquivalentId = id.startsWith("*") ? getRelationKey(source, target, keyIntersectionState, relation, /*ignoreConstraints*/ true) : undefined;
                     for (var 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 3 /* Maybe */;
                         }
                     }
@@ -63923,7 +63931,7 @@ var 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}`.
                     var keysRemapped = !!target.declaration.nameType;
                     var templateType = getTemplateTypeFromMappedType(target);
@@ -65135,48 +65143,56 @@ var ts;
         function isTypeReferenceWithGenericArguments(type) {
             return isNonDeferredTypeReference(type) && ts.some(getTypeArguments(type), function (t) { return !!(t.flags & 262144 /* TypeParameter */) || isTypeReferenceWithGenericArguments(t); });
         }
-        /**
-         * getTypeReferenceId(A<T, number, U>) returns "111=0-12=1"
-         *   where A.id=111 and number.id=12
-         */
-        function getTypeReferenceId(type, typeParameters, depth) {
-            if (depth === void 0) { depth = 0; }
-            var result = "" + type.target.id;
-            for (var _i = 0, _a = getTypeArguments(type); _i < _a.length; _i++) {
-                var t = _a[_i];
-                if (isUnconstrainedTypeParameter(t)) {
-                    var index = typeParameters.indexOf(t);
-                    if (index < 0) {
-                        index = typeParameters.length;
-                        typeParameters.push(t);
+        function getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) {
+            var typeParameters = [];
+            var constraintMarker = "";
+            var sourceId = getTypeReferenceId(source, 0);
+            var 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, depth) {
+                if (depth === void 0) { depth = 0; }
+                var result = "" + type.target.id;
+                for (var _i = 0, _a = getTypeArguments(type); _i < _a.length; _i++) {
+                    var t = _a[_i];
+                    if (t.flags & 262144 /* TypeParameter */) {
+                        if (ignoreConstraints || isUnconstrainedTypeParameter(t)) {
+                            var 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, depth + 1) + ">";
+                        continue;
                     }
-                    result += "=" + index;
-                }
-                else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
-                    result += "<" + getTypeReferenceId(t, 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, target, intersectionState, relation) {
+        function getRelationKey(source, target, intersectionState, relation, ignoreConstraints) {
             if (relation === identityRelation && source.id > target.id) {
                 var temp = source;
                 source = target;
                 target = temp;
             }
             var postFix = intersectionState ? ":" + intersectionState : "";
-            if (isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target)) {
-                var typeParameters = [];
-                return getTypeReferenceId(source, typeParameters) + "," + getTypeReferenceId(target, typeParameters) + postFix;
-            }
-            return source.id + "," + target.id + postFix;
+            return isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target) ?
+                getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) :
+                source.id + "," + target.id + postFix;
         }
         // Invoke the callback for each underlying property symbol of the given symbol and return the first
         // value that isn't undefined.
@@ -65224,28 +65240,35 @@ var ts;
                 !hasBaseType(checkClass, getDeclaringClass(p)) : false; }) ? undefined : checkClass;
         }
         // 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.
+        // 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, stack, depth, maxDepth) {
-            if (maxDepth === void 0) { maxDepth = 5; }
+            if (maxDepth === void 0) { maxDepth = 3; }
             if (depth >= maxDepth) {
                 var identity_1 = getRecursionIdentity(type);
                 var count = 0;
+                var lastTypeId = 0;
                 for (var i = 0; i < depth; i++) {
-                    if (getRecursionIdentity(stack[i]) === identity_1) {
-                        count++;
-                        if (count >= maxDepth) {
-                            return true;
+                    var t = stack[i];
+                    if (getRecursionIdentity(t) === identity_1) {
+                        // 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;
                     }
                 }
             }
@@ -67350,29 +67373,6 @@ var ts;
             }
             return false;
         }
-        function getPropertyAccess(expr) {
-            if (ts.isAccessExpression(expr)) {
-                return expr;
-            }
-            if (ts.isIdentifier(expr)) {
-                var symbol = getResolvedSymbol(expr);
-                if (isConstVariable(symbol)) {
-                    var declaration = symbol.valueDeclaration;
-                    // Given 'const x = obj.kind', allow 'x' as an alias for 'obj.kind'
-                    if (ts.isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && ts.isAccessExpression(declaration.initializer)) {
-                        return declaration.initializer;
-                    }
-                    // Given 'const { kind: x } = obj', allow 'x' as an alias for 'obj.kind'
-                    if (ts.isBindingElement(declaration) && !declaration.initializer) {
-                        var parent = declaration.parent.parent;
-                        if (ts.isVariableDeclaration(parent) && !parent.type && parent.initializer && (ts.isIdentifier(parent.initializer) || ts.isAccessExpression(parent.initializer))) {
-                            return declaration;
-                        }
-                    }
-                }
-            }
-            return undefined;
-        }
         function getAccessedPropertyName(access) {
             var propertyName;
             return access.kind === 205 /* PropertyAccessExpression */ ? access.name.escapedText :
@@ -68271,20 +68271,21 @@ var ts;
             }
             return false;
         }
-        function getFlowTypeOfReference(reference, declaredType, initialType, flowContainer) {
+        function getFlowTypeOfReference(reference, declaredType, initialType, flowContainer, flowNode) {
             if (initialType === void 0) { initialType = declaredType; }
+            if (flowNode === void 0) { flowNode = reference.flowNode; }
             var key;
             var isKeySet = false;
             var flowDepth = 0;
             if (flowAnalysisDisabled) {
                 return errorType;
             }
-            if (!reference.flowNode) {
+            if (!flowNode) {
                 return declaredType;
             }
             flowInvocationCount++;
             var sharedFlowStart = sharedFlowCount;
-            var evolvedType = getTypeFromFlowType(getTypeAtFlowNode(reference.flowNode));
+            var 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
@@ -68716,13 +68717,57 @@ var ts;
                 }
                 return result;
             }
+            function getCandidateDiscriminantPropertyAccess(expr) {
+                if (ts.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 (ts.isIdentifier(expr)) {
+                        var symbol = getResolvedSymbol(expr);
+                        var declaration = symbol.valueDeclaration;
+                        if (declaration && ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && reference === declaration.parent) {
+                            return declaration;
+                        }
+                    }
+                }
+                else if (ts.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 (ts.isIdentifier(expr)) {
+                    var symbol = getResolvedSymbol(expr);
+                    if (isConstVariable(symbol)) {
+                        var declaration = symbol.valueDeclaration;
+                        // Given 'const x = obj.kind', allow 'x' as an alias for 'obj.kind'
+                        if (ts.isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && ts.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 (ts.isBindingElement(declaration) && !declaration.initializer) {
+                            var parent = declaration.parent.parent;
+                            if (ts.isVariableDeclaration(parent) && !parent.type && parent.initializer && (ts.isIdentifier(parent.initializer) || ts.isAccessExpression(parent.initializer)) &&
+                                isMatchingReference(reference, parent.initializer)) {
+                                return declaration;
+                            }
+                        }
+                    }
+                }
+                return undefined;
+            }
             function getDiscriminantPropertyAccess(expr, computedType) {
-                var access, name;
                 var type = declaredType.flags & 1048576 /* Union */ ? declaredType : computedType;
-                return type.flags & 1048576 /* Union */ && (access = getPropertyAccess(expr)) && (name = getAccessedPropertyName(access)) &&
-                    isMatchingReference(reference, ts.isAccessExpression(access) ? access.expression : access.parent.parent.initializer) &&
-                    isDiscriminantProperty(type, name) ?
-                    access : undefined;
+                if (type.flags & 1048576 /* Union */) {
+                    var access = getCandidateDiscriminantPropertyAccess(expr);
+                    if (access) {
+                        var name = getAccessedPropertyName(access);
+                        if (name && isDiscriminantProperty(type, name)) {
+                            return access;
+                        }
+                    }
+                }
+                return undefined;
             }
             function narrowTypeByDiscriminant(type, access, narrowType) {
                 var propName = getAccessedPropertyName(access);
@@ -69480,6 +69525,49 @@ var ts;
                 }
             }
         }
+        function getNarrowedTypeOfSymbol(symbol, location) {
+            // 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.
+            var declaration = symbol.valueDeclaration;
+            if (declaration && ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
+                var parent = declaration.parent.parent;
+                if (parent.kind === 253 /* VariableDeclaration */ && ts.getCombinedNodeFlags(declaration) & 2 /* Const */ || parent.kind === 163 /* Parameter */) {
+                    var links = getNodeLinks(location);
+                    if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
+                        links.flags |= 268435456 /* InCheckIdentifier */;
+                        var parentType = getTypeForBindingElementParent(parent);
+                        links.flags &= ~268435456 /* InCheckIdentifier */;
+                        if (parentType && parentType.flags & 1048576 /* Union */ && !(parent.kind === 163 /* Parameter */ && isSymbolAssigned(symbol))) {
+                            var pattern = declaration.parent;
+                            var narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, /*flowContainer*/ undefined, location.flowNode);
+                            return getBindingElementTypeFromParentType(declaration, narrowedType);
+                        }
+                    }
+                }
+            }
+            return getTypeOfSymbol(symbol);
+        }
         function checkIdentifier(node, checkMode) {
             var symbol = getResolvedSymbol(node);
             if (symbol === unknownSymbol) {
@@ -69553,7 +69641,7 @@ var ts;
                 }
             }
             checkNestedBlockScopedBinding(node, symbol);
-            var type = getTypeOfSymbol(localOrExportSymbol);
+            var type = getNarrowedTypeOfSymbol(localOrExportSymbol, node);
             var assignmentKind = ts.getAssignmentTargetKind(node);
             if (assignmentKind) {
                 if (!(localOrExportSymbol.flags & 3 /* Variable */) &&
@@ -70596,13 +70684,13 @@ var ts;
         function isCircularMappedProperty(symbol) {
             return !!(ts.getCheckFlags(symbol) & 262144 /* Mapped */ && !symbol.type && findResolutionCycleStartIndex(symbol, 0 /* Type */) >= 0);
         }
-        function getTypeOfPropertyOfContextualType(type, name) {
+        function getTypeOfPropertyOfContextualType(type, name, nameType) {
             return mapType(type, function (t) {
                 var _a;
                 if (isGenericMappedType(t)) {
                     var constraint = getConstraintTypeFromMappedType(t);
                     var constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-                    var propertyNameType = getStringLiteralType(ts.unescapeLeadingUnderscores(name));
+                    var propertyNameType = nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name));
                     if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
                         return substituteIndexedMappedType(t, propertyNameType);
                     }
@@ -70618,7 +70706,7 @@ var ts;
                             return restType;
                         }
                     }
-                    return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type;
+                    return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type;
                 }
                 return undefined;
             }, /*noReductions*/ true);
@@ -70646,7 +70734,8 @@ var 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);
+                    var symbol = getSymbolOfNode(element);
+                    return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType);
                 }
                 if (element.name) {
                     var nameType_2 = getLiteralTypeFromPropertyName(element.name);
@@ -82769,8 +82858,11 @@ var ts;
         function checkAssertClause(declaration) {
             var _a;
             if (declaration.assertClause) {
-                if (moduleKind !== ts.ModuleKind.ESNext) {
-                    return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext);
+                var mode = (moduleKind === ts.ModuleKind.NodeNext) && declaration.moduleSpecifier && getUsageModeForExpression(declaration.moduleSpecifier);
+                if (mode !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.ESNext) {
+                    return grammarErrorOnNode(declaration.assertClause, moduleKind === ts.ModuleKind.NodeNext
+                        ? ts.Diagnostics.Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls
+                        : ts.Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext);
                 }
                 if (ts.isImportDeclaration(declaration) ? (_a = declaration.importClause) === null || _a === void 0 ? void 0 : _a.isTypeOnly : declaration.isTypeOnly) {
                     return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Import_assertions_cannot_be_used_with_type_only_imports_or_exports);
@@ -86617,12 +86709,12 @@ var ts;
                 return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments);
             }
             var nodeArguments = node.arguments;
-            if (moduleKind !== ts.ModuleKind.ESNext) {
+            if (moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.NodeNext) {
                 // We are allowed trailing comma after proposal-import-assertions.
                 checkGrammarForDisallowedTrailingComma(nodeArguments);
                 if (nodeArguments.length > 1) {
                     var assertionArgument = nodeArguments[1];
-                    return grammarErrorOnNode(assertionArgument, ts.Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext);
+                    return grammarErrorOnNode(assertionArgument, ts.Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext);
                 }
             }
             if (nodeArguments.length === 0 || nodeArguments.length > 2) {