jsii-diff 1.35.0

package/test/classes.test.js

@@ -0,0 +1,542 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("./util");
+// ----------------------------------------------------------------------
+test('okay to add a new class', () => util_1.expectNoError(`
+    export class Foo1 { }
+  `, `
+    export class Foo1 { }
+    export class Foo2 { }
+  `));
+// ----------------------------------------------------------------------
+test('okay to add a new function to a class', () => util_1.expectNoError(`
+    export class Foo { }
+  `, `
+    export class Foo {
+      public bar(): void { }
+    }
+  `));
+// ----------------------------------------------------------------------
+test('not okay to add a required argument to a method', () => util_1.expectError(/newly required argument/, `
+    export class Foo {
+      public bar(arg1: string): void {
+        Array.isArray(arg1);
+      }
+    }
+  `, `
+    export class Foo {
+      public bar(arg1: string, arg2: string): void {
+        Array.isArray(arg1);
+        Array.isArray(arg2);
+      }
+    }
+  `));
+// ----------------------------------------------------------------------
+test('okay to make a required argument optional', () => util_1.expectNoError(`
+    export class Foo {
+      public bar(arg1: string, arg2: string): void {
+        Array.isArray(arg1);
+        Array.isArray(arg2);
+      }
+    }
+  `, `
+    export class Foo {
+      public bar(arg1: string, arg2?: string): void {
+        Array.isArray(arg1);
+        Array.isArray(arg2);
+      }
+    }
+  `));
+// ----------------------------------------------------------------------
+test('okay to turn required arguments into varargs', () => util_1.expectNoError(`
+    export class Foo {
+      public bar(arg1: string, arg2: number, arg3: number): void {
+        Array.isArray(arg1);
+        Array.isArray(arg2);
+        Array.isArray(arg3);
+      }
+    }
+  `, `
+    export class Foo {
+      public bar(arg1: string, ...args: number[]): void {
+        Array.isArray(arg1);
+        Array.isArray(args);
+      }
+    }
+  `));
+// ----------------------------------------------------------------------
+test('not allowed to change argument type to a different scalar', () => util_1.expectError(/method.*foo.*argument arg1, takes number \(formerly string\): string is not assignable to number/i, `
+    export class Foo {
+      public bar(arg1: string): void {
+        Array.isArray(arg1);
+      }
+    }
+  `, `
+    export class Foo {
+      public bar(arg1: number): void {
+        Array.isArray(arg1);
+      }
+    }
+  `));
+// ----------------------------------------------------------------------
+test('cannot add any abstract members to a subclassable class', () => util_1.expectError(/adds requirement for subclasses to implement 'piet'./, `
+    /**
+     * @subclassable
+     */
+    export abstract class Henk {
+      abstract readonly name: string;
+    }
+  `, `
+    /**
+     * @subclassable
+     */
+    export abstract class Henk {
+      abstract readonly name: string;
+      abstract readonly piet: string;
+    }
+  `));
+// ----------------------------------------------------------------------
+test('cannot add any members to a subclassable interface, not even optional ones', () => util_1.expectError(/adds requirement for subclasses to implement 'piet'./, `
+    /**
+     * @subclassable
+     */
+    export interface IHenk {
+      name: string;
+    }
+  `, `
+    /**
+     * @subclassable
+     */
+    export interface IHenk {
+      name: string;
+      piet?: string;
+    }
+  `));
+// ----------------------------------------------------------------------
+test('cannot make a member less visible', () => util_1.expectError(/changed from 'public' to 'protected'/, `
+    export class Henk {
+      public name: string = 'henk';
+    }
+  `, `
+    export class Henk {
+      protected name: string = 'henk';
+    }
+  `));
+// ----------------------------------------------------------------------
+describe('implement base types need to be present in updated type system', () => {
+    test('for interfaces', () => util_1.expectError(/not assignable to all base types anymore/, `
+      export interface IPapa {
+        readonly pipe: string;
+      }
+
+      export interface IBebe extends IPapa {
+        readonly pacifier: string;
+      }
+    `, `
+      export interface IPapa {
+        readonly pipe: string;
+      }
+
+      export interface IBebe {
+        readonly pacifier: string;
+      }
+    `));
+    test('for structs', () => util_1.expectError(/not assignable to all base types anymore/, `
+      export interface Papa {
+        readonly pipe: string;
+      }
+
+      export interface Bebe extends Papa {
+        readonly pacifier: string;
+      }
+    `, `
+      export interface Papa {
+        readonly pipe: string;
+      }
+
+      export interface Bebe {
+        readonly pacifier: string;
+      }
+    `));
+    test('for classes', () => util_1.expectError(/not assignable to all base types anymore/, `
+      export interface IPapa {
+        readonly pipe: string;
+      }
+
+      export class Bebe implements IPapa {
+        readonly pipe: string = 'pff';
+        readonly pacifier: string = 'mmm';
+      }
+    `, `
+      export interface IPapa {
+        readonly pipe: string;
+      }
+
+      export class Bebe {
+        readonly pipe: string = 'pff';
+        readonly pacifier: string = 'mmm';
+      }
+    `));
+    test('for base classes', () => util_1.expectError(/not assignable to all base types anymore/, `
+      export class Papa {
+        readonly pipe: string = 'pff';
+      }
+
+      export class Bebe extends Papa {
+        readonly pacifier: string = 'mmm';
+      }
+    `, `
+      export class Papa {
+        readonly pipe: string = 'pff';
+      }
+
+      export class Bebe {
+        readonly pacifier: string = 'mmm';
+      }
+    `));
+    test('new levels of inheritance are allowed', () => util_1.expectNoError(`
+      export class Papa {
+        readonly pipe: string = 'pff';
+      }
+
+      export class Bebe extends Papa {
+        readonly pacifier: string = 'mmm';
+      }
+    `, `
+      export class Papa {
+        readonly pipe: string = 'pff';
+      }
+
+      export class Inbetween extends Papa {
+      }
+
+      export class Bebe extends Inbetween {
+        readonly pacifier: string = 'mmm';
+      }
+    `));
+    test('change direct implementation to inherited implementation via interface', () => util_1.expectNoError(`
+      export interface IPapa {
+        readonly pipe: string;
+      }
+
+      export class Bebe implements IPapa {
+        readonly pipe: string = 'pff';
+        readonly pacifier: string = 'mmm';
+      }
+    `, `
+      export interface IPapa {
+        readonly pipe: string;
+      }
+
+      export interface IInbetween extends IPapa {
+      }
+
+      export class Bebe implements IInbetween {
+        readonly pipe: string = 'pff';
+        readonly pacifier: string = 'mmm';
+      }
+    `));
+    test('change direct implementation to inherited implementation via base class', () => util_1.expectNoError(`
+      export interface IPapa {
+        readonly pipe: string;
+      }
+
+      export class Bebe implements IPapa {
+        readonly pipe: string = 'pff';
+        readonly pacifier: string = 'mmm';
+      }
+    `, `
+      export interface IPapa {
+        readonly pipe: string;
+      }
+
+      export class Inbetween implements IPapa {
+        readonly pipe: string = 'pff';
+      }
+
+      export class Bebe extends Inbetween {
+        readonly pacifier: string = 'mmm';
+      }
+    `));
+});
+// ----------------------------------------------------------------------
+test.each([
+    {
+        oldDecl: 'name: string',
+        newDecl: 'name?: string',
+        error: /type Optional<string> \(formerly string\): output type is now optional/,
+    },
+    {
+        oldDecl: 'name?: string',
+        newDecl: 'name: string',
+        error: undefined,
+    },
+    {
+        oldDecl: 'name: string',
+        newDecl: 'name: string | number',
+        error: /string \| number is not assignable to string/,
+    },
+    {
+        oldDecl: 'name: string | number',
+        newDecl: 'name: string',
+        error: undefined,
+    },
+])('change class property ', ({ oldDecl, newDecl, error }) => util_1.expectError(error, `
+    export class Henk {
+      public readonly ${oldDecl} = 'henk';
+    }
+  `, `
+    export class Henk {
+      public readonly ${newDecl} = 'henk';
+    }
+  `));
+// ----------------------------------------------------------------------
+test.each([
+    {
+        oldDecl: 'name: string',
+        newDecl: 'name?: string',
+        error: /changed to Optional<string> \(formerly string\)/,
+    },
+    {
+        oldDecl: 'name?: string',
+        newDecl: 'name: string',
+        error: /changed to string \(formerly Optional<string>\)/,
+    },
+    {
+        oldDecl: 'name: string',
+        newDecl: 'name: string | number',
+        error: /changed to string \| number \(formerly string\)/,
+    },
+    {
+        oldDecl: 'name: string | number',
+        newDecl: 'name: string',
+        error: /changed to string \(formerly string \| number\)/,
+    },
+])('cannot change a mutable class property type: %p to %p', ({ oldDecl, newDecl, error }) => util_1.expectError(error, `
+      export class Henk {
+        public ${oldDecl} = 'henk';
+      }
+    `, `
+      export class Henk {
+        public ${newDecl} = 'henk';
+      }
+    `));
+// ----------------------------------------------------------------------
+test('consider inherited constructor', () => util_1.expectError(/number is not assignable to string/, `
+    export class Super {
+      constructor(param: number) {
+        Array.isArray(param);
+      }
+    }
+    export class Sub extends Super {
+    }
+  `, `
+    export class Super {
+      constructor(param: number) {
+        Array.isArray(param);
+      }
+    }
+    export class Sub extends Super {
+      constructor(param: string) {
+        super(5);
+        Array.isArray(param);
+      }
+    }
+  `));
+// ----------------------------------------------------------------------
+test('consider inherited constructor, the other way', () => util_1.expectError(/newly required argument/, `
+    export class Super {
+      constructor(param: number) {
+        Array.isArray(param);
+      }
+    }
+    export class Sub extends Super {
+      constructor() {
+        super(5);
+      }
+    }
+  `, `
+    export class Super {
+      constructor(param: number) {
+        Array.isArray(param);
+      }
+    }
+    export class Sub extends Super {
+    }
+  `));
+// ----------------------------------------------------------------------
+test('method can be moved to supertype', () => util_1.expectNoError(`
+    export class Super {
+    }
+    export class Sub extends Super {
+      public foo(param: number) {
+        Array.isArray(param);
+      }
+    }
+  `, `
+    export class Super {
+      public foo(param: number) {
+        Array.isArray(param);
+      }
+    }
+    export class Sub extends Super {
+    }
+  `));
+// ----------------------------------------------------------------------
+test('property can be moved to supertype', () => util_1.expectNoError(`
+    export class Super {
+    }
+    export class Sub extends Super {
+      public foo: string = 'foo';
+    }
+  `, `
+    export class Super {
+      public foo: string = 'foo';
+    }
+    export class Sub extends Super {
+    }
+  `));
+// ----------------------------------------------------------------------
+test('subclassable is forever', () => util_1.expectError(/has gone from @subclassable to non-@subclassable/, `
+    /**
+     * @subclassable
+     */
+    export class Super {
+    }
+  `, `
+    export class Super {
+    }
+  `));
+// ----------------------------------------------------------------------
+test('change from method to property', () => util_1.expectError(/changed from method to property/, `
+    export class Boom {
+      public foo() { return 12; }
+    }
+    `, `
+    export class Boom {
+      public get foo() { return 12; }
+    }
+    `));
+// ----------------------------------------------------------------------
+test('change from method with arguments to property', () => util_1.expectError(/changed from method to property/, `
+    export class Boom {
+      public foo(arg: number) { return 12 * arg; }
+    }
+    `, `
+    export class Boom {
+      public get foo() { return 12; }
+    }
+    `));
+// ----------------------------------------------------------------------
+test('change from property to method', () => util_1.expectError(/changed from property to method/, `
+    export class Boom {
+      public get foo() { return 12; }
+    }
+    `, `
+    export class Boom {
+      public foo() { return 12; }
+    }
+    `));
+// ----------------------------------------------------------------------
+test.each([
+    {
+        oldDecl: 'foo(arg: string) { Array.isArray(arg); }',
+        newDecl: 'foo(arg: string | number) { Array.isArray(arg); }',
+    },
+    {
+        oldDecl: 'foo(): string { return "x"; }',
+        newDecl: 'foo(): string | number { return "x"; }',
+    },
+    {
+        oldDecl: 'readonly foo: string = "x";',
+        newDecl: 'readonly foo: string | number = "x";',
+    },
+])('cannot change any type in @subclassable class: %p to %p', ({ oldDecl, newDecl }) => util_1.expectError(/type is @subclassable/, `
+      /** @subclassable */
+      export class Boom {
+        public ${oldDecl}
+      }
+      `, `
+      /** @subclassable */
+      export class Boom {
+        public ${newDecl}
+      }
+      `));
+// ----------------------------------------------------------------------
+test.each([
+    {
+        oldDecl: 'foo(arg: string): void;',
+        newDecl: 'foo(arg: string | number): void;',
+    },
+    { oldDecl: 'foo(): string;', newDecl: 'foo(): string | number;' },
+    {
+        oldDecl: 'readonly foo: string;',
+        newDecl: 'readonly foo: string | number;',
+    },
+])('cannot change any type in @subclassable interface: %p to %p', ({ oldDecl, newDecl }) => util_1.expectError(/type is @subclassable/, `
+      /** @subclassable */
+      export interface IBoom {
+        ${oldDecl}
+      }
+      `, `
+      /** @subclassable */
+      export interface IBoom {
+        ${newDecl}
+      }
+      `));
+// ----------------------------------------------------------------------
+test.each([
+    // No usage => can add field
+    ['', true],
+    // Return type => can add field
+    ['foo(): TheStruct;', true],
+    ['readonly foo: TheStruct;', true],
+    // Input type => can NOT add field
+    ['foo: TheStruct;', false],
+    ['foo(arg: TheStruct): void', false],
+])('add required field to structs: refencing via %p -> allowed %p', (usageDecl, allowed) => util_1.expectError(allowed ? undefined : /newly required property 'fieldTwo' added/, `
+      export interface TheStruct {
+        readonly fieldOne: string;
+      }
+
+      export interface IConsumer {
+        ${usageDecl}
+      }
+      `, `
+      export interface TheStruct {
+        readonly fieldOne: string;
+        readonly fieldTwo: string;
+      }
+
+      export interface IConsumer {
+        ${usageDecl}
+      }
+      `));
+// ----------------------------------------------------------------------
+test.each([
+    // No usage => can add field
+    ['', true],
+    // Return type => can NOT remove information
+    ['foo(): TheStruct;', false],
+    ['readonly foo: TheStruct;', false],
+    ['foo: TheStruct;', false],
+    // Input type => can make optional
+    ['foo(arg: TheStruct): void', true],
+])('make required field optional: refencing via %p -> allowed %p', (usageDecl, allowed) => util_1.expectError(allowed ? undefined : /formerly required property 'fieldOne' is optional/, `
+      export interface TheStruct {
+        readonly fieldOne: string;
+      }
+
+      export interface IConsumer {
+        ${usageDecl}
+      }
+      `, `
+      export interface TheStruct {
+        readonly fieldOne?: string;
+      }
+
+      export interface IConsumer {
+        ${usageDecl}
+      }
+      `));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.test.js","sourceRoot":"","sources":["classes.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { expectError, expectNoError } from './util';\n\n// ----------------------------------------------------------------------\n\ntest('okay to add a new class', () =>\n  expectNoError(\n    `\n    export class Foo1 { }\n  `,\n    `\n    export class Foo1 { }\n    export class Foo2 { }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('okay to add a new function to a class', () =>\n  expectNoError(\n    `\n    export class Foo { }\n  `,\n    `\n    export class Foo {\n      public bar(): void { }\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('not okay to add a required argument to a method', () =>\n  expectError(\n    /newly required argument/,\n    `\n    export class Foo {\n      public bar(arg1: string): void {\n        Array.isArray(arg1);\n      }\n    }\n  `,\n    `\n    export class Foo {\n      public bar(arg1: string, arg2: string): void {\n        Array.isArray(arg1);\n        Array.isArray(arg2);\n      }\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('okay to make a required argument optional', () =>\n  expectNoError(\n    `\n    export class Foo {\n      public bar(arg1: string, arg2: string): void {\n        Array.isArray(arg1);\n        Array.isArray(arg2);\n      }\n    }\n  `,\n    `\n    export class Foo {\n      public bar(arg1: string, arg2?: string): void {\n        Array.isArray(arg1);\n        Array.isArray(arg2);\n      }\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('okay to turn required arguments into varargs', () =>\n  expectNoError(\n    `\n    export class Foo {\n      public bar(arg1: string, arg2: number, arg3: number): void {\n        Array.isArray(arg1);\n        Array.isArray(arg2);\n        Array.isArray(arg3);\n      }\n    }\n  `,\n    `\n    export class Foo {\n      public bar(arg1: string, ...args: number[]): void {\n        Array.isArray(arg1);\n        Array.isArray(args);\n      }\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('not allowed to change argument type to a different scalar', () =>\n  expectError(\n    /method.*foo.*argument arg1, takes number \\(formerly string\\): string is not assignable to number/i,\n    `\n    export class Foo {\n      public bar(arg1: string): void {\n        Array.isArray(arg1);\n      }\n    }\n  `,\n    `\n    export class Foo {\n      public bar(arg1: number): void {\n        Array.isArray(arg1);\n      }\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('cannot add any abstract members to a subclassable class', () =>\n  expectError(\n    /adds requirement for subclasses to implement 'piet'./,\n    `\n    /**\n     * @subclassable\n     */\n    export abstract class Henk {\n      abstract readonly name: string;\n    }\n  `,\n    `\n    /**\n     * @subclassable\n     */\n    export abstract class Henk {\n      abstract readonly name: string;\n      abstract readonly piet: string;\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('cannot add any members to a subclassable interface, not even optional ones', () =>\n  expectError(\n    /adds requirement for subclasses to implement 'piet'./,\n    `\n    /**\n     * @subclassable\n     */\n    export interface IHenk {\n      name: string;\n    }\n  `,\n    `\n    /**\n     * @subclassable\n     */\n    export interface IHenk {\n      name: string;\n      piet?: string;\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('cannot make a member less visible', () =>\n  expectError(\n    /changed from 'public' to 'protected'/,\n    `\n    export class Henk {\n      public name: string = 'henk';\n    }\n  `,\n    `\n    export class Henk {\n      protected name: string = 'henk';\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ndescribe('implement base types need to be present in updated type system', () => {\n  test('for interfaces', () =>\n    expectError(\n      /not assignable to all base types anymore/,\n      `\n      export interface IPapa {\n        readonly pipe: string;\n      }\n\n      export interface IBebe extends IPapa {\n        readonly pacifier: string;\n      }\n    `,\n      `\n      export interface IPapa {\n        readonly pipe: string;\n      }\n\n      export interface IBebe {\n        readonly pacifier: string;\n      }\n    `,\n    ));\n\n  test('for structs', () =>\n    expectError(\n      /not assignable to all base types anymore/,\n      `\n      export interface Papa {\n        readonly pipe: string;\n      }\n\n      export interface Bebe extends Papa {\n        readonly pacifier: string;\n      }\n    `,\n      `\n      export interface Papa {\n        readonly pipe: string;\n      }\n\n      export interface Bebe {\n        readonly pacifier: string;\n      }\n    `,\n    ));\n\n  test('for classes', () =>\n    expectError(\n      /not assignable to all base types anymore/,\n      `\n      export interface IPapa {\n        readonly pipe: string;\n      }\n\n      export class Bebe implements IPapa {\n        readonly pipe: string = 'pff';\n        readonly pacifier: string = 'mmm';\n      }\n    `,\n      `\n      export interface IPapa {\n        readonly pipe: string;\n      }\n\n      export class Bebe {\n        readonly pipe: string = 'pff';\n        readonly pacifier: string = 'mmm';\n      }\n    `,\n    ));\n\n  test('for base classes', () =>\n    expectError(\n      /not assignable to all base types anymore/,\n      `\n      export class Papa {\n        readonly pipe: string = 'pff';\n      }\n\n      export class Bebe extends Papa {\n        readonly pacifier: string = 'mmm';\n      }\n    `,\n      `\n      export class Papa {\n        readonly pipe: string = 'pff';\n      }\n\n      export class Bebe {\n        readonly pacifier: string = 'mmm';\n      }\n    `,\n    ));\n\n  test('new levels of inheritance are allowed', () =>\n    expectNoError(\n      `\n      export class Papa {\n        readonly pipe: string = 'pff';\n      }\n\n      export class Bebe extends Papa {\n        readonly pacifier: string = 'mmm';\n      }\n    `,\n      `\n      export class Papa {\n        readonly pipe: string = 'pff';\n      }\n\n      export class Inbetween extends Papa {\n      }\n\n      export class Bebe extends Inbetween {\n        readonly pacifier: string = 'mmm';\n      }\n    `,\n    ));\n\n  test('change direct implementation to inherited implementation via interface', () =>\n    expectNoError(\n      `\n      export interface IPapa {\n        readonly pipe: string;\n      }\n\n      export class Bebe implements IPapa {\n        readonly pipe: string = 'pff';\n        readonly pacifier: string = 'mmm';\n      }\n    `,\n      `\n      export interface IPapa {\n        readonly pipe: string;\n      }\n\n      export interface IInbetween extends IPapa {\n      }\n\n      export class Bebe implements IInbetween {\n        readonly pipe: string = 'pff';\n        readonly pacifier: string = 'mmm';\n      }\n    `,\n    ));\n\n  test('change direct implementation to inherited implementation via base class', () =>\n    expectNoError(\n      `\n      export interface IPapa {\n        readonly pipe: string;\n      }\n\n      export class Bebe implements IPapa {\n        readonly pipe: string = 'pff';\n        readonly pacifier: string = 'mmm';\n      }\n    `,\n      `\n      export interface IPapa {\n        readonly pipe: string;\n      }\n\n      export class Inbetween implements IPapa {\n        readonly pipe: string = 'pff';\n      }\n\n      export class Bebe extends Inbetween {\n        readonly pacifier: string = 'mmm';\n      }\n    `,\n    ));\n});\n\n// ----------------------------------------------------------------------\n\ntest.each([\n  {\n    oldDecl: 'name: string',\n    newDecl: 'name?: string',\n    error:\n      /type Optional<string> \\(formerly string\\): output type is now optional/,\n  },\n  {\n    oldDecl: 'name?: string',\n    newDecl: 'name: string',\n    error: undefined, // Strengthening is okay\n  },\n  {\n    oldDecl: 'name: string',\n    newDecl: 'name: string | number',\n    error: /string \\| number is not assignable to string/,\n  },\n  {\n    oldDecl: 'name: string | number',\n    newDecl: 'name: string',\n    error: undefined, // Strengthening is okay\n  },\n])('change class property ', ({ oldDecl, newDecl, error }) =>\n  expectError(\n    error,\n    `\n    export class Henk {\n      public readonly ${oldDecl} = 'henk';\n    }\n  `,\n    `\n    export class Henk {\n      public readonly ${newDecl} = 'henk';\n    }\n  `,\n  ),\n);\n\n// ----------------------------------------------------------------------\n\ntest.each([\n  {\n    oldDecl: 'name: string',\n    newDecl: 'name?: string',\n    error: /changed to Optional<string> \\(formerly string\\)/,\n  },\n  {\n    oldDecl: 'name?: string',\n    newDecl: 'name: string',\n    error: /changed to string \\(formerly Optional<string>\\)/,\n  },\n  {\n    oldDecl: 'name: string',\n    newDecl: 'name: string | number',\n    error: /changed to string \\| number \\(formerly string\\)/,\n  },\n  {\n    oldDecl: 'name: string | number',\n    newDecl: 'name: string',\n    error: /changed to string \\(formerly string \\| number\\)/,\n  },\n])(\n  'cannot change a mutable class property type: %p to %p',\n  ({ oldDecl, newDecl, error }) =>\n    expectError(\n      error,\n      `\n      export class Henk {\n        public ${oldDecl} = 'henk';\n      }\n    `,\n      `\n      export class Henk {\n        public ${newDecl} = 'henk';\n      }\n    `,\n    ),\n);\n\n// ----------------------------------------------------------------------\n\ntest('consider inherited constructor', () =>\n  expectError(\n    /number is not assignable to string/,\n    `\n    export class Super {\n      constructor(param: number) {\n        Array.isArray(param);\n      }\n    }\n    export class Sub extends Super {\n    }\n  `,\n    `\n    export class Super {\n      constructor(param: number) {\n        Array.isArray(param);\n      }\n    }\n    export class Sub extends Super {\n      constructor(param: string) {\n        super(5);\n        Array.isArray(param);\n      }\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('consider inherited constructor, the other way', () =>\n  expectError(\n    /newly required argument/,\n    `\n    export class Super {\n      constructor(param: number) {\n        Array.isArray(param);\n      }\n    }\n    export class Sub extends Super {\n      constructor() {\n        super(5);\n      }\n    }\n  `,\n    `\n    export class Super {\n      constructor(param: number) {\n        Array.isArray(param);\n      }\n    }\n    export class Sub extends Super {\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('method can be moved to supertype', () =>\n  expectNoError(\n    `\n    export class Super {\n    }\n    export class Sub extends Super {\n      public foo(param: number) {\n        Array.isArray(param);\n      }\n    }\n  `,\n    `\n    export class Super {\n      public foo(param: number) {\n        Array.isArray(param);\n      }\n    }\n    export class Sub extends Super {\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('property can be moved to supertype', () =>\n  expectNoError(\n    `\n    export class Super {\n    }\n    export class Sub extends Super {\n      public foo: string = 'foo';\n    }\n  `,\n    `\n    export class Super {\n      public foo: string = 'foo';\n    }\n    export class Sub extends Super {\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('subclassable is forever', () =>\n  expectError(\n    /has gone from @subclassable to non-@subclassable/,\n    `\n    /**\n     * @subclassable\n     */\n    export class Super {\n    }\n  `,\n    `\n    export class Super {\n    }\n  `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('change from method to property', () =>\n  expectError(\n    /changed from method to property/,\n    `\n    export class Boom {\n      public foo() { return 12; }\n    }\n    `,\n    `\n    export class Boom {\n      public get foo() { return 12; }\n    }\n    `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('change from method with arguments to property', () =>\n  expectError(\n    /changed from method to property/,\n    `\n    export class Boom {\n      public foo(arg: number) { return 12 * arg; }\n    }\n    `,\n    `\n    export class Boom {\n      public get foo() { return 12; }\n    }\n    `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest('change from property to method', () =>\n  expectError(\n    /changed from property to method/,\n    `\n    export class Boom {\n      public get foo() { return 12; }\n    }\n    `,\n    `\n    export class Boom {\n      public foo() { return 12; }\n    }\n    `,\n  ));\n\n// ----------------------------------------------------------------------\n\ntest.each([\n  {\n    oldDecl: 'foo(arg: string) { Array.isArray(arg); }',\n    newDecl: 'foo(arg: string | number) { Array.isArray(arg); }',\n  },\n  {\n    oldDecl: 'foo(): string { return \"x\"; }',\n    newDecl: 'foo(): string | number { return \"x\"; }',\n  },\n  {\n    oldDecl: 'readonly foo: string = \"x\";',\n    newDecl: 'readonly foo: string | number = \"x\";',\n  },\n])(\n  'cannot change any type in @subclassable class: %p to %p',\n  ({ oldDecl, newDecl }) =>\n    expectError(\n      /type is @subclassable/,\n      `\n      /** @subclassable */\n      export class Boom {\n        public ${oldDecl}\n      }\n      `,\n      `\n      /** @subclassable */\n      export class Boom {\n        public ${newDecl}\n      }\n      `,\n    ),\n);\n\n// ----------------------------------------------------------------------\n\ntest.each([\n  {\n    oldDecl: 'foo(arg: string): void;',\n    newDecl: 'foo(arg: string | number): void;',\n  },\n  { oldDecl: 'foo(): string;', newDecl: 'foo(): string | number;' },\n  {\n    oldDecl: 'readonly foo: string;',\n    newDecl: 'readonly foo: string | number;',\n  },\n])(\n  'cannot change any type in @subclassable interface: %p to %p',\n  ({ oldDecl, newDecl }) =>\n    expectError(\n      /type is @subclassable/,\n      `\n      /** @subclassable */\n      export interface IBoom {\n        ${oldDecl}\n      }\n      `,\n      `\n      /** @subclassable */\n      export interface IBoom {\n        ${newDecl}\n      }\n      `,\n    ),\n);\n\n// ----------------------------------------------------------------------\n\ntest.each([\n  // No usage => can add field\n  ['', true],\n  // Return type => can add field\n  ['foo(): TheStruct;', true],\n  ['readonly foo: TheStruct;', true],\n  // Input type => can NOT add field\n  ['foo: TheStruct;', false],\n  ['foo(arg: TheStruct): void', false],\n])(\n  'add required field to structs: refencing via %p -> allowed %p',\n  (usageDecl, allowed) =>\n    expectError(\n      allowed ? undefined : /newly required property 'fieldTwo' added/,\n      `\n      export interface TheStruct {\n        readonly fieldOne: string;\n      }\n\n      export interface IConsumer {\n        ${usageDecl}\n      }\n      `,\n      `\n      export interface TheStruct {\n        readonly fieldOne: string;\n        readonly fieldTwo: string;\n      }\n\n      export interface IConsumer {\n        ${usageDecl}\n      }\n      `,\n    ),\n);\n\n// ----------------------------------------------------------------------\n\ntest.each([\n  // No usage => can add field\n  ['', true],\n  // Return type => can NOT remove information\n  ['foo(): TheStruct;', false],\n  ['readonly foo: TheStruct;', false],\n  ['foo: TheStruct;', false],\n  // Input type => can make optional\n  ['foo(arg: TheStruct): void', true],\n])(\n  'make required field optional: refencing via %p -> allowed %p',\n  (usageDecl, allowed) =>\n    expectError(\n      allowed ? undefined : /formerly required property 'fieldOne' is optional/,\n      `\n      export interface TheStruct {\n        readonly fieldOne: string;\n      }\n\n      export interface IConsumer {\n        ${usageDecl}\n      }\n      `,\n      `\n      export interface TheStruct {\n        readonly fieldOne?: string;\n      }\n\n      export interface IConsumer {\n        ${usageDecl}\n      }\n      `,\n    ),\n);\n"]}

package/test/diagnostics.test.d.ts

@@ -0,0 +1 @@
+export {};