Accept new baselines

2026-05-20 22:51:17 -05:00 · 2016-08-27 09:50:43 -07:00
parent dba310949f
commit d5c0c054be
89 changed files with 331 additions and 331 deletions
--- a/tests/baselines/reference/amdImportNotAsPrimaryExpression.types
+++ b/tests/baselines/reference/amdImportNotAsPrimaryExpression.types
@@ -28,7 +28,7 @@ var y: typeof foo.C1.s1 = false;
 >foo : typeof foo
 >C1 : typeof foo.C1
 >s1 : boolean
->false : boolean
+>false : false

 var z: foo.M1.I2;
 >z : f.I2
--- a/tests/baselines/reference/arrayBestCommonTypes.types
+++ b/tests/baselines/reference/arrayBestCommonTypes.types
@@ -255,16 +255,16 @@ module EmptyTypes {
 >x : boolean
 >y : base
 >base : base
->[{ x: true, y: new derived() }, { x: false, y: new base() }] : { x: boolean; y: derived; }[]
->{ x: true, y: new derived() } : { x: boolean; y: derived; }
->x : boolean
->true : boolean
+>[{ x: true, y: new derived() }, { x: false, y: new base() }] : ({ x: true; y: derived; } | { x: false; y: base; })[]
+>{ x: true, y: new derived() } : { x: true; y: derived; }
+>x : true
+>true : true
 >y : derived
 >new derived() : derived
 >derived : typeof derived
->{ x: false, y: new base() } : { x: boolean; y: base; }
->x : boolean
->false : boolean
+>{ x: false, y: new base() } : { x: false; y: base; }
+>x : false
+>false : false
 >y : base
 >new base() : base
 >base : typeof base
@@ -658,16 +658,16 @@ module NonEmptyTypes {
 >x : boolean
 >y : base
 >base : base
->[{ x: true, y: new derived() }, { x: false, y: new base() }] : { x: boolean; y: base; }[]
->{ x: true, y: new derived() } : { x: boolean; y: derived; }
->x : boolean
->true : boolean
+>[{ x: true, y: new derived() }, { x: false, y: new base() }] : ({ x: true; y: derived; } | { x: false; y: base; })[]
+>{ x: true, y: new derived() } : { x: true; y: derived; }
+>x : true
+>true : true
 >y : derived
 >new derived() : derived
 >derived : typeof derived
->{ x: false, y: new base() } : { x: boolean; y: base; }
->x : boolean
->false : boolean
+>{ x: false, y: new base() } : { x: false; y: base; }
+>x : false
+>false : false
 >y : base
 >new base() : base
 >base : typeof base
--- a/tests/baselines/reference/assignmentTypeNarrowing.types
+++ b/tests/baselines/reference/assignmentTypeNarrowing.types
@@ -12,14 +12,14 @@ x; // string
 >x : string

 [x] = [true];
->[x] = [true] : [boolean]
+>[x] = [true] : [true]
 >[x] : [string | number | boolean | RegExp]
 >x : string | number | boolean | RegExp
->[true] : [boolean]
->true : boolean
+>[true] : [true]
+>true : true

 x; // boolean
->x : boolean
+>x : true

 [x = ""] = [1];
 >[x = ""] = [1] : [number]
@@ -34,16 +34,16 @@ x; // string | number
 >x : string | number

 ({x} = {x: true});
->({x} = {x: true}) : { x: boolean; }
->{x} = {x: true} : { x: boolean; }
+>({x} = {x: true}) : { x: true; }
+>{x} = {x: true} : { x: true; }
 >{x} : { x: string | number | boolean | RegExp; }
 >x : string | number | boolean | RegExp
->{x: true} : { x: boolean; }
->x : boolean
->true : boolean
+>{x: true} : { x: true; }
+>x : true
+>true : true

 x; // boolean
->x : boolean
+>x : true

 ({y: x} = {y: 1});
 >({y: x} = {y: 1}) : { y: number; }
@@ -59,16 +59,16 @@ x; // number
 >x : number

 ({x = ""} = {x: true});
->({x = ""} = {x: true}) : { x?: boolean; }
->{x = ""} = {x: true} : { x?: boolean; }
+>({x = ""} = {x: true}) : { x?: true; }
+>{x = ""} = {x: true} : { x?: true; }
 >{x = ""} : { x?: string | number | boolean | RegExp; }
 >x : string | number | boolean | RegExp
->{x: true} : { x?: boolean; }
->x : boolean
->true : boolean
+>{x: true} : { x?: true; }
+>x : true
+>true : true

 x; // string | boolean
->x : string | boolean
+>x : string | true

 ({y: x = /a/} = {y: 1});
 >({y: x = /a/} = {y: 1}) : { y?: number; }
--- a/tests/baselines/reference/asyncFunctionReturnType.types
+++ b/tests/baselines/reference/asyncFunctionReturnType.types
@@ -15,8 +15,8 @@ async function fAsyncExplicit(): Promise<[number, boolean]> {

    // This is contextually typed as a tuple.
    return [1, true];
->[1, true] : [number, boolean]
+>[1, true] : [number, true]
 >1 : number
->true : boolean
+>true : true
 }

--- a/tests/baselines/reference/bestCommonTypeOfTuple.types
+++ b/tests/baselines/reference/bestCommonTypeOfTuple.types
@@ -12,7 +12,7 @@ function f2(x: number): number { return 10; }
 function f3(x: number): boolean { return true; }
 >f3 : (x: number) => boolean
 >x : number
->true : boolean
+>true : true

 enum E1 { one }
 >E1 : E1
--- a/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.types
+++ b/tests/baselines/reference/bitwiseNotOperatorWithBooleanType.types
@@ -5,7 +5,7 @@ var BOOLEAN: boolean;

 function foo(): boolean { return true; }
 >foo : () => boolean
->true : boolean
+>true : true

 class A {
 >A : A
--- a/tests/baselines/reference/castTest.types
+++ b/tests/baselines/reference/castTest.types
@@ -23,7 +23,7 @@ var a = <any>0;
 var b = <boolean>true;
 >b : boolean
 ><boolean>true : boolean
->true : boolean
+>true : true

 var s = <string>"";
 >s : string
--- a/tests/baselines/reference/checkSuperCallBeforeThisAccessing3.types
+++ b/tests/baselines/reference/checkSuperCallBeforeThisAccessing3.types
@@ -18,11 +18,11 @@ class Derived extends Based {

            constructor() {
                this.y = true;
->this.y = true : boolean
+>this.y = true : true
 >this.y : boolean
 >this : this
 >y : boolean
->true : boolean
+>true : true
            }
        }
        super();
--- a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.types
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.types
@@ -111,32 +111,32 @@ ANY = undefined, BOOLEAN;
 >BOOLEAN : boolean

 OBJECT = [1, 2, 3], BOOLEAN = false;
->OBJECT = [1, 2, 3], BOOLEAN = false : boolean
+>OBJECT = [1, 2, 3], BOOLEAN = false : false
 >OBJECT = [1, 2, 3] : number[]
 >OBJECT : Object
 >[1, 2, 3] : number[]
 >1 : number
 >2 : number
 >3 : number
->BOOLEAN = false : boolean
+>BOOLEAN = false : false
 >BOOLEAN : boolean
->false : boolean
+>false : false

 var resultIsBoolean6 = (null, BOOLEAN);
->resultIsBoolean6 : boolean
->(null, BOOLEAN) : boolean
->null, BOOLEAN : boolean
+>resultIsBoolean6 : false
+>(null, BOOLEAN) : false
+>null, BOOLEAN : false
 >null : null
->BOOLEAN : boolean
+>BOOLEAN : false

 var resultIsBoolean7 = (ANY = undefined, BOOLEAN);
->resultIsBoolean7 : boolean
->(ANY = undefined, BOOLEAN) : boolean
->ANY = undefined, BOOLEAN : boolean
+>resultIsBoolean7 : false
+>(ANY = undefined, BOOLEAN) : false
+>ANY = undefined, BOOLEAN : false
 >ANY = undefined : undefined
 >ANY : any
 >undefined : undefined
->BOOLEAN : boolean
+>BOOLEAN : false

 var resultIsBoolean8 = (1, true);
 >resultIsBoolean8 : boolean
@@ -154,27 +154,27 @@ var resultIsBoolean9 = (++NUMBER, true);
 >true : boolean

 var resultIsBoolean10 = ([1, 2, 3], !BOOLEAN);
->resultIsBoolean10 : boolean
->([1, 2, 3], !BOOLEAN) : boolean
->[1, 2, 3], !BOOLEAN : boolean
+>resultIsBoolean10 : true
+>([1, 2, 3], !BOOLEAN) : true
+>[1, 2, 3], !BOOLEAN : true
 >[1, 2, 3] : number[]
 >1 : number
 >2 : number
 >3 : number
->!BOOLEAN : boolean
->BOOLEAN : boolean
+>!BOOLEAN : true
+>BOOLEAN : false

 var resultIsBoolean11 = (OBJECT = [1, 2, 3], BOOLEAN = false);
->resultIsBoolean11 : boolean
->(OBJECT = [1, 2, 3], BOOLEAN = false) : boolean
->OBJECT = [1, 2, 3], BOOLEAN = false : boolean
+>resultIsBoolean11 : false
+>(OBJECT = [1, 2, 3], BOOLEAN = false) : false
+>OBJECT = [1, 2, 3], BOOLEAN = false : false
 >OBJECT = [1, 2, 3] : number[]
 >OBJECT : Object
 >[1, 2, 3] : number[]
 >1 : number
 >2 : number
 >3 : number
->BOOLEAN = false : boolean
+>BOOLEAN = false : false
 >BOOLEAN : boolean
->false : boolean
+>false : false

--- a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.types
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.types
@@ -97,9 +97,9 @@ true, 1;

 BOOLEAN = false, 1;
 >BOOLEAN = false, 1 : number
->BOOLEAN = false : boolean
+>BOOLEAN = false : false
 >BOOLEAN : boolean
->false : boolean
+>false : false
 >1 : number

 "", NUMBER = 1;
@@ -146,9 +146,9 @@ var resultIsNumber9 = (BOOLEAN = false, 1);
 >resultIsNumber9 : number
 >(BOOLEAN = false, 1) : number
 >BOOLEAN = false, 1 : number
->BOOLEAN = false : boolean
+>BOOLEAN = false : false
 >BOOLEAN : boolean
->false : boolean
+>false : false
 >1 : number

 var resultIsNumber10 = ("", NUMBER = 1);
--- a/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.types
+++ b/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.types
@@ -28,7 +28,7 @@ var y: typeof foo.C1.s1 = false;
 >foo : typeof foo
 >C1 : typeof foo.C1
 >s1 : boolean
->false : boolean
+>false : false

 var z: foo.M1.I2;
 >z : f.I2
--- a/tests/baselines/reference/compoundAdditionAssignmentWithInvalidOperands.errors.txt
+++ b/tests/baselines/reference/compoundAdditionAssignmentWithInvalidOperands.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(6,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'void'.
-tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(7,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'boolean'.
+tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(7,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'true'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(8,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'number'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(9,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'E'.
 tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmentWithInvalidOperands.ts(10,1): error TS2365: Operator '+=' cannot be applied to types 'boolean' and '{}'.
@@ -38,7 +38,7 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAdditionAssignmen
 !!! error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'void'.
    x1 += true;
    ~~~~~~~~~~
-!!! error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'boolean'.
+!!! error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'true'.
    x1 += 0;
    ~~~~~~~
 !!! error TS2365: Operator '+=' cannot be applied to types 'boolean' and 'number'.
--- a/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.types
+++ b/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.types
@@ -19,7 +19,7 @@ declare function foo<T>(obj: I<T>): T
 foo({
 >foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : string | number | boolean | (() => void) | number[]
 >foo : <T>(obj: I<T>) => T
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: string | number | boolean | (() => void) | number[]; [x: number]: number | (() => void) | number[]; 0: () => void; p: string; }
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: string | number | true | (() => void) | number[]; [x: number]: number | (() => void) | number[]; 0: () => void; p: string; }

    p: "",
 >p : string
@@ -32,7 +32,7 @@ foo({
 >"hi" + "bye" : string
 >"hi" : string
 >"bye" : string
->true : boolean
+>true : true

    [0 + 1]: 0,
 >0 + 1 : number
--- a/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.types
+++ b/tests/baselines/reference/computedPropertyNamesContextualType6_ES6.types
@@ -19,7 +19,7 @@ declare function foo<T>(obj: I<T>): T
 foo({
 >foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : string | number | boolean | (() => void) | number[]
 >foo : <T>(obj: I<T>) => T
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: string | number | boolean | (() => void) | number[]; [x: number]: number | (() => void) | number[]; 0: () => void; p: string; }
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: string | number | true | (() => void) | number[]; [x: number]: number | (() => void) | number[]; 0: () => void; p: string; }

    p: "",
 >p : string
@@ -32,7 +32,7 @@ foo({
 >"hi" + "bye" : string
 >"hi" : string
 >"bye" : string
->true : boolean
+>true : true

    [0 + 1]: 0,
 >0 + 1 : number
--- a/tests/baselines/reference/conditionalOperatorConditionIsBooleanType.types
+++ b/tests/baselines/reference/conditionalOperatorConditionIsBooleanType.types
@@ -146,7 +146,7 @@ true || false ? exprIsObject1 : exprIsObject2;
 >true || false ? exprIsObject1 : exprIsObject2 : Object
 >true || false : boolean
 >true : boolean
->false : boolean
+>false : false
 >exprIsObject1 : Object
 >exprIsObject2 : Object

@@ -291,7 +291,7 @@ var resultIsObject3 = true || false ? exprIsObject1 : exprIsObject2;
 >true || false ? exprIsObject1 : exprIsObject2 : Object
 >true || false : boolean
 >true : boolean
->false : boolean
+>false : false
 >exprIsObject1 : Object
 >exprIsObject2 : Object

--- a/tests/baselines/reference/constEnumPropertyAccess1.types
+++ b/tests/baselines/reference/constEnumPropertyAccess1.types
@@ -35,10 +35,10 @@ var o: {
 >idx : number

 } = {
->{        1: true    } : { 1: boolean; }
+>{        1: true    } : { 1: true; }

        1: true
->true : boolean
+>true : true

    };

--- a/tests/baselines/reference/contextuallyTypedIife.types
+++ b/tests/baselines/reference/contextuallyTypedIife.types
@@ -43,7 +43,7 @@
 >c : boolean
 >"foo" : string
 >101 : number
->false : boolean
+>false : false

 // default parameters
 ((m = 10) => m + 1)(12);
--- a/tests/baselines/reference/controlFlowAssignmentExpression.types
+++ b/tests/baselines/reference/controlFlowAssignmentExpression.types
@@ -21,9 +21,9 @@ x; // number
 >x : number

 x = true;
->x = true : boolean
+>x = true : true
 >x : string | number | boolean
->true : boolean
+>true : true

 (x = "", obj).foo = (x = x.length);
 >(x = "", obj).foo = (x = x.length) : number
--- a/tests/baselines/reference/controlFlowCommaOperator.types
+++ b/tests/baselines/reference/controlFlowCommaOperator.types
@@ -5,11 +5,11 @@ function f(x: string | number | boolean) {

    let y: string | number | boolean = false;
 >y : string | number | boolean
->false : boolean
+>false : false

    let z: string | number | boolean = false;
 >z : string | number | boolean
->false : boolean
+>false : false

    if (y = "", typeof x === "string") {
 >y = "", typeof x === "string" : boolean
@@ -28,7 +28,7 @@ function f(x: string | number | boolean) {
 >y : string

        z; // boolean
->z : boolean
+>z : false
    }
    else if (z = 1, typeof x === "number") {
 >z = 1, typeof x === "number" : boolean
@@ -66,6 +66,6 @@ function f(x: string | number | boolean) {
 >y : string

    z; // number | boolean
->z : number | boolean
+>z : number | false
 }

--- a/tests/baselines/reference/controlFlowDoWhileStatement.types
+++ b/tests/baselines/reference/controlFlowDoWhileStatement.types
@@ -155,9 +155,9 @@ function f() {
 >cond : boolean

            x = true;
->x = true : boolean
+>x = true : true
 >x : string | number | boolean | Function | RegExp
->true : boolean
+>true : true

            continue;
        }
@@ -170,7 +170,7 @@ function f() {
 >cond : boolean

    x; // number | boolean | RegExp
->x : number | boolean | RegExp
+>x : number | true | RegExp
 }
 function g() {
 >g : () => void
@@ -200,9 +200,9 @@ function g() {
 >cond : boolean

            x = true;
->x = true : boolean
+>x = true : true
 >x : string | number | boolean | Function | RegExp
->true : boolean
+>true : true

            continue;
        }
--- a/tests/baselines/reference/controlFlowForInStatement.types
+++ b/tests/baselines/reference/controlFlowForInStatement.types
@@ -38,13 +38,13 @@ for (let y in obj) {
 >cond : boolean

        x = true;
->x = true : boolean
+>x = true : true
 >x : string | number | boolean | Function | RegExp
->true : boolean
+>true : true

        break;
    }
 }
 x; // RegExp | string | number | boolean
->x : string | number | boolean | RegExp
+>x : string | number | true | RegExp

--- a/tests/baselines/reference/controlFlowForOfStatement.types
+++ b/tests/baselines/reference/controlFlowForOfStatement.types
@@ -10,9 +10,9 @@ function a() {
 >a : () => void

    x = true;
->x = true : boolean
+>x = true : true
 >x : string | number | boolean | RegExp
->true : boolean
+>true : true

    for (x of obj) {
 >x : string | number | boolean | RegExp
@@ -27,6 +27,6 @@ function a() {
 >toExponential : (fractionDigits?: number) => string
    }
    x; // string | boolean
->x : string | boolean
+>x : string | true
 }

--- a/tests/baselines/reference/controlFlowForStatement.types
+++ b/tests/baselines/reference/controlFlowForStatement.types
@@ -108,16 +108,16 @@ function e() {
 >0 : number
 >typeof x !== "string" : boolean
 >typeof x : string
->x : string | number | boolean
+>x : string | number | true
 >"string" : "string"
->x = "" || true : string | boolean
+>x = "" || true : string | true
 >x : string | number | boolean | RegExp
->"" || true : string | boolean
+>"" || true : string | true
 >"" : string
->true : boolean
+>true : true

        x; // number | boolean
->x : number | boolean
+>x : number | true
    }
 }
 function f() {
--- a/tests/baselines/reference/controlFlowIfStatement.types
+++ b/tests/baselines/reference/controlFlowIfStatement.types
@@ -12,12 +12,12 @@ x = /a/;
 >/a/ : RegExp

 if (x /* RegExp */, (x = true)) {
->x /* RegExp */, (x = true) : boolean
+>x /* RegExp */, (x = true) : true
 >x : RegExp
->(x = true) : boolean
->x = true : boolean
+>(x = true) : true
+>x = true : true
 >x : string | number | boolean | RegExp
->true : boolean
+>true : true

    x; // boolean
 >x : true
@@ -29,7 +29,7 @@ if (x /* RegExp */, (x = true)) {
 }
 else {
    x; // boolean
->x : boolean
+>x : true

    x = 42;
 >x = 42 : number
--- a/tests/baselines/reference/controlFlowWhileStatement.types
+++ b/tests/baselines/reference/controlFlowWhileStatement.types
@@ -161,9 +161,9 @@ function f() {
 >cond : true

            x = true;
->x = true : boolean
+>x = true : true
 >x : string | number | boolean | Function | RegExp
->true : boolean
+>true : true

            continue;
        }
@@ -173,7 +173,7 @@ function f() {
 >/a/ : RegExp
    }
    x; // string | number | boolean | RegExp
->x : string | number | boolean | RegExp
+>x : string | number | true | RegExp
 }
 function g() {
 >g : () => void
@@ -205,9 +205,9 @@ function g() {
 >cond : boolean

            x = true;
->x = true : boolean
+>x = true : true
 >x : string | number | boolean | Function | RegExp
->true : boolean
+>true : true

            continue;
        }
--- a/tests/baselines/reference/declFileFunctions.types
+++ b/tests/baselines/reference/declFileFunctions.types
@@ -66,7 +66,7 @@ export function fooWithTypePredicate(a: any): a is number {
 >a : any

    return true;
->true : boolean
+>true : true
 }
 export function fooWithTypePredicateAndMulitpleParams(a: any, b: any, c: any): a is number {
 >fooWithTypePredicateAndMulitpleParams : (a: any, b: any, c: any) => a is number
@@ -76,7 +76,7 @@ export function fooWithTypePredicateAndMulitpleParams(a: any, b: any, c: any): a
 >a : any

    return true;
->true : boolean
+>true : true
 }
 export function fooWithTypeTypePredicateAndGeneric<T>(a: any): a is T {
 >fooWithTypeTypePredicateAndGeneric : <T>(a: any) => a is T
@@ -86,7 +86,7 @@ export function fooWithTypeTypePredicateAndGeneric<T>(a: any): a is T {
 >T : T

    return true;
->true : boolean
+>true : true
 }
 export function fooWithTypeTypePredicateAndRestParam(a: any, ...rest): a is number {
 >fooWithTypeTypePredicateAndRestParam : (a: any, ...rest: any[]) => a is number
@@ -95,7 +95,7 @@ export function fooWithTypeTypePredicateAndRestParam(a: any, ...rest): a is numb
 >a : any

    return true;
->true : boolean
+>true : true
 }

 /** This comment should appear for nonExportedFoo*/
--- a/tests/baselines/reference/declFileTypeAnnotationBuiltInType.types
+++ b/tests/baselines/reference/declFileTypeAnnotationBuiltInType.types
@@ -33,7 +33,7 @@ function foo5(): boolean {
 >foo5 : () => boolean

    return true;
->true : boolean
+>true : true
 }
 function foo6() {
 >foo6 : () => boolean
--- a/tests/baselines/reference/declarationsAndAssignments.errors.txt
+++ b/tests/baselines/reference/declarationsAndAssignments.errors.txt
@@ -17,10 +17,10 @@ tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(73,11):
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(73,14): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(74,11): error TS2459: Type 'undefined[]' has no property 'a' and no string index signature.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(74,14): error TS2459: Type 'undefined[]' has no property 'b' and no string index signature.
-tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(106,5): error TS2345: Argument of type '[number, [string, { y: boolean; }]]' is not assignable to parameter of type '[number, [string, { x: any; y?: boolean; }]]'.
-  Type '[string, { y: boolean; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
-    Type '{ y: boolean; }' is not assignable to type '{ x: any; y?: boolean; }'.
-      Property 'x' is missing in type '{ y: boolean; }'.
+tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(106,5): error TS2345: Argument of type '[number, [string, { y: false; }]]' is not assignable to parameter of type '[number, [string, { x: any; y?: boolean; }]]'.
+  Type '[string, { y: false; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
+    Type '{ y: false; }' is not assignable to type '{ x: any; y?: boolean; }'.
+      Property 'x' is missing in type '{ y: false; }'.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(138,6): error TS2322: Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(138,9): error TS2322: Type 'number' is not assignable to type 'string'.

@@ -171,10 +171,10 @@ tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(138,9):
    f14([2, ["abc", { x: 0 }]]);
    f14([2, ["abc", { y: false }]]);  // Error, no x
        ~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type '[number, [string, { y: boolean; }]]' is not assignable to parameter of type '[number, [string, { x: any; y?: boolean; }]]'.
-!!! error TS2345:   Type '[string, { y: boolean; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
-!!! error TS2345:     Type '{ y: boolean; }' is not assignable to type '{ x: any; y?: boolean; }'.
-!!! error TS2345:       Property 'x' is missing in type '{ y: boolean; }'.
+!!! error TS2345: Argument of type '[number, [string, { y: false; }]]' is not assignable to parameter of type '[number, [string, { x: any; y?: boolean; }]]'.
+!!! error TS2345:   Type '[string, { y: false; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
+!!! error TS2345:     Type '{ y: false; }' is not assignable to type '{ x: any; y?: boolean; }'.
+!!! error TS2345:       Property 'x' is missing in type '{ y: false; }'.
    
    module M {
        export var [a, b] = [1, 2];
--- a/tests/baselines/reference/deleteOperatorWithBooleanType.types
+++ b/tests/baselines/reference/deleteOperatorWithBooleanType.types
@@ -5,7 +5,7 @@ var BOOLEAN: boolean;

 function foo(): boolean { return true; }
 >foo : () => boolean
->true : boolean
+>true : true

 class A {
 >A : A
--- a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.types
+++ b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.types
@@ -69,10 +69,10 @@ function foo(): F {
 >F : F

    return {
->{        1: true    } : { 1: boolean; }
+>{        1: true    } : { 1: true; }

        1: true
->true : boolean
+>true : true

    };
 }
@@ -82,10 +82,10 @@ function bar(): F {
 >F : F

    return {
->{        2: true    } : { 2: boolean; }
+>{        2: true    } : { 2: true; }

        2: true
->true : boolean
+>true : true

    };
 }
--- a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.types
+++ b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.types
@@ -69,10 +69,10 @@ function foo(): F {
 >F : F

    return {
->{        1: true    } : { 1: boolean; }
+>{        1: true    } : { 1: true; }

        1: true
->true : boolean
+>true : true

    };
 }
@@ -82,10 +82,10 @@ function bar(): F {
 >F : F

    return {
->{        2: true    } : { 2: boolean; }
+>{        2: true    } : { 2: true; }

        2: true
->true : boolean
+>true : true

    };
 }
--- a/tests/baselines/reference/destructuringVariableDeclaration1ES5.types
+++ b/tests/baselines/reference/destructuringVariableDeclaration1ES5.types
@@ -16,12 +16,12 @@ var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
 >a3 : number
 >a4 : string
 >a5 : boolean
->[1, [["hello"]], true] : [number, [[string]], boolean]
+>[1, [["hello"]], true] : [number, [[string]], true]
 >1 : number
 >[["hello"]] : [[string]]
 >["hello"] : [string]
 >"hello" : string
->true : boolean
+>true : true

 // The type T associated with a destructuring variable declaration is determined as follows:
 //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
@@ -52,12 +52,12 @@ var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }];
 >true : boolean
 >b4 : { t1: boolean; t2: string; }
 >temp : { t1: boolean; t2: string; }
->[3, false, { t1: false, t2: "hello" }] : [number, boolean, { t1: boolean; t2: string; }]
+>[3, false, { t1: false, t2: "hello" }] : [number, false, { t1: false; t2: string; }]
 >3 : number
->false : boolean
->{ t1: false, t2: "hello" } : { t1: boolean; t2: string; }
->t1 : boolean
->false : boolean
+>false : false
+>{ t1: false, t2: "hello" } : { t1: false; t2: string; }
+>t1 : false
+>false : false
 >t2 : string
 >"hello" : string

--- a/tests/baselines/reference/destructuringVariableDeclaration1ES6.types
+++ b/tests/baselines/reference/destructuringVariableDeclaration1ES6.types
@@ -16,12 +16,12 @@ var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
 >a3 : number
 >a4 : string
 >a5 : boolean
->[1, [["hello"]], true] : [number, [[string]], boolean]
+>[1, [["hello"]], true] : [number, [[string]], true]
 >1 : number
 >[["hello"]] : [[string]]
 >["hello"] : [string]
 >"hello" : string
->true : boolean
+>true : true

 // The type T associated with a destructuring variable declaration is determined as follows:
 //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
@@ -52,12 +52,12 @@ var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }];
 >true : boolean
 >b4 : { t1: boolean; t2: string; }
 >temp : { t1: boolean; t2: string; }
->[3, false, { t1: false, t2: "hello" }] : [number, boolean, { t1: boolean; t2: string; }]
+>[3, false, { t1: false, t2: "hello" }] : [number, false, { t1: false; t2: string; }]
 >3 : number
->false : boolean
->{ t1: false, t2: "hello" } : { t1: boolean; t2: string; }
->t1 : boolean
->false : boolean
+>false : false
+>{ t1: false, t2: "hello" } : { t1: false; t2: string; }
+>t1 : false
+>false : false
 >t2 : string
 >"hello" : string

--- a/tests/baselines/reference/destructuringVariableDeclaration2.errors.txt
+++ b/tests/baselines/reference/destructuringVariableDeclaration2.errors.txt
@@ -1,7 +1,7 @@
 tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(3,5): error TS2322: Type '{ a1: boolean; a2: number; }' is not assignable to type '{ a1: number; a2: string; }'.
  Types of property 'a1' are incompatible.
    Type 'boolean' is not assignable to type 'number'.
-tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(4,5): error TS2322: Type '[number, [[boolean]], boolean]' is not assignable to type '[number, [[string]], boolean]'.
+tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(4,5): error TS2322: Type '[number, [[boolean]], true]' is not assignable to type '[number, [[string]], boolean]'.
  Type '[[boolean]]' is not assignable to type '[[string]]'.
    Type '[boolean]' is not assignable to type '[string]'.
      Type 'boolean' is not assignable to type 'string'.
@@ -19,7 +19,7 @@ tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(1
 !!! error TS2322:     Type 'boolean' is not assignable to type 'number'.
    var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [[false]], true];  // Error
        ~~~~~~~~~~~~~~~~
-!!! error TS2322: Type '[number, [[boolean]], boolean]' is not assignable to type '[number, [[string]], boolean]'.
+!!! error TS2322: Type '[number, [[boolean]], true]' is not assignable to type '[number, [[string]], boolean]'.
 !!! error TS2322:   Type '[[boolean]]' is not assignable to type '[[string]]'.
 !!! error TS2322:     Type '[boolean]' is not assignable to type '[string]'.
 !!! error TS2322:       Type 'boolean' is not assignable to type 'string'.
--- a/tests/baselines/reference/emitArrowFunction.types
+++ b/tests/baselines/reference/emitArrowFunction.types
@@ -31,12 +31,12 @@ function foo(func: () => boolean) { }
 foo(() => true);
 >foo(() => true) : void
 >foo : (func: () => boolean) => void
->() => true : () => boolean
->true : boolean
+>() => true : () => true
+>true : true

 foo(() => { return false; });
 >foo(() => { return false; }) : void
 >foo : (func: () => boolean) => void
->() => { return false; } : () => boolean
->false : boolean
+>() => { return false; } : () => false
+>false : false

--- a/tests/baselines/reference/emitArrowFunctionES6.types
+++ b/tests/baselines/reference/emitArrowFunctionES6.types
@@ -31,14 +31,14 @@ function foo(func: () => boolean) { }
 foo(() => true);
 >foo(() => true) : void
 >foo : (func: () => boolean) => void
->() => true : () => boolean
->true : boolean
+>() => true : () => true
+>true : true

 foo(() => { return false; });
 >foo(() => { return false; }) : void
 >foo : (func: () => boolean) => void
->() => { return false; } : () => boolean
->false : boolean
+>() => { return false; } : () => false
+>false : false

 // Binding patterns in arrow functions
 var p1 = ([a]) => { };
--- a/tests/baselines/reference/emitArrowFunctionThisCapturing.types
+++ b/tests/baselines/reference/emitArrowFunctionThisCapturing.types
@@ -32,7 +32,7 @@ function foo(func: () => boolean) { }
 foo(() => {
 >foo(() => {    this.age = 100;    return true;}) : void
 >foo : (func: () => boolean) => void
->() => {    this.age = 100;    return true;} : () => boolean
+>() => {    this.age = 100;    return true;} : () => true

    this.age = 100;
 >this.age = 100 : number
@@ -42,7 +42,7 @@ foo(() => {
 >100 : number

    return true;
->true : boolean
+>true : true

 });

--- a/tests/baselines/reference/emitArrowFunctionThisCapturingES6.types
+++ b/tests/baselines/reference/emitArrowFunctionThisCapturingES6.types
@@ -32,7 +32,7 @@ function foo(func: () => boolean){ }
 foo(() => {
 >foo(() => {    this.age = 100;    return true;}) : void
 >foo : (func: () => boolean) => void
->() => {    this.age = 100;    return true;} : () => boolean
+>() => {    this.age = 100;    return true;} : () => true

    this.age = 100;
 >this.age = 100 : number
@@ -42,7 +42,7 @@ foo(() => {
 >100 : number

    return true;
->true : boolean
+>true : true

 });

--- a/tests/baselines/reference/emitClassDeclarationWithMethodInES6.types
+++ b/tests/baselines/reference/emitClassDeclarationWithMethodInES6.types
@@ -46,7 +46,7 @@ class D {
    static ["computedname6"](a: string): boolean { return true; }
 >"computedname6" : string
 >a : string
->true : boolean
+>true : true

    static staticMethod() {
 >staticMethod : () => number
--- a/tests/baselines/reference/emitClassDeclarationWithPropertyAssignmentInES6.types
+++ b/tests/baselines/reference/emitClassDeclarationWithPropertyAssignmentInES6.types
@@ -33,7 +33,7 @@ class E extends D{

    z: boolean = true;
 >z : boolean
->true : boolean
+>true : true
 }

 class F extends D{
@@ -42,7 +42,7 @@ class F extends D{

    z: boolean = true;
 >z : boolean
->true : boolean
+>true : true

    j: string;
 >j : string
--- a/tests/baselines/reference/escapedIdentifiers.types
+++ b/tests/baselines/reference/escapedIdentifiers.types
@@ -238,9 +238,9 @@ class testClass {
 >'string' : string

        arg\u0033 = true;
->arg\u0033 = true : boolean
+>arg\u0033 = true : true
 >arg\u0033 : boolean
->true : boolean
+>true : true

        arg4 = 2;
 >arg4 = 2 : number
@@ -266,7 +266,7 @@ var constructorTestObject = new constructorTestClass(1, 'string', true, 2);
 >constructorTestClass : typeof constructorTestClass
 >1 : number
 >'string' : string
->true : boolean
+>true : true
 >2 : number

 constructorTestObject.arg\u0031 = 1;
@@ -284,11 +284,11 @@ constructorTestObject.arg2 = 'string';
 >'string' : string

 constructorTestObject.arg\u0033 = true;
->constructorTestObject.arg\u0033 = true : boolean
+>constructorTestObject.arg\u0033 = true : true
 >constructorTestObject.arg\u0033 : boolean
 >constructorTestObject : constructorTestClass
 >arg\u0033 : boolean
->true : boolean
+>true : true

 constructorTestObject.arg4 = 2;
 >constructorTestObject.arg4 = 2 : number
--- a/tests/baselines/reference/for-of36.types
+++ b/tests/baselines/reference/for-of36.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of36.ts ===
 var tuple: [string, boolean] = ["", true];
 >tuple : [string, boolean]
->["", true] : [string, boolean]
+>["", true] : [string, true]
 >"" : string
->true : boolean
+>true : true

 for (var v of tuple) {
 >v : string | boolean
--- a/tests/baselines/reference/for-of37.types
+++ b/tests/baselines/reference/for-of37.types
@@ -3,10 +3,10 @@ var map = new Map([["", true]]);
 >map : Map<string, boolean>
 >new Map([["", true]]) : Map<string, boolean>
 >Map : MapConstructor
->[["", true]] : [string, boolean][]
->["", true] : [string, boolean]
+>[["", true]] : [string, true][]
+>["", true] : [string, true]
 >"" : string
->true : boolean
+>true : true

 for (var v of map) {
 >v : [string, boolean]
--- a/tests/baselines/reference/for-of38.types
+++ b/tests/baselines/reference/for-of38.types
@@ -3,10 +3,10 @@ var map = new Map([["", true]]);
 >map : Map<string, boolean>
 >new Map([["", true]]) : Map<string, boolean>
 >Map : MapConstructor
->[["", true]] : [string, boolean][]
->["", true] : [string, boolean]
+>[["", true]] : [string, true][]
+>["", true] : [string, true]
 >"" : string
->true : boolean
+>true : true

 for (var [k, v] of map) {
 >k : string
--- a/tests/baselines/reference/for-of40.types
+++ b/tests/baselines/reference/for-of40.types
@@ -3,10 +3,10 @@ var map = new Map([["", true]]);
 >map : Map<string, boolean>
 >new Map([["", true]]) : Map<string, boolean>
 >Map : MapConstructor
->[["", true]] : [string, boolean][]
->["", true] : [string, boolean]
+>[["", true]] : [string, true][]
+>["", true] : [string, true]
 >"" : string
->true : boolean
+>true : true

 for (var [k = "", v = false] of map) {
 >k : string
--- a/tests/baselines/reference/for-of44.types
+++ b/tests/baselines/reference/for-of44.types
@@ -1,13 +1,13 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of44.ts ===
 var array: [number, string | boolean | symbol][] = [[0, ""], [0, true], [1, Symbol()]]
 >array : [number, string | boolean | symbol][]
->[[0, ""], [0, true], [1, Symbol()]] : ([number, string] | [number, boolean] | [number, symbol])[]
+>[[0, ""], [0, true], [1, Symbol()]] : ([number, string] | [number, true] | [number, symbol])[]
 >[0, ""] : [number, string]
 >0 : number
 >"" : string
->[0, true] : [number, boolean]
+>[0, true] : [number, true]
 >0 : number
->true : boolean
+>true : true
 >[1, Symbol()] : [number, symbol]
 >1 : number
 >Symbol() : symbol
--- a/tests/baselines/reference/for-of45.types
+++ b/tests/baselines/reference/for-of45.types
@@ -7,19 +7,19 @@ var map = new Map([["", true]]);
 >map : Map<string, boolean>
 >new Map([["", true]]) : Map<string, boolean>
 >Map : MapConstructor
->[["", true]] : [string, boolean][]
->["", true] : [string, boolean]
+>[["", true]] : [string, true][]
+>["", true] : [string, true]
 >"" : string
->true : boolean
+>true : true

 for ([k = "", v = false] of map) {
->[k = "", v = false] : [string, boolean]
+>[k = "", v = false] : [string, false]
 >k = "" : string
 >k : string
 >"" : string
->v = false : boolean
+>v = false : false
 >v : boolean
->false : boolean
+>false : false
 >map : Map<string, boolean>

    k;
--- a/tests/baselines/reference/for-of50.types
+++ b/tests/baselines/reference/for-of50.types
@@ -3,10 +3,10 @@ var map = new Map([["", true]]);
 >map : Map<string, boolean>
 >new Map([["", true]]) : Map<string, boolean>
 >Map : MapConstructor
->[["", true]] : [string, boolean][]
->["", true] : [string, boolean]
+>[["", true]] : [string, true][]
+>["", true] : [string, true]
 >"" : string
->true : boolean
+>true : true

 for (const [k, v] of map) {
 >k : string
--- a/tests/baselines/reference/functionOverloads39.types
+++ b/tests/baselines/reference/functionOverloads39.types
@@ -19,8 +19,8 @@ var x = foo([{a:true}]);
 >x : number
 >foo([{a:true}]) : number
 >foo : { (bar: { a: number; }[]): string; (bar: { a: boolean; }[]): number; }
->[{a:true}] : { a: boolean; }[]
->{a:true} : { a: boolean; }
->a : boolean
->true : boolean
+>[{a:true}] : { a: true; }[]
+>{a:true} : { a: true; }
+>a : true
+>true : true

--- a/tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types
+++ b/tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types
@@ -49,8 +49,8 @@ _.all([true, 1, null, 'yes'], _.identity);
 >_.all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => boolean
 >_ : Underscore.Static
 >all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => boolean
->[true, 1, null, 'yes'] : (string | number | boolean)[]
->true : boolean
+>[true, 1, null, 'yes'] : (string | number | true)[]
+>true : true
 >1 : number
 >null : null
 >'yes' : string
@@ -64,8 +64,8 @@ _.all([true], _.identity);
 >_.all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => boolean
 >_ : Underscore.Static
 >all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => boolean
->[true] : boolean[]
->true : boolean
+>[true] : true[]
+>true : true
 >_.identity : <T>(value: T) => T
 >_ : Underscore.Static
 >identity : <T>(value: T) => T
--- a/tests/baselines/reference/genericCallTypeArgumentInference.types
+++ b/tests/baselines/reference/genericCallTypeArgumentInference.types
@@ -202,7 +202,7 @@ var r6 = c.foo3(true, 1); // boolean
 >c.foo3 : <T>(t: T, u: number) => T
 >c : C<string, number>
 >foo3 : <T>(t: T, u: number) => T
->true : boolean
+>true : true
 >1 : number

 var r7 = c.foo4('', true); // string
@@ -212,7 +212,7 @@ var r7 = c.foo4('', true); // string
 >c : C<string, number>
 >foo4 : <U>(t: string, u: U) => string
 >'' : string
->true : boolean
+>true : true

 var r8 = c.foo5(true, 1); // boolean
 >r8 : boolean
@@ -220,7 +220,7 @@ var r8 = c.foo5(true, 1); // boolean
 >c.foo5 : <T, U>(t: T, u: U) => T
 >c : C<string, number>
 >foo5 : <T, U>(t: T, u: U) => T
->true : boolean
+>true : true
 >1 : number

 var r9 = c.foo6(); // {}
@@ -349,7 +349,7 @@ var r6 = i.foo3(true, 1); // boolean
 >i.foo3 : <T>(t: T, u: number) => T
 >i : I<string, number>
 >foo3 : <T>(t: T, u: number) => T
->true : boolean
+>true : true
 >1 : number

 var r7 = i.foo4('', true); // string
@@ -359,7 +359,7 @@ var r7 = i.foo4('', true); // string
 >i : I<string, number>
 >foo4 : <U>(t: string, u: U) => string
 >'' : string
->true : boolean
+>true : true

 var r8 = i.foo5(true, 1); // boolean
 >r8 : boolean
@@ -367,7 +367,7 @@ var r8 = i.foo5(true, 1); // boolean
 >i.foo5 : <T, U>(t: T, u: U) => T
 >i : I<string, number>
 >foo5 : <T, U>(t: T, u: U) => T
->true : boolean
+>true : true
 >1 : number

 var r9 = i.foo6(); // {}
--- a/tests/baselines/reference/genericClassWithStaticFactory.types
+++ b/tests/baselines/reference/genericClassWithStaticFactory.types
@@ -175,11 +175,11 @@ module Editor {
 >T : T

            entry.isHead = false;
->entry.isHead = false : boolean
+>entry.isHead = false : false
 >entry.isHead : boolean
 >entry : List<T>
 >isHead : boolean
->false : boolean
+>false : false

            entry.next = this.next;
 >entry.next = this.next : List<T>
@@ -237,11 +237,11 @@ module Editor {
 >data : T

            entry.isHead = false;
->entry.isHead = false : boolean
+>entry.isHead = false : false
 >entry.isHead : boolean
 >entry : List<T>
 >isHead : boolean
->false : boolean
+>false : false

            entry.next = this.next;
 >entry.next = this.next : List<T>
@@ -317,11 +317,11 @@ module Editor {
 >T : T

            entry.isHead = false;
->entry.isHead = false : boolean
+>entry.isHead = false : false
 >entry.isHead : boolean
 >entry : List<T>
 >isHead : boolean
->false : boolean
+>false : false

            this.prev.next = entry;
 >this.prev.next = entry : List<T>
@@ -501,7 +501,7 @@ module Editor {
 >new List<T>(true, null) : List<T>
 >List : typeof List
 >T : T
->true : boolean
+>true : true
 >null : null

            entry.prev = entry;
@@ -537,7 +537,7 @@ module Editor {
 >new List<T>(false, data) : List<T>
 >List : typeof List
 >T : T
->false : boolean
+>false : false
 >data : T

            entry.prev = entry;
--- a/tests/baselines/reference/genericTypeArgumentInference1.types
+++ b/tests/baselines/reference/genericTypeArgumentInference1.types
@@ -47,8 +47,8 @@ var r = _.all([true, 1, null, 'yes'], _.identity);
 >_.all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => T
 >_ : Underscore.Static
 >all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => T
->[true, 1, null, 'yes'] : (string | number | boolean)[]
->true : boolean
+>[true, 1, null, 'yes'] : (string | number | true)[]
+>true : true
 >1 : number
 >null : null
 >'yes' : string
@@ -62,8 +62,8 @@ var r2 = _.all([true], _.identity);
 >_.all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => T
 >_ : Underscore.Static
 >all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => T
->[true] : boolean[]
->true : boolean
+>[true] : true[]
+>true : true
 >_.identity : <T>(value: T) => T
 >_ : Underscore.Static
 >identity : <T>(value: T) => T
--- a/tests/baselines/reference/genericWithCallSignatureReturningSpecialization.types
+++ b/tests/baselines/reference/genericWithCallSignatureReturningSpecialization.types
@@ -18,5 +18,5 @@ var x: B<boolean>;
 x(true); // was error
 >x(true) : void
 >x : B<boolean>
->true : boolean
+>true : true

--- a/tests/baselines/reference/getterSetterNonAccessor.types
+++ b/tests/baselines/reference/getterSetterNonAccessor.types
@@ -16,8 +16,8 @@ Object.defineProperty({}, "0", <PropertyDescriptor>({
 >"0" : string
 ><PropertyDescriptor>({          get: getFunc,          set: setFunc,          configurable: true      }) : PropertyDescriptor
 >PropertyDescriptor : PropertyDescriptor
->({          get: getFunc,          set: setFunc,          configurable: true      }) : { get: () => any; set: (v: any) => void; configurable: boolean; }
->{          get: getFunc,          set: setFunc,          configurable: true      } : { get: () => any; set: (v: any) => void; configurable: boolean; }
+>({          get: getFunc,          set: setFunc,          configurable: true      }) : { get: () => any; set: (v: any) => void; configurable: true; }
+>{          get: getFunc,          set: setFunc,          configurable: true      } : { get: () => any; set: (v: any) => void; configurable: true; }

          get: getFunc,
 >get : () => any
@@ -28,8 +28,8 @@ Object.defineProperty({}, "0", <PropertyDescriptor>({
 >setFunc : (v: any) => void

          configurable: true
->configurable : boolean
->true : boolean
+>configurable : true
+>true : true

      }));

--- a/tests/baselines/reference/indexerWithTuple.types
+++ b/tests/baselines/reference/indexerWithTuple.types
@@ -21,8 +21,8 @@ var unionTuple1: [number, string| number] = [10, "foo"];

 var unionTuple2: [boolean, string| number] = [true, "foo"]; 
 >unionTuple2 : [boolean, string | number]
->[true, "foo"] : [boolean, string]
->true : boolean
+>[true, "foo"] : [true, string]
+>true : true
 >"foo" : string

 // no error
--- a/tests/baselines/reference/interfaceContextualType.types
+++ b/tests/baselines/reference/interfaceContextualType.types
@@ -34,31 +34,31 @@ class Bug {
 >{} : {}

        this.values['comments'] = { italic: true };
->this.values['comments'] = { italic: true } : { italic: boolean; }
+>this.values['comments'] = { italic: true } : { italic: true; }
 >this.values['comments'] : IOptions
 >this.values : IMap
 >this : this
 >values : IMap
 >'comments' : string
->{ italic: true } : { italic: boolean; }
->italic : boolean
->true : boolean
+>{ italic: true } : { italic: true; }
+>italic : true
+>true : true
    }
    shouldBeOK() {
 >shouldBeOK : () => void

        this.values = {
->this.values = {            comments: { italic: true }        } : { comments: { italic: boolean; }; }
+>this.values = {            comments: { italic: true }        } : { comments: { italic: true; }; }
 >this.values : IMap
 >this : this
 >values : IMap
->{            comments: { italic: true }        } : { comments: { italic: boolean; }; }
+>{            comments: { italic: true }        } : { comments: { italic: true; }; }

            comments: { italic: true }
->comments : { italic: boolean; }
->{ italic: true } : { italic: boolean; }
->italic : boolean
->true : boolean
+>comments : { italic: true; }
+>{ italic: true } : { italic: true; }
+>italic : true
+>true : true

        };
    }
--- a/tests/baselines/reference/interfaceWithPropertyOfEveryType.types
+++ b/tests/baselines/reference/interfaceWithPropertyOfEveryType.types
@@ -80,7 +80,7 @@ interface Foo {
 var a: Foo = {
 >a : Foo
 >Foo : Foo
->{    a: 1,    b: '',    c: true,    d: {},    e: null ,    f: [1],    g: {},    h: (x: number) => 1,    i: <T>(x: T) => x,    j: <Foo>null,    k: new C(),    l: f1,    m: M,    n: {},    o: E.A} : { a: number; b: string; c: boolean; d: {}; e: null; f: number[]; g: {}; h: (x: number) => number; i: <T>(x: T) => T; j: Foo; k: C; l: () => void; m: typeof M; n: {}; o: E; }
+>{    a: 1,    b: '',    c: true,    d: {},    e: null ,    f: [1],    g: {},    h: (x: number) => 1,    i: <T>(x: T) => x,    j: <Foo>null,    k: new C(),    l: f1,    m: M,    n: {},    o: E.A} : { a: number; b: string; c: true; d: {}; e: null; f: number[]; g: {}; h: (x: number) => number; i: <T>(x: T) => T; j: Foo; k: C; l: () => void; m: typeof M; n: {}; o: E; }

    a: 1,
 >a : number
@@ -91,8 +91,8 @@ var a: Foo = {
 >'' : string

    c: true,
->c : boolean
->true : boolean
+>c : true
+>true : true

    d: {},
 >d : {}
--- a/tests/baselines/reference/iterableArrayPattern30.types
+++ b/tests/baselines/reference/iterableArrayPattern30.types
@@ -6,11 +6,11 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])
 >v2 : boolean
 >new Map([["", true], ["hello", true]]) : Map<string, boolean>
 >Map : MapConstructor
->[["", true], ["hello", true]] : [string, boolean][]
->["", true] : [string, boolean]
+>[["", true], ["hello", true]] : [string, true][]
+>["", true] : [string, true]
 >"" : string
->true : boolean
->["hello", true] : [string, boolean]
+>true : true
+>["hello", true] : [string, true]
 >"hello" : string
->true : boolean
+>true : true

--- a/tests/baselines/reference/logicalNotOperatorWithBooleanType.types
+++ b/tests/baselines/reference/logicalNotOperatorWithBooleanType.types
@@ -5,7 +5,7 @@ var BOOLEAN: boolean;

 function foo(): boolean { return true; }
 >foo : () => boolean
->true : boolean
+>true : true

 class A {
 >A : A
--- a/tests/baselines/reference/memberVariableDeclarations1.types
+++ b/tests/baselines/reference/memberVariableDeclarations1.types
@@ -47,11 +47,11 @@ class Employee2 {

    constructor() {
        this.retired = false;
->this.retired = false : boolean
+>this.retired = false : false
 >this.retired : boolean
 >this : this
 >retired : boolean
->false : boolean
+>false : false

        this.manager = null;
 >this.manager = null : null
--- a/tests/baselines/reference/moduleMemberWithoutTypeAnnotation1.types
+++ b/tests/baselines/reference/moduleMemberWithoutTypeAnnotation1.types
@@ -64,7 +64,7 @@ module TypeScript {
 >findToken : (position: number, includeSkippedTokens?: boolean) => PositionedToken
 >position : number
 >includeSkippedTokens : boolean
->false : boolean
+>false : false
 >PositionedToken : PositionedToken

            var positionedToken = this.findTokenInternal(null, position, 0);
--- a/tests/baselines/reference/negateOperatorWithBooleanType.types
+++ b/tests/baselines/reference/negateOperatorWithBooleanType.types
@@ -5,7 +5,7 @@ var BOOLEAN: boolean;

 function foo(): boolean { return true; }
 >foo : () => boolean
->true : boolean
+>true : true

 class A {
 >A : A
--- a/tests/baselines/reference/noImplicitReturnsInAsync1.types
+++ b/tests/baselines/reference/noImplicitReturnsInAsync1.types
@@ -3,7 +3,7 @@
 async function test(isError: boolean = false) {
 >test : (isError?: boolean) => Promise<void>
 >isError : boolean
->false : boolean
+>false : false

    if (isError === true) {
 >isError === true : boolean
--- a/tests/baselines/reference/plusOperatorWithBooleanType.types
+++ b/tests/baselines/reference/plusOperatorWithBooleanType.types
@@ -5,7 +5,7 @@ var BOOLEAN: boolean;

 function foo(): boolean { return true; }
 >foo : () => boolean
->true : boolean
+>true : true

 class A {
 >A : A
--- a/tests/baselines/reference/privacyCheckAnonymousFunctionParameter.types
+++ b/tests/baselines/reference/privacyCheckAnonymousFunctionParameter.types
@@ -31,11 +31,11 @@ module Query {
        return fromDoWhile(test => {
 >fromDoWhile(test => {            return true;        }) : Iterator<{}>
 >fromDoWhile : <T>(doWhile: (test: Iterator<T>) => boolean) => Iterator<T>
->test => {            return true;        } : (test: Iterator<{}>) => boolean
+>test => {            return true;        } : (test: Iterator<{}>) => true
 >test : Iterator<{}>

            return true;
->true : boolean
+>true : true

        });
    }
--- a/tests/baselines/reference/returnStatements.types
+++ b/tests/baselines/reference/returnStatements.types
@@ -17,7 +17,7 @@ function fn4(): void { return; }

 function fn5(): boolean { return true; }
 >fn5 : () => boolean
->true : boolean
+>true : true

 function fn6(): Date { return new Date(12); }
 >fn6 : () => Date
--- a/tests/baselines/reference/staticAnonymousTypeNotReferencingTypeParameter.types
+++ b/tests/baselines/reference/staticAnonymousTypeNotReferencingTypeParameter.types
@@ -471,10 +471,10 @@ class ListWrapper {
 >1 : number

      return true;
->true : boolean
+>true : true
    }
    return false;
->false : boolean
+>false : false
  }
  static clear(dit: typeof ListWrapper, list: any[]) { list.length = 0; }
 >clear : (dit: typeof ListWrapper, list: any[]) => void
@@ -540,7 +540,7 @@ class ListWrapper {
 >b.length : number
 >b : any[]
 >length : number
->false : boolean
+>false : false

    for (var i = 0; i < a.length; ++i) {
 >i : number
@@ -561,10 +561,10 @@ class ListWrapper {
 >b[i] : any
 >b : any[]
 >i : number
->false : boolean
+>false : false
    }
    return true;
->true : boolean
+>true : true
  }
  static slice<T>(dit: typeof ListWrapper, l: T[], from: number = 0, to: number = null): T[] {
 >slice : <T>(dit: typeof ListWrapper, l: T[], from?: number, to?: number) => T[]
--- a/tests/baselines/reference/stringLiteralTypesOverloads01.types
+++ b/tests/baselines/reference/stringLiteralTypesOverloads01.types
@@ -58,7 +58,7 @@ function getFalsyPrimitive(x: PrimitiveName): number | string | boolean {
 >"boolean" : "boolean"

        return false;
->false : boolean
+>false : false
    }

    // Should be unreachable.
--- a/tests/baselines/reference/symbolProperty18.types
+++ b/tests/baselines/reference/symbolProperty18.types
@@ -40,11 +40,11 @@ var str = i[Symbol.toStringTag]();
 >toStringTag : symbol

 i[Symbol.toPrimitive] = false;
->i[Symbol.toPrimitive] = false : boolean
+>i[Symbol.toPrimitive] = false : false
 >i[Symbol.toPrimitive] : boolean
 >i : { [Symbol.iterator]: number; [Symbol.toStringTag](): string; [Symbol.toPrimitive]: boolean; }
 >Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
 >toPrimitive : symbol
->false : boolean
+>false : false

--- a/tests/baselines/reference/symbolProperty21.errors.txt
+++ b/tests/baselines/reference/symbolProperty21.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/Symbols/symbolProperty21.ts(10,5): error TS2345: Argument of type '{ [Symbol.isConcatSpreadable]: string; [Symbol.toPrimitive]: number; [Symbol.unscopables]: boolean; }' is not assignable to parameter of type 'I<boolean, string>'.
+tests/cases/conformance/es6/Symbols/symbolProperty21.ts(10,5): error TS2345: Argument of type '{ [Symbol.isConcatSpreadable]: string; [Symbol.toPrimitive]: number; [Symbol.unscopables]: true; }' is not assignable to parameter of type 'I<boolean, string>'.
  Object literal may only specify known properties, and '[Symbol.toPrimitive]' does not exist in type 'I<boolean, string>'.


@@ -14,7 +14,7 @@ tests/cases/conformance/es6/Symbols/symbolProperty21.ts(10,5): error TS2345: Arg
        [Symbol.isConcatSpreadable]: "",
        [Symbol.toPrimitive]: 0,
        ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type '{ [Symbol.isConcatSpreadable]: string; [Symbol.toPrimitive]: number; [Symbol.unscopables]: boolean; }' is not assignable to parameter of type 'I<boolean, string>'.
+!!! error TS2345: Argument of type '{ [Symbol.isConcatSpreadable]: string; [Symbol.toPrimitive]: number; [Symbol.unscopables]: true; }' is not assignable to parameter of type 'I<boolean, string>'.
 !!! error TS2345:   Object literal may only specify known properties, and '[Symbol.toPrimitive]' does not exist in type 'I<boolean, string>'.
        [Symbol.unscopables]: true
    });
--- a/tests/baselines/reference/targetTypeArgs.types
+++ b/tests/baselines/reference/targetTypeArgs.types
@@ -35,11 +35,11 @@ foo(function(x) { x });
 >["hello"] : string[]
 >"hello" : string
 >every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
->function(v,i,a) {return true;} : (v: string, i: number, a: string[]) => boolean
+>function(v,i,a) {return true;} : (v: string, i: number, a: string[]) => true
 >v : string
 >i : number
 >a : string[]
->true : boolean
+>true : true

 [1].every(function(v,i,a) {return true;});
 >[1].every(function(v,i,a) {return true;}) : boolean
@@ -47,11 +47,11 @@ foo(function(x) { x });
 >[1] : number[]
 >1 : number
 >every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
->function(v,i,a) {return true;} : (v: number, i: number, a: number[]) => boolean
+>function(v,i,a) {return true;} : (v: number, i: number, a: number[]) => true
 >v : number
 >i : number
 >a : number[]
->true : boolean
+>true : true

 [1].every(function(v,i,a) {return true;});
 >[1].every(function(v,i,a) {return true;}) : boolean
@@ -59,11 +59,11 @@ foo(function(x) { x });
 >[1] : number[]
 >1 : number
 >every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
->function(v,i,a) {return true;} : (v: number, i: number, a: number[]) => boolean
+>function(v,i,a) {return true;} : (v: number, i: number, a: number[]) => true
 >v : number
 >i : number
 >a : number[]
->true : boolean
+>true : true

 ["s"].every(function(v,i,a) {return true;});
 >["s"].every(function(v,i,a) {return true;}) : boolean
@@ -71,11 +71,11 @@ foo(function(x) { x });
 >["s"] : string[]
 >"s" : string
 >every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
->function(v,i,a) {return true;} : (v: string, i: number, a: string[]) => boolean
+>function(v,i,a) {return true;} : (v: string, i: number, a: string[]) => true
 >v : string
 >i : number
 >a : string[]
->true : boolean
+>true : true

 ["s"].forEach(function(v,i,a) { v });
 >["s"].forEach(function(v,i,a) { v }) : void
--- a/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.types
+++ b/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.types
@@ -63,7 +63,7 @@ var r = b.foo(true); // returns Date
 >b.foo : { (x: boolean): number; (x: string): string; (x: boolean): Date; (x: Date): string; }
 >b : B<boolean>
 >foo : { (x: boolean): number; (x: string): string; (x: boolean): Date; (x: Date): string; }
->true : boolean
+>true : true

 // add generic overload
 interface C<T, U> {
--- a/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads2.types
+++ b/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads2.types
@@ -83,13 +83,13 @@ module G {
 >r2 : boolean
 >a(true) : boolean
 >a : A<boolean>
->true : boolean
+>true : true

    var r3 = a(true, 2);
 >r3 : boolean
 >a(true, 2) : boolean
 >a : A<boolean>
->true : boolean
+>true : true
 >2 : number

    var r4 = a(1, true);
@@ -97,5 +97,5 @@ module G {
 >a(1, true) : number
 >a : A<boolean>
 >1 : number
->true : boolean
+>true : true
 }
--- a/tests/baselines/reference/typeAliases.types
+++ b/tests/baselines/reference/typeAliases.types
@@ -231,9 +231,9 @@ f16(x);
 var y: StringAndBoolean = ["1", false];
 >y : [string, boolean]
 >StringAndBoolean : [string, boolean]
->["1", false] : [string, boolean]
+>["1", false] : [string, false]
 >"1" : string
->false : boolean
+>false : false

 y[0].toLowerCase();
 >y[0].toLowerCase() : string
--- a/tests/baselines/reference/typeGuardFunction.types
+++ b/tests/baselines/reference/typeGuardFunction.types
@@ -151,7 +151,7 @@ class D {
 >C : C

        return true;
->true : boolean
+>true : true
    }
 }

@@ -163,7 +163,7 @@ let f1 = (p1: A): p1 is C => false;
 >A : A
 >p1 : any
 >C : C
->false : boolean
+>false : false

 // Function type
 declare function f2(p1: (p1: A) => p1 is C);
@@ -185,7 +185,7 @@ f2(function(p1: A): p1 is C {
 >C : C

    return true;
->true : boolean
+>true : true

 });

--- a/tests/baselines/reference/typeGuardFunctionOfFormThis.types
+++ b/tests/baselines/reference/typeGuardFunctionOfFormThis.types
@@ -259,13 +259,13 @@ if (crate.isSundries()) {
 >isSundries : () => this is Crate<Sundries>

    crate.contents.broken = true;
->crate.contents.broken = true : boolean
+>crate.contents.broken = true : true
 >crate.contents.broken : boolean
 >crate.contents : Sundries
 >crate : Crate<Sundries>
 >contents : Sundries
 >broken : boolean
->true : boolean
+>true : true
 }
 else if (crate.isSupplies()) {
 >crate.isSupplies() : boolean
@@ -274,13 +274,13 @@ else if (crate.isSupplies()) {
 >isSupplies : () => this is Crate<Supplies>

    crate.contents.spoiled = true;
->crate.contents.spoiled = true : boolean
+>crate.contents.spoiled = true : true
 >crate.contents.spoiled : boolean
 >crate.contents : Supplies
 >crate : Crate<Supplies>
 >contents : Supplies
 >spoiled : boolean
->true : boolean
+>true : true
 }

 // Matching guards should be assignable
--- a/tests/baselines/reference/typeGuardNesting.types
+++ b/tests/baselines/reference/typeGuardNesting.types
@@ -37,7 +37,7 @@ if ((typeof strOrBool === 'boolean' && !strOrBool) || typeof strOrBool === 'stri
 >strOrBool : string | boolean
 >'boolean' : "boolean"
 >strOrBool : boolean
->false : boolean
+>false : false

 	let label2: string = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
 >label2 : string
@@ -59,7 +59,7 @@ if ((typeof strOrBool === 'boolean' && !strOrBool) || typeof strOrBool === 'stri
 >strOrBool : string | boolean
 >'string' : "string"
 >strOrBool : boolean
->false : boolean
+>false : false
 }

 if ((typeof strOrBool !== 'string' && !strOrBool) || typeof strOrBool !== 'boolean') {
@@ -97,7 +97,7 @@ if ((typeof strOrBool !== 'string' && !strOrBool) || typeof strOrBool !== 'boole
 >strOrBool : string | boolean
 >'boolean' : "boolean"
 >strOrBool : boolean
->false : boolean
+>false : false

 	let label2: string = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
 >label2 : string
@@ -119,6 +119,6 @@ if ((typeof strOrBool !== 'string' && !strOrBool) || typeof strOrBool !== 'boole
 >strOrBool : string | boolean
 >'string' : "string"
 >strOrBool : boolean
->false : boolean
+>false : false
 }

--- a/tests/baselines/reference/typeGuardOfFormIsType.types
+++ b/tests/baselines/reference/typeGuardOfFormIsType.types
@@ -35,7 +35,7 @@ function isC1(x: any): x is C1 {
 >C1 : C1

    return true;
->true : boolean
+>true : true
 }

 function isC2(x: any): x is C2 {
@@ -45,7 +45,7 @@ function isC2(x: any): x is C2 {
 >C2 : C2

    return true;
->true : boolean
+>true : true
 }

 function isD1(x: any): x is D1 {
@@ -55,7 +55,7 @@ function isD1(x: any): x is D1 {
 >D1 : D1

    return true;
->true : boolean
+>true : true
 }

 var c1Orc2: C1 | C2;
--- a/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.types
+++ b/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.types
@@ -54,7 +54,7 @@ function isC1(x: any): x is C1 {
 >C1 : C1

    return true;
->true : boolean
+>true : true
 }

 function isC2(x: any): x is C2 {
@@ -64,7 +64,7 @@ function isC2(x: any): x is C2 {
 >C2 : C2

    return true;
->true : boolean
+>true : true
 }

 function isD1(x: any): x is D1 {
@@ -74,7 +74,7 @@ function isD1(x: any): x is D1 {
 >D1 : D1

    return true;
->true : boolean
+>true : true
 }

 var c1: C1;
--- a/tests/baselines/reference/typeGuardsInDoStatement.types
+++ b/tests/baselines/reference/typeGuardsInDoStatement.types
@@ -7,13 +7,13 @@ function a(x: string | number | boolean) {
 >x : string | number | boolean

    x = true;
->x = true : boolean
+>x = true : true
 >x : string | number | boolean
->true : boolean
+>true : true

    do {
        x; // boolean | string
->x : string | boolean
+>x : string | true

        x = undefined;
 >x = undefined : undefined
@@ -34,13 +34,13 @@ function b(x: string | number | boolean) {
 >x : string | number | boolean

    x = true;
->x = true : boolean
+>x = true : true
 >x : string | number | boolean
->true : boolean
+>true : true

    do {
        x; // boolean | string
->x : string | boolean
+>x : string | true

        if (cond) continue;
 >cond : boolean
--- a/tests/baselines/reference/typeGuardsOnClassProperty.types
+++ b/tests/baselines/reference/typeGuardsOnClassProperty.types
@@ -67,15 +67,15 @@ var o: {
 >prop2 : string | boolean

 } = {
->{        prop1: "string" ,        prop2: true    } : { prop1: string; prop2: boolean; }
+>{        prop1: "string" ,        prop2: true    } : { prop1: string; prop2: true; }

        prop1: "string" ,
 >prop1 : string
 >"string" : string

        prop2: true
->prop2 : boolean
->true : boolean
+>prop2 : true
+>true : true
    }

 if (typeof o.prop1 === "string" && o.prop1.toLowerCase()) {}
--- a/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively.types
+++ b/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively.types
@@ -62,13 +62,13 @@ foo({ x: 1 }, { x: 1, y: '' }, { x: 2, y: '', z: true });
 >1 : number
 >y : string
 >'' : string
->{ x: 2, y: '', z: true } : { x: number; y: string; z: boolean; }
+>{ x: 2, y: '', z: true } : { x: number; y: string; z: true; }
 >x : number
 >2 : number
 >y : string
 >'' : string
->z : boolean
->true : boolean
+>z : true
+>true : true

 foo(a, b, c);
 >foo(a, b, c) : C
@@ -82,13 +82,13 @@ foo(a, b, { foo: 1, bar: '', hm: true });
 >foo : <T, U, V>(x: T, y: U, z: V) => V
 >a : A
 >b : B
->{ foo: 1, bar: '', hm: true } : { foo: number; bar: string; hm: boolean; }
+>{ foo: 1, bar: '', hm: true } : { foo: number; bar: string; hm: true; }
 >foo : number
 >1 : number
 >bar : string
 >'' : string
->hm : boolean
->true : boolean
+>hm : true
+>true : true

 foo((x: number, y) => { }, (x) => { }, () => { });
 >foo((x: number, y) => { }, (x) => { }, () => { }) : () => void
--- a/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively2.types
+++ b/tests/baselines/reference/typeParameterAsTypeParameterConstraintTransitively2.types
@@ -62,13 +62,13 @@ foo({ x: 1 }, { x: 1, y: '' }, { x: 2, y: 2, z: true });
 >1 : number
 >y : string
 >'' : string
->{ x: 2, y: 2, z: true } : { x: number; y: number; z: boolean; }
+>{ x: 2, y: 2, z: true } : { x: number; y: number; z: true; }
 >x : number
 >2 : number
 >y : number
 >2 : number
->z : boolean
->true : boolean
+>z : true
+>true : true

 foo(a, b, a);
 >foo(a, b, a) : A
@@ -81,13 +81,13 @@ foo(a, { foo: 1, bar: '', hm: true }, b);
 >foo(a, { foo: 1, bar: '', hm: true }, b) : B
 >foo : <T, U, V>(x: T, y: U, z: V) => V
 >a : A
->{ foo: 1, bar: '', hm: true } : { foo: number; bar: string; hm: boolean; }
+>{ foo: 1, bar: '', hm: true } : { foo: number; bar: string; hm: true; }
 >foo : number
 >1 : number
 >bar : string
 >'' : string
->hm : boolean
->true : boolean
+>hm : true
+>true : true
 >b : B

 foo((x: number, y: string) => { }, (x, y: boolean) => { }, () => { });
--- a/tests/baselines/reference/typeofOperatorWithBooleanType.types
+++ b/tests/baselines/reference/typeofOperatorWithBooleanType.types
@@ -6,7 +6,7 @@ var BOOLEAN: boolean;

 function foo(): boolean { return true; }
 >foo : () => boolean
->true : boolean
+>true : true

 class A {
 >A : A
--- a/tests/baselines/reference/underscoreTest1.types
+++ b/tests/baselines/reference/underscoreTest1.types
@@ -235,8 +235,8 @@ _.all([true, 1, null, 'yes'], _.identity);
 >_.all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
 >_ : Underscore.Static
 >all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
->[true, 1, null, 'yes'] : (string | number | boolean)[]
->true : boolean
+>[true, 1, null, 'yes'] : (string | number | true)[]
+>true : true
 >1 : number
 >null : null
 >'yes' : string
@@ -249,11 +249,11 @@ _.any([null, 0, 'yes', false]);
 >_.any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
 >_ : Underscore.Static
 >any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
->[null, 0, 'yes', false] : (string | number | boolean)[]
+>[null, 0, 'yes', false] : (string | number | false)[]
 >null : null
 >0 : number
 >'yes' : string
->false : boolean
+>false : false

 _.contains([1, 2, 3], 3);
 >_.contains([1, 2, 3], 3) : boolean
@@ -512,10 +512,10 @@ _.compact([0, 1, false, 2, '', 3]);
 >_.compact : <T>(list: T[]) => T[]
 >_ : Underscore.Static
 >compact : <T>(list: T[]) => T[]
->[0, 1, false, 2, '', 3] : (string | number | boolean)[]
+>[0, 1, false, 2, '', 3] : (string | number | false)[]
 >0 : number
 >1 : number
->false : boolean
+>false : false
 >2 : number
 >'' : string
 >3 : number
@@ -571,7 +571,7 @@ _.flatten([1, [2], [3, [[4]]]], true);
 >[[4]] : number[][]
 >[4] : number[]
 >4 : number
->true : boolean
+>true : true

 _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
 >_.without([1, 2, 1, 0, 3, 1, 4], 0, 1) : number[]
@@ -668,9 +668,9 @@ _.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
 >40 : number
 >50 : number
 >[true, false, false] : boolean[]
->true : boolean
->false : boolean
->false : boolean
+>true : true
+>false : false
+>false : false

 _.object(['moe', 'larry', 'curly'], [30, 40, 50]);
 >_.object(['moe', 'larry', 'curly'], [30, 40, 50]) : any
--- a/tests/baselines/reference/unionTypeCallSignatures2.types
+++ b/tests/baselines/reference/unionTypeCallSignatures2.types
@@ -81,8 +81,8 @@ var a1 = f1([true, false]);  // boolean[]
 >f1([true, false]) : boolean[]
 >f1 : A | B | C
 >[true, false] : boolean[]
->true : boolean
->false : boolean
+>true : true
+>false : false

 var f2: C | B | A;
 >f2 : A | B | C
@@ -107,8 +107,8 @@ var a2 = f2([true, false]);  // boolean[]
 >f2([true, false]) : boolean[]
 >f2 : A | B | C
 >[true, false] : boolean[]
->true : boolean
->false : boolean
+>true : true
+>false : false

 var f3: B | A | C;
 >f3 : A | B | C
@@ -133,7 +133,7 @@ var a3 = f3([true, false]);  // boolean[]
 >f3([true, false]) : boolean[]
 >f3 : A | B | C
 >[true, false] : boolean[]
->true : boolean
->false : boolean
+>true : true
+>false : false


--- a/tests/baselines/reference/unionTypeInference.types
+++ b/tests/baselines/reference/unionTypeInference.types
@@ -77,9 +77,9 @@ var b1 = g(["string", true]);
 >b1 : boolean
 >g(["string", true]) : boolean
 >g : <T>(value: [string, T]) => T
->["string", true] : [string, boolean]
+>["string", true] : [string, true]
 >"string" : string
->true : boolean
+>true : true

 function h<T>(x: string|boolean|T): T {
 >h : <T>(x: string | boolean | T) => T
--- a/tests/baselines/reference/voidOperatorWithBooleanType.types
+++ b/tests/baselines/reference/voidOperatorWithBooleanType.types
@@ -5,7 +5,7 @@ var BOOLEAN: boolean;

 function foo(): boolean { return true; }
 >foo : () => boolean
->true : boolean
+>true : true

 class A {
 >A : A