Design Meeting Notes for 4/15/2016

[DanielRosenwasser]

Control flow based type analysis (#8010)

let x: string | number | boolean;
x = ""; // 1

while (/*...*/) {
 x; // 2
 x = foo(x); // 3
 x; // 4
}
x; // 5

function foo(x: string): number;
function foo(x: number): boolean;
function foo(x: boolean): string;
function foo() {
 // ...
}

• How do you determine all the types of x?

  • We are certain that x can at least have type string.

• Issues with loops.

  • The type in a loop can go through an "evolution" of types.
  • Have to iterate to a fixed point to get the "eventual" type of that variable.
  • The compiler is not written to fully accomodate this scenario.
  • Symbols are not equipped to have types that vary.
  • Can create a mechanism to allow a variable whose declared type can go through iterations.
  • Currently this means we do a lot more overload resolution
    • Adds quite a bit of work to large projects like Monaco.
    • Unclear how to handle some situations with editor scenarios.
  • We will need to try this all out with existing code.

• Need to introduce the notion of "incomplete types".

  • Iterate until a type does not change and then "complete" the type.

• What if you never hit a fixed point?

  • Recall, when we see an assignment, we reduce the declared type of x, we don't add!

• Still issues with circularly dependent variables:

  let x: string | number | boolean;
  x = ""; // 1
  
  while (/*...*/) {
   x; // 2
   let y = foo(x); // 3
   x = y; // 4
   x; // 5
  }
  x; // 6
  
  function foo(x: string): number;
  function foo(x: number): boolean;
  function foo(x: boolean): string;
  function foo() {
   // ...
  }

Some other issues

• Allow comaprison to undefined and null even if they're not in the union of types you have.
  • We're disallowing defensive code even though you could be called from within JS.
  • Should allow it.

Functions with this types called with new (#8109)

interface FooType {
 x: number;
}

function Foo(this: FooType, x: number) {
 this.x = x;
}

let foo = new Foo(12);

• Should Foo be new-able?
  • Foo might be a plugin or callback with an intended this binding.
  • Really a new syntax should clarify the intent.
  • Signatures like function new Foo(x: number): FooType;.
  • 👍 for new signature syntax.
  • Needs a proposal though.

Indexing with enums and string literals (#2491, #7656)

• This is a problem and we need to address it.
• Unions will likely get priority and then we want to carry that to enums.

Numeric Literal Types (#7480)

• Not drastically different form string literal types.
• Currently has some strange behavior for flow of arithmetic on types.
• Need to look at implementation.