Repository: TypeScript
Issue: Object literals should have a `this` type too
Labels: Suggestion,Needs Proposal,Awaiting More Feedback,Experimentation Needed

<!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨

Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker. Even if you think you've found a *bug*, please read the FAQ first, especially the Common "Bugs" That Aren't Bugs section!

Please help us by doing the following steps before logging an issue:
  * Search: https://github.com/Microsoft/TypeScript/search?type=Issues
  * Read the FAQ: https://github.com/Microsoft/TypeScript/wiki/FAQ

Please fill in the *entire* template below.
-->

<!-- Please try to reproduce the issue with `typescript@next`. It may have already been fixed. -->
**TypeScript Version:**  3.7.0-dev.20190831

<!-- Search terms you tried before logging this (so others can find this issue more easily) -->
**Search Terms:** `this` return type object composing composition 

**Code**

I tried writing some self-contained parts of objects as a kind of multiple-inheritance or object composition, which I would combine later, and ran into this case.

```ts
const a = {
	Clone() {
		return this;
	},
	x: 1,
};

const b = {
	Clone: a.Clone,
	y: 2,
};

console.log(b.Clone().x); // number, bad! Should be an error!
console.log(b.Clone().y); // compiler error, bad! This should be acceptable!
```

**Expected behavior:** `this`, the return type of `Clone`, should evaluate to `typeof b` in `b.Clone()`

**Actual behavior:** It evaluates to `typeof a`, since it was defined in `a`

This can be circumvented by defining `this` as a type parameter like so:

```ts
const a = {
	Clone<T>(this: T) {
		return this;
	},
	x: 1,
}

const b = {
	Clone: a.Clone,
	y: 2
};

console.log(b.Clone().x); // compiler error, good!
console.log(b.Clone().y); // works! Also good!
```

Another interesting problem at play here though, is that using a type parameter for `this` also means that TS doesn't know what could be inside of `this`. This means you have to manually specify whatever members you hope to have access to. It would be nice if you could do `T extends typeof a` and it would automatically drop all the members of `a` in there. Right now, it will error if you do this:

`'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.ts(7022)`

I think all methods like this should, therefore, be implicitly equivalent to the following:
```ts
const a = {
	Clone<T extends typeof a>(this: T) {
		console.log(this.x); // should work
		return this;
	},
	x: 1,
}
```

Then, `b.Clone()` would error since `b` is not a superset of `a`. Unless you did `c = Object.assign({}, a, b)`, and did `c.Clone()`

**Playground Link:** https://www.typescriptlang.org/play/?target=6#code/MYewdgzgLgBAhjAvDA3gKAJAGEA24CmAFAJSqYYBO+UArhWDFABYCWEA3JgL4A0mAHgC4YARjRdOaUJFgAjJGWx4w+YXAB0uAnwwBPYQCZxk6RBA586vAHNCszcqLF1-YuxgB6DzBpgAJvgAZiwqflLgZhZWILb2Wiok6rpunt6gALYADiwWFDD4FBQgFEA<!-- A link to a TypeScript Playground "Share" link which demonstrates this behavior -->

**Related Issues:** https://github.com/microsoft/TypeScript/issues/29122 <!-- Did you find other bugs that looked similar? -->