typescript 4.6.0-dev.20220209 → 4.6.0-dev.20220210

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.20220209";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220210";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8045,10 +8045,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."),
@@ -8216,6 +8216,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),
@@ -14136,6 +14138,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 */:
@@ -46913,6 +46919,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) {
@@ -47965,13 +47974,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) {
@@ -47983,12 +47992,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;
@@ -48445,6 +48458,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;
@@ -48704,9 +48719,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.
@@ -49840,16 +49855,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 */) {
@@ -54336,9 +54355,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 */); });
@@ -54456,7 +54478,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) {
@@ -54528,9 +54551,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);
@@ -54553,11 +54576,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 */) {
@@ -54634,7 +54657,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))) {
@@ -55006,7 +55029,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);
@@ -55095,7 +55118,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);
@@ -55324,10 +55347,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)) {
@@ -55342,6 +55367,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;
             }
@@ -69899,12 +69925,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) {
@@ -69917,7 +69947,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) {
@@ -69985,7 +70015,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;
@@ -70838,7 +70868,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 */) {
@@ -76004,7 +76034,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) {
@@ -77735,11 +77765,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.
@@ -77759,10 +77789,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;
@@ -80699,7 +80731,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);
@@ -81938,7 +81971,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);
                         }
@@ -83044,7 +83077,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;
@@ -83360,7 +83393,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;
             }
@@ -83393,7 +83426,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;
             }
@@ -83430,7 +83463,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;
             }
@@ -84664,7 +84697,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);
@@ -114411,9 +114444,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,
@@ -115481,7 +115514,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