@typescript-deploys/pr-build 4.9.0-pr-50309-2 → 4.9.0-pr-50329-13

package/lib/tsserver.js

@@ -109,7 +109,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-insiders.20220815";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220817";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -7037,7 +7037,6 @@ var ts;
         // not actually work.
         var byteOrderMarkIndicator = "\uFEFF";
         function getNodeSystem() {
-            var _a;
             var nativePattern = /^native |^\([^)]+\)$|^(internal[\\/]|[a-zA-Z0-9_\s]+(\.js)?$)/;
             var _fs = require("fs");
             var _path = require("path");
@@ -7047,7 +7046,7 @@ var ts;
             try {
                 _crypto = require("crypto");
             }
-            catch (_b) {
+            catch (_a) {
                 _crypto = undefined;
             }
             var activeSession;
@@ -7058,10 +7057,10 @@ var ts;
             var isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin";
             var platform = _os.platform();
             var useCaseSensitiveFileNames = isFileSystemCaseSensitive();
-            var realpathSync = (_a = _fs.realpathSync.native) !== null && _a !== void 0 ? _a : _fs.realpathSync;
+            var fsRealpath = !!_fs.realpathSync.native ? process.platform === "win32" ? fsRealPathHandlingLongPath : _fs.realpathSync.native : _fs.realpathSync;
             var fsSupportsRecursiveFsWatch = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin");
             var getCurrentDirectory = ts.memoize(function () { return process.cwd(); });
-            var _c = createSystemWatchFunctions({
+            var _b = createSystemWatchFunctions({
                 pollingWatchFile: createSingleFileWatcherPerName(fsWatchFileWorker, useCaseSensitiveFileNames),
                 getModifiedTime: getModifiedTime,
                 setTimeout: setTimeout,
@@ -7081,7 +7080,7 @@ var ts;
                 defaultWatchFileKind: function () { var _a, _b; return (_b = (_a = sys).defaultWatchFileKind) === null || _b === void 0 ? void 0 : _b.call(_a); },
                 inodeWatching: isLinuxOrMacOs,
                 sysLog: sysLog,
-            }), watchFile = _c.watchFile, watchDirectory = _c.watchDirectory;
+            }), watchFile = _b.watchFile, watchDirectory = _b.watchDirectory;
             var nodeSystem = {
                 args: process.argv.slice(2),
                 newLine: _os.EOL,
@@ -7474,9 +7473,12 @@ var ts;
             function getDirectories(path) {
                 return getAccessibleFileSystemEntries(path).directories.slice();
             }
+            function fsRealPathHandlingLongPath(path) {
+                return path.length < 260 ? _fs.realpathSync.native(path) : _fs.realpathSync(path);
+            }
             function realpath(path) {
                 try {
-                    return realpathSync(path);
+                    return fsRealpath(path);
                 }
                 catch (_a) {
                     return path;
@@ -65683,6 +65685,38 @@ var ts;
                     }
                     return 0 /* False */;
                 }
+                // Before normalization: Intersections applied to unions create an explosion of types when normalized -
+                // handling those inner intersections can be very costly, so it can be beneficial to factor them out early.
+                // If both the source and target are intersections, we can remove the common types from them before formal normalization,
+                // and run a simplified comparison without those common members.
+                if (originalSource.flags & originalTarget.flags & 2097152 /* Intersection */) {
+                    var combinedTypeSet_1 = new ts.Map();
+                    ts.forEach(originalSource.types, function (t) { return combinedTypeSet_1.set(getTypeId(t), 1); });
+                    var hasOverlap_1 = false;
+                    ts.forEach(originalTarget.types, function (t) {
+                        var id = getTypeId(t);
+                        if (combinedTypeSet_1.has(id)) {
+                            combinedTypeSet_1.set(getTypeId(t), 2);
+                            hasOverlap_1 = true;
+                        }
+                    });
+                    if (hasOverlap_1) {
+                        var filteredSource = ts.filter(originalSource.types, function (t) { return combinedTypeSet_1.get(getTypeId(t)) !== 2; });
+                        var filteredTarget = ts.filter(originalTarget.types, function (t) { return combinedTypeSet_1.get(getTypeId(t)) !== 2; });
+                        if (!ts.length(filteredTarget)) {
+                            return -1 /* True */; // Source has all parts of target
+                        }
+                        if (ts.length(filteredSource)) {
+                            var result_7;
+                            if (result_7 = isRelatedTo(getIntersectionType(filteredSource), getIntersectionType(filteredTarget), recursionFlags, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
+                                return result_7;
+                            }
+                            // In the false case, we may still be assignable at the structural level, rather than the algebraic level
+                        }
+                        // Even if every member of the source is in the target but the target still has members left, the source may still be assignable
+                        // to the target, either if some member of the original source is assignable to the other members of the target, or if there is structural assignability
+                    }
+                }
                 // Normalize the source and target types: Turn fresh literal types into regular literal types,
                 // turn deferred type references into regular type references, simplify indexed access and
                 // conditional types, and resolve substitution types to either the substitution (on the source
@@ -65733,7 +65767,8 @@ var ts;
                             return 0 /* False */;
                         }
                     }
-                    var isPerformingCommonPropertyChecks = relation !== comparableRelation && !(intersectionState & 2 /* Target */) &&
+                    var isPerformingCommonPropertyChecks = (relation !== comparableRelation || relation === comparableRelation && isLiteralType(source)) &&
+                        !(intersectionState & 2 /* Target */) &&
                         source.flags & (131068 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source !== globalObjectType &&
                         target.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target) &&
                         (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source));
@@ -65757,7 +65792,7 @@ var ts;
                     traceUnionsOrIntersectionsTooLarge(source, target);
                     var skipCaching = source.flags & 1048576 /* Union */ && source.types.length < 4 && !(target.flags & 1048576 /* Union */) ||
                         target.flags & 1048576 /* Union */ && target.types.length < 4 && !(source.flags & 469499904 /* StructuredOrInstantiable */);
-                    var result_7 = skipCaching ?
+                    var result_8 = skipCaching ?
                         unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) :
                         recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags);
                     // For certain combinations involving intersections and optional, excess, or mismatched properties we need
@@ -65775,14 +65810,14 @@ var ts;
                     //
                     // We suppress recursive intersection property checks because they can generate lots of work when relating
                     // recursive intersections that are structurally similar but not exactly identical. See #37854.
-                    if (result_7 && !inPropertyCheck && (target.flags & 2097152 /* Intersection */ && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
+                    if (result_8 && !inPropertyCheck && (target.flags & 2097152 /* Intersection */ && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
                         isNonGenericObjectType(target) && !isArrayOrTupleType(target) && source.flags & 2097152 /* Intersection */ && getApparentType(source).flags & 3670016 /* StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 262144 /* NonInferrableType */); }))) {
                         inPropertyCheck = true;
-                        result_7 &= recursiveTypeRelatedTo(source, target, reportErrors, 4 /* PropertyCheck */, recursionFlags);
+                        result_8 &= recursiveTypeRelatedTo(source, target, reportErrors, 4 /* PropertyCheck */, recursionFlags);
                         inPropertyCheck = false;
                     }
-                    if (result_7) {
-                        return result_7;
+                    if (result_8) {
+                        return result_8;
                     }
                 }
                 if (reportErrors) {
@@ -66171,6 +66206,9 @@ var ts;
             // equal and infinitely expanding. Fourth, if we have reached a depth of 100 nested comparisons, assume we have runaway recursion
             // and issue an error. Otherwise, actually compare the structure of the two types.
             function recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags) {
+                if (relation.size > Math.pow(2, 20)) {
+                    debugger;
+                }
                 if (overflow) {
                     return 0 /* False */;
                 }
@@ -66329,11 +66367,11 @@ var ts;
                 if (relation === identityRelation) {
                     // We've already checked that source.flags and target.flags are identical
                     if (sourceFlags & 3145728 /* UnionOrIntersection */) {
-                        var result_8 = eachTypeRelatedToSomeType(source, target);
-                        if (result_8) {
-                            result_8 &= eachTypeRelatedToSomeType(target, source);
+                        var result_9 = eachTypeRelatedToSomeType(source, target);
+                        if (result_9) {
+                            result_9 &= eachTypeRelatedToSomeType(target, source);
                         }
-                        return result_8;
+                        return result_9;
                     }
                     if (sourceFlags & 4194304 /* Index */) {
                         return isRelatedTo(source.type, target.type, 3 /* Both */, /*reportErrors*/ false);
@@ -66510,7 +66548,7 @@ var ts;
                                     // create a new chain for the constraint error
                                     resetErrorInfo(saveErrorInfo);
                                 }
-                                if (result = isRelatedTo(source, constraint, 2 /* Target */, reportErrors)) {
+                                if (result = isRelatedTo(source, constraint, 2 /* Target */, reportErrors, /* headMessage */ undefined, intersectionState)) {
                                     return result;
                                 }
                                 // prefer the shorter chain of the constraint comparison chain, and the direct comparison chain
@@ -66822,9 +66860,9 @@ var ts;
                     if (sourceFlags & (524288 /* Object */ | 2097152 /* Intersection */) && targetFlags & 1048576 /* Union */) {
                         var objectOnlyTarget = extractTypesOfKind(target, 524288 /* Object */ | 2097152 /* Intersection */ | 33554432 /* Substitution */);
                         if (objectOnlyTarget.flags & 1048576 /* Union */) {
-                            var result_9 = typeRelatedToDiscriminatedType(source, objectOnlyTarget);
-                            if (result_9) {
-                                return result_9;
+                            var result_10 = typeRelatedToDiscriminatedType(source, objectOnlyTarget);
+                            if (result_10) {
+                                return result_10;
                             }
                         }
                     }
@@ -66884,13 +66922,13 @@ var ts;
                 var modifiersRelated = relation === comparableRelation || (relation === identityRelation ? getMappedTypeModifiers(source) === getMappedTypeModifiers(target) :
                     getCombinedMappedTypeOptionality(source) <= getCombinedMappedTypeOptionality(target));
                 if (modifiersRelated) {
-                    var result_10;
+                    var result_11;
                     var targetConstraint = getConstraintTypeFromMappedType(target);
                     var sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source), getCombinedMappedTypeOptionality(source) < 0 ? reportUnmeasurableMapper : reportUnreliableMapper);
-                    if (result_10 = isRelatedTo(targetConstraint, sourceConstraint, 3 /* Both */, reportErrors)) {
+                    if (result_11 = isRelatedTo(targetConstraint, sourceConstraint, 3 /* Both */, reportErrors)) {
                         var mapper = createTypeMapper([getTypeParameterFromMappedType(source)], [getTypeParameterFromMappedType(target)]);
                         if (instantiateType(getNameTypeFromMappedType(source), mapper) === instantiateType(getNameTypeFromMappedType(target), mapper)) {
-                            return result_10 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), 3 /* Both */, reportErrors);
+                            return result_11 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), 3 /* Both */, reportErrors);
                         }
                     }
                 }
@@ -68216,7 +68254,7 @@ var ts;
             if (!isLiteralOfContextualType(type, contextualType)) {
                 type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
             }
-            return type;
+            return getRegularTypeOfLiteralType(type);
         }
         function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
             if (type && isUnitType(type)) {
@@ -78241,10 +78279,10 @@ var ts;
                         hasSignatures || (hasSignatures = resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0);
                         hasApplicableSignature || (hasApplicableSignature = callSignatures.length !== 0 || constructSignatures.length !== 0);
                         if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
-                            var result_11 = createAnonymousType(undefined, resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
-                            result_11.objectFlags |= 8388608 /* InstantiationExpressionType */;
-                            result_11.node = node;
-                            return result_11;
+                            var result_12 = createAnonymousType(undefined, resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
+                            result_12.objectFlags |= 8388608 /* InstantiationExpressionType */;
+                            result_12.node = node;
+                            return result_12;
                         }
                     }
                     else if (type.flags & 58982400 /* InstantiableNonPrimitive */) {
@@ -82079,12 +82117,12 @@ var ts;
                     case 265 /* ImportEqualsDeclaration */:
                     case 268 /* NamespaceImport */:
                     case 267 /* ImportClause */:
-                        var result_12 = 0 /* None */;
+                        var result_13 = 0 /* None */;
                         var target = resolveAlias(getSymbolOfNode(d));
                         ts.forEach(target.declarations, function (d) {
-                            result_12 |= getDeclarationSpaces(d);
+                            result_13 |= getDeclarationSpaces(d);
                         });
-                        return result_12;
+                        return result_13;
                     case 254 /* VariableDeclaration */:
                     case 203 /* BindingElement */:
                     case 256 /* FunctionDeclaration */:
@@ -99265,8 +99303,8 @@ var ts;
         function convertJsxChildrenToChildrenPropAssignment(children) {
             var nonWhitespaceChildren = ts.getSemanticJsxChildren(children);
             if (ts.length(nonWhitespaceChildren) === 1 && !nonWhitespaceChildren[0].dotDotDotToken) {
-                var result_13 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
-                return result_13 && factory.createPropertyAssignment("children", result_13);
+                var result_14 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
+                return result_14 && factory.createPropertyAssignment("children", result_14);
             }
             var result = ts.mapDefined(children, transformJsxChildToExpression);
             return ts.length(result) ? factory.createPropertyAssignment("children", factory.createArrayLiteralExpression(result)) : undefined;
@@ -118521,15 +118559,15 @@ var ts;
                 // which per above occurred during the current program creation.
                 // Since we assume the filesystem does not change during program creation,
                 // it is safe to reuse resolutions from the earlier call.
-                var result_14 = [];
+                var result_15 = [];
                 var i = 0;
                 for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) {
                     var moduleName = moduleNames_1[_i];
                     var resolvedModule = file.resolvedModules.get(moduleName, getModeForResolutionAtIndex(file, i));
                     i++;
-                    result_14.push(resolvedModule);
+                    result_15.push(resolvedModule);
                 }
-                return result_14;
+                return result_15;
             }
             // At this point, we know at least one of the following hold:
             // - file has local declarations for ambient modules
@@ -121989,14 +122027,14 @@ var ts;
                 fileNames_1.push(relativeToBuildInfo(sourceFile.resolvedPath));
                 fileInfos_1.push(sourceFile.version);
             });
-            var result_15 = {
+            var result_16 = {
                 fileNames: fileNames_1,
                 fileInfos: fileInfos_1,
                 options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo"),
                 outSignature: state.outSignature,
                 latestChangedDtsFile: latestChangedDtsFile,
             };
-            return result_15;
+            return result_16;
         }
         var fileNames = [];
         var fileNameToFileId = new ts.Map();
@@ -123934,9 +123972,9 @@ var ts;
             if (!preferSymlinks) {
                 // Symlinks inside ignored paths are already filtered out of the symlink cache,
                 // so we only need to remove them from the realpath filenames.
-                var result_16 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
-                if (result_16)
-                    return result_16;
+                var result_17 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
+                if (result_17)
+                    return result_17;
             }
             var symlinkedDirectories = (_a = host.getSymlinkCache) === null || _a === void 0 ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
             var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd);
@@ -123956,10 +123994,10 @@ var ts;
                     for (var _i = 0, symlinkDirectories_1 = symlinkDirectories; _i < symlinkDirectories_1.length; _i++) {
                         var symlinkDirectory = symlinkDirectories_1[_i];
                         var option = ts.resolvePath(symlinkDirectory, relative);
-                        var result_17 = cb(option, target === referenceRedirect);
+                        var result_18 = cb(option, target === referenceRedirect);
                         shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths
-                        if (result_17)
-                            return result_17;
+                        if (result_18)
+                            return result_18;
                     }
                 });
             });
@@ -159745,23 +159783,36 @@ var ts;
          * @param body If defined, this will be the body of the member node passed to `addClassElement`. Otherwise, the body will default to a stub.
          */
         function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement, body, preserveOptional, isAmbient) {
+            var _a;
             if (preserveOptional === void 0) { preserveOptional = 3 /* All */; }
             if (isAmbient === void 0) { isAmbient = false; }
             var declarations = symbol.getDeclarations();
-            if (!(declarations && declarations.length)) {
-                return undefined;
-            }
+            var declaration = declarations === null || declarations === void 0 ? void 0 : declarations[0];
             var checker = context.program.getTypeChecker();
             var scriptTarget = ts.getEmitScriptTarget(context.program.getCompilerOptions());
-            var declaration = declarations[0];
+            /**
+             * (#49811)
+             * Note that there are cases in which the symbol declaration is not present. For example, in the code below both
+             * `MappedIndirect.ax` and `MappedIndirect.ay` have no declaration node attached (due to their mapped-type
+             * parent):
+             *
+             * >>> ```ts
+             * >>> type Base = { ax: number; ay: string };
+             * >>> type BaseKeys = keyof Base;
+             * >>> type MappedIndirect = { [K in BaseKeys]: boolean };
+             * >>> ```
+             *
+             * In such cases, we assume the declaration to be a `PropertySignature`.
+             */
+            var kind = (_a = declaration === null || declaration === void 0 ? void 0 : declaration.kind) !== null && _a !== void 0 ? _a : 166 /* PropertySignature */;
             var name = ts.getSynthesizedDeepClone(ts.getNameOfDeclaration(declaration), /*includeTrivia*/ false);
-            var visibilityModifier = createVisibilityModifier(ts.getEffectiveModifierFlags(declaration));
+            var visibilityModifier = createVisibilityModifier(declaration ? ts.getEffectiveModifierFlags(declaration) : 0 /* None */);
             var modifiers = visibilityModifier ? ts.factory.createNodeArray([visibilityModifier]) : undefined;
             var type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
             var optional = !!(symbol.flags & 16777216 /* Optional */);
             var ambient = !!(enclosingDeclaration.flags & 16777216 /* Ambient */) || isAmbient;
             var quotePreference = ts.getQuotePreference(sourceFile, preferences);
-            switch (declaration.kind) {
+            switch (kind) {
                 case 166 /* PropertySignature */:
                 case 167 /* PropertyDeclaration */:
                     var flags = quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : undefined;
@@ -159773,11 +159824,12 @@ var ts;
                             importSymbols(importAdder, importableReference.symbols);
                         }
                     }
-                    addClassElement(ts.factory.createPropertyDeclaration(modifiers, name, optional && (preserveOptional & 2 /* Property */) ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeNode, 
+                    addClassElement(ts.factory.createPropertyDeclaration(modifiers, declaration ? name : symbol.getName(), optional && (preserveOptional & 2 /* Property */) ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeNode, 
                     /*initializer*/ undefined));
                     break;
                 case 172 /* GetAccessor */:
                 case 173 /* SetAccessor */: {
+                    ts.Debug.assertIsDefined(declarations);
                     var typeNode_1 = checker.typeToTypeNode(type, enclosingDeclaration, /*flags*/ undefined, getNoopSymbolTrackerWithResolver(context));
                     var allAccessors = ts.getAllAccessorDeclarations(declarations, declaration);
                     var orderedAccessors = allAccessors.secondAccessor
@@ -159813,6 +159865,7 @@ var ts;
                     // If there is more than one overload but no implementation signature
                     // (eg: an abstract method or interface declaration), there is a 1-1
                     // correspondence of declarations and signatures.
+                    ts.Debug.assertIsDefined(declarations);
                     var signatures = type.isUnion() ? ts.flatMap(type.types, function (t) { return t.getCallSignatures(); }) : type.getCallSignatures();
                     if (!ts.some(signatures)) {
                         break;
@@ -159823,8 +159876,8 @@ var ts;
                         outputMethod(quotePreference, signature, modifiers, name, ambient ? undefined : body || createStubbedMethodBody(quotePreference));
                         break;
                     }
-                    for (var _a = 0, signatures_1 = signatures; _a < signatures_1.length; _a++) {
-                        var signature = signatures_1[_a];
+                    for (var _b = 0, signatures_1 = signatures; _b < signatures_1.length; _b++) {
+                        var signature = signatures_1[_b];
                         // Ensure nodes are fresh so they can have different positions when going through formatting.
                         outputMethod(quotePreference, signature, ts.getSynthesizedDeepClones(modifiers, /*includeTrivia*/ false), ts.getSynthesizedDeepClone(name, /*includeTrivia*/ false));
                     }