Add decorator-related diagnostic codes to expectError

source/lib/compiler.ts

@@ -45,6 +45,16 @@ const expectErrorDiagnosticCodesToIgnore = new Set<DiagnosticCode>([
 	DiagnosticCode.StringLiteralTypeIsNotAssignableToUnionTypeWithSuggestion,
 	DiagnosticCode.ObjectLiteralMayOnlySpecifyKnownProperties,
 	DiagnosticCode.ObjectLiteralMayOnlySpecifyKnownProperties2,
+	DiagnosticCode.UnableToResolveSignatureOfClassDecorator,
+	DiagnosticCode.UnableToResolveSignatureOfParameterDecorator,
+	DiagnosticCode.UnableToResolveSignatureOfPropertyDecorator,
+	DiagnosticCode.UnableToResolveSignatureOfMethodDecorator,
+	DiagnosticCode.DecoratorCanOnlyDecorateMethodImplementation,
+	DiagnosticCode.DecoratorFunctionReturnTypeNotAssignableToType,
+	DiagnosticCode.DecoratorFunctionReturnTypeExpectedToBeVoidOrAny,
+	DiagnosticCode.RuntimeWillInvokeDecoratorWithXArgumentsButDecoratorExpectsY,
+	DiagnosticCode.RuntimeWillInvokeDecoratorWithXArgumentsButDecoratorExpectsAtLeastY,
+	DiagnosticCode.AcceptsTooFewArgumentsToBeUsedAsDecoratorHere,
 ]);
 
 type IgnoreDiagnosticResult = 'preserve' | 'ignore' | Location;
@@ -76,19 +86,19 @@ const ignoreDiagnostic = (
 
 		// Diagnostic is inside of `expectError` clause
 		if (diagnosticFileName === location.fileName && start > location.start && start < location.end) {
+			if (expectErrorDiagnosticCodesToIgnore.has(diagnostic.code)) {
+				return location;
+			}
+
 			// Ignore syntactical errors
 			if (diagnostic.code < 2000) {
 				expectedErrors.delete(location);
 				return 'preserve';
 			}
 
 			// Set diagnostic code on `ExpectedError` to log
-			if (!expectErrorDiagnosticCodesToIgnore.has(diagnostic.code)) {
-				error.code = diagnostic.code;
-				return 'preserve';
-			}
-
-			return location;
+			error.code = diagnostic.code;
+			return 'preserve';
 		}
 	}
 

source/lib/interfaces.ts

@@ -23,7 +23,17 @@ export interface Context {
 }
 
 export enum DiagnosticCode {
+	UnableToResolveSignatureOfClassDecorator = 1238,
+	UnableToResolveSignatureOfParameterDecorator = 1239,
+	UnableToResolveSignatureOfPropertyDecorator = 1240,
+	UnableToResolveSignatureOfMethodDecorator = 1241,
+	DecoratorCanOnlyDecorateMethodImplementation = 1249,
+	DecoratorFunctionReturnTypeNotAssignableToType = 1270,
+	DecoratorFunctionReturnTypeExpectedToBeVoidOrAny = 1271,
+	RuntimeWillInvokeDecoratorWithXArgumentsButDecoratorExpectsY = 1278,
+	RuntimeWillInvokeDecoratorWithXArgumentsButDecoratorExpectsAtLeastY = 1279,
 	AwaitExpressionOnlyAllowedWithinAsyncFunction = 1308,
+	AcceptsTooFewArgumentsToBeUsedAsDecoratorHere = 1329,
 	TopLevelAwaitOnlyAllowedWhenModuleESNextOrSystem = 1378,
 	GenericTypeRequiresTypeArguments = 2314,
 	GenericTypeRequiresBetweenXAndYTypeArugments = 2707,

source/test/expect-error.ts

@@ -52,6 +52,18 @@ test('expectError for values (exactOptionalPropertyTypes enabled)', async t => {
 	verify(t, diagnostics, []);
 });
 
+test('expectError for decorators', async t => {
+	const diagnostics = await tsd({cwd: path.join(__dirname, 'fixtures/expect-error/decorators')});
+
+	verify(t, diagnostics, []);
+});
+
+test('expectError for experimental decorators', async t => {
+	const diagnostics = await tsd({cwd: path.join(__dirname, 'fixtures/expect-error/experimental-decorators')});
+
+	verify(t, diagnostics, []);
+});
+
 test('expectError should report missing diagnostic codes', async t => {
 	const diagnostics = await tsd({cwd: path.join(__dirname, 'fixtures/expect-error/missing-diagnostic-code')});
 

source/test/fixtures/expect-error/decorators/index.d.ts

@@ -0,0 +1,15 @@
+export declare class Base {
+	dummy(a: string, b: number): boolean;
+}
+
+export function classDec<T extends new (a: number, b: boolean) => Base>(value: T, context: ClassDecoratorContext<T>): T;
+export function methodDec(value: (this: Base, a: string, b: number) => boolean, context: ClassMethodDecoratorContext<Base, (this:Base, a: string, b: number) => boolean>): (this: Base, a: string, b: number) => boolean
+export function getterDec(value: (this: Base) => number, context: ClassGetterDecoratorContext<Base, number>): (this: Base) => number;
+export function setterDec(value: (this: Base, value: number) => void, context: ClassSetterDecoratorContext<Base, number>): (this: Base, value: number) => void;
+export function accessorDec(value: ClassAccessorDecoratorTarget<Base, string>, context: ClassAccessorDecoratorContext<Base, string>): ClassAccessorDecoratorResult<Base, string>;
+export function fieldDec(value: undefined, context: ClassFieldDecoratorContext<Base, number>): (initialValue: number) => number;
+
+export function tooFewArguments(value: Function): void;
+export function badReturnType(value: ClassAccessorDecoratorTarget<Base, number>, context: ClassAccessorDecoratorContext<Base, number>): number;
+
+export function factory(arg: number): (value: (a: number) => void, context: ClassMethodDecoratorContext<unknown, (a: number) => void>) => void;

source/test/fixtures/expect-error/decorators/index.js

@@ -0,0 +1,6 @@
+module.exports.classDec = (value, context) => {};
+module.exports.methodDec = (value, context) => {};
+module.exports.getterDec = (value, context) => {};
+module.exports.setterDec = (value, context) => {};
+module.exports.accessorDec = (value, context) => {};
+module.exports.fieldDec = (value, context) => {};

source/test/fixtures/expect-error/decorators/index.test-d.ts

@@ -0,0 +1,77 @@
+import {expectError} from '../../../..';
+import {Base, classDec, methodDec, getterDec, setterDec, accessorDec, fieldDec, tooFewArguments, badReturnType, factory} from '.';
+
+expectError(@classDec class {}); // 1238, 1270
+expectError(() => { // 1238, 1270
+	@classDec
+	abstract class Test extends Base {}
+});
+
+expectError(class extends Base { // 1241
+	@methodDec static foo(a: string, b: number) { return true; }
+});
+expectError(class extends Base { // 1241, 1270
+	@methodDec foo() {}
+});
+expectError(class { // 1241
+	@methodDec foo(a: string, b: number) { return true; }
+});
+expectError(class extends Base { // 1249
+	@methodDec override dummy(a: string, b: number): boolean
+	dummy(): void
+	dummy(a?: string, b?: number) : boolean|void {}
+});
+
+expectError(class extends Base { // 1241
+	@getterDec static get foo() { return 42; }
+});
+expectError(class extends Base { // 1241, 1270
+	@getterDec get foo() { return "bar"; }
+});
+expectError(class { // 1241
+	@getterDec get foo() { return 42; }
+});
+
+expectError(class extends Base { // 1241
+	@setterDec static set foo(value: number) {}
+});
+expectError(class extends Base { // 1241, 1270
+	@setterDec set foo(value: string) {}
+});
+expectError(class { // 1241
+	@setterDec set foo(value: number) {}
+});
+
+expectError(class extends Base { // 1240, 1270
+	@accessorDec static accessor foo = "bar";
+});
+expectError(class extends Base { // 1240, 1270
+	@accessorDec accessor foo = 42;
+});
+expectError(class { // 1240, 1270
+	@accessorDec accessor foo = "bar";
+});
+
+expectError(class extends Base { // 1240
+	@fieldDec static foo = 42;
+});
+expectError(class extends Base { // 1240, 1270
+	@fieldDec foo = "bar"
+});
+expectError(class { // 1240
+	@fieldDec foo = 42;
+});
+
+expectError(class {
+	@tooFewArguments foo() {}
+});
+expectError(class extends Base {
+	@badReturnType accessor foo = 42;
+})
+
+expectError(class {
+	@factory("bar") foo(a: number) {}
+});
+expectError(class {
+	@factory foo(a: number) {}
+});

source/test/fixtures/expect-error/decorators/package.json

@@ -0,0 +1,3 @@
+{
+	"name": "foo"
+}

source/test/fixtures/expect-error/experimental-decorators/index.d.ts

@@ -0,0 +1,15 @@
+export declare class Base {
+	dummy(a: string, b: number): boolean;
+}
+
+export function classDec<T extends new (a: number, b: boolean) => Base>(constructor: T): T;
+export function methodDec(target: Base, propertyKey: string, descriptor: TypedPropertyDescriptor<(a: number, b: number) => boolean>): void
+export function getterDec(target: Base, propertyKey: string, descriptor: TypedPropertyDescriptor<number>): void;
+export function setterDec(target: Base, propertyKey: string, descriptor: TypedPropertyDescriptor<number>): void;
+export function propertyDec(target: Base, propertyKey: string): void;
+export function parameterDec(target: Base, propertyKey: string, parameterIndex: number): void;
+
+export function tooFewArguments(target: Base): PropertyDescriptor;
+export function badReturnType(target: Base, propertyKey: string, descriptor: PropertyDescriptor): number;
+
+export function factory(arg: number): (target: Base, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

source/test/fixtures/expect-error/experimental-decorators/index.js

@@ -0,0 +1,6 @@
+module.exports.classDec = (constructor) => {};
+module.exports.methodDec = (target, propertyKey, descriptor) => {};
+module.exports.getterDec = (target, propertyKey, descriptor) => {};
+module.exports.setterDec = (target, propertyKey, descriptor) => {};
+module.exports.accessorDec = (target, propertyKey, descriptor) => {};
+module.exports.fieldDec = (target, propertyKey, descriptor) => {};

source/test/fixtures/expect-error/experimental-decorators/index.test-d.ts

@@ -0,0 +1,111 @@
+import {expectError} from '../../../..';
+import {Base, classDec, methodDec, getterDec, setterDec, propertyDec, parameterDec, tooFewArguments, badReturnType, factory} from '.';
+
+expectError(() => { // 1238, 1270
+	@classDec
+	class Test {}
+});
+expectError(() => { // 1238, 1270
+	@classDec
+	abstract class Test extends Base {}
+});
+
+expectError(() => { // 1241
+	class Test extends Base {
+		@methodDec static foo(a: string, b: number) { return true; }
+	}
+});
+expectError(() => { // 1241
+	class Test extends Base {
+		@methodDec foo() {}
+	}
+});
+expectError(() => { // 1241
+	class Test {
+		@methodDec foo(a: string, b: number) { return true; }
+	}
+});
+expectError(() => { // 1249
+	class Test extends Base {
+		@methodDec override dummy(a: string, b: number): boolean
+		dummy(): void
+		dummy(a?: string, b?: number) : boolean|void {}
+	}
+});
+
+expectError(() => { // 1241
+	class Test extends Base {
+		@getterDec static get foo() { return 42; }
+	}
+});
+expectError(() => { // 1241
+	class Test extends Base {
+		@getterDec get foo() { return "bar"; }
+	}
+});
+expectError(() => { // 1241
+	class Test {
+		@getterDec get foo() { return 42; }
+	}
+});
+
+expectError(() => { // 1241
+	class Test extends Base {
+		@setterDec static set foo(value: number) {}
+	}
+});
+expectError(() => { // 1241
+	class Test extends Base {
+		@setterDec static set foo(value: string) {}
+	}
+});
+expectError(() => { // 1241
+	class Test {
+		@setterDec set foo(value: number) {}
+	}
+});
+
+expectError(() => { // 1240
+	class Test extends Base {
+		@propertyDec static foo = 42;
+	}
+});
+expectError(() => { // 1240
+	class Test {
+		@propertyDec foo = 42;
+	}
+});
+
+expectError(() => { // 1239
+	class Test extends Base {
+		static foo(@parameterDec a: number) {}
+	}
+});
+expectError(() => { // 1241
+	class Test {
+		foo(@parameterDec a: number) {}
+	}
+});
+
+
+expectError(() => {
+	class Test {
+		@tooFewArguments foo() {}
+	}
+});
+expectError(() => { // 1271
+	class Test extends Base {
+		@badReturnType accessor foo = 42;
+	}
+})
+
+expectError(() => {
+	class Test {
+		@factory("bar") foo(a: number) {}
+	}
+});
+expectError(() => {
+	class Test {
+		@factory foo(a: number) {}
+	}
+});

source/test/fixtures/expect-error/experimental-decorators/package.json

@@ -0,0 +1,8 @@
+{
+	"name": "foo",
+	"tsd": {
+		"compilerOptions": {
+			"experimentalDecorators": true
+		}
+	}
+}