Merge remote-tracking branch 'origin/master' into release-3.8

Author: DanielRosenwasser

src/compiler/checker.ts

@@ -6981,7 +6981,7 @@ namespace ts {
                     getTypeWithFacts(type, TypeFacts.NEUndefined) :
                     type;
             }
-            return getUnionType([getTypeWithFacts(type, TypeFacts.NEUndefined), checkDeclarationInitializer(declaration)], UnionReduction.Subtype);
+            return widenTypeInferredFromInitializer(declaration, getUnionType([getTypeWithFacts(type, TypeFacts.NEUndefined), checkDeclarationInitializer(declaration)], UnionReduction.Subtype));
         }
 
         function getTypeForDeclarationFromJSDocComment(declaration: Node) {
@@ -7098,7 +7098,7 @@ namespace ts {
             // Use the type of the initializer expression if one is present and the declaration is
             // not a parameter of a contextually typed function
             if (declaration.initializer && !isParameterOfContextuallyTypedFunction(declaration)) {
-                const type = checkDeclarationInitializer(declaration);
+                const type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration));
                 return addOptionality(type, isOptional);
             }
 
@@ -7330,7 +7330,11 @@ namespace ts {
         // pattern. Otherwise, it is the type any.
         function getTypeFromBindingElement(element: BindingElement, includePatternInType?: boolean, reportErrors?: boolean): Type {
             if (element.initializer) {
-                return addOptionality(checkDeclarationInitializer(element));
+                // The type implied by a binding pattern is independent of context, so we check the initializer with no
+                // contextual type or, if the element itself is a binding pattern, with the type implied by that binding
+                // pattern.
+                const contextualType = isBindingPattern(element.name) ? getTypeFromBindingPattern(element.name, /*includePatternInType*/ true, /*reportErrors*/ false) : unknownType;
+                return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, contextualType)));
             }
             if (isBindingPattern(element.name)) {
                 return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors);
@@ -21195,9 +21199,10 @@ namespace ts {
         }
 
         function getContextualTypeForBindingElement(declaration: BindingElement): Type | undefined {
-            const parentDeclaration = declaration.parent.parent;
+            const parent = declaration.parent.parent;
             const name = declaration.propertyName || declaration.name;
-            const parentType = getContextualTypeForVariableLikeDeclaration(parentDeclaration);
+            const parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
+                parent.kind !== SyntaxKind.BindingElement && parent.initializer && checkDeclarationInitializer(parent);
             if (parentType && !isBindingPattern(name) && !isComputedNonLiteralName(name)) {
                 const nameType = getLiteralTypeFromPropertyName(name);
                 if (isTypeUsableAsPropertyName(nameType)) {
@@ -27661,27 +27666,13 @@ namespace ts {
             return node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression;
         }
 
-        function checkDeclarationInitializer(declaration: HasExpressionInitializer) {
+        function checkDeclarationInitializer(declaration: HasExpressionInitializer, contextualType?: Type | undefined) {
             const initializer = getEffectiveInitializer(declaration)!;
-            const type = getQuickTypeOfExpression(initializer) || checkExpressionCached(initializer);
-            const padded = isParameter(declaration) && declaration.name.kind === SyntaxKind.ArrayBindingPattern &&
+            const type = getQuickTypeOfExpression(initializer) ||
+                (contextualType ? checkExpressionWithContextualType(initializer, contextualType, /*inferenceContext*/ undefined, CheckMode.Normal) : checkExpressionCached(initializer));
+            return isParameter(declaration) && declaration.name.kind === SyntaxKind.ArrayBindingPattern &&
                 isTupleType(type) && !type.target.hasRestElement && getTypeReferenceArity(type) < declaration.name.elements.length ?
                 padTupleType(type, declaration.name) : type;
-            const widened = getCombinedNodeFlags(declaration) & NodeFlags.Const ||
-                isDeclarationReadonly(declaration) ||
-                isTypeAssertion(initializer) ||
-                isLiteralOfContextualType(padded, getContextualType(initializer)) ? padded : getWidenedLiteralType(padded);
-            if (isInJSFile(declaration)) {
-                if (widened.flags & TypeFlags.Nullable) {
-                    reportImplicitAny(declaration, anyType);
-                    return anyType;
-                }
-                else if (isEmptyArrayLiteralType(widened)) {
-                    reportImplicitAny(declaration, anyArrayType);
-                    return anyArrayType;
-                }
-            }
-            return widened;
         }
 
         function padTupleType(type: TupleTypeReference, pattern: ArrayBindingPattern) {
@@ -27700,6 +27691,21 @@ namespace ts {
             return createTupleType(elementTypes, type.target.minLength, /*hasRestElement*/ false, type.target.readonly);
         }
 
+        function widenTypeInferredFromInitializer(declaration: HasExpressionInitializer, type: Type) {
+            const widened = getCombinedNodeFlags(declaration) & NodeFlags.Const || isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type);
+            if (isInJSFile(declaration)) {
+                if (widened.flags & TypeFlags.Nullable) {
+                    reportImplicitAny(declaration, anyType);
+                    return anyType;
+                }
+                else if (isEmptyArrayLiteralType(widened)) {
+                    reportImplicitAny(declaration, anyArrayType);
+                    return anyArrayType;
+                }
+            }
+            return widened;
+        }
+
         function isLiteralOfContextualType(candidateType: Type, contextualType: Type | undefined): boolean {
             if (contextualType) {
                 if (contextualType.flags & TypeFlags.UnionOrIntersection) {
@@ -33128,12 +33134,12 @@ namespace ts {
                     importClauseContainsReferencedImport(statement.importClause) &&
                     !isReferencedAliasDeclaration(statement.importClause, /*checkChildren*/ true)
                 ) {
-                    const isError = compilerOptions.importsNotUsedAsValue === ImportsNotUsedAsValue.Error;
+                    const isError = compilerOptions.importsNotUsedAsValues === importsNotUsedAsValues.Error;
                     errorOrSuggestion(
                         isError,
                         statement,
                         isError
-                            ? Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValue_is_set_to_error
+                            ? Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error
                             : Diagnostics.This_import_may_be_converted_to_a_type_only_import);
                 }
             }

src/compiler/commandLineParser.ts

@@ -473,11 +473,11 @@ namespace ts {
             description: Diagnostics.Import_emit_helpers_from_tslib
         },
         {
-            name: "importsNotUsedAsValue",
+            name: "importsNotUsedAsValues",
             type: createMapFromTemplate({
-                remove: ImportsNotUsedAsValue.Remove,
-                preserve: ImportsNotUsedAsValue.Preserve,
-                error: ImportsNotUsedAsValue.Error
+                remove: importsNotUsedAsValues.Remove,
+                preserve: importsNotUsedAsValues.Preserve,
+                error: importsNotUsedAsValues.Error
             }),
             affectsEmit: true,
             category: Diagnostics.Advanced_Options,

src/compiler/diagnosticMessages.json

@@ -1099,7 +1099,7 @@
         "category": "Error",
         "code": 1370
     },
-    "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'.": {
         "category": "Error",
         "code": 1371
     },

src/compiler/transformers/ts.ts

@@ -2760,7 +2760,7 @@ namespace ts {
         }
 
         /**
-         * Visits an import declaration, eliding it if it is not referenced and `importsNotUsedAsValue` is not 'preserve'.
+         * Visits an import declaration, eliding it if it is not referenced and `importsNotUsedAsValues` is not 'preserve'.
          *
          * @param node The import declaration node.
          */
@@ -2778,8 +2778,8 @@ namespace ts {
             // Elide the declaration if the import clause was elided.
             const importClause = visitNode(node.importClause, visitImportClause, isImportClause);
             return importClause ||
-                compilerOptions.importsNotUsedAsValue === ImportsNotUsedAsValue.Preserve ||
-                compilerOptions.importsNotUsedAsValue === ImportsNotUsedAsValue.Error
+                compilerOptions.importsNotUsedAsValues === importsNotUsedAsValues.Preserve ||
+                compilerOptions.importsNotUsedAsValues === importsNotUsedAsValues.Error
                 ? updateImportDeclaration(
                     node,
                     /*decorators*/ undefined,
@@ -2931,7 +2931,7 @@ namespace ts {
             if (isExternalModuleImportEqualsDeclaration(node)) {
                 const isReferenced = resolver.isReferencedAliasDeclaration(node);
                 // If the alias is unreferenced but we want to keep the import, replace with 'import "mod"'.
-                if (!isReferenced && compilerOptions.importsNotUsedAsValue === ImportsNotUsedAsValue.Preserve) {
+                if (!isReferenced && compilerOptions.importsNotUsedAsValues === importsNotUsedAsValues.Preserve) {
                     return setOriginalNode(
                         setTextRange(
                             createImportDeclaration(

src/compiler/types.ts

@@ -5043,7 +5043,7 @@ namespace ts {
         /*@internal*/generateCpuProfile?: string;
         /*@internal*/help?: boolean;
         importHelpers?: boolean;
-        importsNotUsedAsValue?: ImportsNotUsedAsValue;
+        importsNotUsedAsValues?: importsNotUsedAsValues;
         /*@internal*/init?: boolean;
         inlineSourceMap?: boolean;
         inlineSources?: boolean;
@@ -5165,7 +5165,7 @@ namespace ts {
         ReactNative = 3
     }
 
-    export const enum ImportsNotUsedAsValue {
+    export const enum importsNotUsedAsValues {
         Remove,
         Preserve,
         Error

src/lib/es5.d.ts

@@ -298,7 +298,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.

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -2651,7 +2651,7 @@ declare namespace ts {
         experimentalDecorators?: boolean;
         forceConsistentCasingInFileNames?: boolean;
         importHelpers?: boolean;
-        importsNotUsedAsValue?: ImportsNotUsedAsValue;
+        importsNotUsedAsValues?: importsNotUsedAsValues;
         inlineSourceMap?: boolean;
         inlineSources?: boolean;
         isolatedModules?: boolean;
@@ -2750,7 +2750,7 @@ declare namespace ts {
         React = 2,
         ReactNative = 3
     }
-    export enum ImportsNotUsedAsValue {
+    export enum importsNotUsedAsValues {
         Remove = 0,
         Preserve = 1,
         Error = 2

tests/baselines/reference/api/typescript.d.ts

@@ -2651,7 +2651,7 @@ declare namespace ts {
         experimentalDecorators?: boolean;
         forceConsistentCasingInFileNames?: boolean;
         importHelpers?: boolean;
-        importsNotUsedAsValue?: ImportsNotUsedAsValue;
+        importsNotUsedAsValues?: importsNotUsedAsValues;
         inlineSourceMap?: boolean;
         inlineSources?: boolean;
         isolatedModules?: boolean;
@@ -2750,7 +2750,7 @@ declare namespace ts {
         React = 2,
         ReactNative = 3
     }
-    export enum ImportsNotUsedAsValue {
+    export enum importsNotUsedAsValues {
         Remove = 0,
         Preserve = 1,
         Error = 2

tests/baselines/reference/crashInGetTextOfComputedPropertyName.errors.txt

@@ -56,16 +56,16 @@ const {
     items: { [itemId]: itemWithTSError } = {} /*happens when default value is provided*/
 >items : any
 >itemId : "some-id"
->itemWithTSError : any
->{} : { "some-id": any; }
+>itemWithTSError : AB
+>{} : {}
 
 } = objWithItems
 >objWithItems : ObjWithItems
 
 // in order to re-produce the error, uncomment next line:
 typeof itemWithTSError // :(
 >typeof itemWithTSError : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
->itemWithTSError : any
+>itemWithTSError : AB
 
 // will result in:
 // Error from compilation: TypeError: Cannot read property 'charCodeAt' of undefined  TypeError: Cannot read property 'charCodeAt' of undefined