Feature: Lazy object initialization

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:

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:

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:

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:

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:

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:

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:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Start by reviewing the TypeScript compiler and type-checking design relevant to variable assignment, property tracking, inferred types, and scope checks; the issue names no specific files or tests. Done means defining and implementing the proposed lazyof behavior, including assignment restrictions, evolving inferred types, property access errors, and validation when a variable leaves scope.