Merge branch 'master' into report-multiple-overload-errors

src/compiler/checker.ts

@@ -13398,7 +13398,14 @@ namespace ts {
                         }
                     }
                     else if (isReadonlyArrayType(target) ? isArrayType(source) || isTupleType(source) : isArrayType(target) && isTupleType(source) && !source.target.readonly) {
-                        return isRelatedTo(getIndexTypeOfType(source, IndexKind.Number) || anyType, getIndexTypeOfType(target, IndexKind.Number) || anyType, reportErrors);
+                        if (relation !== identityRelation) {
+                            return isRelatedTo(getIndexTypeOfType(source, IndexKind.Number) || anyType, getIndexTypeOfType(target, IndexKind.Number) || anyType, reportErrors);
+                        }
+                        else {
+                            // By flags alone, we know that the `target` is a readonly array while the source is a normal array or tuple
+                            // or `target` is an array and source is a tuple - in both cases the types cannot be identical, by construction
+                            return Ternary.False;
+                        }
                     }
                     // Consider a fresh empty object literal type "closed" under the subtype relationship - this way `{} <- {[idx: string]: any} <- fresh({})`
                     // and not `{} <- fresh({}) <- {[idx: string]: any}`

src/testRunner/parallel/host.ts

@@ -14,7 +14,7 @@ namespace Harness.Parallel.Host {
         const isatty = tty.isatty(1) && tty.isatty(2);
         const path = require("path") as typeof import("path");
         const { fork } = require("child_process") as typeof import("child_process");
-        const { statSync } = require("fs") as typeof import("fs");
+        const { statSync, readFileSync } = require("fs") as typeof import("fs");
 
         // NOTE: paths for module and types for FailedTestReporter _do not_ line up due to our use of --outFile for run.js
         // tslint:disable-next-line:variable-name
@@ -192,6 +192,31 @@ namespace Harness.Parallel.Host {
             return `tsrunner-${runner}://${test}`;
         }
 
+        function skipCostlyTests(tasks: Task[]) {
+            if (statSync("tests/.test-cost.json")) {
+                const costs = JSON.parse(readFileSync("tests/.test-cost.json", "utf8")) as {
+                    totalTime: number,
+                    totalEdits: number,
+                    data: { name: string, time: number, edits: number, costs: number }[]
+                };
+                let skippedEdits = 0;
+                let skippedTime = 0;
+                const skippedTests = new Set<string>();
+                let i = 0;
+                for (; i < costs.data.length && (skippedEdits / costs.totalEdits) < (skipPercent / 100); i++) {
+                    skippedEdits += costs.data[i].edits;
+                    skippedTime += costs.data[i].time;
+                    skippedTests.add(costs.data[i].name);
+                }
+                console.log(`Skipped ${i} expensive tests; estimated time savings of ${(skippedTime / costs.totalTime * 100).toFixed(2)}% with --skipPercent=${skipPercent.toFixed(2)} chance of missing a test.`);
+                return tasks.filter(t => !skippedTests.has(t.file));
+            }
+            else {
+                console.log("No cost analysis discovered.");
+                return tasks;
+            }
+        }
+
         function startDelayed(perfData: { [testHash: string]: number } | undefined, totalCost: number) {
             console.log(`Discovered ${tasks.length} unittest suites` + (newTasks.length ? ` and ${newTasks.length} new suites.` : "."));
             console.log("Discovering runner-based tests...");
@@ -231,6 +256,7 @@ namespace Harness.Parallel.Host {
             }
             tasks.sort((a, b) => a.size - b.size);
             tasks = tasks.concat(newTasks);
+            tasks = skipCostlyTests(tasks);
             const batchCount = workerCount;
             const packfraction = 0.9;
             const chunkSize = 1000; // ~1KB or 1s for sending batches near the end of a test

src/testRunner/runner.ts

@@ -65,6 +65,7 @@ let runUnitTests: boolean | undefined;
 let stackTraceLimit: number | "full" | undefined;
 let noColors = false;
 let keepFailed = false;
+let skipPercent = 5;
 
 interface TestConfig {
     light?: boolean;
@@ -78,6 +79,7 @@ interface TestConfig {
     noColors?: boolean;
     timeout?: number;
     keepFailed?: boolean;
+    skipPercent?: number;
 }
 
 interface TaskSet {
@@ -109,6 +111,9 @@ function handleTestConfig() {
         if (testConfig.keepFailed) {
             keepFailed = true;
         }
+        if (testConfig.skipPercent !== undefined) {
+            skipPercent = testConfig.skipPercent;
+        }
 
         if (testConfig.stackTraceLimit === "full") {
             (<any>Error).stackTraceLimit = Infinity;