Control flow based type guards

src/compiler/parser.ts

@@ -1811,7 +1811,7 @@ namespace ts {
  function parseEntityName(allowReservedWords: boolean, diagnosticMessage?: DiagnosticMessage): EntityName {
  let entity: EntityName = parseIdentifier(diagnosticMessage);
  while (parseOptional(SyntaxKind.DotToken)) {
- const node = <QualifiedName>createNode(SyntaxKind.QualifiedName, entity.pos);
+ const node: QualifiedName = <QualifiedName>createNode(SyntaxKind.QualifiedName, entity.pos);
  node.left = entity;
  node.right = parseRightSideOfDot(allowReservedWords);
  entity = finishNode(node);
@@ -3639,7 +3639,7 @@ namespace ts {
  let elementName: EntityName = parseIdentifierName();
  while (parseOptional(SyntaxKind.DotToken)) {
  scanJsxIdentifier();
- const node = <QualifiedName>createNode(SyntaxKind.QualifiedName, elementName.pos);
+ const node: QualifiedName = <QualifiedName>createNode(SyntaxKind.QualifiedName, elementName.pos);
  node.left = elementName;
  node.right = parseIdentifierName();
  elementName = finishNode(node);

src/compiler/types.ts

@@ -443,7 +443,8 @@ namespace ts {
  decorators?: NodeArray<Decorator>; // Array of decorators (in document order)
  modifiers?: ModifiersArray; // Array of modifiers
  /* @internal */ id?: number; // Unique id (used to look up NodeLinks)
- parent?: Node; // Parent node (initialized by binding
+ parent?: Node; // Parent node (initialized by binding)
+ previous?: FlowMarkerTarget[]; // Previous occurencies of flowmarkers (initialized by binding)
  /* @internal */ jsDocComment?: JSDocComment; // JSDoc for the node, if it has any. Only for .js files.
  /* @internal */ symbol?: Symbol; // Symbol declared by node (initialized by binding)
  /* @internal */ locals?: SymbolTable; // Locals associated with node (initialized by binding)
@@ -459,6 +460,16 @@ namespace ts {
  flags: number;
  }
 
+ export type FlowMarkerTarget = Node | BranchFlow;
+ export type BranchFlowNode = IfStatement | WhileStatement | ForStatement | DoStatement | ConditionalExpression | BinaryExpression
+ export interface BranchFlow {
+ id: number;
+ previous: FlowMarkerTarget[];
+ node: BranchFlowNode;
+ expression: Expression;
+ trueBranch: boolean;
+ }
+
  // @kind(SyntaxKind.AbstractKeyword)
  // @kind(SyntaxKind.AsyncKeyword)
  // @kind(SyntaxKind.ConstKeyword)
@@ -471,6 +482,13 @@ namespace ts {
  // @kind(SyntaxKind.StaticKeyword)
  export interface Modifier extends Node { }
 
+ /* @internal */
+ export enum NarrowingState {
+ Uninitialized,
+ Narrowing,
+ Done,
+ Failed
+ }
  // @kind(SyntaxKind.Identifier)
  export interface Identifier extends PrimaryExpression {
  text: string; // Text of identifier (with escapes converted to characters)
@@ -2095,6 +2113,8 @@ namespace ts {
  resolvedJsxType?: Type; // resolved element attributes type of a JSX openinglike element
  hasSuperCall?: boolean; // recorded result when we try to find super-call. We only try to find one if this flag is undefined, indicating that we haven't made an attempt.
  superCall?: ExpressionStatement; // Cached first super-call found in the constructor. Used in checking whether super is called before this-accessing 
+ narrowingState?: NarrowingState;
+ localType?: Type;
  }
 
  export const enum TypeFlags {

src/compiler/utilities.ts

@@ -1412,7 +1412,7 @@ namespace ts {
  }
 
  // True if the given identifier, string literal, or number literal is the name of a declaration node
- export function isDeclarationName(name: Node): name is Identifier | StringLiteral | LiteralExpression {
+ export function isDeclarationName(name: Node): name is (Identifier & { __weakTypeGuard: void; }) | StringLiteral | LiteralExpression {
  if (name.kind !== SyntaxKind.Identifier && name.kind !== SyntaxKind.StringLiteral && name.kind !== SyntaxKind.NumericLiteral) {
  return false;
  }

tests/baselines/reference/TypeGuardWithEnumUnion.types

@@ -77,7 +77,7 @@ function f2(x: Color | string | string[]) {
  if (typeof x === "string") {
 >typeof x === "string" : boolean
 >typeof x : string
->x : Color | string | string[]
+>x : string | string[] | Color
 >"string" : string
 
  var a = x;
@@ -89,11 +89,11 @@ function f2(x: Color | string | string[]) {
  }
  else {
  var b = x;
->b : Color | string[]
->x : Color | string[]
+>b : string[] | Color
+>x : string[] | Color
 
  var b: Color | string[];
->b : Color | string[]
+>b : string[] | Color
 >Color : Color
  }
 }

tests/baselines/reference/assignmentTypeNarrowing.js

@@ -0,0 +1,53 @@
+//// [assignmentTypeNarrowing.ts]
+let x: string | number | boolean | RegExp;
+
+x = "";
+x; // string
+
+[x] = [true];
+x; // boolean
+
+[x = ""] = [1];
+x; // string | number
+
+({x} = {x: true});
+x; // boolean
+
+({y: x} = {y: 1});
+x; // number
+
+({x = ""} = {x: true});
+x; // string | boolean
+
+({y: x = /a/} = {y: 1});
+x; // number | RegExp
+
+let a: string[];
+
+for (x of a) {
+ x; // string
+}
+
+
+//// [assignmentTypeNarrowing.js]
+var x;
+x = "";
+x; // string
+x = [true][0];
+x; // boolean
+_a = [1][0], x = _a === void 0 ? "" : _a;
+x; // string | number
+(_b = { x: true }, x = _b.x, _b);
+x; // boolean
+(_c = { y: 1 }, x = _c.y, _c);
+x; // number
+(_d = { x: true }, _e = _d.x, x = _e === void 0 ? "" : _e, _d);
+x; // string | boolean
+(_f = { y: 1 }, _g = _f.y, x = _g === void 0 ? /a/ : _g, _f);
+x; // number | RegExp
+var a;
+for (var _i = 0, a_1 = a; _i < a_1.length; _i++) {
+ x = a_1[_i];
+ x; // string
+}
+var _a, _b, _c, _d, _e, _f, _g;

tests/baselines/reference/assignmentTypeNarrowing.symbols

@@ -0,0 +1,64 @@
+=== tests/cases/conformance/expressions/assignmentOperator/assignmentTypeNarrowing.ts ===
+let x: string | number | boolean | RegExp;
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+x = "";
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+x; // string
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+[x] = [true];
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+x; // boolean
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+[x = ""] = [1];
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+x; // string | number
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+({x} = {x: true});
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 11, 2))
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 11, 8))
+
+x; // boolean
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+({y: x} = {y: 1});
+>y : Symbol(y, Decl(assignmentTypeNarrowing.ts, 14, 2))
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+>y : Symbol(y, Decl(assignmentTypeNarrowing.ts, 14, 11))
+
+x; // number
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+({x = ""} = {x: true});
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 17, 2))
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 17, 13))
+
+x; // string | boolean
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+({y: x = /a/} = {y: 1});
+>y : Symbol(y, Decl(assignmentTypeNarrowing.ts, 20, 2))
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+>y : Symbol(y, Decl(assignmentTypeNarrowing.ts, 20, 17))
+
+x; // number | RegExp
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+let a: string[];
+>a : Symbol(a, Decl(assignmentTypeNarrowing.ts, 23, 3))
+
+for (x of a) {
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+>a : Symbol(a, Decl(assignmentTypeNarrowing.ts, 23, 3))
+
+ x; // string
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+}
+

tests/baselines/reference/assignmentTypeNarrowing.types

@@ -0,0 +1,98 @@
+=== tests/cases/conformance/expressions/assignmentOperator/assignmentTypeNarrowing.ts ===
+let x: string | number | boolean | RegExp;
+>x : string | number | boolean | RegExp
+>RegExp : RegExp
+
+x = "";
+>x = "" : string
+>x : string | number | boolean | RegExp
+>"" : string
+
+x; // string
+>x : string
+
+[x] = [true];
+>[x] = [true] : [boolean]
+>[x] : [string | number | boolean | RegExp]
+>x : string | number | boolean | RegExp
+>[true] : [boolean]
+>true : boolean
+
+x; // boolean
+>x : boolean
+
+[x = ""] = [1];
+>[x = ""] = [1] : [number]
+>[x = ""] : [string]
+>x = "" : string
+>x : string | number | boolean | RegExp
+>"" : string
+>[1] : [number]
+>1 : number
+
+x; // string | number
+>x : string | number
+
+({x} = {x: true});
+>({x} = {x: true}) : { x: boolean; }
+>{x} = {x: true} : { x: boolean; }
+>{x} : { x: string | number | boolean | RegExp; }
+>x : string | number | boolean | RegExp
+>{x: true} : { x: boolean; }
+>x : boolean
+>true : boolean
+
+x; // boolean
+>x : boolean
+
+({y: x} = {y: 1});
+>({y: x} = {y: 1}) : { y: number; }
+>{y: x} = {y: 1} : { y: number; }
+>{y: x} : { y: string | number | boolean | RegExp; }
+>y : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp
+>{y: 1} : { y: number; }
+>y : number
+>1 : number
+
+x; // number
+>x : number
+
+({x = ""} = {x: true});
+>({x = ""} = {x: true}) : { x?: boolean; }
+>{x = ""} = {x: true} : { x?: boolean; }
+>{x = ""} : { x?: string | number | boolean | RegExp; }
+>x : string | number | boolean | RegExp
+>{x: true} : { x?: boolean; }
+>x : boolean
+>true : boolean
+
+x; // string | boolean
+>x : string | boolean
+
+({y: x = /a/} = {y: 1});
+>({y: x = /a/} = {y: 1}) : { y?: number; }
+>{y: x = /a/} = {y: 1} : { y?: number; }
+>{y: x = /a/} : { y?: RegExp; }
+>y : RegExp
+>x = /a/ : RegExp
+>x : string | number | boolean | RegExp
+>/a/ : RegExp
+>{y: 1} : { y?: number; }
+>y : number
+>1 : number
+
+x; // number | RegExp
+>x : number | RegExp
+
+let a: string[];
+>a : string[]
+
+for (x of a) {
+>x : string | number | boolean | RegExp
+>a : string[]
+
+ x; // string
+>x : string
+}
+

tests/baselines/reference/controlFlowAssignmentExpression.js

@@ -0,0 +1,22 @@
+//// [controlFlowAssignmentExpression.ts]
+let x: string | boolean | number;
+let obj: any;
+
+x = "";
+x = x.length;
+x; // number
+
+x = true;
+(x = "", obj).foo = (x = x.length);
+x; // number
+
+
+//// [controlFlowAssignmentExpression.js]
+var x;
+var obj;
+x = "";
+x = x.length;
+x; // number
+x = true;
+(x = "", obj).foo = (x = x.length);
+x; // number

tests/baselines/reference/controlFlowAssignmentExpression.symbols

@@ -0,0 +1,33 @@
+=== tests/cases/conformance/controlFlow/controlFlowAssignmentExpression.ts ===
+let x: string | boolean | number;
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+
+let obj: any;
+>obj : Symbol(obj, Decl(controlFlowAssignmentExpression.ts, 1, 3))
+
+x = "";
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+
+x = x.length;
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
+x; // number
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+
+x = true;
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+
+(x = "", obj).foo = (x = x.length);
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+>obj : Symbol(obj, Decl(controlFlowAssignmentExpression.ts, 1, 3))
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
+x; // number
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+