Improved any Inference

Previously, if TypeScript couldn’t figure out the type of a variable, it would choose the any type.

  1. let x;      // implicitly 'any'
  2. let y = []; // implicitly 'any[]'
  4. let z: any; // explicitly 'any'.

With TypeScript 2.1, instead of just choosing any, TypeScript will infer types based on what you end up assigning later on.

This is only enabled if —noImplicitAny is set.

Example
  1. let x;
  3. // You can still assign anything you want to 'x'.
  4. x = () => 42;
  6. // After that last assignment, TypeScript 2.1 knows that 'x' has type '() => number'.
  7. let y = x();
  9. // Thanks to that, it will now tell you that you can't add a number to a function!
  10. console.log(x + y);
  11. //          ~~~~~
  12. // Error! Operator '+' cannot be applied to types '() => number' and 'number'.
  14. // TypeScript still allows you to assign anything you want to 'x'.
  15. x = "Hello world!";
  17. // But now it also knows that 'x' is a 'string'!
  18. x.toLowerCase();

The same sort of tracking is now also done for empty arrays.

A variable declared with no type annotation and an initial value of [] is considered an implicit any[] variable.However, each subsequent x.push(value), x.unshift(value) or x[n] = value operation evolves the type of the variable in accordance with what elements are added to it.

  1. function f1() {
  2.     let x = [];
  3.     x.push(5);
  4.     x[1] = "hello";
  5.     x.unshift(true);
  6.     return x;  // (string | number | boolean)[]
  7. }
  9. function f2() {
  10.     let x = null;
  11.     if (cond()) {
  12.         x = [];
  13.         while (cond()) {
  14.             x.push("hello");
  15.         }
  16.     }
  17.     return x;  // string[] | null
  18. }