feat: tsd expectError

src/common/error.ts

@@ -12,6 +12,7 @@ export enum ErrorCode {
   ASSERT_TYPE_NOT_IDENTICAL,
   ASSERT_TYPE_IDENTICAL,
   ASSERT_TYPE_TOO_WIDE,
+  ASSERT_ERROR,
 }
 
 export const errorMessages: Record<ErrorCode, string> = {
@@ -28,6 +29,7 @@ export const errorMessages: Record<ErrorCode, string> = {
   [ErrorCode.ASSERT_TYPE_NOT_IDENTICAL]: "Type '{expected}' is not identical to argument type '{argument}'.",
   [ErrorCode.ASSERT_TYPE_IDENTICAL]: "Type '{expected}' is identical to argument type '{argument}'.",
   [ErrorCode.ASSERT_TYPE_TOO_WIDE]: "Type '{expected}' is declared too wide for argument type '{argument}'.",
+  [ErrorCode.ASSERT_ERROR]: 'An error is expected.',
 };
 
 export function errorMessage(code: ErrorCode, data?: Record<string, unknown>): string {

src/plugin/assert/tsd/expect-error.ts

@@ -0,0 +1,42 @@
+import { missingArgument } from './util';
+import type ts from 'unleashed-typescript';
+import type { Assertion } from '../../types';
+import type { Compiler } from '../../../typescript/types';
+import { createAssertionDiagnostic } from '../../diagnostics';
+import { ErrorCode, errorMessage } from '../../../common/error';
+
+// https://github.dev/SamVerschueren/tsd/blob/e4a398c1b47a4d2f914446b662840e2be5994997/source/lib/compiler.ts#L54-L55
+export function expectError({ node }: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  const argument = node.arguments[0];
+
+  if (!argument) {
+    return missingArgument(node, compiler.sourceFile);
+  }
+
+  let assertDiagnostic: ts.Diagnostic | undefined = undefined;
+
+  if (!compiler.diagnostics.length) {
+    return createAssertionDiagnostic(errorMessage(ErrorCode.ASSERT_ERROR), compiler.sourceFile, argument.getStart());
+  }
+
+  // TODO: Create a method in Compiler for cleanly removing/filter a diagnostic.
+  compiler.diagnostics = compiler.diagnostics.filter((diagnostic) => {
+    if (assertDiagnostic || !diagnostic.start) {
+      return true;
+    }
+
+    if (diagnostic.start < argument.getStart() || diagnostic.start > argument.getEnd()) {
+      assertDiagnostic = createAssertionDiagnostic(
+        errorMessage(ErrorCode.ASSERT_ERROR),
+        compiler.sourceFile,
+        diagnostic.start,
+      );
+
+      return true;
+    }
+
+    return false;
+  });
+
+  return assertDiagnostic;
+}

src/plugin/assert/tsd/index.ts

@@ -7,15 +7,12 @@ export * from './expect-type';
 export * from './expect-not-type';
 export * from './expect-assignable';
 export * from './expect-not-assignable';
+export * from './expect-error';
 
 // All credits go to tsd! Most of the logic here comme from their code:
 // https://github.com/SamVerschueren/tsd/blob/main/source/lib/assertions/index.ts
 // https://github.com/SamVerschueren/tsd/tree/main/source/lib/assertions/handlers
 
-export function expectError(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
-  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
-}
-
 export function expectDeprecated(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
   return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
 }

src/plugin/transform.ts

@@ -13,10 +13,6 @@ export function transform({ code, fileName, report, typescript }: TransformSetti
   const compiler = createCompiler({ config: typescript.config, fileName });
   const newCode = new MagicString(code);
 
-  if (report.includes('type-error')) {
-    reportDiagnostics(compiler.diagnostics, newCode, fileName);
-  }
-
   if (report.includes('type-assertion')) {
     const assertions = getAssertions(compiler.sourceFile, compiler.typeChecker);
     const diagnostics = processAssertions(assertions, compiler);
@@ -26,6 +22,10 @@ export function transform({ code, fileName, report, typescript }: TransformSetti
     }
   }
 
+  if (report.includes('type-error')) {
+    reportDiagnostics(compiler.diagnostics, newCode, fileName);
+  }
+
   return {
     code: newCode.toString(),
     map: newCode.generateMap({ hires: true }),

src/typescript/types.ts

@@ -9,8 +9,8 @@ export interface Compiler {
   program: ts.Program;
   sourceFile: ts.SourceFile;
   typeChecker: ts.TypeChecker;
+  diagnostics: ts.Diagnostic[];
   compilerOptions: ts.CompilerOptions;
-  diagnostics: readonly ts.Diagnostic[];
 }
 
 export interface TypeScriptConfigOptions {

test/tsd.test.ts

@@ -29,3 +29,12 @@ test('test-2', () => {
 test('test-3', () => {
   tsd.expectNotType<string>('hello');
 });
+
+test('test-4', () => {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  tsd.expectError(42 === 'life');
+});
+
+test('test-5', () => {
+  tsd.expectError(true);
+});