Merge branch 'main' into fewer-files

Author: jakebailey

.eslintrc.json

@@ -11,7 +11,7 @@
         "es6": true
     },
     "plugins": [
-        "@typescript-eslint", "jsdoc", "no-null", "import", "eslint-plugin-local"
+        "@typescript-eslint", "no-null", "import", "eslint-plugin-local"
     ],
     "ignorePatterns": [
         "**/node_modules/**",
@@ -107,9 +107,6 @@
         // eslint-plugin-no-null
         "no-null/no-null": "error",
 
-        // eslint-plugin-jsdoc
-        "jsdoc/check-alignment": "error",
-
         // eslint
         "constructor-super": "error",
         "curly": ["error", "multi-line"],

.github/workflows/ci.yml

@@ -86,6 +86,66 @@ jobs:
     - name: Build src
       run: npx hereby build-src
 
+  smoke:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-node@v3
+      with:
+        node-version: "*"
+        check-latest: true
+    - run:  npm ci
+
+    - run: npx hereby lkg
+    - run: |
+        npm pack
+        mv typescript*.tgz typescript.tgz
+        echo "PACKAGE=$PWD/typescript.tgz" >> $GITHUB_ENV
+
+    - name: Smoke test
+      run: |
+        cd "$(mktemp -d)"
+        npm init --yes
+        npm install $PACKAGE tslib
+
+        npx tsc --version
+        echo '{"seq": 1, "command": "status"}' | npx tsserver
+
+        cat > smoke.js << EOF
+        const { __importDefault, __importStar } = require("tslib");
+        const ts = require(process.argv[2]);
+
+        // See: https://github.com/microsoft/TypeScript/pull/51474#issuecomment-1310871623
+        const fns = [
+          [() => ts.version,                          true],
+          [() => ts.default.version,                  false],
+          [() => __importDefault(ts).version,         false],
+          [() => __importDefault(ts).default.version, true],
+          [() => __importStar(ts).version,            true],
+          [() => __importStar(ts).default.version,    true],
+        ];
+
+        for (const [fn, shouldSucceed] of fns) {
+          let success = false;
+          try {
+            success = !!fn();
+          }
+          catch {}
+          if (success !== shouldSucceed) {
+            if (success) {
+              console.error(`${fn.toString()} unexpectedly succeeded.`);
+            }
+            else {
+              console.error(`${fn.toString()} did not succeed.`);
+            }
+            process.exitCode = 1;
+          }
+        }
+        EOF
+
+        node ./smoke.js typescript
+        node ./smoke.js typescript/lib/tsserverlibrary
 
   misc:
     runs-on: ubuntu-latest

Herebyfile.mjs

@@ -6,12 +6,15 @@ import { task } from "hereby";
 import _glob from "glob";
 import util from "util";
 import chalk from "chalk";
-import { exec, readJson, getDiffTool, getDirSize, memoize, needsUpdate } from "./scripts/build/utils.mjs";
-import { runConsoleTests, refBaseline, localBaseline, refRwcBaseline, localRwcBaseline } from "./scripts/build/tests.mjs";
+import { exec, readJson, getDiffTool, getDirSize, memoize, needsUpdate, Debouncer, Deferred } from "./scripts/build/utils.mjs";
+import { runConsoleTests, refBaseline, localBaseline, refRwcBaseline, localRwcBaseline, cleanTestDirs } from "./scripts/build/tests.mjs";
 import { buildProject as realBuildProject, cleanProject, watchProject } from "./scripts/build/projects.mjs";
 import { localizationDirectories } from "./scripts/build/localization.mjs";
 import cmdLineOptions from "./scripts/build/options.mjs";
 import esbuild from "esbuild";
+import chokidar from "chokidar";
+import { EventEmitter } from "events";
+import { CancelToken } from "@esfx/canceltoken";
 
 const glob = util.promisify(_glob);
 
@@ -141,7 +144,7 @@ const localize = task({
     dependencies: [generateDiagnostics],
     run: async () => {
         if (needsUpdate(diagnosticMessagesGeneratedJson, generatedLCGFile)) {
-            return exec(process.execPath, ["scripts/generateLocalizedDiagnosticMessages.mjs", "src/loc/lcl", "built/local", diagnosticMessagesGeneratedJson], { ignoreExitCode: true });
+            await exec(process.execPath, ["scripts/generateLocalizedDiagnosticMessages.mjs", "src/loc/lcl", "built/local", diagnosticMessagesGeneratedJson], { ignoreExitCode: true });
         }
     }
 });
@@ -191,6 +194,7 @@ async function runDtsBundler(entrypoint, output) {
  * @property {string[]} [external]
  * @property {boolean} [exportIsTsObject]
  * @property {boolean} [treeShaking]
+ * @property {esbuild.WatchMode} [watchMode]
  */
 function createBundler(entrypoint, outfile, taskOptions = {}) {
     const getOptions = memoize(async () => {
@@ -269,7 +273,7 @@ function createBundler(entrypoint, outfile, taskOptions = {}) {
 
     return {
         build: async () => esbuild.build(await getOptions()),
-        watch: async () => esbuild.build({ ...await getOptions(), watch: true, logLevel: "info" }),
+        watch: async () => esbuild.build({ ...await getOptions(), watch: taskOptions.watchMode ?? true, logLevel: "info" }),
     };
 }
 
@@ -320,7 +324,7 @@ function entrypointBuildTask(options) {
             const outDir = path.dirname(options.output);
             await fs.promises.mkdir(outDir, { recursive: true });
             const moduleSpecifier = path.relative(outDir, options.builtEntrypoint);
-            await fs.promises.writeFile(options.output, `module.exports = require("./${moduleSpecifier}")`);
+            await fs.promises.writeFile(options.output, `module.exports = require("./${moduleSpecifier.replace(/[\\/]/g, "/")}")`);
         },
     });
 
@@ -354,7 +358,7 @@ function entrypointBuildTask(options) {
 }
 
 
-const { main: tsc, watch: watchTsc } = entrypointBuildTask({
+const { main: tsc, build: buildTsc, watch: watchTsc } = entrypointBuildTask({
     name: "tsc",
     description: "Builds the command-line compiler",
     buildDeps: [generateDiagnostics],
@@ -386,13 +390,13 @@ export const dtsServices = task({
     dependencies: [buildServices],
     run: async () => {
         if (needsUpdate("./built/local/typescript/tsconfig.tsbuildinfo", ["./built/local/typescript.d.ts", "./built/local/typescript.internal.d.ts"])) {
-            runDtsBundler("./built/local/typescript/typescript.d.ts", "./built/local/typescript.d.ts");
+            await runDtsBundler("./built/local/typescript/typescript.d.ts", "./built/local/typescript.d.ts");
         }
     },
 });
 
 
-const { main: tsserver, watch: watchTsserver } = entrypointBuildTask({
+const { main: tsserver, build: buildTsserver, watch: watchTsserver } = entrypointBuildTask({
     name: "tsserver",
     description: "Builds the language server",
     buildDeps: [generateDiagnostics],
@@ -410,10 +414,15 @@ const { main: tsserver, watch: watchTsserver } = entrypointBuildTask({
 export { tsserver, watchTsserver };
 
 
+const buildMin = task({
+    name: "build-min",
+    dependencies: [buildTsc, buildTsserver],
+});
+
 export const min = task({
     name: "min",
     description: "Builds only tsc and tsserver",
-    dependencies: [tsc, tsserver],
+    dependencies: [tsc, tsserver].concat(cmdLineOptions.typecheck ? [buildMin] : []),
 });
 
 export const watchMin = task({
@@ -456,7 +465,7 @@ export const dts = task({
 
 
 const testRunner = "./built/local/run.js";
-
+const watchTestsEmitter = new EventEmitter();
 const { main: tests, watch: watchTests } = entrypointBuildTask({
     name: "tests",
     description: "Builds the test infrastructure",
@@ -477,6 +486,11 @@ const { main: tests, watch: watchTests } = entrypointBuildTask({
             "mocha",
             "ms",
         ],
+        watchMode: {
+            onRebuild() {
+                watchTestsEmitter.emit("rebuild");
+            }
+        }
     },
 });
 export { tests, watchTests };
@@ -577,10 +591,15 @@ export const watchOtherOutputs = task({
     dependencies: [watchCancellationToken, watchTypingsInstaller, watchWatchGuard, generateTypesMap, copyBuiltLocalDiagnosticMessages],
 });
 
+const buildLocal = task({
+    name: "build-local",
+    dependencies: [buildTsc, buildTsserver, buildServices, buildLssl]
+});
+
 export const local = task({
     name: "local",
     description: "Builds the full compiler and services",
-    dependencies: [localize, tsc, tsserver, services, lssl, otherOutputs, dts, buildSrc],
+    dependencies: [localize, tsc, tsserver, services, lssl, otherOutputs, dts].concat(cmdLineOptions.typecheck ? [buildLocal] : []),
 });
 export default local;
 
@@ -591,11 +610,12 @@ export const watchLocal = task({
     dependencies: [localize, watchTsc, watchTsserver, watchServices, watchLssl, watchOtherOutputs, dts, watchSrc],
 });
 
+const runtestsDeps = [tests, generateLibs].concat(cmdLineOptions.typecheck ? [dts, buildSrc] : []);
 
 export const runTests = task({
     name: "runtests",
     description: "Runs the tests using the built run.js file.",
-    dependencies: [tests, generateLibs, dts, buildSrc],
+    dependencies: runtestsDeps,
     run: () => runConsoleTests(testRunner, "mocha-fivemat-progress-reporter", /*runInParallel*/ false),
 });
 // task("runtests").flags = {
@@ -614,10 +634,121 @@ export const runTests = task({
 //     "   --shardId": "1-based ID of this shard (default: 1)",
 // };
 
+export const runTestsAndWatch = task({
+    name: "runtests-watch",
+    dependencies: [watchTests],
+    run: async () => {
+        if (!cmdLineOptions.tests && !cmdLineOptions.failed) {
+            console.log(chalk.redBright(`You must specifiy either --tests/-t or --failed to use 'runtests-watch'.`));
+            return;
+        }
+
+        let watching = true;
+        let running = true;
+        let lastTestChangeTimeMs = Date.now();
+        let testsChangedDeferred = /** @type {Deferred<void>} */(new Deferred());
+        let testsChangedCancelSource = CancelToken.source();
+
+        const testsChangedDebouncer = new Debouncer(1_000, endRunTests);
+        const testCaseWatcher = chokidar.watch([
+            "tests/cases/**/*.*",
+            "tests/lib/**/*.*",
+            "tests/projects/**/*.*",
+        ], {
+            ignorePermissionErrors: true,
+            alwaysStat: true
+        });
+
+        process.on("SIGINT", endWatchMode);
+        process.on("SIGKILL", endWatchMode);
+        process.on("beforeExit", endWatchMode);
+        watchTestsEmitter.on("rebuild", onRebuild);
+        testCaseWatcher.on("all", onChange);
+
+        while (watching) {
+            const promise = testsChangedDeferred.promise;
+            const token = testsChangedCancelSource.token;
+            if (!token.signaled) {
+                running = true;
+                try {
+                    await runConsoleTests(testRunner, "mocha-fivemat-progress-reporter", /*runInParallel*/ false, { token, watching: true });
+                }
+                catch {
+                    // ignore
+                }
+                running = false;
+            }
+            if (watching) {
+                console.log(chalk.yellowBright(`[watch] test run complete, waiting for changes...`));
+                await promise;
+            }
+        }
+
+        function onRebuild() {
+            beginRunTests(testRunner);
+        }
+
+        /**
+         * @param {'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir'} eventName
+         * @param {string} path
+         * @param {fs.Stats | undefined} stats
+         */
+        function onChange(eventName, path, stats) {
+            switch (eventName) {
+                case "change":
+                case "unlink":
+                case "unlinkDir":
+                    break;
+                case "add":
+                case "addDir":
+                    // skip files that are detected as 'add' but haven't actually changed since the last time tests were
+                    // run.
+                    if (stats && stats.mtimeMs <= lastTestChangeTimeMs) {
+                        return;
+                    }
+                    break;
+            }
+            beginRunTests(path);
+        }
+
+        /**
+         * @param {string} path
+         */
+        function beginRunTests(path) {
+            if (testsChangedDebouncer.empty) {
+                console.log(chalk.yellowBright(`[watch] tests changed due to '${path}', restarting...`));
+                if (running) {
+                    console.log(chalk.yellowBright("[watch] aborting in-progress test run..."));
+                }
+                testsChangedCancelSource.cancel();
+                testsChangedCancelSource = CancelToken.source();
+            }
+
+            testsChangedDebouncer.enqueue();
+        }
+
+        function endRunTests() {
+            lastTestChangeTimeMs = Date.now();
+            testsChangedDeferred.resolve();
+            testsChangedDeferred = /** @type {Deferred<void>} */(new Deferred());
+        }
+
+        function endWatchMode() {
+            if (watching) {
+                watching = false;
+                console.log(chalk.yellowBright("[watch] exiting watch mode..."));
+                testsChangedCancelSource.cancel();
+                testCaseWatcher.close();
+                watchTestsEmitter.off("rebuild", onRebuild);
+            }
+        }
+    },
+});
+
 export const runTestsParallel = task({
     name: "runtests-parallel",
     description: "Runs all the tests in parallel using the built run.js file.",
-    dependencies: [tests, generateLibs, dts, buildSrc],
+    dependencies: runtestsDeps,
     run: () => runConsoleTests(testRunner, "min", /*runInParallel*/ cmdLineOptions.workers > 1),
 });
 // task("runtests-parallel").flags = {
@@ -715,7 +846,7 @@ export const importDefinitelyTypedTests = task({
 export const produceLKG = task({
     name: "LKG",
     description: "Makes a new LKG out of the built js files",
-    dependencies: [localize, tsc, tsserver, services, lssl, otherOutputs, dts],
+    dependencies: [local],
     run: async () => {
         if (!cmdLineOptions.bundle) {
             throw new Error("LKG cannot be created when --bundle=false");