Repository: TypeScript
Issue: Feature: Lazy object initialization
Labels: Suggestion,In Discussion

<!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨

Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker. Please read the FAQ first, especially the "Common Feature Requests" section.

-->

## Search Terms
lazy object initialization

## Suggestion

Introduce ability to initialize objects lazily and check if it was initialized.
I suggest new keyword `lazyof` (or other name) which would work as following:
- You can assign `Partial<T>` to `lazyof T`.
- Only property from type `T` can be assigned to `lazyof T`.
- Compiler should keep track of what properties were assigned to variable of type `lazyof T`.
- Every time you reference variable with type `lazyof T` it should be treated as if it's type was `{ properties, which, you, assigned, up, to, this, point }`. This implies that when you assign such variable to other variable/return it, the implicit type should be latter (see example 1 and 2).
- When `lazyof T` variable goes out of scope, compiler should check if all the required properties of `T` are set.

## Use Cases

1. Initializing objects like this:
```javascript
const obj = {};
obj.foo = 1;
```
is common practice in JS. It would be nice to have a proper type checking

2. Easier migration from JS to TS. You don't need to convert lazy object initialization to eager.

3. Eager object initialization is not always the simplest approach and might complicate code

4. Ability to check whether object was properly initialized in constructor/named constructor (see last example)

## Examples

Simple example:
```typescript
const obj: lazyof { [key: string]: any } = {};
obj.foo = 1;
const otherObj = obj; // otherObj implicit type is { foo: number }
obj.bar = 'a';
const otherObj2 = obj; // otherObj2 implicit type is { foo: number, bar: string }
```
Implicit function return type:
```typescript
function initialize() {
  const obj: lazyof { [key: string]: any } = {};
  obj.foo = 1;
  obj.bar = 'a';
  return obj; // function initialize implicit return type is { foo: number, bar: string }
}
```
With specific interface:
```typescript
interface Obj {
  foo: number;
}
const obj: lazyof Obj = {};
obj.foo = 1;
obj.bar = 'a'; // error, property bar doesn't exists on Obj.
```
Going out of scope:
```typescript
interface Obj {
  foo: number;
  bar: string;
}
function initialize(obj: lazyof Obj) {
  obj.foo = 1;.
  // error. obj variable goes out of scope, but { foo: number } is not assignable to Obj
}
```
Check if object instance is initialized:
```typescript
class Obj {
  foo: number;
  bar: string;
  private constructor() {}
  static namedConstructor(): Obj {
    const self: lazyof Obj = new Obj;
    self.foo = 1;
    console.log(obj.bar); // // error, property bar doesn't exists on { foo: number }
    return self;
    // error. self variable goes out of scope, but { foo: number } is not assignable to Obj
  }
}
```

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).