5353475fce
* Always generate type & symbol baselines * Accept changed shadowed baselines * Accept brand new type and symbol baselines * Allow `getTypeAtLocation` to return undefined in the type writer * Accept baselines which had missing type information * Bind container for dynamically names enum members so they may be printed * Accept type/symbol baselines for enums with computed members * First pass at reducing typeWriter memory overhead * Use generators to allow for type and symbol baselines with no cache * Accept new baselines for tests whose output was fixed by better newline splitting * Hard cap on number of declarations printed, cache declaration print text * handle differing newlines better still to handle RWC newlines * Lower abridging count, accept abridged baselines * Limit max RWC error output size, limit RWC type and symbol baseline input size * Move skip logic into type and symbol baseliner to streamline error handling * Accept removal of empty baselines * Canonicalize path earlier to handle odd paths in input files * Do canonicalization earlier still, also ensure parallel perf profiles for different targets do not trample one another * No need to pathify again
412 lines
6.8 KiB
Plaintext
412 lines
6.8 KiB
Plaintext
=== tests/cases/conformance/types/witness/witness.ts ===
|
|
// Initializers
|
|
var varInit = varInit; // any
|
|
>varInit : any
|
|
>varInit : any
|
|
|
|
var pInit: any;
|
|
>pInit : any
|
|
|
|
function fn(pInit = pInit) {
|
|
>fn : (pInit?: any) => void
|
|
>pInit : any
|
|
>pInit : any
|
|
|
|
var pInit: any;
|
|
>pInit : any
|
|
}
|
|
class InitClass {
|
|
>InitClass : InitClass
|
|
|
|
x = this.x;
|
|
>x : any
|
|
>this.x : any
|
|
>this : this
|
|
>x : any
|
|
|
|
fn() {
|
|
>fn : () => void
|
|
|
|
var y = this.x;
|
|
>y : any
|
|
>this.x : any
|
|
>this : this
|
|
>x : any
|
|
|
|
var y: any;
|
|
>y : any
|
|
}
|
|
}
|
|
|
|
// Return type
|
|
function fnReturn1() {
|
|
>fnReturn1 : () => any
|
|
|
|
return fnReturn1();
|
|
>fnReturn1() : any
|
|
>fnReturn1 : () => any
|
|
}
|
|
var a: any;
|
|
>a : any
|
|
|
|
var a = fnReturn1();
|
|
>a : any
|
|
>fnReturn1() : any
|
|
>fnReturn1 : () => any
|
|
|
|
function fnReturn2() {
|
|
>fnReturn2 : () => typeof fnReturn2
|
|
|
|
return fnReturn2;
|
|
>fnReturn2 : () => typeof fnReturn2
|
|
}
|
|
var fnr2: () => any = fnReturn2();
|
|
>fnr2 : () => any
|
|
>fnReturn2() : () => typeof fnReturn2
|
|
>fnReturn2 : () => typeof fnReturn2
|
|
|
|
// Comma
|
|
var co1 = (co1, 3);
|
|
>co1 : any
|
|
>(co1, 3) : 3
|
|
>co1, 3 : 3
|
|
>co1 : any
|
|
>3 : 3
|
|
|
|
var co1: number;
|
|
>co1 : any
|
|
|
|
var co2 = (3, 4, co2);
|
|
>co2 : any
|
|
>(3, 4, co2) : any
|
|
>3, 4, co2 : any
|
|
>3, 4 : 4
|
|
>3 : 3
|
|
>4 : 4
|
|
>co2 : any
|
|
|
|
var co2: any;
|
|
>co2 : any
|
|
|
|
var co3 = (co1, co2, co3, co1);
|
|
>co3 : any
|
|
>(co1, co2, co3, co1) : any
|
|
>co1, co2, co3, co1 : any
|
|
>co1, co2, co3 : any
|
|
>co1, co2 : any
|
|
>co1 : any
|
|
>co2 : any
|
|
>co3 : any
|
|
>co1 : any
|
|
|
|
var co3: number;
|
|
>co3 : any
|
|
|
|
// Assignment
|
|
var as1 = (as1 = 2);
|
|
>as1 : any
|
|
>(as1 = 2) : 2
|
|
>as1 = 2 : 2
|
|
>as1 : any
|
|
>2 : 2
|
|
|
|
var as1: number;
|
|
>as1 : any
|
|
|
|
var as2 = (as2 = as2 = 2);
|
|
>as2 : any
|
|
>(as2 = as2 = 2) : 2
|
|
>as2 = as2 = 2 : 2
|
|
>as2 : any
|
|
>as2 = 2 : 2
|
|
>as2 : any
|
|
>2 : 2
|
|
|
|
var as2: number;
|
|
>as2 : any
|
|
|
|
// Conditional
|
|
var cnd1 = cnd1 ? 0 : 1;
|
|
>cnd1 : any
|
|
>cnd1 ? 0 : 1 : 0 | 1
|
|
>cnd1 : any
|
|
>0 : 0
|
|
>1 : 1
|
|
|
|
var cnd1: number;
|
|
>cnd1 : any
|
|
|
|
var cnd2 = cnd1 ? cnd1 ? '' : "" : '';
|
|
>cnd2 : string
|
|
>cnd1 ? cnd1 ? '' : "" : '' : ""
|
|
>cnd1 : any
|
|
>cnd1 ? '' : "" : ""
|
|
>cnd1 : any
|
|
>'' : ""
|
|
>"" : ""
|
|
>'' : ""
|
|
|
|
var cnd2: string;
|
|
>cnd2 : string
|
|
|
|
// ||
|
|
var or1 = or1 || '';
|
|
>or1 : any
|
|
>or1 || '' : any
|
|
>or1 : any
|
|
>'' : ""
|
|
|
|
var or1: any;
|
|
>or1 : any
|
|
|
|
var or2 = '' || or2;
|
|
>or2 : any
|
|
>'' || or2 : any
|
|
>'' : ""
|
|
>or2 : any
|
|
|
|
var or2: any;
|
|
>or2 : any
|
|
|
|
var or3 = or3 || or3;
|
|
>or3 : any
|
|
>or3 || or3 : any
|
|
>or3 : any
|
|
>or3 : any
|
|
|
|
var or3: any;
|
|
>or3 : any
|
|
|
|
// &&
|
|
var and1 = and1 && '';
|
|
>and1 : any
|
|
>and1 && '' : ""
|
|
>and1 : any
|
|
>'' : ""
|
|
|
|
var and1: string;
|
|
>and1 : any
|
|
|
|
var and2 = '' && and2;
|
|
>and2 : any
|
|
>'' && and2 : ""
|
|
>'' : ""
|
|
>and2 : any
|
|
|
|
var and2: any;
|
|
>and2 : any
|
|
|
|
var and3 = and3 && and3;
|
|
>and3 : any
|
|
>and3 && and3 : any
|
|
>and3 : any
|
|
>and3 : any
|
|
|
|
var and3: any;
|
|
>and3 : any
|
|
|
|
// function call return type
|
|
function fnCall() {
|
|
>fnCall : () => any
|
|
|
|
return fnCall();
|
|
>fnCall() : any
|
|
>fnCall : () => any
|
|
}
|
|
var fnCallResult = fnCall();
|
|
>fnCallResult : any
|
|
>fnCall() : any
|
|
>fnCall : () => any
|
|
|
|
var fnCallResult: any;
|
|
>fnCallResult : any
|
|
|
|
// Call argument
|
|
function fnArg1(x: typeof fnArg1, y: number) {
|
|
>fnArg1 : (x: typeof fnArg1, y: number) => void
|
|
>x : (x: typeof fnArg1, y: number) => void
|
|
>fnArg1 : (x: typeof fnArg1, y: number) => void
|
|
>y : number
|
|
|
|
var x: (n: typeof fnArg1, m: number) => void;
|
|
>x : (x: typeof fnArg1, y: number) => void
|
|
>n : (x: typeof fnArg1, y: number) => void
|
|
>fnArg1 : (x: typeof fnArg1, y: number) => void
|
|
>m : number
|
|
|
|
fnArg1(fnArg1, 0);
|
|
>fnArg1(fnArg1, 0) : void
|
|
>fnArg1 : (x: typeof fnArg1, y: number) => void
|
|
>fnArg1 : (x: typeof fnArg1, y: number) => void
|
|
>0 : 0
|
|
}
|
|
|
|
function overload1(x: (n: string) => string): string;
|
|
>overload1 : { (x: (n: string) => string): string; (x: (n: number) => number): number; (x: (n: any) => any): any; }
|
|
>x : (n: string) => string
|
|
>n : string
|
|
|
|
function overload1(x: (n: number) => number): number;
|
|
>overload1 : { (x: (n: string) => string): string; (x: (n: number) => number): number; (x: (n: any) => any): any; }
|
|
>x : (n: number) => number
|
|
>n : number
|
|
|
|
function overload1(x: (n: any) => any): any;
|
|
>overload1 : { (x: (n: string) => string): string; (x: (n: number) => number): number; (x: (n: any) => any): any; }
|
|
>x : (n: any) => any
|
|
>n : any
|
|
|
|
function overload1() { return undefined; };
|
|
>overload1 : { (x: (n: string) => string): string; (x: (n: number) => number): number; (x: (n: any) => any): any; }
|
|
>undefined : undefined
|
|
|
|
function fnArg2() {
|
|
>fnArg2 : () => any
|
|
|
|
return overload1(fnArg2);
|
|
>overload1(fnArg2) : any
|
|
>overload1 : { (x: (n: string) => string): string; (x: (n: number) => number): number; (x: (n: any) => any): any; }
|
|
>fnArg2 : () => any
|
|
}
|
|
var t = fnArg2(); // t: should be 'any', but is 'string'
|
|
>t : any
|
|
>fnArg2() : any
|
|
>fnArg2 : () => any
|
|
|
|
// New operator
|
|
class C {
|
|
>C : C
|
|
|
|
fn1() {
|
|
>fn1 : () => any
|
|
|
|
return new (this.fn1())();
|
|
>new (this.fn1())() : any
|
|
>(this.fn1()) : any
|
|
>this.fn1() : any
|
|
>this.fn1 : () => any
|
|
>this : this
|
|
>fn1 : () => any
|
|
}
|
|
fn2() {
|
|
>fn2 : () => any
|
|
|
|
return new (this.fn2());
|
|
>new (this.fn2()) : any
|
|
>(this.fn2()) : any
|
|
>this.fn2() : any
|
|
>this.fn2 : () => any
|
|
>this : this
|
|
>fn2 : () => any
|
|
}
|
|
fn3() {
|
|
>fn3 : () => number
|
|
|
|
var a: new(x) => number;
|
|
>a : new (x: any) => number
|
|
>x : any
|
|
|
|
return new a(this.fn3);
|
|
>new a(this.fn3) : number
|
|
>a : new (x: any) => number
|
|
>this.fn3 : () => number
|
|
>this : this
|
|
>fn3 : () => number
|
|
}
|
|
}
|
|
|
|
function fn5() {
|
|
>fn5 : () => number
|
|
|
|
var a: new (x) => number;
|
|
>a : new (x: any) => number
|
|
>x : any
|
|
|
|
return new a(fn5);
|
|
>new a(fn5) : number
|
|
>a : new (x: any) => number
|
|
>fn5 : () => number
|
|
}
|
|
var fn5r = fn5(); // fn5r: should be 'any', but is 'number'
|
|
>fn5r : number
|
|
>fn5() : number
|
|
>fn5 : () => number
|
|
|
|
// Property access
|
|
var propAcc1 = {
|
|
>propAcc1 : any
|
|
>{ m: propAcc1.m} : { m: any; }
|
|
|
|
m: propAcc1.m
|
|
>m : any
|
|
>propAcc1.m : any
|
|
>propAcc1 : any
|
|
>m : any
|
|
|
|
};
|
|
var propAcc1: { m: any; }
|
|
>propAcc1 : any
|
|
>m : any
|
|
|
|
// Property access of module member
|
|
module M2 {
|
|
>M2 : typeof M2
|
|
|
|
export var x = M2.x;
|
|
>x : any
|
|
>M2.x : any
|
|
>M2 : typeof M2
|
|
>x : any
|
|
|
|
var y = x;
|
|
>y : any
|
|
>x : any
|
|
|
|
var y: any;
|
|
>y : any
|
|
}
|
|
|
|
// Property access of class instance type
|
|
class C2 {
|
|
>C2 : C2
|
|
|
|
n = this.n; // n: any
|
|
>n : any
|
|
>this.n : any
|
|
>this : this
|
|
>n : any
|
|
}
|
|
var c2inst = new C2().n;
|
|
>c2inst : any
|
|
>new C2().n : any
|
|
>new C2() : C2
|
|
>C2 : typeof C2
|
|
>n : any
|
|
|
|
var c2inst: any;
|
|
>c2inst : any
|
|
|
|
// Constructor function property access
|
|
class C3 {
|
|
>C3 : C3
|
|
|
|
static q = C3.q;
|
|
>q : any
|
|
>C3.q : any
|
|
>C3 : typeof C3
|
|
>q : any
|
|
}
|
|
var qq = C3.q;
|
|
>qq : any
|
|
>C3.q : any
|
|
>C3 : typeof C3
|
|
>q : any
|
|
|
|
var qq: any;
|
|
>qq : any
|
|
|
|
// Parentheses - tested a bunch above
|
|
|
|
|
|
|