Adds examples/tests of constructing generic types.

This mostly works as expected, with the one caveat that constructing a generic `Foo<T>` with `ctor.new(Foo)` actually results in a return-only generic. TypeScript is a little awkward about these and it will actually be typed as `Foo<unknown>`. This is unfortunate, and the best practice around return-only generics is generally considered casting them to the desired type at each call site. This means that a user should really do `ctor.new(Foo) as ctor<Foo<T>>`, which is a bit annoying syntatically, but not that big a deal in the grand scheme of things.

More annoyingly is that TypeScript does not allow type parameters in the `extends` clause of a class when used as an expression. This makes sense for TypeScript because a class type `T` is not known until the class is instantiated, long after it was declared as extending a different class. However, with the recent changes in `ctor<T>`, the inheritance hierarchy is not built until construction-time, so we actually do know the value of `T`. Unfortunately this can't be expressed in TypeScript, so our best option is to simply `@ts-ignore` the error. This is not ideal, but TypeScript *mostly* does what we want in this case. The one issue here is that superclass members are typed as `any`, which is quite unfortunate but I don't see a good way around that.

See: microsoft/TypeScript#26154 (comment)

Author: dgp1130

src/ctor_test.ts

@@ -165,6 +165,66 @@ describe('ctor', () => {
         expect(bar.abstractFooMethod()).toBe('abstractFooMethod');
     });
 
+    it('supports generics', () => {
+        class Foo<T> {
+            public readonly value: T;
+
+            /** Boilerplate, should be generated by compiler. */
+            public constructor({ value }: { value: T }) {
+                this.value = value;
+            }
+
+            public static from<T>(value: T): Foo<T> {
+                return Foo.extend(value).construct();
+            }
+
+            public static extend<T>(value: T): ctor<Foo<T>> {
+                // Ctor has a return-only generic, so generic classes need to be
+                // casted to the correct T value.
+                return ctor.new(Foo, { value }) as ctor<Foo<T>>;
+            }
+        }
+
+        const foo = Foo.from('test');
+        expect(foo).toBeInstanceOf(Foo);
+        expect(foo.value).toBe('test');
+        // @ts-expect-error `foo.value` should be typed as string.
+        ((x: number) => x = foo.value);
+
+        // @ts-ignore In TypeScript, type parameters are not in scope for
+        // superclass declarations because type T is not known when the class
+        // hierarchy is created. This makes sense in TypeScript, but not for
+        // `ctor<T>`, where the class hierarchy is dynamic until it is
+        // constructed. We simply ignore the type error for now.
+        // See: https://github.com/microsoft/TypeScript/issues/26154#issuecomment-410848076
+        class Bar<T1, T2> extends Implementation<Foo<T1>>() {
+            public readonly value2: T2;
+
+            /** Boilerplate, should be generated by compiler. */
+            public constructor({ value2 }: { value2: T2 }) {
+                super();
+                this.value2 = value2;
+            }
+
+            public static from<T1, T2>(value: T1, value2: T2): Bar<T1, T2> {
+                const barCtor = from(Foo.extend(value))
+                        .new(Bar, { value2 }) as ctor<Bar<T1, T2>>;
+                return barCtor.construct();
+            }
+        }
+
+        const bar = Bar.from('test', 1);
+        expect(bar).toBeInstanceOf(Foo);
+        expect(bar).toBeInstanceOf(Bar);
+        expect(bar.value).toBe('test');
+        expect(bar.value2).toBe(1);
+        // `bar.value` **should** be typed as string, but TypeScript's generic
+        // limitations mean this is currently incorrectly typed as `any`.
+        ((x: number) => x = bar.value);
+        // @ts-expect-error `bar.value2` should be typed as number.
+        ((x: string) => x = bar.value2);
+    });
+
     it('allows static factories of the same name across inherited classes', () => {
         class Foo {
             public readonly foo: string;