Update LKG.

Author: DanielRosenwasser

lib/lib.es5.d.ts

@@ -318,7 +318,7 @@ declare var Function: FunctionConstructor;
 /**
  * Extracts the type of the 'this' parameter of a function type, or 'unknown' if the function type has no 'this' parameter.
  */
-type ThisParameterType<T> = T extends (this: unknown, ...args: any[]) => any ? unknown : T extends (this: infer U, ...args: any[]) => any ? U : unknown;
+type ThisParameterType<T> = T extends (this: infer U, ...args: any[]) => any ? U : unknown;
 
 /**
  * Removes the 'this' parameter from a function type.

lib/tsc.js

@@ -4351,7 +4351,7 @@ var ts;
         Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(1368, ts.DiagnosticCategory.Message, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_1368", "Specify emit/checking behavior for imports that are only used for types"),
         Did_you_mean_0: diag(1369, ts.DiagnosticCategory.Message, "Did_you_mean_0_1369", "Did you mean '{0}'?"),
         Only_ECMAScript_imports_may_use_import_type: diag(1370, ts.DiagnosticCategory.Error, "Only_ECMAScript_imports_may_use_import_type_1370", "Only ECMAScript imports may use 'import type'."),
-        This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValue_is_set_to_error: diag(1371, ts.DiagnosticCategory.Error, "This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValue_is_s_1371", "This import is never used as a value and must use 'import type' because the 'importsNotUsedAsValue' is set to 'error'."),
+        This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error: diag(1371, ts.DiagnosticCategory.Error, "This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is__1371", "This import is never used as a value and must use 'import type' because the 'importsNotUsedAsValues' is set to 'error'."),
         This_import_may_be_converted_to_a_type_only_import: diag(1372, ts.DiagnosticCategory.Suggestion, "This_import_may_be_converted_to_a_type_only_import_1372", "This import may be converted to a type-only import."),
         Convert_to_type_only_import: diag(1373, ts.DiagnosticCategory.Message, "Convert_to_type_only_import_1373", "Convert to type-only import"),
         Convert_all_imports_not_used_as_a_value_to_type_only_imports: diag(1374, ts.DiagnosticCategory.Message, "Convert_all_imports_not_used_as_a_value_to_type_only_imports_1374", "Convert all imports not used as a value to type-only imports"),
@@ -21052,7 +21052,7 @@ var ts;
             description: ts.Diagnostics.Import_emit_helpers_from_tslib
         },
         {
-            name: "importsNotUsedAsValue",
+            name: "importsNotUsedAsValues",
             type: ts.createMapFromTemplate({
                 remove: 0,
                 preserve: 1,
@@ -32887,7 +32887,7 @@ var ts;
                     getTypeWithFacts(type, 524288) :
                     type;
             }
-            return getUnionType([getTypeWithFacts(type, 524288), checkDeclarationInitializer(declaration)], 2);
+            return widenTypeInferredFromInitializer(declaration, getUnionType([getTypeWithFacts(type, 524288), checkDeclarationInitializer(declaration)], 2));
         }
         function getTypeForDeclarationFromJSDocComment(declaration) {
             var jsdocType = ts.getJSDocType(declaration);
@@ -32973,7 +32973,7 @@ var ts;
                 }
             }
             if (declaration.initializer && !isParameterOfContextuallyTypedFunction(declaration)) {
-                var type = checkDeclarationInitializer(declaration);
+                var type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration));
                 return addOptionality(type, isOptional);
             }
             if (ts.isJsxAttribute(declaration)) {
@@ -33173,7 +33173,8 @@ var ts;
         }
         function getTypeFromBindingElement(element, includePatternInType, reportErrors) {
             if (element.initializer) {
-                return addOptionality(checkDeclarationInitializer(element));
+                var contextualType = ts.isBindingPattern(element.name) ? getTypeFromBindingPattern(element.name, true, false) : unknownType;
+                return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, contextualType)));
             }
             if (ts.isBindingPattern(element.name)) {
                 return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors);
@@ -44423,9 +44424,10 @@ var ts;
             }
         }
         function getContextualTypeForBindingElement(declaration) {
-            var parentDeclaration = declaration.parent.parent;
+            var parent = declaration.parent.parent;
             var name = declaration.propertyName || declaration.name;
-            var parentType = getContextualTypeForVariableLikeDeclaration(parentDeclaration);
+            var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
+                parent.kind !== 191 && parent.initializer && checkDeclarationInitializer(parent);
             if (parentType && !ts.isBindingPattern(name) && !isComputedNonLiteralName(name)) {
                 var nameType = getLiteralTypeFromPropertyName(name);
                 if (isTypeUsableAsPropertyName(nameType)) {
@@ -49397,27 +49399,13 @@ var ts;
             node = ts.skipParentheses(node);
             return node.kind === 199 || node.kind === 217;
         }
-        function checkDeclarationInitializer(declaration) {
+        function checkDeclarationInitializer(declaration, contextualType) {
             var initializer = ts.getEffectiveInitializer(declaration);
-            var type = getQuickTypeOfExpression(initializer) || checkExpressionCached(initializer);
-            var padded = ts.isParameter(declaration) && declaration.name.kind === 190 &&
+            var type = getQuickTypeOfExpression(initializer) ||
+                (contextualType ? checkExpressionWithContextualType(initializer, contextualType, undefined, 0) : checkExpressionCached(initializer));
+            return ts.isParameter(declaration) && declaration.name.kind === 190 &&
                 isTupleType(type) && !type.target.hasRestElement && getTypeReferenceArity(type) < declaration.name.elements.length ?
                 padTupleType(type, declaration.name) : type;
-            var widened = ts.getCombinedNodeFlags(declaration) & 2 ||
-                ts.isDeclarationReadonly(declaration) ||
-                isTypeAssertion(initializer) ||
-                isLiteralOfContextualType(padded, getContextualType(initializer)) ? padded : getWidenedLiteralType(padded);
-            if (ts.isInJSFile(declaration)) {
-                if (widened.flags & 98304) {
-                    reportImplicitAny(declaration, anyType);
-                    return anyType;
-                }
-                else if (isEmptyArrayLiteralType(widened)) {
-                    reportImplicitAny(declaration, anyArrayType);
-                    return anyArrayType;
-                }
-            }
-            return widened;
         }
         function padTupleType(type, pattern) {
             var patternElements = pattern.elements;
@@ -49434,6 +49422,20 @@ var ts;
             }
             return createTupleType(elementTypes, type.target.minLength, false, type.target.readonly);
         }
+        function widenTypeInferredFromInitializer(declaration, type) {
+            var widened = ts.getCombinedNodeFlags(declaration) & 2 || ts.isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type);
+            if (ts.isInJSFile(declaration)) {
+                if (widened.flags & 98304) {
+                    reportImplicitAny(declaration, anyType);
+                    return anyType;
+                }
+                else if (isEmptyArrayLiteralType(widened)) {
+                    reportImplicitAny(declaration, anyArrayType);
+                    return anyArrayType;
+                }
+            }
+            return widened;
+        }
         function isLiteralOfContextualType(candidateType, contextualType) {
             if (contextualType) {
                 if (contextualType.flags & 3145728) {
@@ -53524,9 +53526,9 @@ var ts;
                     !statement.importClause.isTypeOnly &&
                     importClauseContainsReferencedImport(statement.importClause) &&
                     !isReferencedAliasDeclaration(statement.importClause, true)) {
-                    var isError = compilerOptions.importsNotUsedAsValue === 2;
+                    var isError = compilerOptions.importsNotUsedAsValues === 2;
                     errorOrSuggestion(isError, statement, isError
-                        ? ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValue_is_set_to_error
+                        ? ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error
                         : ts.Diagnostics.This_import_may_be_converted_to_a_type_only_import);
                 }
             }
@@ -64410,8 +64412,8 @@ var ts;
             }
             var importClause = ts.visitNode(node.importClause, visitImportClause, ts.isImportClause);
             return importClause ||
-                compilerOptions.importsNotUsedAsValue === 1 ||
-                compilerOptions.importsNotUsedAsValue === 2
+                compilerOptions.importsNotUsedAsValues === 1 ||
+                compilerOptions.importsNotUsedAsValues === 2
                 ? ts.updateImportDeclaration(node, undefined, undefined, importClause, node.moduleSpecifier)
                 : undefined;
         }
@@ -64476,7 +64478,7 @@ var ts;
         function visitImportEqualsDeclaration(node) {
             if (ts.isExternalModuleImportEqualsDeclaration(node)) {
                 var isReferenced = resolver.isReferencedAliasDeclaration(node);
-                if (!isReferenced && compilerOptions.importsNotUsedAsValue === 1) {
+                if (!isReferenced && compilerOptions.importsNotUsedAsValues === 1) {
                     return ts.setOriginalNode(ts.setTextRange(ts.createImportDeclaration(undefined, undefined, undefined, node.moduleReference.expression), node), node);
                 }
                 return isReferenced ? ts.visitEachChild(node, visitor, context) : undefined;