TS types transformer: Throw diagnostics as error on empty emit

packages/core/integration-tests/test/integration/ts-types/error/file2.ts

@@ -0,0 +1,7 @@
+type Snapshot<T> = {
+  readonly [K in keyof T]: Snapshot<T[K]>;
+};
+
+export function snapShot<V>(): Snapshot<V> {
+  return 1 as any;
+}

packages/core/integration-tests/test/integration/ts-types/error/index.ts

@@ -0,0 +1,15 @@
+import { snapShot } from "./file2";
+
+export interface State {
+  value: any;
+}
+
+type ContextType = ReturnType<typeof snapShot<State>>;
+function id<T>(v: T) {
+  return v;
+}
+const Context = id<ContextType | null>(null);
+
+export function useStateContext() {
+  return Context;
+}

packages/core/integration-tests/test/integration/ts-types/error/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "ts-types-error",
+  "private": true,
+  "main": "dist/main.js",
+  "types": "dist/types.d.ts",
+  "dependencies": {
+    "react": "*"
+  }
+}

packages/core/integration-tests/test/ts-types.js

@@ -8,6 +8,7 @@ import {
   outputFS,
   ncp,
 } from '@parcel/test-utils';
+import {md} from '@parcel/diagnostic';
 
 describe('typescript types', function () {
   it('should generate a typescript declaration file', async function () {
@@ -324,6 +325,46 @@ describe('typescript types', function () {
     assert.equal(dist, expected);
   });
 
+  it('should throw a diagnostic on fatal errors', async function () {
+    let message = md`Return type of exported function has or is using name 'Snapshot' from external module "${path.join(
+      __dirname,
+      '/integration/ts-types/error/file2',
+    )}" but cannot be named.`;
+    await assert.rejects(
+      () =>
+        bundle(path.join(__dirname, '/integration/ts-types/error/index.ts')),
+      {
+        name: 'BuildError',
+        message,
+        diagnostics: [
+          {
+            message,
+            codeFrames: [
+              {
+                filePath: path.join(
+                  __dirname,
+                  '/integration/ts-types/error/index.ts',
+                ),
+                code: await inputFS.readFile(
+                  path.join(__dirname, '/integration/ts-types/error/index.ts'),
+                  'utf8',
+                ),
+                codeHighlights: [
+                  {
+                    start: {line: 13, column: 17},
+                    end: {line: 13, column: 32},
+                    message,
+                  },
+                ],
+              },
+            ],
+            origin: '@parcel/transformer-typescript-types',
+          },
+        ],
+      },
+    );
+  });
+
   it('should work with module augmentation', async function () {
     let fixtureDir = path.join(__dirname, 'integration/ts-types/augmentation');
     await outputFS.mkdirp(path.join(fixtureDir, 'node_modules'));

packages/transformers/typescript-types/src/TSTypesTransformer.js

@@ -9,7 +9,7 @@ import type {CompilerOptions} from 'typescript';
 import ts from 'typescript';
 import {CompilerHost, loadTSConfig} from '@parcel/ts-utils';
 import {normalizeSeparators} from '@parcel/utils';
-import {escapeMarkdown} from '@parcel/diagnostic';
+import ThrowableDiagnostic, {escapeMarkdown} from '@parcel/diagnostic';
 import {TSModuleGraph} from './TSModuleGraph';
 import nullthrows from 'nullthrows';
 import {collect} from './collect';
@@ -76,67 +76,90 @@ export default (new Transformer({
       .getPreEmitDiagnostics(program)
       .concat(emitResult.diagnostics);
 
-    if (diagnostics.length > 0) {
-      for (let diagnostic of diagnostics) {
-        let filename = asset.filePath;
-        let {file} = diagnostic;
-
-        let diagnosticMessage =
-          typeof diagnostic.messageText === 'string'
-            ? diagnostic.messageText
-            : diagnostic.messageText.messageText;
-
-        let codeframe: ?DiagnosticCodeFrame;
-        if (file != null && diagnostic.start != null) {
-          let source = file.text || diagnostic.source;
-          if (file.fileName) {
-            filename = file.fileName;
-          }
+    let diagnosticIds = new Set();
+    let deduplicatedDiagnostics = [];
+    for (let d of diagnostics) {
+      if (d.start != null && d.length != null && d.messageText != null) {
+        let id = `${d.start}:${d.length}:${ts.flattenDiagnosticMessageText(
+          d.messageText,
+          '\n',
+        )}`;
+        if (!diagnosticIds.has(id)) {
+          deduplicatedDiagnostics.push(d);
+        }
+        diagnosticIds.add(id);
+      } else {
+        deduplicatedDiagnostics.push(d);
+      }
+    }
 
-          // $FlowFixMe
-          if (source) {
-            let lineChar = file.getLineAndCharacterOfPosition(diagnostic.start);
-            let start = {
-              line: lineChar.line + 1,
-              column: lineChar.character + 1,
-            };
-            let end = {
-              line: start.line,
-              column: start.column + 1,
-            };
+    let parcelDiagnostics = deduplicatedDiagnostics.map(diagnostic => {
+      let filename = asset.filePath;
+      let {file} = diagnostic;
+
+      let diagnosticMessage = ts.flattenDiagnosticMessageText(
+        diagnostic.messageText,
+        '\n',
+      );
 
-            if (
-              typeof diagnostic.start === 'number' &&
-              typeof diagnostic.length === 'number'
-            ) {
-              let endCharPosition = file.getLineAndCharacterOfPosition(
-                diagnostic.start + diagnostic.length,
-              );
-
-              end = {
-                line: endCharPosition.line + 1,
-                column: endCharPosition.character + 1,
-              };
-            }
-
-            codeframe = {
-              filePath: filename,
-              code: source,
-              codeHighlights: [
-                {
-                  start,
-                  end,
-                  message: escapeMarkdown(diagnosticMessage),
-                },
-              ],
+      let codeframe: ?DiagnosticCodeFrame;
+      if (file != null && diagnostic.start != null) {
+        let source = file.text || diagnostic.source;
+        if (file.fileName) {
+          filename = file.fileName;
+        }
+
+        // $FlowFixMe
+        if (source) {
+          let lineChar = file.getLineAndCharacterOfPosition(diagnostic.start);
+          let start = {
+            line: lineChar.line + 1,
+            column: lineChar.character + 1,
+          };
+          let end = {
+            line: start.line,
+            column: start.column + 1,
+          };
+
+          if (
+            typeof diagnostic.start === 'number' &&
+            typeof diagnostic.length === 'number'
+          ) {
+            let endCharPosition = file.getLineAndCharacterOfPosition(
+              diagnostic.start + diagnostic.length,
+            );
+
+            end = {
+              line: endCharPosition.line + 1,
+              column: endCharPosition.character + 1,
             };
           }
+
+          codeframe = {
+            filePath: filename,
+            code: source,
+            codeHighlights: [
+              {
+                start,
+                end,
+                message: escapeMarkdown(diagnosticMessage),
+              },
+            ],
+          };
         }
+      }
+
+      return {
+        message: escapeMarkdown(diagnosticMessage),
+        codeFrames: codeframe ? [codeframe] : undefined,
+      };
+    });
 
-        logger.warn({
-          message: escapeMarkdown(diagnosticMessage),
-          codeFrames: codeframe ? [codeframe] : undefined,
-        });
+    if (host.outputCode == null) {
+      throw new ThrowableDiagnostic({diagnostic: parcelDiagnostics});
+    } else {
+      for (let d of parcelDiagnostics) {
+        logger.warn(d);
       }
     }