Repository: TypeScript
Issue: Need a dummy overload to improve inference
Labels: Bug

**TypeScript Version:**  3.x, 4.0.0-beta, nightly

**Search Terms:** dummy fake overload infer

**Code**
```ts
class FieldEvent<T extends Field> {
    constructor(readonly field: T, readonly message: string) { }
}

class Field {
    listen<T extends FieldEvent<Field>>(type: new (...args: any[]) => T, listener: (event: T) => void): void { }
}

class BeforeSetEvent<T extends number | string> extends FieldEvent<ValueField<T>> {
    constructor(field: ValueField<T>, public newValue: T) { super(field, ""); }
}

class AfterSetEvent<T extends number | string> extends FieldEvent<ValueField<T>> {
    constructor(field: ValueField<T>, readonly oldValue: T) { super(field, ""); }
}

class ValueField<T extends number | string> extends Field {
    constructor(public value: T) { super(); }

    // listen<U extends FieldEvent<Field>>(type: new (arg: this) => U, listener: (event: U) => void): void;
    // listen<U extends FieldEvent<Field>>(type: new (...args: any[]) => U, listener: (event: U) => void): void;
    listen<U extends FieldEvent<Field>>(type: new (...args: any[]) => U, listener: (event: U) => void): void {
        super.listen(type, listener);
    }
}

let field = new ValueField(0);
field.listen(FieldEvent, (event) => event.field);                           // event: FieldEvent<any>
field.listen(BeforeSetEvent, (event) => { event.field; event.newValue; });  // event: BeforeSetEvent<any>
field.listen(AfterSetEvent, (event) => { event.field; event.oldValue; });   // event: AfterSetEvent<any>
```

**Expected behavior:**
`event` to be better inferred than `any`.

**Actual behavior:**
`event` inferred as `any`.

But if we uncomment the 2 overloads, then `event` is correctly inferred:
```
field.listen(FieldEvent, (event) => event.field);                           // event: FieldEvent<ValueField<0>>
field.listen(BeforeSetEvent, (event) => { event.field; event.newValue; });  // event: BeforeSetEvent<0>
field.listen(AfterSetEvent, (event) => { event.field; event.oldValue; });   // event: AfterSetEvent<0>
```

What's surprising (so the reason I consider it as a bug):
 * The 1st overload doesn't match any signature.
 * But it influences the way the other overload is inferred.

Note that if we replace `(arg: this)` by `()` or another type, then:
```
field.listen(FieldEvent, (event) => event.field);                           // event: FieldEvent<Field>
field.listen(BeforeSetEvent, (event) => { event.field; event.newValue; });  // event: BeforeSetEvent<string | number>
field.listen(AfterSetEvent, (event) => { event.field; event.oldValue; });   // event: AfterSetEvent<string | number>
```

**Playground Link:** [Playground Link](https://www.typescriptlang.org/play/index.html?ts=4.0.0-beta#code/MYGwhgzhAEBiCWBTEATAogN0QOwC4B4AVaRAD1xxRgWRQD5oBvAKGjemAHtsJcAnAK7BcnPgAo+iMCm4gAntABmSVAC5ohADTRJ02QoC2iKGADmidbz7xspgJRNoAX2YvmoSNRUomrdiHheHCISckovWkwcAhpUOjoxXDkABwtobEQAd2gxADp8sD5TCHUwbDkAbQBdBwBeBi1oAKCMvnUxRCw8dUI6hgxOeBQ7dQGhxxc3DyhoACFERVFEAGVEXCi8ELIKbCp0gQMAI0Q+aAAfaCsbUwZt8LhvDYIANTAQAURYlCJ433YObhWIQicTKWjqV7vT7eH7aZICQ4BYDpLKQj49ByMS4CVKg7zaABEBLsAG5nK5mO5wDMAIKKCh8VbrLoEYh3XYwbAHY6nC5XWy3MIch6RFn4NHQ2g-Bgsf5cHj8YGiMRgtTQCVfWE6KQybDyaCcVASjGOCA4k4q-HQImk8lTakwDUwtlCvZco4nc6XfjXQU7PZfP7seVA4TK+GI+DIjBvdEaTHY3FiW1uf4AejTTUCO3wAFVQv6IqgnvgvvFEik0hlsmJCqZ1LgABaBPrQXPaZo7E7tTrRdS51tjYajQYoEl+NgZrMtPMF+5fEtlhJJVLqas5fK5OslaBlSo1aD1Nsd7M4bs5XvdNuD0cjaBD8f-TvBfPsgOPMVLiurlE1zfb0pymqVt22nLs2gvFl+xvIY7yHIN-jYM1cVyZ9sG-RATxaE5SQnO1KRANYlG8Q9f3VWNJVQMQAAZcNVFBUNPdCFxZbQOhZVtL1wXJ6NtRD+IEwSpy49QWOifA9zoZh6MYloxHmRZJCZJ42K41ssS4njvDJTTqwlMknD44SoLmBYlmUsVJOk7xZJ2MQ6QZCzolUjjDxlEgWS02gdM8w0UH05w+OgYy+2gByTiczYrKAA)

**Related Issues:** I first posted #36226 but was not able to solve my issue, until I found the `(arg: this)` trick.