typescript 4.7.0-dev.20220329 → 4.7.0-dev.20220401

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.20220329";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220401";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -9484,6 +9484,7 @@ var ts;
         An_expanded_version_of_this_information_showing_all_possible_compiler_options: diag(6928, ts.DiagnosticCategory.Message, "An_expanded_version_of_this_information_showing_all_possible_compiler_options_6928", "An expanded version of this information, showing all possible compiler options"),
         Compiles_the_current_project_with_additional_settings: diag(6929, ts.DiagnosticCategory.Message, "Compiles_the_current_project_with_additional_settings_6929", "Compiles the current project, with additional settings."),
         true_for_ES2022_and_above_including_ESNext: diag(6930, ts.DiagnosticCategory.Message, "true_for_ES2022_and_above_including_ESNext_6930", "`true` for ES2022 and above, including ESNext."),
+        List_of_file_name_suffixes_to_search_when_resolving_a_module: diag(6931, ts.DiagnosticCategory.Error, "List_of_file_name_suffixes_to_search_when_resolving_a_module_6931", "List of file name suffixes to search when resolving a module."),
         Variable_0_implicitly_has_an_1_type: diag(7005, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_an_1_type_7005", "Variable '{0}' implicitly has an '{1}' type."),
         Parameter_0_implicitly_has_an_1_type: diag(7006, ts.DiagnosticCategory.Error, "Parameter_0_implicitly_has_an_1_type_7006", "Parameter '{0}' implicitly has an '{1}' type."),
         Member_0_implicitly_has_an_1_type: diag(7008, ts.DiagnosticCategory.Error, "Member_0_implicitly_has_an_1_type_7008", "Member '{0}' implicitly has an '{1}' type."),
@@ -39478,6 +39479,18 @@ var ts;
             description: ts.Diagnostics.Allow_accessing_UMD_globals_from_modules,
             defaultValueDescription: false,
         },
+        {
+            name: "moduleSuffixes",
+            type: "list",
+            element: {
+                name: "suffix",
+                type: "string",
+            },
+            listPreserveFalsyValues: true,
+            affectsModuleResolution: true,
+            category: ts.Diagnostics.Modules,
+            description: ts.Diagnostics.List_of_file_name_suffixes_to_search_when_resolving_a_module,
+        },
         // Source Maps
         {
             name: "sourceRoot",
@@ -41404,7 +41417,7 @@ var ts;
         if (option.type === "list") {
             var listOption_1 = option;
             if (listOption_1.element.isFilePath || !ts.isString(listOption_1.element.type)) {
-                return ts.filter(ts.map(value, function (v) { return normalizeOptionValue(listOption_1.element, basePath, v); }), function (v) { return !!v; });
+                return ts.filter(ts.map(value, function (v) { return normalizeOptionValue(listOption_1.element, basePath, v); }), function (v) { return listOption_1.listPreserveFalsyValues ? true : !!v; });
             }
             return value;
         }
@@ -41445,7 +41458,7 @@ var ts;
         }
     }
     function convertJsonOptionOfListType(option, values, basePath, errors) {
-        return ts.filter(ts.map(values, function (v) { return convertJsonOption(option.element, v, basePath, errors); }), function (v) { return !!v; });
+        return ts.filter(ts.map(values, function (v) { return convertJsonOption(option.element, v, basePath, errors); }), function (v) { return option.listPreserveFalsyValues ? true : !!v; });
     }
     /**
      * Tests for a path that ends in a recursive directory wildcard.
@@ -43071,6 +43084,15 @@ var ts;
     }
     /** Return the file if it exists. */
     function tryFile(fileName, onlyRecordFailures, state) {
+        var _a, _b;
+        if (!((_a = state.compilerOptions.moduleSuffixes) === null || _a === void 0 ? void 0 : _a.length)) {
+            return tryFileLookup(fileName, onlyRecordFailures, state);
+        }
+        var ext = (_b = ts.tryGetExtensionFromPath(fileName)) !== null && _b !== void 0 ? _b : "";
+        var fileNameNoExtension = ext ? ts.removeExtension(fileName, ext) : fileName;
+        return ts.forEach(state.compilerOptions.moduleSuffixes, function (suffix) { return tryFileLookup(fileNameNoExtension + suffix + ext, onlyRecordFailures, state); });
+    }
+    function tryFileLookup(fileName, onlyRecordFailures, state) {
         if (!onlyRecordFailures) {
             if (state.host.fileExists(fileName)) {
                 if (state.traceEnabled) {
@@ -47395,7 +47417,8 @@ var ts;
         CheckMode[CheckMode["SkipContextSensitive"] = 4] = "SkipContextSensitive";
         CheckMode[CheckMode["SkipGenericFunctions"] = 8] = "SkipGenericFunctions";
         CheckMode[CheckMode["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
-        CheckMode[CheckMode["RestBindingElement"] = 32] = "RestBindingElement";
+        CheckMode[CheckMode["IsForStringLiteralArgumentCompletions"] = 32] = "IsForStringLiteralArgumentCompletions";
+        CheckMode[CheckMode["RestBindingElement"] = 64] = "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 = {}));
@@ -47733,26 +47756,10 @@ var ts;
                 if (!node) {
                     return undefined;
                 }
-                var containingCall = ts.findAncestor(node, ts.isCallLikeExpression);
-                var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
-                if (contextFlags & 4 /* Completions */ && containingCall) {
-                    var toMarkSkip = node;
-                    do {
-                        getNodeLinks(toMarkSkip).skipDirectInference = true;
-                        toMarkSkip = toMarkSkip.parent;
-                    } while (toMarkSkip && toMarkSkip !== containingCall);
-                    getNodeLinks(containingCall).resolvedSignature = undefined;
-                }
-                var result = getContextualType(node, contextFlags);
-                if (contextFlags & 4 /* Completions */ && containingCall) {
-                    var toMarkSkip = node;
-                    do {
-                        getNodeLinks(toMarkSkip).skipDirectInference = undefined;
-                        toMarkSkip = toMarkSkip.parent;
-                    } while (toMarkSkip && toMarkSkip !== containingCall);
-                    getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
+                if (contextFlags & 4 /* Completions */) {
+                    return runWithInferenceBlockedFromSourceNode(node, function () { return getContextualType(node, contextFlags); });
                 }
-                return result;
+                return getContextualType(node, contextFlags);
             },
             getContextualTypeForObjectLiteralElement: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isObjectLiteralElementLike);
@@ -47772,6 +47779,9 @@ var ts;
             getResolvedSignature: function (node, candidatesOutArray, argumentCount) {
                 return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0 /* Normal */);
             },
+            getResolvedSignatureForStringLiteralCompletions: function (call, editingArgument, candidatesOutArray) {
+                return getResolvedSignatureWorker(call, candidatesOutArray, /*argumentCount*/ undefined, 32 /* IsForStringLiteralArgumentCompletions */, editingArgument);
+            },
             getResolvedSignatureForSignatureHelp: function (node, candidatesOutArray, argumentCount) {
                 return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* IsForSignatureHelp */);
             },
@@ -47924,10 +47934,34 @@ var ts;
             getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration,
             getMemberOverrideModifierStatus: getMemberOverrideModifierStatus,
         };
-        function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
+        function runWithInferenceBlockedFromSourceNode(node, fn) {
+            var containingCall = ts.findAncestor(node, ts.isCallLikeExpression);
+            var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
+            if (containingCall) {
+                var toMarkSkip = node;
+                do {
+                    getNodeLinks(toMarkSkip).skipDirectInference = true;
+                    toMarkSkip = toMarkSkip.parent;
+                } while (toMarkSkip && toMarkSkip !== containingCall);
+                getNodeLinks(containingCall).resolvedSignature = undefined;
+            }
+            var result = fn();
+            if (containingCall) {
+                var toMarkSkip = node;
+                do {
+                    getNodeLinks(toMarkSkip).skipDirectInference = undefined;
+                    toMarkSkip = toMarkSkip.parent;
+                } while (toMarkSkip && toMarkSkip !== containingCall);
+                getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
+            }
+            return result;
+        }
+        function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode, editingArgument) {
             var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
             apparentArgumentCount = argumentCount;
-            var res = node ? getResolvedSignature(node, candidatesOutArray, checkMode) : undefined;
+            var res = !node ? undefined :
+                editingArgument ? runWithInferenceBlockedFromSourceNode(editingArgument, function () { return getResolvedSignature(node, candidatesOutArray, checkMode); }) :
+                    getResolvedSignature(node, candidatesOutArray, checkMode);
             apparentArgumentCount = undefined;
             return res;
         }
@@ -52054,7 +52088,15 @@ var ts;
                         if (!ts.nodeIsSynthesized(node) && ts.getParseTreeNode(node) === node) {
                             return node;
                         }
-                        return ts.setTextRange(ts.factory.cloneNode(ts.visitEachChild(node, deepCloneOrReuseNode, ts.nullTransformationContext)), node);
+                        return ts.setTextRange(ts.factory.cloneNode(ts.visitEachChild(node, deepCloneOrReuseNode, ts.nullTransformationContext, deepCloneOrReuseNodes)), node);
+                    }
+                    function deepCloneOrReuseNodes(nodes, visitor, test, start, count) {
+                        if (nodes && nodes.length === 0) {
+                            // Ensure we explicitly make a copy of an empty array; visitNodes will not do this unless the array has elements,
+                            // which can lead to us reusing the same empty NodeArray more than once within the same AST during type noding.
+                            return ts.setTextRange(ts.factory.createNodeArray(/*nodes*/ undefined, nodes.hasTrailingComma), nodes);
+                        }
+                        return ts.visitNodes(nodes, visitor, test, start, count);
                     }
                 }
                 function createTypeNodeFromObjectType(type) {
@@ -55061,7 +55103,7 @@ var ts;
         }
         /** Return the inferred type for a binding element */
         function getTypeForBindingElement(declaration) {
-            var checkMode = declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
+            var checkMode = declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
             var parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
             return parentType && getBindingElementTypeFromParentType(declaration, parentType);
         }
@@ -68189,7 +68231,7 @@ var ts;
                 for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
                     var targetProp = properties_3[_i];
                     var sourceProp = getPropertyOfType(source, targetProp.escapedName);
-                    if (sourceProp) {
+                    if (sourceProp && !ts.some(sourceProp.declarations, hasSkipDirectInferenceFlag)) {
                         inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
                     }
                 }
@@ -70663,7 +70705,7 @@ var ts;
             // 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) &&
-                (checkMode && checkMode & 32 /* RestBindingElement */ ?
+                (checkMode && checkMode & 64 /* RestBindingElement */ ?
                     getContextualType(node, 8 /* SkipBindingPatterns */)
                     : getContextualType(node));
             return contextualType && !isGenericType(contextualType);
@@ -70784,7 +70826,7 @@ var ts;
                     if (func.parameters.length >= 2 && isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
                         var contextualSignature = getContextualSignature(func);
                         if (contextualSignature && contextualSignature.parameters.length === 1 && signatureHasRestParameter(contextualSignature)) {
-                            var restType = getTypeOfSymbol(contextualSignature.parameters[0]);
+                            var restType = getReducedApparentType(getTypeOfSymbol(contextualSignature.parameters[0]));
                             if (restType.flags & 1048576 /* Union */ && everyType(restType, isTupleType) && !isSymbolAssigned(symbol)) {
                                 var narrowedType = getFlowTypeOfReference(func, restType, restType, /*flowContainer*/ undefined, location.flowNode);
                                 var index = func.parameters.indexOf(declaration) - (ts.getThisParameter(func) ? 1 : 0);
@@ -71602,7 +71644,7 @@ var ts;
             var parent = declaration.parent.parent;
             var name = declaration.propertyName || declaration.name;
             var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
-                parent.kind !== 203 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */);
+                parent.kind !== 203 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
             if (!parentType || ts.isBindingPattern(name) || ts.isComputedNonLiteralName(name))
                 return undefined;
             if (parent.name.kind === 202 /* ArrayBindingPattern */) {
@@ -72089,9 +72131,14 @@ var ts;
                         return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
                     }
                     // For other purposes (e.g. determining whether to produce literal types) we only
-                    // incorporate inferences made from the return type in a function call.
+                    // incorporate inferences made from the return type in a function call. We remove
+                    // the 'boolean' type from the contextual type such that contextually typed boolean
+                    // literals actually end up widening to 'boolean' (see #48363).
                     if (inferenceContext.returnMapper) {
-                        return instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+                        var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+                        return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
+                            filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
+                            type;
                     }
                 }
             }
@@ -74656,7 +74703,7 @@ var ts;
             }
             for (var i = 0; i < argCount; i++) {
                 var arg = args[i];
-                if (arg.kind !== 227 /* OmittedExpression */) {
+                if (arg.kind !== 227 /* OmittedExpression */ && !(checkMode & 32 /* IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) {
                     var paramType = getTypeAtPosition(signature, i);
                     var argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
                     inferTypes(context.inferences, argType, paramType);
@@ -75341,7 +75388,7 @@ var ts;
                     }
                 }
             }
-            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray);
+            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
             function addImplementationSuccessElaboration(failed, diagnostic) {
                 var _a, _b;
                 var oldCandidatesForArgumentError = candidatesForArgumentError;
@@ -75442,14 +75489,14 @@ var ts;
             }
         }
         // No signature was applicable. We have already reported the errors for the invalid signature.
-        function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray) {
+        function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray, checkMode) {
             ts.Debug.assert(candidates.length > 0); // Else should not have called this.
             checkNodeDeferred(node);
             // Normally we will combine overloads. Skip this if they have type parameters since that's hard to combine.
             // Don't do this if there is a `candidatesOutArray`,
             // because then we want the chosen best candidate to be one of the overloads, not a combination.
             return hasCandidatesOutArray || candidates.length === 1 || candidates.some(function (c) { return !!c.typeParameters; })
-                ? pickLongestCandidateSignature(node, candidates, args)
+                ? pickLongestCandidateSignature(node, candidates, args, checkMode)
                 : createUnionOfSignaturesForOverloadFailure(candidates);
         }
         function createUnionOfSignaturesForOverloadFailure(candidates) {
@@ -75497,7 +75544,7 @@ var ts;
             // This function is currently only used for erroneous overloads, so it's good enough to just use the first source.
             return createSymbolWithType(ts.first(sources), type);
         }
-        function pickLongestCandidateSignature(node, candidates, args) {
+        function pickLongestCandidateSignature(node, candidates, args, checkMode) {
             // Pick the longest signature. This way we can get a contextual type for cases like:
             //     declare function f(a: { xa: number; xb: number; }, b: number);
             //     f({ |
@@ -75513,7 +75560,7 @@ var ts;
             var typeArgumentNodes = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments : undefined;
             var instantiated = typeArgumentNodes
                 ? createSignatureInstantiation(candidate, getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, ts.isInJSFile(node)))
-                : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args);
+                : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode);
             candidates[bestIndex] = instantiated;
             return instantiated;
         }
@@ -75527,9 +75574,9 @@ var ts;
             }
             return typeArguments;
         }
-        function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args) {
+        function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode) {
             var inferenceContext = createInferenceContext(typeParameters, candidate, /*flags*/ ts.isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */);
-            var typeArgumentTypes = inferTypeArguments(node, candidate, args, 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
+            var typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
             return createSignatureInstantiation(candidate, typeArgumentTypes);
         }
         function getLongestCandidateIndex(candidates, argsCount) {
@@ -81595,7 +81642,7 @@ var ts;
                 }
                 // check private/protected variable access
                 var parent = node.parent.parent;
-                var parentCheckMode = node.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
+                var parentCheckMode = node.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
                 var parentType = getTypeForBindingElementParent(parent, parentCheckMode);
                 var name = node.propertyName || node.name;
                 if (parentType && !ts.isBindingPattern(name)) {
@@ -111100,6 +111147,7 @@ var ts;
                 writeLine();
                 decreaseIndent();
             }
+            emitList(node, node.members, 2 /* PreserveLines */);
             writePunctuation("}");
         }
         function emitLiteralType(node) {
@@ -116693,6 +116741,13 @@ var ts;
                                 return "skip";
                             }
                             break;
+                        case 270 /* ImportSpecifier */:
+                        case 275 /* ExportSpecifier */:
+                            if (node.isTypeOnly) {
+                                diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, ts.isImportSpecifier(node) ? "import...type" : "export...type"));
+                                return "skip";
+                            }
+                            break;
                         case 265 /* ImportEqualsDeclaration */:
                             diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_TypeScript_files));
                             return "skip";

package/package.json

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