=== tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithAnyOtherType.ts ===
// ! operator on any type

var ANY: any;
>ANY : any

var ANY1;
>ANY1 : any

var ANY2: any[] = ["", ""];
>ANY2 : any[]
>["", ""] : string[]
>"" : ""
>"" : ""

var obj: () => {}
>obj : () => {}

var obj1 = { x: "", y: () => { }};
>obj1 : { x: string; y: () => void; }
>{ x: "", y: () => { }} : { x: string; y: () => void; }
>x : string
>"" : ""
>y : () => void
>() => { } : () => void

function foo(): any {
>foo : () => any

    var a;
>a : any

    return a;
>a : any
}
class A {
>A : A

    public a: any;
>a : any

    static foo() {
>foo : () => any

        var a;
>a : any

        return a;
>a : any
    }
}
module M {
>M : typeof M

    export var n: any;
>n : any
}
var objA = new A();
>objA : A
>new A() : A
>A : typeof A

// any type var
var ResultIsBoolean1 = !ANY1;
>ResultIsBoolean1 : boolean
>!ANY1 : boolean
>ANY1 : any

var ResultIsBoolean2 = !ANY2;
>ResultIsBoolean2 : boolean
>!ANY2 : boolean
>ANY2 : any[]

var ResultIsBoolean3 = !A;
>ResultIsBoolean3 : boolean
>!A : boolean
>A : typeof A

var ResultIsBoolean4 = !M;
>ResultIsBoolean4 : boolean
>!M : boolean
>M : typeof M

var ResultIsBoolean5 = !obj;
>ResultIsBoolean5 : boolean
>!obj : boolean
>obj : () => {}

var ResultIsBoolean6 = !obj1;
>ResultIsBoolean6 : boolean
>!obj1 : boolean
>obj1 : { x: string; y: () => void; }

// any type literal
var ResultIsBoolean7 = !undefined;
>ResultIsBoolean7 : boolean
>!undefined : true
>undefined : undefined

var ResultIsBoolean8 = !null;
>ResultIsBoolean8 : boolean
>!null : true
>null : null

// any type expressions
var ResultIsBoolean9 = !ANY2[0];
>ResultIsBoolean9 : boolean
>!ANY2[0] : boolean
>ANY2[0] : any
>ANY2 : any[]
>0 : 0

var ResultIsBoolean10 = !obj1.x;
>ResultIsBoolean10 : boolean
>!obj1.x : boolean
>obj1.x : string
>obj1 : { x: string; y: () => void; }
>x : string

var ResultIsBoolean11 = !obj1.y;
>ResultIsBoolean11 : boolean
>!obj1.y : boolean
>obj1.y : () => void
>obj1 : { x: string; y: () => void; }
>y : () => void

var ResultIsBoolean12 = !objA.a;
>ResultIsBoolean12 : boolean
>!objA.a : boolean
>objA.a : any
>objA : A
>a : any

var ResultIsBoolean13 = !M.n;
>ResultIsBoolean13 : boolean
>!M.n : boolean
>M.n : any
>M : typeof M
>n : any

var ResultIsBoolean14 = !foo();
>ResultIsBoolean14 : boolean
>!foo() : boolean
>foo() : any
>foo : () => any

var ResultIsBoolean15 = !A.foo();
>ResultIsBoolean15 : boolean
>!A.foo() : boolean
>A.foo() : any
>A.foo : () => any
>A : typeof A
>foo : () => any

var ResultIsBoolean16 = !(ANY + ANY1);
>ResultIsBoolean16 : boolean
>!(ANY + ANY1) : boolean
>(ANY + ANY1) : any
>ANY + ANY1 : any
>ANY : any
>ANY1 : any

var ResultIsBoolean17 = !(null + undefined);
>ResultIsBoolean17 : boolean
>!(null + undefined) : boolean
>(null + undefined) : any
>null + undefined : any
>null : null
>undefined : undefined

var ResultIsBoolean18 = !(null + null);
>ResultIsBoolean18 : boolean
>!(null + null) : boolean
>(null + null) : any
>null + null : any
>null : null
>null : null

var ResultIsBoolean19 = !(undefined + undefined);
>ResultIsBoolean19 : boolean
>!(undefined + undefined) : boolean
>(undefined + undefined) : any
>undefined + undefined : any
>undefined : undefined
>undefined : undefined

// multiple ! operators
var ResultIsBoolean20 = !!ANY;
>ResultIsBoolean20 : boolean
>!!ANY : boolean
>!ANY : boolean
>ANY : any

var ResultIsBoolean21 = !!!(ANY + ANY1);
>ResultIsBoolean21 : boolean
>!!!(ANY + ANY1) : boolean
>!!(ANY + ANY1) : boolean
>!(ANY + ANY1) : boolean
>(ANY + ANY1) : any
>ANY + ANY1 : any
>ANY : any
>ANY1 : any

// miss assignment operators
!ANY;
>!ANY : boolean
>ANY : any

!ANY1;
>!ANY1 : boolean
>ANY1 : any

!ANY2[0];
>!ANY2[0] : boolean
>ANY2[0] : any
>ANY2 : any[]
>0 : 0

!ANY, ANY1;
>!ANY, ANY1 : any
>!ANY : boolean
>ANY : any
>ANY1 : any

!objA.a;
>!objA.a : boolean
>objA.a : any
>objA : A
>a : any

!M.n;
>!M.n : boolean
>M.n : any
>M : typeof M
>n : any

