Report errors in corrrect process for gulp-typescript-oop

Author: rbuckton

Gulpfile.js

@@ -46,7 +46,7 @@ const produceLKGJs = "scripts/produceLKG.js";
 const word2mdJs = "scripts/word2md.js";
 gulp.task("scripts", /*help*/ false, () => project.compile(scriptsProject), {
     aliases: [
-        configurePrereleaseJs, 
+        configurePrereleaseJs,
         processDiagnosticMessagesJs,
         generateLocalizedDiagnosticMessagesJs,
         produceLKGJs,
@@ -134,10 +134,11 @@ gulp.task(generatedLCGFile, /*help*/ false, [generateLocalizedDiagnosticMessages
 
 gulp.task("localize", /*help*/ false, [generatedLCGFile]);
 
+const servicesProject = "src/services/tsconfig.json";
 const typescriptServicesProject = "built/local/typescriptServices.tsconfig.json";
 gulp.task(typescriptServicesProject, /*help*/ false, () => {
     // NOTE: flatten services so that we can properly strip @internal
-    project.flatten("src/services/tsconfig.json", typescriptServicesProject, {
+    project.flatten(servicesProject, typescriptServicesProject, {
         compilerOptions: {
             "removeComments": true,
             "stripInternal": true,
@@ -148,7 +149,7 @@ gulp.task(typescriptServicesProject, /*help*/ false, () => {
 
 const typescriptServicesJs = "built/local/typescriptServices.js";
 const typescriptServicesDts = "built/local/typescriptServices.d.ts";
-gulp.task(typescriptServicesJs, /*help*/ false, ["lib", "generate-diagnostics", typescriptServicesProject], () => 
+gulp.task(typescriptServicesJs, /*help*/ false, ["lib", "generate-diagnostics", typescriptServicesProject], () =>
     project.compile(typescriptServicesProject, { dts: files => files.pipe(convertConstEnums()) }),
     { aliases: [typescriptServicesDts] });
 
@@ -225,7 +226,7 @@ gulp.task(tsserverlibraryProject, /*help*/ false, () => {
 const tsserverlibraryJs = "built/local/tsserverlibrary.js";
 const tsserverlibraryDts = "built/local/tsserverlibrary.d.ts";
 gulp.task(tsserverlibraryJs, /*help*/ false, [typescriptServicesJs, tsserverlibraryProject], () =>
-    project.compile(tsserverlibraryProject, { 
+    project.compile(tsserverlibraryProject, {
         dts: files => files
             .pipe(convertConstEnums())
             .pipe(append("\nexport = ts;\nexport as namespace ts;")),
@@ -253,21 +254,21 @@ gulp.task(specMd, /*help*/ false, [word2mdJs], () =>
     exec("cscript", ["//nologo", word2mdJs, path.resolve(specMd), path.resolve("doc/TypeScript Language Specification.docx")]));
 
 gulp.task(
-    "generate-spec", 
-    "Generates a Markdown version of the Language Specification", 
+    "generate-spec",
+    "Generates a Markdown version of the Language Specification",
     [specMd]);
 
 gulp.task("produce-LKG", /*help*/ false, ["scripts", "local", cancellationTokenJs, typingsInstallerJs, watchGuardJs, tscReleaseJs], () => {
     const expectedFiles = [
-        tscReleaseJs, 
-        typescriptServicesJs, 
-        tsserverJs, 
-        typescriptJs, 
-        typescriptDts, 
-        typescriptServicesDts, 
-        tsserverlibraryDts, 
-        tsserverlibraryDts, 
-        typingsInstallerJs, 
+        tscReleaseJs,
+        typescriptServicesJs,
+        tsserverJs,
+        typescriptJs,
+        typescriptDts,
+        typescriptServicesDts,
+        tsserverlibraryDts,
+        tsserverlibraryDts,
+        typingsInstallerJs,
         cancellationTokenJs
     ].concat(libraryTargets);
     const missingFiles = expectedFiles
@@ -286,8 +287,8 @@ gulp.task("produce-LKG", /*help*/ false, ["scripts", "local", cancellationTokenJ
 });
 
 gulp.task(
-    "LKG", 
-    "Makes a new LKG out of the built js files", 
+    "LKG",
+    "Makes a new LKG out of the built js files",
     () => runSequence("clean-built", "produce-LKG"));
 
 // Task to build the tests infrastructure using the built compiler
@@ -464,12 +465,40 @@ gulp.task(
     "Runs 'local'",
     ["local"]);
 
+gulp.task(
+    "watch-diagnostics",
+    /*help*/ false,
+    [processDiagnosticMessagesJs],
+    () => gulp.watch([diagnosticMessagesJson], [diagnosticInformationMapTs, builtGeneratedDiagnosticMessagesJson]));
+
+gulp.task(
+    "watch-lib",
+    /*help*/ false,
+    () => gulp.watch(["src/lib/**/*"], ["lib"]));
+
 gulp.task(
     "watch-tsc",
-    "Watches for changes to the build inputs for built/local/tsc.js",
-    [typescriptServicesJs],
+    /*help*/ false,
+    ["watch-diagnostics", "watch-lib", typescriptServicesJs],
     () => project.watch(tscProject, { typescript: "built" }));
 
+gulp.task(
+    "watch-services",
+    /*help*/ false,
+    ["watch-diagnostics", "watch-lib", typescriptServicesJs],
+    () => project.watch(servicesProject, { typescript: "built" }));
+
+gulp.task(
+    "watch-server",
+    /*help*/ false,
+    ["watch-diagnostics", "watch-lib", typescriptServicesJs],
+    () => project.watch(tsserverProject, { typescript: "built" }));
+
+gulp.task(
+    "watch-local",
+    /*help*/ false,
+    ["watch-lib", "watch-tsc", "watch-services", "watch-server"]);
+
 gulp.task(
     "watch",
     "Watches for changes to the build inputs for built/local/run.js executes runtests-parallel.",

package-lock.json

@@ -0,0 +1,145 @@
+// @ts-check
+const path = require("path");
+const child_process = require("child_process");
+const tsc = require("gulp-typescript");
+const Vinyl = require("vinyl");
+const { Duplex, Readable } = require("stream");
+const protocol = require("./protocol");
+
+/**
+ * @param {string | undefined} tsConfigFileName
+ * @param {tsc.Settings} settings
+ * @param {CreateProjectOptions} options
+ *
+ * @typedef CreateProjectOptions
+ * @property {string} [typescript]
+ * @property {boolean} [parse]
+ */
+function createProject(tsConfigFileName, settings, options) {
+    settings = Object.assign({}, settings);
+    options = Object.assign({}, options);
+    if (settings.typescript) throw new Error();
+
+    const localSettings = Object.assign({}, settings);
+    if (options.typescript) {
+        options.typescript = path.resolve(options.typescript);
+        localSettings.typescript = require(options.typescript);
+    }
+
+    const project = tsConfigFileName === undefined ? tsc.createProject(localSettings) : tsc.createProject(tsConfigFileName, localSettings);
+    const wrappedProject = /** @type {tsc.Project} */((reporter = tsc.reporter.defaultReporter()) => {
+        const ts = project.typescript;
+        const proc = child_process.fork(require.resolve("./worker.js"), [], {
+            // Prevent errors when debugging gulpfile due to the same debug port being passed to forked children.
+            execArgv: []
+        });
+        /** @type {Map<string, import("vinyl")>} */
+        const inputs = new Map();
+        /** @type {Map<string, *>} */
+        const sourceFiles = new Map();
+        /** @type {protocol.SourceFileHost & protocol.VinylHost} */
+        const host = {
+            getVinyl(path) { return inputs.get(path); },
+            getSourceFile(fileName) { return sourceFiles.get(fileName); },
+            createSourceFile(fileName, text, languageVersion) {
+                if (text === undefined) throw new Error("File not cached.");
+                /** @type {protocol.SourceFile} */
+                let file;
+                if (options.parse) {
+                    file = ts.createSourceFile(fileName, text, languageVersion, /*setParentNodes*/ true);
+                }
+                else {
+                    // NOTE: the built-in reporters in gulp-typescript don't actually need a full
+                    // source file, so save time by faking one unless requested.
+                    file = /**@type {protocol.SourceFile}*/({
+                        pos: 0,
+                        end: text.length,
+                        kind: ts.SyntaxKind.SourceFile,
+                        fileName,
+                        text,
+                        languageVersion,
+                        statements: /**@type {*} */([]),
+                        endOfFileToken: { pos: text.length, end: text.length, kind: ts.SyntaxKind.EndOfFileToken },
+                        amdDependencies: /**@type {*} */([]),
+                        referencedFiles: /**@type {*} */([]),
+                        typeReferenceDirectives: /**@type {*} */([]),
+                        libReferenceDirectives: /**@type {*} */([]),
+                        languageVariant: ts.LanguageVariant.Standard,
+                        isDeclarationFile: /\.d\.ts$/.test(fileName),
+                        hasNoDefaultLib: /[\\/]lib\.[^\\/]+\.d\.ts$/.test(fileName)
+                    });
+                }
+                sourceFiles.set(fileName, file);
+                return file;
+            }
+        };
+        /** @type {Duplex & { js?: Readable, dts?: Readable }} */
+        const compileStream = new Duplex({
+            objectMode: true,
+            read() {},
+            /** @param {*} file */
+            write(file, _encoding, callback) {
+                inputs.set(file.path, file);
+                proc.send(protocol.message.write(file));
+                callback();
+            },
+            final(callback) {
+                proc.send(protocol.message.final());
+                callback();
+            }
+        });
+        const jsStream = compileStream.js = new Readable({
+            objectMode: true,
+            read() {}
+        });
+        const dtsStream = compileStream.dts = new Readable({
+            objectMode: true,
+            read() {}
+        });
+        proc.send(protocol.message.createProject(tsConfigFileName, settings, options));
+        proc.on("message", (/**@type {protocol.WorkerMessage}*/ message) => {
+            switch (message.method) {
+                case "write": {
+                    const file = protocol.vinylFromJson(message.params);
+                    compileStream.push(file);
+                    if (file.path.endsWith(".d.ts")) {
+                        dtsStream.push(file);
+                    }
+                    else {
+                        jsStream.push(file);
+                    }
+                    break;
+                }
+                case "final": {
+                    compileStream.push(null);
+                    jsStream.push(null);
+                    dtsStream.push(null);
+                    proc.kill(); // TODO(rbuckton): pool workers? may not be feasible due to gulp-typescript holding onto memory
+                    break;
+                }
+                case "error": {
+                    const error = protocol.errorFromJson(message.params);
+                    compileStream.emit("error", error);
+                    proc.kill(); // TODO(rbuckton): pool workers? may not be feasible due to gulp-typescript holding onto memory
+                    break;
+                }
+                case "reporter.error": {
+                    if (reporter.error) {
+                        const error = protocol.typeScriptErrorFromJson(message.params, host);
+                        reporter.error(error, project.typescript);
+                    }
+                    break;
+                }
+                case "reporter.finish": {
+                    if (reporter.finish) {
+                        reporter.finish(message.params);
+                    }
+                }
+            }
+        });
+        return /** @type {*} */(compileStream);
+    });
+    return Object.assign(wrappedProject, project);
+}
+
+exports.createProject = createProject;