Merge branch 'master' of https://github.com/Microsoft/TypeScript into feature/eslint

Author: a-tarasyuk

src/compiler/checker.ts

@@ -10891,7 +10891,11 @@ namespace ts {
         }
 
         function getAliasSymbolForTypeNode(node: TypeNode) {
-            return isTypeAlias(node.parent) ? getSymbolOfNode(node.parent) : undefined;
+            let host = node.parent;
+            while (isParenthesizedTypeNode(host)) {
+                host = host.parent;
+            }
+            return isTypeAlias(host) ? getSymbolOfNode(host) : undefined;
         }
 
         function getTypeArgumentsForAliasSymbol(symbol: Symbol | undefined) {

src/compiler/diagnosticMessages.json

@@ -5116,6 +5116,10 @@
         "category": "Message",
         "code": 95088
     },
+    "Add 'await' to initializers": {
+        "category": "Message",
+        "code": 95089
+    },
 
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",

src/compiler/resolutionCache.ts

@@ -90,22 +90,36 @@ namespace ts {
             return false;
         }
 
-        const nextDirectorySeparator = dirPath.indexOf(directorySeparator, rootLength);
+        let nextDirectorySeparator = dirPath.indexOf(directorySeparator, rootLength);
         if (nextDirectorySeparator === -1) {
             // ignore "/user", "c:/users" or "c:/folderAtRoot"
             return false;
         }
 
-        if (dirPath.charCodeAt(0) !== CharacterCodes.slash &&
-            dirPath.substr(rootLength, nextDirectorySeparator).search(/users/i) === -1) {
+        let pathPartForUserCheck = dirPath.substring(rootLength, nextDirectorySeparator + 1);
+        const isNonDirectorySeparatorRoot = rootLength > 1 || dirPath.charCodeAt(0) !== CharacterCodes.slash;
+        if (isNonDirectorySeparatorRoot &&
+            dirPath.search(/[a-zA-Z]:/) !== 0 && // Non dos style paths
+            pathPartForUserCheck.search(/[a-zA-z]\$\//) === 0) { // Dos style nextPart
+            nextDirectorySeparator = dirPath.indexOf(directorySeparator, nextDirectorySeparator + 1);
+            if (nextDirectorySeparator === -1) {
+                // ignore "//vda1cs4850/c$/folderAtRoot"
+                return false;
+            }
+
+            pathPartForUserCheck = dirPath.substring(rootLength + pathPartForUserCheck.length, nextDirectorySeparator + 1);
+        }
+
+        if (isNonDirectorySeparatorRoot &&
+            pathPartForUserCheck.search(/users\//i) !== 0) {
             // Paths like c:/folderAtRoot/subFolder are allowed
             return true;
         }
 
         for (let searchIndex = nextDirectorySeparator + 1, searchLevels = 2; searchLevels > 0; searchLevels--) {
             searchIndex = dirPath.indexOf(directorySeparator, searchIndex) + 1;
             if (searchIndex === 0) {
-                // Folder isnt at expected minimun levels
+                // Folder isnt at expected minimum levels
                 return false;
             }
         }

src/compiler/scanner.ts

@@ -2183,7 +2183,7 @@ namespace ts {
 
             if (isIdentifierStart(ch, languageVersion)) {
                 let char = ch;
-                while (pos < end && isIdentifierPart(char = codePointAt(text, pos), languageVersion)) pos += charSize(char);
+                while (pos < end && isIdentifierPart(char = codePointAt(text, pos), languageVersion) || text.charCodeAt(pos) === CharacterCodes.minus) pos += charSize(char);
                 tokenValue = text.substring(tokenPos, pos);
                 if (char === CharacterCodes.backslash) {
                     tokenValue += scanIdentifierParts();

src/harness/virtualFileSystemWithWatch.ts

@@ -35,38 +35,16 @@ interface Array<T> { length: number; [n: number]: T; }`
         executingFilePath?: string;
         currentDirectory?: string;
         newLine?: string;
-        useWindowsStylePaths?: boolean;
+        windowsStyleRoot?: string;
         environmentVariables?: Map<string>;
     }
 
     export function createWatchedSystem(fileOrFolderList: readonly FileOrFolderOrSymLink[], params?: TestServerHostCreationParameters): TestServerHost {
-        if (!params) {
-            params = {};
-        }
-        const host = new TestServerHost(/*withSafelist*/ false,
-            params.useCaseSensitiveFileNames !== undefined ? params.useCaseSensitiveFileNames : false,
-            params.executingFilePath || getExecutingFilePathFromLibFile(),
-            params.currentDirectory || "/",
-            fileOrFolderList,
-            params.newLine,
-            params.useWindowsStylePaths,
-            params.environmentVariables);
-        return host;
+        return new TestServerHost(/*withSafelist*/ false, fileOrFolderList, params);
     }
 
     export function createServerHost(fileOrFolderList: readonly FileOrFolderOrSymLink[], params?: TestServerHostCreationParameters): TestServerHost {
-        if (!params) {
-            params = {};
-        }
-        const host = new TestServerHost(/*withSafelist*/ true,
-            params.useCaseSensitiveFileNames !== undefined ? params.useCaseSensitiveFileNames : false,
-            params.executingFilePath || getExecutingFilePathFromLibFile(),
-            params.currentDirectory || "/",
-            fileOrFolderList,
-            params.newLine,
-            params.useWindowsStylePaths,
-            params.environmentVariables);
-        return host;
+        return new TestServerHost(/*withSafelist*/ true, fileOrFolderList, params);
     }
 
     export interface File {
@@ -326,6 +304,16 @@ interface Array<T> { length: number; [n: number]: T; }`
     }
 
     const timeIncrements = 1000;
+    export interface TestServerHostOptions {
+        useCaseSensitiveFileNames: boolean;
+        executingFilePath: string;
+        currentDirectory: string;
+        fileOrFolderorSymLinkList: readonly FileOrFolderOrSymLink[];
+        newLine?: string;
+        useWindowsStylePaths?: boolean;
+        environmentVariables?: Map<string>;
+    }
+
     export class TestServerHost implements server.ServerHost, FormatDiagnosticsHost, ModuleResolutionHost {
         args: string[] = [];
 
@@ -342,16 +330,31 @@ interface Array<T> { length: number; [n: number]: T; }`
         readonly watchedDirectories = createMultiMap<TestDirectoryWatcher>();
         readonly watchedDirectoriesRecursive = createMultiMap<TestDirectoryWatcher>();
         readonly watchedFiles = createMultiMap<TestFileWatcher>();
+        public readonly useCaseSensitiveFileNames: boolean;
+        public readonly newLine: string;
+        public readonly windowsStyleRoot?: string;
+        private readonly environmentVariables?: Map<string>;
         private readonly executingFilePath: string;
         private readonly currentDirectory: string;
         private readonly customWatchFile: HostWatchFile | undefined;
         private readonly customRecursiveWatchDirectory: HostWatchDirectory | undefined;
         public require: ((initialPath: string, moduleName: string) => server.RequireResult) | undefined;
 
-        constructor(public withSafeList: boolean, public useCaseSensitiveFileNames: boolean, executingFilePath: string, currentDirectory: string, fileOrFolderorSymLinkList: readonly FileOrFolderOrSymLink[], public readonly newLine = "\n", public readonly useWindowsStylePath?: boolean, private readonly environmentVariables?: Map<string>) {
-            this.getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
+        constructor(
+            public withSafeList: boolean,
+            fileOrFolderorSymLinkList: readonly FileOrFolderOrSymLink[],
+            {
+                useCaseSensitiveFileNames, executingFilePath, currentDirectory,
+                newLine, windowsStyleRoot, environmentVariables
+            }: TestServerHostCreationParameters = {}) {
+            this.useCaseSensitiveFileNames = !!useCaseSensitiveFileNames;
+            this.newLine = newLine || "\n";
+            this.windowsStyleRoot = windowsStyleRoot;
+            this.environmentVariables = environmentVariables;
+            currentDirectory = currentDirectory || "/";
+            this.getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
             this.toPath = s => toPath(s, currentDirectory, this.getCanonicalFileName);
-            this.executingFilePath = this.getHostSpecificPath(executingFilePath);
+            this.executingFilePath = this.getHostSpecificPath(executingFilePath || getExecutingFilePathFromLibFile());
             this.currentDirectory = this.getHostSpecificPath(currentDirectory);
             this.reloadFS(fileOrFolderorSymLinkList);
             const tscWatchFile = this.environmentVariables && this.environmentVariables.get("TSC_WATCHFILE") as Tsc_WatchFile;
@@ -418,8 +421,8 @@ interface Array<T> { length: number; [n: number]: T; }`
         }
 
         getHostSpecificPath(s: string) {
-            if (this.useWindowsStylePath && s.startsWith(directorySeparator)) {
-                return "c:/" + s.substring(1);
+            if (this.windowsStyleRoot && s.startsWith(directorySeparator)) {
+                return this.windowsStyleRoot + s.substring(1);
             }
             return s;
         }
@@ -433,7 +436,7 @@ interface Array<T> { length: number; [n: number]: T; }`
             const mapNewLeaves = createMap<true>();
             const isNewFs = this.fs.size === 0;
             fileOrFolderOrSymLinkList = fileOrFolderOrSymLinkList.concat(this.withSafeList ? safeList : []);
-            const filesOrFoldersToLoad: readonly FileOrFolderOrSymLink[] = !this.useWindowsStylePath ? fileOrFolderOrSymLinkList :
+            const filesOrFoldersToLoad: readonly FileOrFolderOrSymLink[] = !this.windowsStyleRoot ? fileOrFolderOrSymLinkList :
                 fileOrFolderOrSymLinkList.map<FileOrFolderOrSymLink>(f => {
                     const result = clone(f);
                     result.path = this.getHostSpecificPath(f.path);