Use noEmitOnError=false internally.

See microsoft/TypeScript#24444 for the reason.
Errors are detected by checking the diagnostic types and emit is skipped
"manually", depending on that check result.

Author: AlCalzone

src/compiler.ts

@@ -23,10 +23,19 @@ export function compile(script: string, compilerOptions?: ts.CompilerOptions, am
 
 	// set default compiler options
 	compilerOptions = compilerOptions || {};
+	compilerOptions.moduleResolution = ts.ModuleResolutionKind.NodeJs;
+	// Don't emit faulty code (by default)
 	if (compilerOptions.noEmitOnError == null) compilerOptions.noEmitOnError = true;
 	// emit declarations if possible
 	if (compilerOptions.declaration == null) compilerOptions.declaration = true;
-	compilerOptions.moduleResolution = ts.ModuleResolutionKind.NodeJs;
+
+	// According to https://github.com/Microsoft/TypeScript/issues/24444#issuecomment-392970120
+	// combining noEmitOnError=true and declaration=true massively increases the work done
+	// by the compiler. To work around it, we call the compiler with noEmitOnError=false
+	// and use the actual value to determine if we continue with the emit
+	const internalOptions = Object.assign({}, compilerOptions, {
+		noEmitOnError: false,
+	} as ts.CompilerOptions);
 
 	// provide the source file in the virtual fs
 	const fs = new VirtualFileSystem();
@@ -38,20 +47,20 @@ export function compile(script: string, compilerOptions?: ts.CompilerOptions, am
 	}
 
 	// create the virtual host
-	const host = new InMemoryHost(fs, compilerOptions);
+	const host = new InMemoryHost(fs, internalOptions);
 	// create the compiler and provide nodejs typings
 	const allFiles = [
 		"@types/node/index.d.ts",
 		...Object.keys(ambientDeclarations),
 		SCRIPT_FILENAME,
 	];
-	const program = ts.createProgram(allFiles, compilerOptions, host);
+	const program = ts.createProgram(allFiles, internalOptions, host);
 
 	// compile the script
 	const emitResult = program.emit();
 
 	// diagnose the compilation result
-	const rawDiagnostics = compilerOptions.noEmitOnError ? emitResult.diagnostics : ts.getPreEmitDiagnostics(program);
+	const rawDiagnostics = internalOptions.noEmitOnError ? emitResult.diagnostics : ts.getPreEmitDiagnostics(program);
 	const diagnostics = rawDiagnostics.map(diagnostic => {
 		let lineNr = 0;
 		let charNr = 0;
@@ -76,12 +85,14 @@ ${type.toUpperCase()}: ${description}`;
 	});
 
 	const hasError = (
-		(!diagnostics.every(d => d.type !== "error") || emitResult.emitSkipped)
+		(
+			diagnostics.find(d => d.type === "error") != null
+			|| (emitResult.emitSkipped && !compilerOptions.emitDeclarationOnly)
+		)
 		&& compilerOptions.noEmitOnError
 	);
 	let result: string;
 	const resultFilename = SCRIPT_FILENAME.replace(/ts$/, "js");
-
 	let declarations: string;
 	const declarationsFilename = SCRIPT_FILENAME.replace(/ts$/, "d.ts");
 	if (!hasError && fs.fileExists(resultFilename)) result = fs.readFile(resultFilename);

src/index.test.ts

@@ -14,7 +14,6 @@ const options = {
 };
 
 describe("compiler => ", function() {
-
 	this.timeout(30000);
 
 	it("it should not explode", () => {
@@ -66,40 +65,40 @@ declare global {
 	it("it should force ambient declarations to be .d.ts files", () => {
 		expect(() => compile("", null, { "global.ts": "" })).to.throw();
 	});
+});
 
-	describe("performance check =>", () => {
-		it("compile()", function() {
-			this.timeout(10000);
-			const ambient = fs.readFileSync("./test/ioBroker.d.ts", "utf8");
-			let result: CompileResult;
-			for (let i = 0; i < 5; i++) {
-				result = compile(
-					`const buf = Buffer.alloc(${i} + 1);
-console.log(buf.length)`,
-					null, { "global.d.ts": ambient },
-				);
-				expect(result.success).to.be.true;
-				// about 700ms per call
-			}
-		});
+describe("performance check =>", function() {
+	this.timeout(30000);
 
-		it("service host", () => {
-			const tsserver = new Server(options);
-			const ambient = fs.readFileSync("./test/ioBroker.d.ts", "utf8");
-			tsserver.provideAmbientDeclarations({ "global.d.ts": ambient });
-			let result: CompileResult;
-			for (let i = 0; i < 5; i++) {
-				log("starting compilation", "info");
-				result = tsserver.compile("index.ts",
-					`const buf = Buffer.alloc(${i} + 1);
+	it("compiler", () => {
+		const ambient = fs.readFileSync("./test/ioBroker.d.ts", "utf8");
+		let result: CompileResult;
+		for (let i = 0; i < 5; i++) {
+			result = compile(
+				`const buf = Buffer.alloc(${i} + 1);
 console.log(buf.length)`,
-				);
-				log("compilation done!", "info");
-				expect(result.success).to.be.true;
-				expect(result.declarations).to.equal("declare const buf: Buffer;\r\n");
-				// about 4ms per call (after the 1st one)
-			}
-		});
+				null, { "global.d.ts": ambient },
+			);
+			expect(result.success).to.be.true;
+			// call durations: ~1200..900 ms
+		}
 	});
 
+	it("service host", () => {
+		const tsserver = new Server(options);
+		const ambient = fs.readFileSync("./test/ioBroker.d.ts", "utf8");
+		tsserver.provideAmbientDeclarations({ "global.d.ts": ambient });
+		let result: CompileResult;
+		for (let i = 0; i < 5; i++) {
+			log("starting compilation", "info");
+			result = tsserver.compile("index.ts",
+				`const buf = Buffer.alloc(${i} + 1);
+console.log(buf.length)`,
+			);
+			log("compilation done!", "info");
+			expect(result.success).to.be.true;
+			expect(result.declarations).to.equal("declare const buf: Buffer;\r\n");
+			// call durations: ~1200, then ~100..200 ms for the following calls
+		}
+	});
 });

src/server.ts

@@ -20,15 +20,23 @@ export class Server {
 
 		// set default compiler options
 		this.options = this.options || {};
-		// TODO: We would like this to be true, but there's a bit performance hit
-		/* if (this.options.noEmitOnError == null) */ this.options.noEmitOnError = false;
+		this.options.moduleResolution = ts.ModuleResolutionKind.NodeJs;
+		// Don't emit faulty code (by default)
+		if (this.options.noEmitOnError == null) this.options.noEmitOnError = true;
 		// emit declarations if possible
 		if (this.options.declaration == null) this.options.declaration = true;
-		this.options.moduleResolution = ts.ModuleResolutionKind.NodeJs;
+
+		// According to https://github.com/Microsoft/TypeScript/issues/24444#issuecomment-392970120
+		// combining noEmitOnError=true and declaration=true massively increases the work done
+		// by the compiler. To work around it, we call the compiler with noEmitOnError=false
+		// and use the actual value to determine if we continue with the emit
+		const internalOptions = Object.assign({}, this.options, {
+			noEmitOnError: false,
+		} as ts.CompilerOptions);
 
 		// set up the build pipeline
 		this.fs = new VirtualFileSystem();
-		this.host = new InMemoryServiceHost(this.fs, this.options);
+		this.host = new InMemoryServiceHost(this.fs, internalOptions);
 		this.service = ts.createLanguageService(this.host, ts.createDocumentRegistry());
 
 		// provide the requested lib files
@@ -98,8 +106,8 @@ ${type.toUpperCase()}: ${description}`;
 
 		const hasError = (
 			(
-				!diagnostics.every(d => d.type !== "error") ||
-				(emitResult.emitSkipped && !this.options.emitDeclarationOnly)
+				diagnostics.find(d => d.type === "error") != null
+				|| (emitResult.emitSkipped && !this.options.emitDeclarationOnly)
 			)
 			&& this.options.noEmitOnError
 		);