typescript 4.6.0-dev.20220206 → 4.6.0-dev.20220210

package/lib/typescript.js

@@ -294,7 +294,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.20220206";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220210";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8239,10 +8239,10 @@ var ts;
         A_type_predicate_cannot_reference_a_rest_parameter: diag(1229, ts.DiagnosticCategory.Error, "A_type_predicate_cannot_reference_a_rest_parameter_1229", "A type predicate cannot reference a rest parameter."),
         A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: diag(1230, ts.DiagnosticCategory.Error, "A_type_predicate_cannot_reference_element_0_in_a_binding_pattern_1230", "A type predicate cannot reference element '{0}' in a binding pattern."),
         An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration: diag(1231, ts.DiagnosticCategory.Error, "An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration_1231", "An export assignment must be at the top level of a file or module declaration."),
-        An_import_declaration_can_only_be_used_in_a_namespace_or_module: diag(1232, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_in_a_namespace_or_module_1232", "An import declaration can only be used in a namespace or module."),
-        An_export_declaration_can_only_be_used_in_a_module: diag(1233, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_in_a_module_1233", "An export declaration can only be used in a module."),
+        An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module: diag(1232, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module_1232", "An import declaration can only be used at the top level of a namespace or module."),
+        An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module: diag(1233, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module_1233", "An export declaration can only be used at the top level of a namespace or module."),
         An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: diag(1234, ts.DiagnosticCategory.Error, "An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file_1234", "An ambient module declaration is only allowed at the top level in a file."),
-        A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: diag(1235, ts.DiagnosticCategory.Error, "A_namespace_declaration_is_only_allowed_in_a_namespace_or_module_1235", "A namespace declaration is only allowed in a namespace or module."),
+        A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module: diag(1235, ts.DiagnosticCategory.Error, "A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module_1235", "A namespace declaration is only allowed at the top level of a namespace or module."),
         The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: diag(1236, ts.DiagnosticCategory.Error, "The_return_type_of_a_property_decorator_function_must_be_either_void_or_any_1236", "The return type of a property decorator function must be either 'void' or 'any'."),
         The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: diag(1237, ts.DiagnosticCategory.Error, "The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any_1237", "The return type of a parameter decorator function must be either 'void' or 'any'."),
         Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: diag(1238, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression_1238", "Unable to resolve signature of class decorator when called as an expression."),
@@ -8410,6 +8410,8 @@ var ts;
         The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output: diag(1470, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470", "The 'import.meta' meta-property is not allowed in files which will build into CommonJS output."),
         Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead: diag(1471, ts.DiagnosticCategory.Error, "Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_c_1471", "Module '{0}' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported synchronously. Use dynamic import instead."),
         catch_or_finally_expected: diag(1472, ts.DiagnosticCategory.Error, "catch_or_finally_expected_1472", "'catch' or 'finally' expected."),
+        An_import_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1473, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_module_1473", "An import declaration can only be used at the top level of a module."),
+        An_export_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1474, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_module_1474", "An export declaration can only be used at the top level of a module."),
         The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
         The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
         Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
@@ -14091,6 +14093,10 @@ var ts;
         return undefined;
     }
     ts.getDeclarationOfKind = getDeclarationOfKind;
+    function getDeclarationsOfKind(symbol, kind) {
+        return ts.filter(symbol.declarations || ts.emptyArray, function (d) { return d.kind === kind; });
+    }
+    ts.getDeclarationsOfKind = getDeclarationsOfKind;
     function createSymbolTable(symbols) {
         var result = new ts.Map();
         if (symbols) {
@@ -14326,6 +14332,10 @@ var ts;
         return getSourceFileOfNode(module.valueDeclaration || getNonAugmentationDeclaration(module));
     }
     ts.getSourceFileOfModule = getSourceFileOfModule;
+    function isPlainJsFile(file, checkJs) {
+        return !!file && (file.scriptKind === 1 /* JS */ || file.scriptKind === 2 /* JSX */) && !file.checkJsDirective && checkJs === undefined;
+    }
+    ts.isPlainJsFile = isPlainJsFile;
     function isStatementWithLocals(node) {
         switch (node.kind) {
             case 234 /* Block */:
@@ -47103,6 +47113,9 @@ var ts;
         CheckMode[CheckMode["SkipContextSensitive"] = 4] = "SkipContextSensitive";
         CheckMode[CheckMode["SkipGenericFunctions"] = 8] = "SkipGenericFunctions";
         CheckMode[CheckMode["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
+        CheckMode[CheckMode["RestBindingElement"] = 32] = "RestBindingElement";
+        //   e.g. in `const { a, ...rest } = foo`, when checking the type of `foo` to determine the type of `rest`,
+        //   we need to preserve generic types instead of substituting them for constraints
     })(CheckMode || (CheckMode = {}));
     var SignatureCheckMode;
     (function (SignatureCheckMode) {
@@ -48155,13 +48168,13 @@ var ts;
             else { // error
                 var isEitherEnum = !!(target.flags & 384 /* Enum */ || source.flags & 384 /* Enum */);
                 var isEitherBlockScoped_1 = !!(target.flags & 2 /* BlockScopedVariable */ || source.flags & 2 /* BlockScopedVariable */);
-                var message = isEitherEnum
-                    ? ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations
-                    : isEitherBlockScoped_1
-                        ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
+                var message = isEitherEnum ? ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations
+                    : isEitherBlockScoped_1 ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
                         : ts.Diagnostics.Duplicate_identifier_0;
                 var sourceSymbolFile = source.declarations && ts.getSourceFileOfNode(source.declarations[0]);
                 var targetSymbolFile = target.declarations && ts.getSourceFileOfNode(target.declarations[0]);
+                var isSourcePlainJs = ts.isPlainJsFile(sourceSymbolFile, compilerOptions.checkJs);
+                var isTargetPlainJs = ts.isPlainJsFile(targetSymbolFile, compilerOptions.checkJs);
                 var symbolName_1 = symbolToString(source);
                 // Collect top-level duplicate identifier errors into one mapping, so we can then merge their diagnostics if there are a bunch
                 if (sourceSymbolFile && targetSymbolFile && amalgamatedDuplicates && !isEitherEnum && sourceSymbolFile !== targetSymbolFile) {
@@ -48173,12 +48186,16 @@ var ts;
                     var conflictingSymbolInfo = ts.getOrUpdate(filesDuplicates.conflictingSymbols, symbolName_1, function () {
                         return ({ isBlockScoped: isEitherBlockScoped_1, firstFileLocations: [], secondFileLocations: [] });
                     });
-                    addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source);
-                    addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target);
+                    if (!isSourcePlainJs)
+                        addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source);
+                    if (!isTargetPlainJs)
+                        addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target);
                 }
                 else {
-                    addDuplicateDeclarationErrorsForSymbols(source, message, symbolName_1, target);
-                    addDuplicateDeclarationErrorsForSymbols(target, message, symbolName_1, source);
+                    if (!isSourcePlainJs)
+                        addDuplicateDeclarationErrorsForSymbols(source, message, symbolName_1, target);
+                    if (!isTargetPlainJs)
+                        addDuplicateDeclarationErrorsForSymbols(target, message, symbolName_1, source);
                 }
             }
             return target;
@@ -48635,6 +48652,8 @@ var ts;
                                     // type parameters are visible in parameter list, return type and type parameter list
                                     ? lastLocation === location.type ||
                                         lastLocation.kind === 163 /* Parameter */ ||
+                                        lastLocation.kind === 338 /* JSDocParameterTag */ ||
+                                        lastLocation.kind === 339 /* JSDocReturnTag */ ||
                                         lastLocation.kind === 162 /* TypeParameter */
                                     // local types not visible outside the function body
                                     : false;
@@ -48894,9 +48913,9 @@ var ts;
                     lastSelfReferenceLocation = location;
                 }
                 lastLocation = location;
-                location = ts.isJSDocTemplateTag(location) ?
-                    ts.getEffectiveContainerForJSDocTemplateTag(location) || location.parent :
-                    location.parent;
+                location = ts.isJSDocTemplateTag(location) ? ts.getEffectiveContainerForJSDocTemplateTag(location) || location.parent :
+                    ts.isJSDocParameterTag(location) || ts.isJSDocReturnTag(location) ? ts.getHostSignatureFromJSDoc(location) || location.parent :
+                        location.parent;
             }
             // We just climbed up parents looking for the name, meaning that we started in a descendant node of `lastLocation`.
             // If `result === lastSelfReferenceLocation.symbol`, that means that we are somewhere inside `lastSelfReferenceLocation` looking up a name, and resolving to `lastLocation` itself.
@@ -50030,16 +50049,20 @@ var ts;
                 return;
             }
             var host = ts.getJSDocHost(node);
-            if (host &&
-                ts.isExpressionStatement(host) &&
-                ts.isBinaryExpression(host.expression) &&
-                ts.getAssignmentDeclarationKind(host.expression) === 3 /* PrototypeProperty */) {
-                // X.prototype.m = /** @param {K} p */ function () { } <-- look for K on X's declaration
+            if (host && ts.isExpressionStatement(host) && ts.isPrototypePropertyAssignment(host.expression)) {
+                // /** @param {K} p */ X.prototype.m = function () { } <-- look for K on X's declaration
                 var symbol = getSymbolOfNode(host.expression.left);
                 if (symbol) {
                     return getDeclarationOfJSPrototypeContainer(symbol);
                 }
             }
+            if (host && ts.isFunctionExpression(host) && ts.isPrototypePropertyAssignment(host.parent) && ts.isExpressionStatement(host.parent.parent)) {
+                // X.prototype.m = /** @param {K} p */ function () { } <-- look for K on X's declaration
+                var symbol = getSymbolOfNode(host.parent.left);
+                if (symbol) {
+                    return getDeclarationOfJSPrototypeContainer(symbol);
+                }
+            }
             if (host && (ts.isObjectLiteralMethod(host) || ts.isPropertyAssignment(host)) &&
                 ts.isBinaryExpression(host.parent.parent) &&
                 ts.getAssignmentDeclarationKind(host.parent.parent) === 6 /* Prototype */) {
@@ -54526,9 +54549,12 @@ var ts;
         }
         // Return the type of a binding element parent. We check SymbolLinks first to see if a type has been
         // assigned by contextual typing.
-        function getTypeForBindingElementParent(node) {
+        function getTypeForBindingElementParent(node, checkMode) {
+            if (checkMode !== 0 /* Normal */) {
+                return getTypeForVariableLikeDeclaration(node, /*includeOptionality*/ false, checkMode);
+            }
             var symbol = getSymbolOfNode(node);
-            return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, /*includeOptionality*/ false);
+            return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, /*includeOptionality*/ false, checkMode);
         }
         function getRestType(source, properties, symbol) {
             source = filterType(source, function (t) { return !(t.flags & 98304 /* Nullable */); });
@@ -54646,7 +54672,8 @@ var ts;
         }
         /** Return the inferred type for a binding element */
         function getTypeForBindingElement(declaration) {
-            var parentType = getTypeForBindingElementParent(declaration.parent.parent);
+            var checkMode = declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
+            var parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
             return parentType && getBindingElementTypeFromParentType(declaration, parentType);
         }
         function getBindingElementTypeFromParentType(declaration, parentType) {
@@ -54718,9 +54745,9 @@ var ts;
             if (ts.getEffectiveTypeAnnotationNode(ts.walkUpBindingElementsAndPatterns(declaration))) {
                 // In strict null checking mode, if a default value of a non-undefined type is specified, remove
                 // undefined from the final type.
-                return strictNullChecks && !(getFalsyFlags(checkDeclarationInitializer(declaration)) & 32768 /* Undefined */) ? getNonUndefinedType(type) : type;
+                return strictNullChecks && !(getFalsyFlags(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 32768 /* Undefined */) ? getNonUndefinedType(type) : type;
             }
-            return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration)], 2 /* Subtype */));
+            return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration, 0 /* Normal */)], 2 /* Subtype */));
         }
         function getTypeForDeclarationFromJSDocComment(declaration) {
             var jsdocType = ts.getJSDocType(declaration);
@@ -54743,11 +54770,11 @@ var ts;
             return strictNullChecks && isOptional ? getOptionalType(type, isProperty) : type;
         }
         // Return the inferred type for a variable, parameter, or property declaration
-        function getTypeForVariableLikeDeclaration(declaration, includeOptionality) {
+        function getTypeForVariableLikeDeclaration(declaration, includeOptionality, checkMode) {
             // A variable declared in a for..in statement is of type string, or of type keyof T when the
             // right hand expression is of a type parameter type.
             if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 242 /* ForInStatement */) {
-                var indexType = getIndexType(getNonNullableTypeIfNeeded(checkExpression(declaration.parent.parent.expression)));
+                var indexType = getIndexType(getNonNullableTypeIfNeeded(checkExpression(declaration.parent.parent.expression, /*checkMode*/ checkMode)));
                 return indexType.flags & (262144 /* TypeParameter */ | 4194304 /* Index */) ? getExtractStringType(indexType) : stringType;
             }
             if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 243 /* ForOfStatement */) {
@@ -54824,7 +54851,7 @@ var ts;
                         return containerObjectType;
                     }
                 }
-                var type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration));
+                var type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration, checkMode));
                 return addOptionality(type, isProperty, isOptional);
             }
             if (ts.isPropertyDeclaration(declaration) && (noImplicitAny || ts.isInJSFile(declaration))) {
@@ -55196,7 +55223,7 @@ var ts;
                 // contextual type or, if the element itself is a binding pattern, with the type implied by that binding
                 // pattern.
                 var contextualType = ts.isBindingPattern(element.name) ? getTypeFromBindingPattern(element.name, /*includePatternInType*/ true, /*reportErrors*/ false) : unknownType;
-                return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, contextualType)));
+                return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, 0 /* Normal */, contextualType)));
             }
             if (ts.isBindingPattern(element.name)) {
                 return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors);
@@ -55285,7 +55312,7 @@ var ts;
         // binding pattern [x, s = ""]. Because the contextual type is a tuple type, the resulting type of [1, "one"] is the
         // tuple type [number, string]. Thus, the type inferred for 'x' is number and the type inferred for 's' is string.
         function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) {
-            return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ true), declaration, reportErrors);
+            return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ true, 0 /* Normal */), declaration, reportErrors);
         }
         function isGlobalSymbolConstructor(node) {
             var symbol = getSymbolOfNode(node);
@@ -55514,10 +55541,12 @@ var ts;
             if (writing === void 0) { writing = false; }
             var getter = ts.getDeclarationOfKind(symbol, 171 /* GetAccessor */);
             var setter = ts.getDeclarationOfKind(symbol, 172 /* SetAccessor */);
-            var setterType = getAnnotatedAccessorType(setter);
             // For write operations, prioritize type annotations on the setter
-            if (writing && setterType) {
-                return instantiateTypeIfNeeded(setterType, symbol);
+            if (writing) {
+                var setterType_1 = getAnnotatedAccessorType(setter);
+                if (setterType_1) {
+                    return instantiateTypeIfNeeded(setterType_1, symbol);
+                }
             }
             // Else defer to the getter type
             if (getter && ts.isInJSFile(getter)) {
@@ -55532,6 +55561,7 @@ var ts;
                 return instantiateTypeIfNeeded(getterType, symbol);
             }
             // If the user didn't specify a return type, try to use the set-accessor's parameter type.
+            var setterType = getAnnotatedAccessorType(setter);
             if (setterType) {
                 return setterType;
             }
@@ -55680,6 +55710,39 @@ var ts;
             }
             return links.type;
         }
+        function getWriteTypeOfSymbolWithDeferredType(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.writeType && links.deferralWriteConstituents) {
+                ts.Debug.assertIsDefined(links.deferralParent);
+                ts.Debug.assertIsDefined(links.deferralConstituents);
+                links.writeType = links.deferralParent.flags & 1048576 /* Union */ ? getUnionType(links.deferralWriteConstituents) : getIntersectionType(links.deferralWriteConstituents);
+            }
+            return links.writeType;
+        }
+        /**
+         * Distinct write types come only from set accessors, but union and intersection
+         * properties deriving from set accessors will either pre-compute or defer the
+         * union or intersection of the writeTypes of their constituents. To account for
+         * this, we will assume that any deferred type or transient symbol may have a
+         * `writeType` (or a deferred write type ready to be computed) that should be
+         * used before looking for set accessor declarations.
+         */
+        function getWriteTypeOfSymbol(symbol) {
+            var checkFlags = ts.getCheckFlags(symbol);
+            if (checkFlags & 65536 /* DeferredType */) {
+                var writeType = getWriteTypeOfSymbolWithDeferredType(symbol);
+                if (writeType) {
+                    return writeType;
+                }
+            }
+            if (symbol.flags & 33554432 /* Transient */) {
+                var writeType = symbol.writeType;
+                if (writeType) {
+                    return writeType;
+                }
+            }
+            return getSetAccessorTypeOfSymbol(symbol);
+        }
         function getSetAccessorTypeOfSymbol(symbol) {
             if (symbol.flags & 98304 /* Accessor */) {
                 var type = getTypeOfSetAccessor(symbol);
@@ -58050,6 +58113,7 @@ var ts;
             var firstType;
             var nameType;
             var propTypes = [];
+            var writeTypes;
             var firstValueDeclaration;
             var hasNonUniformValueDeclaration = false;
             for (var _d = 0, props_1 = props; _d < props_1.length; _d++) {
@@ -58066,6 +58130,10 @@ var ts;
                     firstType = type;
                     nameType = getSymbolLinks(prop).nameType;
                 }
+                var writeType = getWriteTypeOfSymbol(prop);
+                if (writeTypes || writeType !== type) {
+                    writeTypes = ts.append(!writeTypes ? propTypes.slice() : writeTypes, writeType);
+                }
                 else if (type !== firstType) {
                     checkFlags |= 64 /* HasNonUniformType */;
                 }
@@ -58094,9 +58162,13 @@ var ts;
                 result.checkFlags |= 65536 /* DeferredType */;
                 result.deferralParent = containingType;
                 result.deferralConstituents = propTypes;
+                result.deferralWriteConstituents = writeTypes;
             }
             else {
                 result.type = isUnion ? getUnionType(propTypes) : getIntersectionType(propTypes);
+                if (writeTypes) {
+                    result.writeType = isUnion ? getUnionType(writeTypes) : getIntersectionType(writeTypes);
+                }
             }
             return result;
         }
@@ -59238,7 +59310,7 @@ var ts;
         }
         function getImpliedConstraint(type, checkNode, extendsNode) {
             return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(type, checkNode.elements[0], extendsNode.elements[0]) :
-                getActualTypeVariable(getTypeFromTypeNode(checkNode)) === type ? getTypeFromTypeNode(extendsNode) :
+                getActualTypeVariable(getTypeFromTypeNode(checkNode)) === getActualTypeVariable(type) ? getTypeFromTypeNode(extendsNode) :
                     undefined;
         }
         function getConditionalFlowTypeOfType(type, node) {
@@ -70047,12 +70119,16 @@ var ts;
         function isGenericTypeWithoutNullableConstraint(type) {
             return !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
         }
-        function hasNonBindingPatternContextualTypeWithNoGenericTypes(node) {
+        function hasContextualTypeWithNoGenericTypes(node, checkMode) {
             // Computing the contextual type for a child of a JSX element involves resolving the type of the
             // element's tag name, so we exclude that here to avoid circularities.
+            // If check mode has `CheckMode.RestBindingElement`, we skip binding pattern contextual types,
+            // as we want the type of a rest element to be generic when possible.
             var contextualType = (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
                 !((ts.isJsxOpeningElement(node.parent) || ts.isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) &&
-                getContextualType(node, 8 /* SkipBindingPatterns */);
+                (checkMode && checkMode & 32 /* RestBindingElement */ ?
+                    getContextualType(node, 8 /* SkipBindingPatterns */)
+                    : getContextualType(node));
             return contextualType && !isGenericType(contextualType);
         }
         function getNarrowableTypeForReference(type, reference, checkMode) {
@@ -70065,7 +70141,7 @@ var ts;
             // 'string | undefined' to give control flow analysis the opportunity to narrow to type 'string'.
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
-                (isConstraintPosition(type, reference) || hasNonBindingPatternContextualTypeWithNoGenericTypes(reference));
+                (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
             return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ && !isMappedTypeGenericIndexedAccess(t) ? getBaseConstraintOrType(t) : t; }) : type;
         }
         function isExportOrExportExpression(location) {
@@ -70133,7 +70209,7 @@ var ts;
                         var links = getNodeLinks(location);
                         if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
                             links.flags |= 268435456 /* InCheckIdentifier */;
-                            var parentType = getTypeForBindingElementParent(parent);
+                            var parentType = getTypeForBindingElementParent(parent, 0 /* Normal */);
                             links.flags &= ~268435456 /* InCheckIdentifier */;
                             if (parentType && parentType.flags & 1048576 /* Union */ && !(parent.kind === 163 /* Parameter */ && isSymbolAssigned(symbol))) {
                                 var pattern = declaration.parent;
@@ -70986,7 +71062,7 @@ var ts;
             var parent = declaration.parent.parent;
             var name = declaration.propertyName || declaration.name;
             var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
-                parent.kind !== 202 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent);
+                parent.kind !== 202 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */);
             if (!parentType || ts.isBindingPattern(name) || ts.isComputedNonLiteralName(name))
                 return undefined;
             if (parent.name.kind === 201 /* ArrayBindingPattern */) {
@@ -73227,7 +73303,7 @@ var ts;
                     error(right, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, ts.idText(right));
                     return errorType;
                 }
-                propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writing ? getSetAccessorTypeOfSymbol(prop) : getTypeOfSymbol(prop);
+                propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writing ? getWriteTypeOfSymbol(prop) : getTypeOfSymbol(prop);
             }
             return getFlowTypeOfAccessExpression(node, prop, propType, right, checkMode);
         }
@@ -76152,7 +76228,7 @@ var ts;
             var links = getSymbolLinks(parameter);
             if (!links.type) {
                 var declaration = parameter.valueDeclaration;
-                links.type = type || getWidenedTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ true);
+                links.type = type || getWidenedTypeForVariableLikeDeclaration(declaration, /*reportErrors*/ true);
                 if (declaration.name.kind !== 79 /* Identifier */) {
                     // if inference didn't come up with anything but unknown, fall back to the binding pattern if present.
                     if (links.type === unknownType) {
@@ -77883,11 +77959,11 @@ var ts;
             }
         }
         function checkExpressionCached(node, checkMode) {
+            if (checkMode && checkMode !== 0 /* Normal */) {
+                return checkExpression(node, checkMode);
+            }
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
-                if (checkMode && checkMode !== 0 /* Normal */) {
-                    return checkExpression(node, checkMode);
-                }
                 // When computing a type that we're going to cache, we need to ignore any ongoing control flow
                 // analysis because variables may have transient types in indeterminable states. Moving flowLoopStart
                 // to the top of the stack ensures all transient types are computed from a known point.
@@ -77907,10 +77983,12 @@ var ts;
                 node.kind === 228 /* AsExpression */ ||
                 ts.isJSDocTypeAssertion(node);
         }
-        function checkDeclarationInitializer(declaration, contextualType) {
+        function checkDeclarationInitializer(declaration, checkMode, contextualType) {
             var initializer = ts.getEffectiveInitializer(declaration);
             var type = getQuickTypeOfExpression(initializer) ||
-                (contextualType ? checkExpressionWithContextualType(initializer, contextualType, /*inferenceContext*/ undefined, 0 /* Normal */) : checkExpressionCached(initializer));
+                (contextualType ?
+                    checkExpressionWithContextualType(initializer, contextualType, /*inferenceContext*/ undefined, checkMode || 0 /* Normal */)
+                    : checkExpressionCached(initializer, checkMode));
             return ts.isParameter(declaration) && declaration.name.kind === 201 /* ArrayBindingPattern */ &&
                 isTupleType(type) && !type.target.hasRestElement && getTypeReferenceArity(type) < declaration.name.elements.length ?
                 padTupleType(type, declaration.name) : type;
@@ -80847,7 +80925,8 @@ var ts;
                 }
                 // check private/protected variable access
                 var parent = node.parent.parent;
-                var parentType = getTypeForBindingElementParent(parent);
+                var parentCheckMode = node.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
+                var parentType = getTypeForBindingElementParent(parent, parentCheckMode);
                 var name = node.propertyName || node.name;
                 if (parentType && !ts.isBindingPattern(name)) {
                     var exprType = getLiteralTypeFromPropertyName(name);
@@ -82086,7 +82165,7 @@ var ts;
                     var declaration = catchClause.variableDeclaration;
                     var typeNode = ts.getEffectiveTypeAnnotationNode(ts.getRootDeclaration(declaration));
                     if (typeNode) {
-                        var type = getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ false);
+                        var type = getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ false, 0 /* Normal */);
                         if (type && !(type.flags & 3 /* AnyOrUnknown */)) {
                             grammarErrorOnFirstToken(typeNode, ts.Diagnostics.Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified);
                         }
@@ -83192,7 +83271,7 @@ var ts;
                 var isAmbientExternalModule = ts.isAmbientModule(node);
                 var contextErrorMessage = isAmbientExternalModule
                     ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file
-                    : ts.Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module;
+                    : ts.Diagnostics.A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module;
                 if (checkGrammarModuleElementContext(node, contextErrorMessage)) {
                     // If we hit a module declaration in an illegal context, just bail out to avoid cascading errors.
                     return;
@@ -83508,7 +83587,7 @@ var ts;
             }
         }
         function checkImportDeclaration(node) {
-            if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
+            if (checkGrammarModuleElementContext(node, ts.isInJSFile(node) ? ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
                 // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
@@ -83541,7 +83620,7 @@ var ts;
             checkAssertClause(node);
         }
         function checkImportEqualsDeclaration(node) {
-            if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
+            if (checkGrammarModuleElementContext(node, ts.isInJSFile(node) ? ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
                 // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
@@ -83578,7 +83657,7 @@ var ts;
             }
         }
         function checkExportDeclaration(node) {
-            if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) {
+            if (checkGrammarModuleElementContext(node, ts.isInJSFile(node) ? ts.Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module : ts.Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
                 // If we hit an export in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
@@ -84812,7 +84891,7 @@ var ts;
                 return errorType;
             }
             if (ts.isBindingPattern(node)) {
-                return getTypeForVariableLikeDeclaration(node.parent, /*includeOptionality*/ true) || errorType;
+                return getTypeForVariableLikeDeclaration(node.parent, /*includeOptionality*/ true, 0 /* Normal */) || errorType;
             }
             if (isInRightSideOfImportOrExportAssignment(node)) {
                 var symbol = getSymbolAtLocation(node);
@@ -114559,9 +114638,9 @@ var ts;
         ts.Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block.code,
         ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter.code,
         ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter.code,
-        ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module.code,
+        ts.Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module.code,
         ts.Diagnostics.An_export_declaration_cannot_have_modifiers.code,
-        ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module.code,
+        ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module.code,
         ts.Diagnostics.An_import_declaration_cannot_have_modifiers.code,
         ts.Diagnostics.An_object_member_cannot_be_declared_optional.code,
         ts.Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element.code,
@@ -115629,7 +115708,7 @@ var ts;
                 ts.Debug.assert(!!sourceFile.bindDiagnostics);
                 var isJs = sourceFile.scriptKind === 1 /* JS */ || sourceFile.scriptKind === 2 /* JSX */;
                 var isCheckJs = isJs && ts.isCheckJsEnabledForFile(sourceFile, options);
-                var isPlainJs = isJs && !sourceFile.checkJsDirective && options.checkJs === undefined;
+                var isPlainJs = ts.isPlainJsFile(sourceFile, options.checkJs);
                 var isTsNoCheck = !!sourceFile.checkJsDirective && sourceFile.checkJsDirective.enabled === false;
                 // 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
@@ -130939,7 +131018,8 @@ var ts;
                 case 103 /* NewKeyword */:
                     return checker.getContextualType(parent);
                 case 82 /* CaseKeyword */:
-                    return ts.getSwitchedType(ts.cast(parent, ts.isCaseClause), checker);
+                    var caseClause = ts.tryCast(parent, ts.isCaseClause);
+                    return caseClause ? ts.getSwitchedType(caseClause, checker) : undefined;
                 case 18 /* OpenBraceToken */:
                     return ts.isJsxExpression(parent) && !ts.isJsxElement(parent.parent) && !ts.isJsxFragment(parent.parent) ? checker.getContextualTypeForJsxAttribute(parent.parent) : undefined;
                 default:
@@ -133584,7 +133664,24 @@ var ts;
         function acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, acquiring, scriptKind) {
             scriptKind = ts.ensureScriptKind(fileName, scriptKind);
             var scriptTarget = scriptKind === 6 /* JSON */ ? 100 /* JSON */ : ts.getEmitScriptTarget(compilationSettings);
+            var oldBucketCount = buckets.size;
             var bucket = ts.getOrUpdate(buckets, key, function () { return new ts.Map(); });
+            if (ts.tracing) {
+                if (buckets.size > oldBucketCount) {
+                    // It is interesting, but not definitively problematic if a build requires multiple document registry buckets -
+                    // perhaps they are for two projects that don't have any overlap.
+                    // Bonus: these events can help us interpret the more interesting event below.
+                    ts.tracing.instant("session" /* Session */, "createdDocumentRegistryBucket", { configFilePath: compilationSettings.configFilePath, key: key });
+                }
+                // It is fairly suspicious to have one path in two buckets - you'd expect dependencies to have similar configurations.
+                // If this occurs unexpectedly, the fix is likely to synchronize the project settings.
+                // Skip .d.ts files to reduce noise (should also cover most of node_modules).
+                var otherBucketKey = !ts.fileExtensionIs(path, ".d.ts" /* Dts */) &&
+                    ts.forEachEntry(buckets, function (bucket, bucketKey) { return bucketKey !== key && bucket.has(path) && bucketKey; });
+                if (otherBucketKey) {
+                    ts.tracing.instant("session" /* Session */, "documentRegistryBucketOverlap", { path: path, key1: otherBucketKey, key2: key });
+                }
+            }
             var bucketEntry = bucket.get(path);
             var entry = bucketEntry && getDocumentRegistryEntry(bucketEntry, scriptKind);
             if (!entry && externalCache) {
@@ -145720,6 +145817,8 @@ var ts;
                     case 179 /* ConstructorType */:
                     case 174 /* ConstructSignature */:
                         return getList(node.typeParameters) || getList(node.parameters);
+                    case 171 /* GetAccessor */:
+                        return getList(node.parameters);
                     case 256 /* ClassDeclaration */:
                     case 225 /* ClassExpression */:
                     case 257 /* InterfaceDeclaration */:
@@ -153156,6 +153255,9 @@ var ts;
                 case 172 /* SetAccessor */:
                     // Setter must have a parameter
                     return false;
+                case 171 /* GetAccessor */:
+                    // Getter cannot have parameters
+                    return true;
                 default:
                     return ts.Debug.failBadSyntaxKind(parent);
             }
@@ -155766,10 +155868,12 @@ var ts;
         });
         function getInfo(sourceFile, pos) {
             var token = ts.getTokenAtPosition(sourceFile, pos);
-            var indexSignature = ts.cast(token.parent.parent, ts.isIndexSignatureDeclaration);
-            if (ts.isClassDeclaration(indexSignature.parent))
+            var indexSignature = ts.tryCast(token.parent.parent, ts.isIndexSignatureDeclaration);
+            if (!indexSignature)
+                return undefined;
+            var container = ts.isInterfaceDeclaration(indexSignature.parent) ? indexSignature.parent : ts.tryCast(indexSignature.parent.parent, ts.isTypeAliasDeclaration);
+            if (!container)
                 return undefined;
-            var container = ts.isInterfaceDeclaration(indexSignature.parent) ? indexSignature.parent : ts.cast(indexSignature.parent.parent, ts.isTypeAliasDeclaration);
             return { indexSignature: indexSignature, container: container };
         }
         function createTypeAliasFromInterface(declaration, type) {
@@ -157360,8 +157464,8 @@ var ts;
                                 // but a super *method call* simply implies a 'this' reference
                                 if (node.parent.kind === 207 /* CallExpression */) {
                                     // Super constructor call
-                                    var containingClass_1 = ts.getContainingClass(node); // TODO:GH#18217
-                                    if (containingClass_1.pos < span.start || containingClass_1.end >= (span.start + span.length)) {
+                                    var containingClass_1 = ts.getContainingClass(node);
+                                    if (containingClass_1 === undefined || containingClass_1.pos < span.start || containingClass_1.end >= (span.start + span.length)) {
                                         (errors || (errors = [])).push(ts.createDiagnosticForNode(node, Messages.cannotExtractSuper));
                                         return true;
                                     }