Merge branch 'master' into update-dom-042019

Author: sandersn

scripts/open-user-pr.ts

@@ -18,9 +18,9 @@ function padNum(number: number) {
 }
 
 const userName = process.env.GH_USERNAME;
-const reviewers = ["weswigham", "sandersn", "RyanCavanaugh"]
+const reviewers = process.env.requesting_user ? [process.env.requesting_user] : ["weswigham", "sandersn", "RyanCavanaugh"];
 const now = new Date();
-const branchName = `user-update-${now.getFullYear()}${padNum(now.getMonth())}${padNum(now.getDay())}`;
+const branchName = `user-update-${process.env.TARGET_FORK}-${now.getFullYear()}${padNum(now.getMonth())}${padNum(now.getDay())}${process.env.TARGET_BRANCH ? "-" + process.env.TARGET_BRANCH : ""}`;
 const remoteUrl = `https://${process.argv[2]}@github.com/${userName}/TypeScript.git`;
 runSequence([
     ["git", ["checkout", "."]], // reset any changes
@@ -41,23 +41,33 @@ gh.pulls.create({
     owner: process.env.TARGET_FORK,
     repo: "TypeScript",
     maintainer_can_modify: true,
-    title: `🤖 User test baselines have changed`,
+    title: `🤖 User test baselines have changed` + (process.env.TARGET_BRANCH ? ` for ${process.env.TARGET_BRANCH}` : ""),
     head: `${userName}:${branchName}`,
-    base: "master",
+    base: process.env.TARGET_BRANCH || "master",
     body:
-`Please review the diff and merge if no changes are unexpected.
+`${process.env.source_issue ? `This test run was triggerd by a request on https://github.com/Microsoft/TypeScript/pull/${process.env.source_issue} `+"\n" : ""}Please review the diff and merge if no changes are unexpected.
 You can view the build log [here](https://typescript.visualstudio.com/TypeScript/_build/index?buildId=${process.env.BUILD_BUILDID}&_a=summary).
 
 cc ${reviewers.map(r => "@" + r).join(" ")}`,
-}).then(r => {
+}).then(async r => {
     const num = r.data.number;
     console.log(`Pull request ${num} created.`);
-    return gh.pulls.createReviewRequest({
-        owner: process.env.TARGET_FORK,
-        repo: "TypeScript",
-        number: num,
-        reviewers,
-    });
+    if (!process.env.source_issue) {
+        await gh.pulls.createReviewRequest({
+            owner: process.env.TARGET_FORK,
+            repo: "TypeScript",
+            number: num,
+            reviewers,
+        });
+    }
+    else {
+        await gh.issues.createComment({
+            number: +process.env.source_issue,
+            owner: "Microsoft",
+            repo: "TypeScript",
+            body: `The user suite test run you requested has finished and _failed_. I've opened a [PR with the baseline diff from master](${r.data.html_url}).`
+        });
+    }
 }).then(() => {
     console.log(`Reviewers requested, done.`);
 }).catch(e => {

src/compiler/checker.ts

@@ -1134,7 +1134,7 @@ namespace ts {
             function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName: string): boolean {
                 const resolutionToFile = getResolvedModule(oldSourceFile!, moduleName);
                 const resolvedFile = resolutionToFile && oldProgram!.getSourceFile(resolutionToFile.resolvedFileName);
-                if (resolutionToFile && resolvedFile && !resolvedFile.externalModuleIndicator) {
+                if (resolutionToFile && resolvedFile) {
                     // In the old program, we resolved to an ambient module that was in the same
                     //   place as we expected to find an actual module file.
                     // We actually need to return 'false' here even though this seems like a 'true' case

src/compiler/program.ts

@@ -4507,6 +4507,7 @@ namespace FourSlashInterface {
             typeEntry("Record"),
             typeEntry("Exclude"),
             typeEntry("Extract"),
+            typeEntry("Omit"),
             typeEntry("NonNullable"),
             typeEntry("Parameters"),
             typeEntry("ConstructorParameters"),

src/harness/fourslash.ts

@@ -1443,6 +1443,11 @@ type Exclude<T, U> = T extends U ? never : T;
  */
 type Extract<T, U> = T extends U ? T : never;
 
+/**
+ * Construct a type with the properties of T except for those in type K.
+ */
+type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
+
 /**
  * Exclude null and undefined from T
  */

src/lib/es5.d.ts

@@ -958,6 +958,9 @@ namespace ts.server {
             );
             const elapsed = timestamp() - start;
             this.writeLog(`Finishing updateGraphWorker: Project: ${this.getProjectName()} Version: ${this.getProjectVersion()} structureChanged: ${hasNewProgram} Elapsed: ${elapsed}ms`);
+            if (this.program !== oldProgram) {
+                this.print();
+            }
             return hasNewProgram;
         }
 

src/server/project.ts

@@ -10,6 +10,7 @@ interface ExecResult {
 
 interface UserConfig {
     types: string[];
+    path?: string;
 }
 
 abstract class ExternalCompileRunnerBase extends RunnerBase {
@@ -57,7 +58,7 @@ abstract class ExternalCompileRunnerBase extends RunnerBase {
                     ts.Debug.assert(!!config.types, "Bad format from test.json: Types field must be present.");
                     types = config.types;
 
-                    cwd = submoduleDir;
+                    cwd = config.path ? path.join(cwd, config.path) : submoduleDir;
                 }
                 if (fs.existsSync(path.join(cwd, "package.json"))) {
                     if (fs.existsSync(path.join(cwd, "package-lock.json"))) {

src/testRunner/externalCompileRunner.ts

@@ -445,5 +445,13 @@ var x = 0;`, {
                 }
             }
         });
+
+        transpilesCorrectly("Supports readonly keyword for arrays", "let x: readonly string[];", {
+            options: { compilerOptions: { module: ModuleKind.CommonJS } }
+        });
+
+        transpilesCorrectly("Supports 'as const' arrays", `([] as const).forEach(k => console.log(k));`, {
+            options: { compilerOptions: { module: ModuleKind.CommonJS } }
+        });
     });
 }

src/testRunner/unittests/services/transpile.ts

@@ -479,6 +479,90 @@ namespace ts.projectSystem {
                 session.clearMessages();
             }
         });
+
+        it("Correct errors when resolution resolves to file that has same ambient module and is also module", () => {
+            const projectRootPath = "/users/username/projects/myproject";
+            const aFile: File = {
+                path: `${projectRootPath}/src/a.ts`,
+                content: `import * as myModule from "@custom/plugin";
+function foo() {
+  // hello
+}`
+            };
+            const config: File = {
+                path: `${projectRootPath}/tsconfig.json`,
+                content: JSON.stringify({ include: ["src"] })
+            };
+            const plugin: File = {
+                path: `${projectRootPath}/node_modules/@custom/plugin/index.d.ts`,
+                content: `import './proposed';
+declare module '@custom/plugin' {
+    export const version: string;
+}`
+            };
+            const pluginProposed: File = {
+                path: `${projectRootPath}/node_modules/@custom/plugin/proposed.d.ts`,
+                content: `declare module '@custom/plugin' {
+    export const bar = 10;
+}`
+            };
+            const files = [libFile, aFile, config, plugin, pluginProposed];
+            const host = createServerHost(files);
+            const session = createSession(host, { canUseEvents: true });
+            const service = session.getProjectService();
+            openFilesForSession([aFile], session);
+
+            checkNumberOfProjects(service, { configuredProjects: 1 });
+            session.clearMessages();
+            checkErrors();
+
+            session.executeCommandSeq<protocol.ChangeRequest>({
+                command: protocol.CommandTypes.Change,
+                arguments: {
+                    file: aFile.path,
+                    line: 3,
+                    offset: 8,
+                    endLine: 3,
+                    endOffset: 8,
+                    insertString: "o"
+                }
+            });
+            checkErrors();
+
+            function checkErrors() {
+                host.checkTimeoutQueueLength(0);
+                const expectedSequenceId = session.getNextSeq();
+                session.executeCommandSeq<protocol.GeterrRequest>({
+                    command: server.CommandNames.Geterr,
+                    arguments: {
+                        delay: 0,
+                        files: [aFile.path],
+                    }
+                });
+
+                host.checkTimeoutQueueLengthAndRun(1);
+
+                checkErrorMessage(session, "syntaxDiag", { file: aFile.path, diagnostics: [] }, /*isMostRecent*/ true);
+                session.clearMessages();
+
+                host.runQueuedImmediateCallbacks(1);
+
+                checkErrorMessage(session, "semanticDiag", { file: aFile.path, diagnostics: [] });
+                session.clearMessages();
+
+                host.runQueuedImmediateCallbacks(1);
+
+                checkErrorMessage(session, "suggestionDiag", {
+                    file: aFile.path,
+                    diagnostics: [
+                        createDiagnostic({ line: 1, offset: 1 }, { line: 1, offset: 44 }, Diagnostics._0_is_declared_but_its_value_is_never_read, ["myModule"], "suggestion", /*reportsUnnecessary*/ true),
+                        createDiagnostic({ line: 2, offset: 10 }, { line: 2, offset: 13 }, Diagnostics._0_is_declared_but_its_value_is_never_read, ["foo"], "suggestion", /*reportsUnnecessary*/ true)
+                    ],
+                });
+                checkCompleteEvent(session, 2, expectedSequenceId);
+                session.clearMessages();
+            }
+        });
     });
 
     describe("unittests:: tsserver:: Project Errors for Configure file diagnostics events", () => {

src/testRunner/unittests/tsserver/projectErrors.ts

@@ -136,24 +136,24 @@ class C2<T, U> {
     }
 }
 var r6 = (new C2()).f<number>(1, '');
->r6 : {}
->(new C2()).f<number>(1, '') : {}
->(new C2()).f : (x: {}, y: {}) => {}
->(new C2()) : C2<{}, {}>
->new C2() : C2<{}, {}>
+>r6 : unknown
+>(new C2()).f<number>(1, '') : unknown
+>(new C2()).f : (x: unknown, y: unknown) => unknown
+>(new C2()) : C2<unknown, unknown>
+>new C2() : C2<unknown, unknown>
 >C2 : typeof C2
->f : (x: {}, y: {}) => {}
+>f : (x: unknown, y: unknown) => unknown
 >1 : 1
 >'' : ""
 
 var r6b = (new C2()).f<number, string, number>(1, '');
->r6b : {}
->(new C2()).f<number, string, number>(1, '') : {}
->(new C2()).f : (x: {}, y: {}) => {}
->(new C2()) : C2<{}, {}>
->new C2() : C2<{}, {}>
+>r6b : unknown
+>(new C2()).f<number, string, number>(1, '') : unknown
+>(new C2()).f : (x: unknown, y: unknown) => unknown
+>(new C2()) : C2<unknown, unknown>
+>new C2() : C2<unknown, unknown>
 >C2 : typeof C2
->f : (x: {}, y: {}) => {}
+>f : (x: unknown, y: unknown) => unknown
 >1 : 1
 >'' : ""
 

tests/baselines/reference/callGenericFunctionWithIncorrectNumberOfTypeArguments.types

@@ -83,13 +83,13 @@ class C2<T> {
     }
 }
 var r6 = (new C2()).f(1);
->r6 : {}
->(new C2()).f(1) : {}
->(new C2()).f : (x: {}) => {}
->(new C2()) : C2<{}>
->new C2() : C2<{}>
+>r6 : unknown
+>(new C2()).f(1) : unknown
+>(new C2()).f : (x: unknown) => unknown
+>(new C2()) : C2<unknown>
+>new C2() : C2<unknown>
 >C2 : typeof C2
->f : (x: {}) => {}
+>f : (x: unknown) => unknown
 >1 : 1
 
 interface I2<T> {