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

package/lib/typingsInstaller.js

@@ -89,7 +89,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) {
@@ -8034,10 +8034,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."),
@@ -8205,6 +8205,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),
@@ -13886,6 +13888,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) {
@@ -14121,6 +14127,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 */:
@@ -46898,6 +46908,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) {
@@ -47950,13 +47963,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) {
@@ -47968,12 +47981,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;
@@ -48430,6 +48447,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;
@@ -48689,9 +48708,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.
@@ -49825,16 +49844,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 */) {
@@ -54321,9 +54344,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 */); });
@@ -54441,7 +54467,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) {
@@ -54513,9 +54540,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);
@@ -54538,11 +54565,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 */) {
@@ -54619,7 +54646,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))) {
@@ -54991,7 +55018,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);
@@ -55080,7 +55107,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);
@@ -55309,10 +55336,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)) {
@@ -55327,6 +55356,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;
             }
@@ -55475,6 +55505,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);
@@ -57845,6 +57908,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++) {
@@ -57861,6 +57925,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 */;
                 }
@@ -57889,9 +57957,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;
         }
@@ -59033,7 +59105,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) {
@@ -69842,12 +69914,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) {
@@ -69860,7 +69936,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) {
@@ -69928,7 +70004,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;
@@ -70781,7 +70857,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 */) {
@@ -73022,7 +73098,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);
         }
@@ -75947,7 +76023,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) {
@@ -77678,11 +77754,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.
@@ -77702,10 +77778,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;
@@ -80642,7 +80720,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);
@@ -81881,7 +81960,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);
                         }
@@ -82987,7 +83066,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;
@@ -83303,7 +83382,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;
             }
@@ -83336,7 +83415,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;
             }
@@ -83373,7 +83452,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;
             }
@@ -84607,7 +84686,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);
@@ -114354,9 +114433,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,
@@ -115424,7 +115503,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

package/lib/zh-cn/diagnosticMessages.generated.json

@@ -435,6 +435,7 @@
   "Convert_function_to_an_ES2015_class_95001": "将函数转换为 ES2015 类",
   "Convert_invalid_character_to_its_html_entity_code_95100": "将无效字符转换为其 HTML 实体代码",
   "Convert_named_export_to_default_export_95062": "将命名导出转换为默认导出",
+  "Convert_named_imports_to_default_import_95170": "将命名导入转换为默认导入",
   "Convert_named_imports_to_namespace_import_95057": "将命名导入转换为命名空间导入",
   "Convert_namespace_import_to_named_imports_95056": "将命名空间导入转换为命名导入",
   "Convert_overload_list_to_single_signature_95118": "将重载列表转换为单一签名",
@@ -1116,7 +1117,6 @@
   "Property_0_is_protected_in_type_1_but_public_in_type_2_2444": "属性“{0}”在类型“{1}”中受保护，但在类型“{2}”中为公共属性。",
   "Property_0_is_used_before_being_assigned_2565": "在赋值前使用了属性“{0}”。",
   "Property_0_is_used_before_its_initialization_2729": "属性 \"{0}\" 在其初始化前已被使用。",
-  "Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnex_2810": "当 “target” 为 “esnext” 且 “useDefineForClassFields” 为 ”false” 时，属性“{0}”不能用在同一类静态属性的初始化表达式中。",
   "Property_0_may_not_exist_on_type_1_Did_you_mean_2_2568": "类型“{1}”上不存在属性“{0}”。你是否是指“{2}”?",
   "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606": "JSX 展开特性的“{0}”属性不能分配给目标属性。",
   "Property_0_of_exported_class_expression_may_not_be_private_or_protected_4094": "导出类表达式的属性“{0}”可能不是私密或受保护的属性。",
@@ -1324,7 +1324,6 @@
   "Starting_compilation_in_watch_mode_6031": "在监视模式下开始编译...",
   "Statement_expected_1129": "应为语句。",
   "Statements_are_not_allowed_in_ambient_contexts_1036": "不允许在环境上下文中使用语句。",
-  "Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_no_2805": "若未使用 \"esnext\" 的 \"--target\" 指定 \"--useDefineForClassFields\" 标志，则具有专用名称的静态字段不能有初始值设定项。请考虑添加 \"--useDefineForClassFields\" 标志。",
   "Static_members_cannot_reference_class_type_parameters_2302": "静态成员不能引用类类型参数。",
   "Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1_2699": "静态属性“{0}”与构造函数“{1}”的内置属性函数“{0}”冲突。",
   "String_literal_expected_1141": "应为字符串文本。",

package/lib/zh-tw/diagnosticMessages.generated.json

@@ -435,6 +435,7 @@
   "Convert_function_to_an_ES2015_class_95001": "將函式轉換為 ES2015 類別",
   "Convert_invalid_character_to_its_html_entity_code_95100": "將無效字元轉換為其 HTML 實體代碼",
   "Convert_named_export_to_default_export_95062": "將具名匯出轉換為預設匯出",
+  "Convert_named_imports_to_default_import_95170": "將具名匯入轉換為預設匯入",
   "Convert_named_imports_to_namespace_import_95057": "將具名匯入轉換為命名空間匯入",
   "Convert_namespace_import_to_named_imports_95056": "將命名空間匯入轉換為具名匯入",
   "Convert_overload_list_to_single_signature_95118": "將多載清單轉換成單一特徵標記",
@@ -1116,7 +1117,6 @@
   "Property_0_is_protected_in_type_1_but_public_in_type_2_2444": "在類型 '{1}' 中，'{0}' 是受保護屬性，但在類型 '{2}' 中是公用屬性。",
   "Property_0_is_used_before_being_assigned_2565": "屬性 '{0}' 已在指派之前使用。",
   "Property_0_is_used_before_its_initialization_2729": "將屬性 '{0}' 初始化前已使用該屬性。",
-  "Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnex_2810": "當 'target' 為 'esnext' 且 'useDefineForClassFields' 為 'false' 時，不能在同一個類別的靜態屬性初始設定式中使用屬性 '{0}'。",
   "Property_0_may_not_exist_on_type_1_Did_you_mean_2_2568": "類型 '{1}' 可能不存在屬性 '{0}'。您指的是 '{2}' 嗎?",
   "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606": "JSX 擴張屬性 (Attribute) 的屬性 (Property) '{0}' 不可指派給目標屬性 (Property)。",
   "Property_0_of_exported_class_expression_may_not_be_private_or_protected_4094": "匯出之類別運算式的屬性 '{0}' 可能為私人或受保護。",
@@ -1324,7 +1324,6 @@
   "Starting_compilation_in_watch_mode_6031": "在監看模式中開始編譯...",
   "Statement_expected_1129": "必須是陳述式。",
   "Statements_are_not_allowed_in_ambient_contexts_1036": "環境內容中不得有陳述式。",
-  "Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_no_2805": "當 '--useDefineForClassFields' 旗標未以 'esnext' 的 '--target' 指定時，具有私人名稱的靜態欄位不得有初始設定式。請考慮新增 '--useDefineForClassFields' 旗標。",
   "Static_members_cannot_reference_class_type_parameters_2302": "靜態成員不得參考類別類型參數。",
   "Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1_2699": "靜態屬性 '{0}' 與建構函式 '{1}' 的內建屬性 'Function.{0}' 相衝突。",
   "String_literal_expected_1141": "必須是字串常值。",

package/package.json

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