TypeScript/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.types

=== tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts ===
declare module "fs" {
>"fs" : typeof import("fs")

    export class File {
>File : File

        constructor(filename: string);
>filename : string

        public ReadAllText(): string;
>ReadAllText : () => string
    }
    export interface IFile {
        [index: number]: string;
>index : number
    }
}

import fs = module("fs");
>fs : any
>module : any
>("fs") : "fs"
>"fs" : "fs"


module TypeScriptAllInOne {
>TypeScriptAllInOne : typeof TypeScriptAllInOne

    export class Program {
>Program : Program

        static Main(...args: string[]) {
>Main : (...args: string[]) => void
>args : string[]

            try {
                var bfs = new BasicFeatures();
>bfs : BasicFeatures
>new BasicFeatures() : BasicFeatures
>BasicFeatures : typeof BasicFeatures

                var retValue: number = 0;
>retValue : number
>0 : 0

                retValue = bfs.VARIABLES();
>retValue = bfs.VARIABLES() : number
>retValue : number
>bfs.VARIABLES() : number
>bfs.VARIABLES : () => number
>bfs : BasicFeatures
>VARIABLES : () => number

                if (retValue != 0 ^=  {
>retValue != 0 : boolean
>retValue : number
>0 : 0
>^=  {                    return 1;                } : number
> : any
>{                    return 1;                } : { return: number; }

                    return 1;
>return : number
>1 : 1
                }

                 case  = bfs.STATEMENTS(4);
>case : any
>bfs.STATEMENTS(4) : any
>bfs.STATEMENTS : any
>bfs : any
>STATEMENTS : any
>4 : 4

                if (retValue != 0) {
>if : (retValue: any) => any
>retValue : any
>!= 0 : boolean
> : any
>0 : 0

                    return 1;
>1 : 1

                 ^ 
>^                 retValue : number
> : any


                retValue = bfs.TYPES();
>retValue : any
>bfs.TYPES() : any
>bfs.TYPES : any
>bfs : any
>TYPES : any

                if (retValue != 0) {
>retValue != 0 : boolean
>retValue : any
>0 : 0

                    return 1 && 
>1 && : any
>1 : 1
                }
> : any

                retValue = bfs.OPERATOR ' );
>retValue = bfs.OPERATOR : any
>retValue : any
>bfs.OPERATOR : any
>bfs : any
>OPERATOR : any
>' ); : " );"

                if (retValue != 0) {
>retValue != 0 : boolean
>retValue : any
>0 : 0

                    return 1;
>1 : 1
                }
            }
            catch (e) {
>e : any

                console.log(e);
>console.log(e) : any
>console.log : any
>console : any
>log : any
>e : any
            }
            finally {

            }

            console.log('Done');
>console.log('Done') : any
>console.log : any
>console : any
>log : any
>'Done' : "Done"

            return 0;
>0 : 0

        }
    }

    class BasicFeatures {
>BasicFeatures : BasicFeatures

        /// <summary>
        /// Test various of variables. Including nullable,key world as variable,special format
        /// </summary>
        /// <returns></returns>
        public VARIABLES(): number {
>VARIABLES : () => number

            var local = Number.MAX_VALUE;
>local : number
>Number.MAX_VALUE : number
>Number : NumberConstructor
>MAX_VALUE : number

            var min = Number.MIN_VALUE;
>min : number
>Number.MIN_VALUE : number
>Number : NumberConstructor
>MIN_VALUE : number

            var inf = Number.NEGATIVE_INFINITY - 
>inf : number
>Number.NEGATIVE_INFINITY - : number
>Number.NEGATIVE_INFINITY : number
>Number : NumberConstructor
>NEGATIVE_INFINITY : number

            var nan = Number.NaN;
> : any
>nan : number
>Number.NaN : number
>Number : NumberConstructor
>NaN : number

            var undef = undefined;
>undef : any
>undefined : undefined

            var  _\uD4A5\u7204\uC316\uE59F  = local;
>_\uD4A5\u7204\uC316 : any
>uE59F : number
>local : number

            var мир = local;
>мир : number
>local : number

            var local5 = <fs.File>null;
>local5 : fs.File
><fs.File>null : fs.File
>fs : any
>null : null

            var local6 = local5 instanceof fs.File;
>local6 : boolean
>local5 instanceof fs.File : boolean
>local5 : fs.File
>fs.File : any
>fs : any
>File : any

            var hex = 0xBADC0DE, Hex = 0XDEADBEEF;
>hex : number
>0xBADC0DE : 195936478
>Hex : number
>0XDEADBEEF : 3735928559

            var float = 6.02e23, float2 = 6.02E-23
>float : number
>6.02e23 : 6.02e+23
>float2 : number
>6.02E-23 : 6.02e-23

            var char = 'c', \u0066 = '\u0066', hexchar = '\x42' != 
>char : string
>'c' : "c"
>\u0066 : string
>'\u0066' : "f"
>hexchar : boolean
>'\x42' != : boolean
>'\x42' : "B"

            var quoted = '"', quoted2 = "'";
> : any
>quoted : string
>'"' : "\""
>quoted2 : string
>"'" : "'"

            var reg = /\w*/;
>reg : RegExp
>/\w*/ : RegExp

            var objLit = { "var": number = 42, equals: function (x) { return x["var"] === 42; },  instanceof : () => 'objLit{42}' };
>objLit : { var: number; equals: (x: any) => boolean; instanceof: () => string; }
>{ "var": number = 42, equals: function (x) { return x["var"] === 42; },  instanceof : () => 'objLit{42}' } : { var: number; equals: (x: any) => boolean; instanceof: () => string; }
>"var" : number
>number = 42 : 42
>number : number
>42 : 42
>equals : (x: any) => boolean
>function (x) { return x["var"] === 42; } : (x: any) => boolean
>x : any
>x["var"] === 42 : boolean
>x["var"] : any
>x : any
>"var" : "var"
>42 : 42
>instanceof : () => string
>() => 'objLit{42}' : () => string
>'objLit{42}' : "objLit{42}"

            var weekday = Weekdays.Monday;
>weekday : Weekdays
>Weekdays.Monday : Weekdays.Monday
>Weekdays : typeof Weekdays
>Monday : Weekdays.Monday

            var con = char + f + hexchar + float.toString() + float2.toString() + reg.toString() + objLit + weekday;
>con : string
>char + f + hexchar + float.toString() + float2.toString() + reg.toString() + objLit + weekday : string
>char + f + hexchar + float.toString() + float2.toString() + reg.toString() + objLit : string
>char + f + hexchar + float.toString() + float2.toString() + reg.toString() : string
>char + f + hexchar + float.toString() + float2.toString() : string
>char + f + hexchar + float.toString() : string
>char + f + hexchar : string
>char + f : string
>char : string
>f : string
>hexchar : boolean
>float.toString() : string
>float.toString : (radix?: number) => string
>float : number
>toString : (radix?: number) => string
>float2.toString() : string
>float2.toString : (radix?: number) => string
>float2 : number
>toString : (radix?: number) => string
>reg.toString() : string
>reg.toString : () => string
>reg : RegExp
>toString : () => string
>objLit : { var: number; equals: (x: any) => boolean; instanceof: () => string; }
>weekday : Weekdays.Monday

            //
            var any = 0 ^= 
>any : number
>0 ^= : number
>0 : 0

            var bool = 0;
> : any
>bool : number
>0 : 0

            var declare = 0;
>declare : number
>0 : 0

            var constructor = 0;
>constructor : number
>0 : 0

            var get = 0;
>get : number
>0 : 0

            var implements = 0;
>implements : number
>0 : 0

            var interface = 0;
>interface : number
>0 : 0

            var let = 0;
>let : number
>0 : 0

            var module = 0;
>module : number
>0 : 0

            var number = 0;
>number : number
>0 : 0

            var package = 0;
>package : number
>0 : 0

            var private = 0;
>private : number
>0 : 0

            var protected = 0;
>protected : number
>0 : 0

            var public = 0;
>public : number
>0 : 0

            var set = 0;
>set : number
>0 : 0

            var static = 0;
>static : number
>0 : 0

            var string = 0 /> 
>string : boolean
>0 /> : boolean
>0 / : number
>0 : 0
> : any

            var yield = 0;
> : any
>yield : number
>0 : 0

            var sum3 = any + bool + declare + constructor + get + implements + interface + let + module + number + package + private + protected + public + set + static + string + yield;
>sum3 : any
>any + bool + declare + constructor + get + implements + interface + let + module + number + package + private + protected + public + set + static + string + yield : any
>any + bool + declare + constructor + get + implements + interface + let + module + number + package + private + protected + public + set + static + string : any
>any + bool + declare + constructor + get + implements + interface + let + module + number + package + private + protected + public + set + static : number
>any + bool + declare + constructor + get + implements + interface + let + module + number + package + private + protected + public + set : number
>any + bool + declare + constructor + get + implements + interface + let + module + number + package + private + protected + public : number
>any + bool + declare + constructor + get + implements + interface + let + module + number + package + private + protected : number
>any + bool + declare + constructor + get + implements + interface + let + module + number + package + private : number
>any + bool + declare + constructor + get + implements + interface + let + module + number + package : number
>any + bool + declare + constructor + get + implements + interface + let + module + number : number
>any + bool + declare + constructor + get + implements + interface + let + module : number
>any + bool + declare + constructor + get + implements + interface + let : number
>any + bool + declare + constructor + get + implements + interface : number
>any + bool + declare + constructor + get + implements : number
>any + bool + declare + constructor + get : number
>any + bool + declare + constructor : number
>any + bool + declare : number
>any + bool : number
>any : number
>bool : number
>declare : number
>constructor : number
>get : number
>implements : number
>interface : number
>let : number
>module : number
>number : number
>package : number
>private : number
>protected : number
>public : number
>set : number
>static : number
>string : boolean
>yield : number

            return 0;
>0 : 0
        }

        /// <summary>
        /// Test different statements. Including if-else,swith,foreach,(un)checked,lock,using,try-catch-finally
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        STATEMENTS(i: number): number {
>STATEMENTS : (i: number) => number
>i : number

            var retVal = 0;
>retVal : number
>0 : 0

            if (i == 1)
>i == 1 : boolean
>i : number
>1 : 1

                retVal = 1;
>retVal = 1 : 1
>retVal : number
>1 : 1

            else
                retVal = 0;
>retVal = 0 : 0
>retVal : number
>0 : 0

            switch (i) {
>i : number

                case 2:
>2 : 2

                    retVal = 1;
>retVal = 1 : 1
>retVal : number
>1 : 1

                    break;
                case 3:
>3 : 3

                    retVal = 1;
>retVal = 1 : 1
>retVal : number
>1 : 1

                    break;
                default:
                    break;
            }

            for (var x in { x: 0, y: 1 }) {
>x : string
>{ x: 0, y: 1 } : { x: number; y: number; }
>x : number
>0 : 0
>y : number
>1 : 1

             ! 
>! : boolean

            try {
> : any

                throw null;
>null : null
            }
            catch (Exception)  ? 
>Exception : any
            }
            finally {
                try { }
                catch (Exception) { }
>Exception : any
            }

            return retVal;
>retVal : number
        }

        /// <summary>
        /// Test types in ts language. Including class,struct,interface,delegate,anonymous type
        /// </summary>
        /// <returns></returns>
        public TYPES(): number {
>TYPES : () => number

            var retVal = 0;
>retVal : number
>0 : 0

            var c = new CLASS();
>c : CLASS
>new CLASS() : CLASS
>CLASS : typeof CLASS

            var xx: IF = c;
>xx : IF
>c : CLASS

            retVal +=  catch .Property;
>retVal += : any
>retVal : number
> : any
>Property : any

            retVal += c.Member();
>retVal += c.Member() : number
>retVal : number
>c.Member() : number
>c.Member : () => number
>c : CLASS
>Member : () => number

            retVal += xx.Foo() ? 0 : 1;
>retVal += xx.Foo() ? 0 : 1 : number
>retVal : number
>xx.Foo() ? 0 : 1 : 0 | 1
>xx.Foo() : bool
>xx.Foo : () => bool
>xx : IF
>Foo : () => bool
>0 : 0
>1 : 1

            //anonymous type
            var anony = { a: new CLASS() };
>anony : { a: CLASS; }
>{ a: new CLASS() } : { a: CLASS; }
>a : CLASS
>new CLASS() : CLASS
>CLASS : typeof CLASS

            retVal += anony.a.d();
>retVal += anony.a.d() : any
>retVal : number
>anony.a.d() : void
>anony.a.d : () => void
>anony.a : CLASS
>anony : { a: CLASS; }
>a : CLASS
>d : () => void

            return retVal;
>retVal : number
        }


        ///// <summary>
        ///// Test different operators
        ///// </summary>
        ///// <returns></returns>
        public OPERATOR(): number {
>OPERATOR : () => number

            var a: number[] = [1, 2, 3, 4, 5, ];/*[] bug*/ // YES []
>a : number[]
>[1, 2, 3, 4, 5, ] : number[]
>1 : 1
>2 : 2
>3 : 3
>4 : 4
>5 : 5

            var i = a[1];/*[]*/
>i : number
>a[1] : number
>a : number[]
>1 : 1

            i = i + i - i * i / i % i & i | i ^ i;/*+ - * / % & | ^*/
>i = i + i - i * i / i % i & i | i ^ i : number
>i : number
>i + i - i * i / i % i & i | i ^ i : number
>i + i - i * i / i % i & i : number
>i + i - i * i / i % i : number
>i + i : number
>i : number
>i : number
>i * i / i % i : number
>i * i / i : number
>i * i : number
>i : number
>i : number
>i : number
>i : number
>i : number
>i ^ i : number
>i : number
>i : number

            var b  =  true && false || true ^ false;/*& | ^*/
>b : number
>true && false || true ^ false : number
>true && false : false
>true : true
>false : false
>true ^ false : number
>true : true
>false : false

            b = !b;/*!*/
>b = !b : boolean
>b : number
>!b : boolean
>b : number

            i = ~i;/*~i*/
>i = ~i : number
>i : number
>~i : number
>i : number

            b = i < (i - 1) && (i + 1) > i;/*< && >*/
>b = i < (i - 1) && (i + 1) > i : boolean
>b : number
>i < (i - 1) && (i + 1) > i : boolean
>i < (i - 1) : boolean
>i : number
>(i - 1) : number
>i - 1 : number
>i : number
>1 : 1
>(i + 1) > i : boolean
>(i + 1) : number
>i + 1 : number
>i : number
>1 : 1
>i : number

            var f = true ? 1 : 0;/*? :*/   // YES :
>f : number
>true ? 1 : 0 : 0 | 1
>true : true
>1 : 1
>0 : 0

            i++;/*++*/
>i++ : number
>i : number

            i--;/*--*/
>i-- : number
>i : number

            b = true && false || true;/*&& ||*/
>b = true && false || true : true
>b : number
>true && false || true : true
>true && false : false
>true : true
>false : false
>true : true

            i = i << 5;/*<<*/
>i = i << 5 : number
>i : number
>i << 5 : number
>i : number
>5 : 5

            i = i >> 5;/*>>*/
>i = i >> 5 : number
>i : number
>i >> 5 : number
>i : number
>5 : 5

            var j = i;
>j : number
>i : number

            b = i == j && i != j && i <= j && i >= j;/*= == && != <= >=*/
>b = i == j && i != j && i <= j && i >= j : boolean
>b : number
>i == j && i != j && i <= j && i >= j : boolean
>i == j && i != j && i <= j : boolean
>i == j && i != j : boolean
>i == j : boolean
>i : number
>j : number
>i != j : boolean
>i : number
>j : number
>i <= j : boolean
>i : number
>j : number
>i >= j : boolean
>i : number
>j : number

            i += <number>5.0;/*+=*/
>i += <number>5.0 : number
>i : number
><number>5.0 : number
>5.0 : 5

            i -= i;/*-=*/
>i -= i : number
>i : number
>i : number

            i *= i;/**=*/
>i *= i : number
>i : number
>i : number

            if (i == 0)
>i == 0 : boolean
>i : number
>0 : 0

                i++;
>i++ : number
>i : number

            i /= i;/*/=*/
>i /= i : number
>i : number
>i : number

            i %= i;/*%=*/
>i %= i : number
>i : number
>i : number

            i &= i;/*&=*/
>i &= i : number
>i : number
>i : number

            i |= i;/*|=*/
>i |= i : number
>i : number
>i : number

            i ^= i;/*^=*/
>i ^= i : number
>i : number
>i : number

            i <<= i;/*<<=*/
>i <<= i : number
>i : number
>i : number

            i >>= i;/*>>=*/
>i >>= i : number
>i : number
>i : number

            if (i == 0 &&  != b && f == 1)
>i == 0 &&  != b && f == 1 : boolean
>i == 0 &&  != b : boolean
>i == 0 : boolean
>i : number
>0 : 0
>!= b : boolean
> : any
>b : number
>f == 1 : boolean
>f : number
>1 : 1

                return 0;
>0 : 0

            else return 1;
>1 : 1
        }

    }

    interface IF {
        Foo(): bool;
>Foo : () => bool
    }

    class CLASS implements IF {
>CLASS : CLASS

         case  d = () => {  yield  0; };
>d : () => void
>() => {  yield  0; } : () => void
>yield  0 : any
>0 : 0

        public get Property() { return 0; }
>Property : number
>0 : 0

        public Member() {
>Member : () => number

            return 0;
>0 : 0
        }
        public Foo(): bool {
>Foo : () => bool

            var myEvent = () => { return 1; };
>myEvent : () => number
>() => { return 1; } : () => number
>1 : 1

            if (myEvent() == 1)
>myEvent() == 1 : boolean
>myEvent() : number
>myEvent : () => number
>1 : 1

                return true ? 
>true ? : any
>true : true

            else
> : any
> : any

                return false;
>false : false
        }
    }


    // todo: use these
    class A  . 
>A : A

        public method1(val:number) {
>method1(val:number) : any
>method1 : any
>val : any
>number : any

            return val;
>val : any
        }
        public method2() {
>method2() : any
>method2 : any

            return 2 * this.method1(2);
>2 * this.method1(2) : number
>2 : 2
>this.method1(2) : any
>this.method1 : any
>this : typeof globalThis
>method1 : any
>2 : 2
        }
    }

    class B extends A {
>B : B
>A : A

        public method2() {
>method2 : () => any

            return this.method1(2);
>this.method1(2) : any
>this.method1 : any
>this : this
>method1 : any
>2 : 2
        }
    }

    class Overloading {
>Overloading : Overloading

        private otherValue = 42;
>otherValue : number
>42 : 42

        constructor(private value: number, public name: string)  :  }
>value : number
>name : string
       
        public Overloads(value: string);
>Overloads(value: string) : any
>Overloads : any
>value : any
>string : any

        public Overloads( while : string, ...rest: string[]) {  & 
>Overloads( : any
>Overloads : any
> : any
> : any
>string, : any
>string : any
> : any
>rest : any
>string[] : any
>string : any
> : any
>&         public : number
> : any

        public DefaultValue(value?: string = "Hello") { }
>public : any
>DefaultValue(value?: string = "Hello") : any
>DefaultValue : any
>value?: string = "Hello" : any
>value : any
> : any
>string = "Hello" : "Hello"
>string : any
>"Hello" : "Hello"
    }
}

enum Weekdays {
>Weekdays : Weekdays

    Monday,
>Monday : Weekdays.Monday

    Tuesday,
>Tuesday : Weekdays.Tuesday

    Weekend,
>Weekend : Weekdays.Weekend
}

enum Fruit {
>Fruit : Fruit

    Apple,
>Apple : Fruit.Apple

    Pear
>Pear : Fruit.Pear
}

interface IDisposable {
    Dispose(): void;
>Dispose : () => void
}

TypeScriptAllInOne.Program.Main();
>TypeScriptAllInOne.Program.Main() : void
>TypeScriptAllInOne.Program.Main : (...args: string[]) => void
>TypeScriptAllInOne.Program : typeof TypeScriptAllInOne.Program
>TypeScriptAllInOne : typeof TypeScriptAllInOne
>Program : typeof TypeScriptAllInOne.Program
>Main : (...args: string[]) => void