@typescript-deploys/pr-build 4.8.0-pr-49245-7 → 4.8.0-pr-48997-21

package/lib/typingsInstaller.js

@@ -6308,7 +6308,7 @@ var ts;
      */
     /*@internal*/
     function createDirectoryWatcherSupportingRecursive(_a) {
-        var watchDirectory = _a.watchDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, directoryExists = _a.directoryExists, realpath = _a.realpath, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout;
+        var watchDirectory = _a.watchDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, fileSystemEntryExists = _a.fileSystemEntryExists, realpath = _a.realpath, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout;
         var cache = new ts.Map();
         var callbackCache = ts.createMultiMap();
         var cacheToUpdateChildWatches = new ts.Map();
@@ -6408,7 +6408,7 @@ var ts;
         function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
             // Iterate through existing children and update the watches if needed
             var parentWatcher = cache.get(dirPath);
-            if (parentWatcher && directoryExists(dirName)) {
+            if (parentWatcher && fileSystemEntryExists(dirName, 1 /* Directory */)) {
                 // Schedule the update and postpone invoke for callbacks
                 scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
                 return;
@@ -6481,7 +6481,7 @@ var ts;
             if (!parentWatcher)
                 return false;
             var newChildWatches;
-            var hasChanges = ts.enumerateInsertsAndDeletes(directoryExists(parentDir) ? ts.mapDefined(getAccessibleSortedChildDirectories(parentDir), function (child) {
+            var hasChanges = ts.enumerateInsertsAndDeletes(fileSystemEntryExists(parentDir, 1 /* Directory */) ? ts.mapDefined(getAccessibleSortedChildDirectories(parentDir), function (child) {
                 var childFullName = ts.getNormalizedAbsolutePath(child, parentDir);
                 // Filter our the symbolic link directories since those arent included in recursive watch
                 // which is same behaviour when recursive: true is passed to fs.watch
@@ -6527,10 +6527,10 @@ var ts;
         return function (_fileName, eventKind) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", ""); };
     }
     ts.createFileWatcherCallback = createFileWatcherCallback;
-    function createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists) {
+    function createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileSystemEntryExists) {
         return function (eventName) {
             if (eventName === "rename") {
-                callback(fileName, fileExists(fileName) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);
+                callback(fileName, fileSystemEntryExists(fileName, 0 /* File */) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);
             }
             else {
                 // Change
@@ -6558,11 +6558,12 @@ var ts;
     }
     /*@internal*/
     function createSystemWatchFunctions(_a) {
-        var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatch = _a.fsWatch, fileExists = _a.fileExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, directoryExists = _a.directoryExists, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory, defaultWatchFileKind = _a.defaultWatchFileKind;
+        var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatchWorker = _a.fsWatchWorker, fileSystemEntryExists = _a.fileSystemEntryExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory, defaultWatchFileKind = _a.defaultWatchFileKind, inodeWatching = _a.inodeWatching, sysLog = _a.sysLog;
         var dynamicPollingWatchFile;
         var fixedChunkSizePollingWatchFile;
         var nonPollingWatchFile;
         var hostRecursiveDirectoryWatcher;
+        var hitSystemWatcherLimit = false;
         return {
             watchFile: watchFile,
             watchDirectory: watchDirectory
@@ -6580,7 +6581,7 @@ var ts;
                 case ts.WatchFileKind.FixedChunkSizePolling:
                     return ensureFixedChunkSizePollingWatchFile()(fileName, callback, /* pollingInterval */ undefined, /*options*/ undefined);
                 case ts.WatchFileKind.UseFsEvents:
-                    return fsWatch(fileName, 0 /* File */, createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists), 
+                    return fsWatch(fileName, 0 /* File */, createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileSystemEntryExists), 
                     /*recursive*/ false, pollingInterval, ts.getFallbackOptions(options));
                 case ts.WatchFileKind.UseFsEventsOnParentDirectory:
                     if (!nonPollingWatchFile) {
@@ -6641,7 +6642,7 @@ var ts;
                 hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({
                     useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                     getCurrentDirectory: getCurrentDirectory,
-                    directoryExists: directoryExists,
+                    fileSystemEntryExists: fileSystemEntryExists,
                     getAccessibleSortedChildDirectories: getAccessibleSortedChildDirectories,
                     watchDirectory: nonRecursiveWatchDirectory,
                     realpath: realpath,
@@ -6692,6 +6693,114 @@ var ts;
                     };
             }
         }
+        function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
+            var lastDirectoryPartWithDirectorySeparator;
+            var lastDirectoryPart;
+            if (inodeWatching) {
+                lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substring(fileOrDirectory.lastIndexOf(ts.directorySeparator));
+                lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(ts.directorySeparator.length);
+            }
+            /** Watcher for the file system entry depending on whether it is missing or present */
+            var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ?
+                watchMissingFileSystemEntry() :
+                watchPresentFileSystemEntry();
+            return {
+                close: function () {
+                    // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
+                    watcher.close();
+                    watcher = undefined;
+                }
+            };
+            function updateWatcher(createWatcher) {
+                // If watcher is not closed, update it
+                if (watcher) {
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher");
+                    watcher.close();
+                    watcher = createWatcher();
+                }
+            }
+            /**
+             * Watch the file or directory that is currently present
+             * and when the watched file or directory is deleted, switch to missing file system entry watcher
+             */
+            function watchPresentFileSystemEntry() {
+                if (hitSystemWatcherLimit) {
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Defaulting to watchFile");
+                    return watchPresentFileSystemEntryWithFsWatchFile();
+                }
+                try {
+                    var presentWatcher = fsWatchWorker(fileOrDirectory, recursive, inodeWatching ?
+                        callbackChangingToMissingFileSystemEntry :
+                        function (eventName, relativeFileName) {
+                            sysLog("sysLog:: watchPresentFileSystemEntry:: " + fileOrDirectory + " " + entryKind + " " + eventName + ":: " + relativeFileName);
+                            callback(eventName, relativeFileName);
+                        });
+                    // Watch the missing file or directory or error
+                    presentWatcher.on("error", function () {
+                        sysLog("sysLog:: watchPresentFileSystemEntry:: on Error " + fileOrDirectory + " " + entryKind + " rename, \"\"");
+                        callback("rename", "");
+                        updateWatcher(watchMissingFileSystemEntry);
+                    });
+                    return presentWatcher;
+                }
+                catch (e) {
+                    // Catch the exception and use polling instead
+                    // Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
+                    // so instead of throwing error, use fs.watchFile
+                    hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing to watchFile");
+                    return watchPresentFileSystemEntryWithFsWatchFile();
+                }
+            }
+            function callbackChangingToMissingFileSystemEntry(event, relativeName) {
+                sysLog("sysLog:: callbackChangingToMissingFileSystemEntry:: " + fileOrDirectory + " " + entryKind + " " + event + ":: " + relativeName + " " + inodeWatching + " " + lastDirectoryPart + " " + lastDirectoryPartWithDirectorySeparator);
+                if (relativeName && ts.endsWith(relativeName, "~")) {
+                    relativeName = relativeName.slice(0, relativeName.length - 1);
+                    sysLog("sysLog:: callbackChangingToMissingFileSystemEntry:: changed the relative name to " + relativeName);
+                }
+                callback(event, relativeName);
+                // because relativeName is not guaranteed to be correct we need to check on each rename with few combinations
+                // Eg on ubuntu while watching app/node_modules the relativeName is "node_modules" which is neither relative nor full path
+                if (event === "rename" &&
+                    (!relativeName ||
+                        relativeName === lastDirectoryPart ||
+                        ts.endsWith(relativeName, lastDirectoryPartWithDirectorySeparator))) {
+                    if (inodeWatching) {
+                        updateWatcher(!fileSystemEntryExists(fileOrDirectory, entryKind) ? watchMissingFileSystemEntry : watchPresentFileSystemEntry);
+                    }
+                    else if (!fileSystemEntryExists(fileOrDirectory, entryKind)) {
+                        updateWatcher(watchMissingFileSystemEntry);
+                    }
+                }
+            }
+            /**
+             * Watch the file or directory using fs.watchFile since fs.watch threw exception
+             * Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
+             */
+            function watchPresentFileSystemEntryWithFsWatchFile() {
+                return watchFile(fileOrDirectory, createFileWatcherCallback(function (eventName, relativeFileName) {
+                    sysLog("sysLog:: watchPresentFileSystemEntryWithFsWatchFile:: " + fileOrDirectory + " " + entryKind + " " + eventName + ":: " + relativeFileName);
+                    callback(eventName, relativeFileName);
+                }), fallbackPollingInterval, fallbackOptions);
+            }
+            /**
+             * Watch the file or directory that is missing
+             * and switch to existing file or directory when the missing filesystem entry is created
+             */
+            function watchMissingFileSystemEntry() {
+                return watchFile(fileOrDirectory, function (_fileName, eventKind) {
+                    sysLog("sysLog:: watchMissingFileSystemEntry:: " + fileOrDirectory + " " + entryKind + " " + _fileName + ":: " + eventKind);
+                    if (eventKind === FileWatcherEventKind.Created && fileSystemEntryExists(fileOrDirectory, entryKind)) {
+                        sysLog("sysLog:: watchMissingFileSystemEntry::  Callback :: rename, \"\" and will update the watcher");
+                        callback("rename", "");
+                        // Call the callback for current file or directory
+                        // For now it could be callback for the inner directory creation,
+                        // but just return current directory, better than current no-op
+                        updateWatcher(watchPresentFileSystemEntry);
+                    }
+                }, fallbackPollingInterval, fallbackOptions);
+            }
+        }
     }
     ts.createSystemWatchFunctions = createSystemWatchFunctions;
     /**
@@ -6744,7 +6853,6 @@ var ts;
             }
             var activeSession;
             var profilePath = "./profile.cpuprofile";
-            var hitSystemWatcherLimit = false;
             var Buffer = require("buffer").Buffer;
             var nodeVersion = getNodeMajorVersion();
             var isNode4OrLater = nodeVersion >= 4;
@@ -6759,20 +6867,21 @@ var ts;
                 getModifiedTime: getModifiedTime,
                 setTimeout: setTimeout,
                 clearTimeout: clearTimeout,
-                fsWatch: fsWatch,
+                fsWatchWorker: fsWatchWorker,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                 getCurrentDirectory: getCurrentDirectory,
-                fileExists: fileExists,
+                fileSystemEntryExists: fileSystemEntryExists,
                 // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
                 // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
                 fsSupportsRecursiveFsWatch: fsSupportsRecursiveFsWatch,
-                directoryExists: directoryExists,
                 getAccessibleSortedChildDirectories: function (path) { return getAccessibleFileSystemEntries(path).directories; },
                 realpath: realpath,
                 tscWatchFile: process.env.TSC_WATCHFILE,
                 useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER,
                 tscWatchDirectory: process.env.TSC_WATCHDIRECTORY,
                 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;
             var nodeSystem = {
                 args: process.argv.slice(2),
@@ -7025,107 +7134,11 @@ var ts;
                     callback(fileName, eventKind);
                 }
             }
-            function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
-                var options;
-                var lastDirectoryPartWithDirectorySeparator;
-                var lastDirectoryPart;
-                if (isLinuxOrMacOs) {
-                    lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substr(fileOrDirectory.lastIndexOf(ts.directorySeparator));
-                    lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(ts.directorySeparator.length);
-                }
-                /** Watcher for the file system entry depending on whether it is missing or present */
-                var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ?
-                    watchMissingFileSystemEntry() :
-                    watchPresentFileSystemEntry();
-                return {
-                    close: function () {
-                        // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                        watcher.close();
-                        watcher = undefined;
-                    }
-                };
-                /**
-                 * Invoke the callback with rename and update the watcher if not closed
-                 * @param createWatcher
-                 */
-                function invokeCallbackAndUpdateWatcher(createWatcher) {
-                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher");
-                    // Call the callback for current directory
-                    callback("rename", "");
-                    // If watcher is not closed, update it
-                    if (watcher) {
-                        watcher.close();
-                        watcher = createWatcher();
-                    }
-                }
-                /**
-                 * Watch the file or directory that is currently present
-                 * and when the watched file or directory is deleted, switch to missing file system entry watcher
-                 */
-                function watchPresentFileSystemEntry() {
-                    // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
-                    // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
-                    if (options === undefined) {
-                        if (fsSupportsRecursiveFsWatch) {
-                            options = { persistent: true, recursive: !!recursive };
-                        }
-                        else {
-                            options = { persistent: true };
-                        }
-                    }
-                    if (hitSystemWatcherLimit) {
-                        sysLog("sysLog:: " + fileOrDirectory + ":: Defaulting to fsWatchFile");
-                        return watchPresentFileSystemEntryWithFsWatchFile();
-                    }
-                    try {
-                        var presentWatcher = _fs.watch(fileOrDirectory, options, isLinuxOrMacOs ?
-                            callbackChangingToMissingFileSystemEntry :
-                            callback);
-                        // Watch the missing file or directory or error
-                        presentWatcher.on("error", function () { return invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry); });
-                        return presentWatcher;
-                    }
-                    catch (e) {
-                        // Catch the exception and use polling instead
-                        // Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
-                        // so instead of throwing error, use fs.watchFile
-                        hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
-                        sysLog("sysLog:: " + fileOrDirectory + ":: Changing to fsWatchFile");
-                        return watchPresentFileSystemEntryWithFsWatchFile();
-                    }
-                }
-                function callbackChangingToMissingFileSystemEntry(event, relativeName) {
-                    // because relativeName is not guaranteed to be correct we need to check on each rename with few combinations
-                    // Eg on ubuntu while watching app/node_modules the relativeName is "node_modules" which is neither relative nor full path
-                    return event === "rename" &&
-                        (!relativeName ||
-                            relativeName === lastDirectoryPart ||
-                            (relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) !== -1 && relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) === relativeName.length - lastDirectoryPartWithDirectorySeparator.length)) &&
-                        !fileSystemEntryExists(fileOrDirectory, entryKind) ?
-                        invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry) :
-                        callback(event, relativeName);
-                }
-                /**
-                 * Watch the file or directory using fs.watchFile since fs.watch threw exception
-                 * Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
-                 */
-                function watchPresentFileSystemEntryWithFsWatchFile() {
-                    return watchFile(fileOrDirectory, createFileWatcherCallback(callback), fallbackPollingInterval, fallbackOptions);
-                }
-                /**
-                 * Watch the file or directory that is missing
-                 * and switch to existing file or directory when the missing filesystem entry is created
-                 */
-                function watchMissingFileSystemEntry() {
-                    return watchFile(fileOrDirectory, function (_fileName, eventKind) {
-                        if (eventKind === FileWatcherEventKind.Created && fileSystemEntryExists(fileOrDirectory, entryKind)) {
-                            // Call the callback for current file or directory
-                            // For now it could be callback for the inner directory creation,
-                            // but just return current directory, better than current no-op
-                            invokeCallbackAndUpdateWatcher(watchPresentFileSystemEntry);
-                        }
-                    }, fallbackPollingInterval, fallbackOptions);
-                }
+            function fsWatchWorker(fileOrDirectory, recursive, callback) {
+                // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
+                // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
+                return _fs.watch(fileOrDirectory, fsSupportsRecursiveFsWatch ?
+                    { persistent: true, recursive: !!recursive } : { persistent: true }, callback);
             }
             function readFileWorker(fileName, _encoding) {
                 var buffer;
@@ -42032,7 +42045,7 @@ var ts;
         }
         if (ts.isImplicitGlob(spec.substring(spec.lastIndexOf(ts.directorySeparator) + 1))) {
             return {
-                key: useCaseSensitiveFileNames ? spec : ts.toFileNameLowerCase(spec),
+                key: ts.removeTrailingDirectorySeparator(useCaseSensitiveFileNames ? spec : ts.toFileNameLowerCase(spec)),
                 flags: 1 /* Recursive */
             };
         }
@@ -78422,11 +78435,6 @@ var ts;
                 ts.every(source.types, function (subType) { return allTypesAssignableToKind(subType, kind, strict); }) :
                 isTypeAssignableToKind(source, kind, strict);
         }
-        function anyTypesAssignableToKind(source, kind, strict) {
-            return source.flags & 1048576 /* Union */ ?
-                ts.some(source.types, function (subType) { return allTypesAssignableToKind(subType, kind, strict); }) :
-                isTypeAssignableToKind(source, kind, strict);
-        }
         function isConstEnumObjectType(type) {
             return !!(ts.getObjectFlags(type) & 16 /* Anonymous */) && !!type.symbol && isConstEnumSymbol(type.symbol);
         }
@@ -82807,9 +82815,7 @@ var ts;
             }
             // unknownType is returned i.e. if node.expression is identifier whose name cannot be resolved
             // in this case error about missing name is already reported - do not report extra one
-            // TypeFlags.Nullable must be explicitly checked for in rightType for this check for non-strict modes, where
-            // `getNonNullableTypeIfNeeded` is a noop (and the nullable types as any-ish).
-            if (!isTypeAny(rightType) && !(rightType.flags & 98304 /* Nullable */) && anyTypesAssignableToKind(getBaseConstraintOrType(rightType), (131068 /* Primitive */ | 131072 /* Never */) & ~98304 /* Nullable */)) {
+            if (rightType === neverType || !isTypeAssignableToKind(rightType, 67108864 /* NonPrimitive */ | 58982400 /* InstantiableNonPrimitive */)) {
                 error(node.expression, ts.Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0, typeToString(rightType));
             }
             checkSourceElement(node.statement);
@@ -123643,6 +123649,7 @@ var ts;
         }
         function reloadFileNamesFromConfigFile() {
             writeLog("Reloading new file names and options");
+            reloadLevel = ts.ConfigFileProgramReloadLevel.None;
             rootFileNames = ts.getFileNamesFromConfigSpecs(compilerOptions.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions);
             if (ts.updateErrorForNoInputFiles(rootFileNames, ts.getNormalizedAbsolutePath(configFileName, currentDirectory), compilerOptions.configFile.configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) {
                 hasChangedConfigFileParsingErrors = true;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "4.8.0-pr-49245-7",
+  "version": "4.8.0-pr-48997-21",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [