157 lines
2.2 KiB
Plaintext
157 lines
2.2 KiB
Plaintext
=== tests/cases/conformance/interfaces/interfaceDeclarations/interfaceWithPropertyOfEveryType.ts ===
|
|
class C { foo: string; }
|
|
>C : C
|
|
>foo : string
|
|
|
|
function f1() { }
|
|
>f1 : () => void
|
|
|
|
module M {
|
|
>M : typeof M
|
|
|
|
export var y = 1;
|
|
>y : number
|
|
>1 : number
|
|
}
|
|
enum E { A }
|
|
>E : E
|
|
>A : E
|
|
|
|
interface Foo {
|
|
>Foo : Foo
|
|
|
|
a: number;
|
|
>a : number
|
|
|
|
b: string;
|
|
>b : string
|
|
|
|
c: boolean;
|
|
>c : boolean
|
|
|
|
d: any;
|
|
>d : any
|
|
|
|
e: void;
|
|
>e : void
|
|
|
|
f: number[];
|
|
>f : number[]
|
|
|
|
g: Object;
|
|
>g : Object
|
|
>Object : Object
|
|
|
|
h: (x: number) => number;
|
|
>h : (x: number) => number
|
|
>x : number
|
|
|
|
i: <T>(x: T) => T;
|
|
>i : <T>(x: T) => T
|
|
>T : T
|
|
>x : T
|
|
>T : T
|
|
>T : T
|
|
|
|
j: Foo;
|
|
>j : Foo
|
|
>Foo : Foo
|
|
|
|
k: C;
|
|
>k : C
|
|
>C : C
|
|
|
|
l: typeof f1;
|
|
>l : () => void
|
|
>f1 : () => void
|
|
|
|
m: typeof M;
|
|
>m : typeof M
|
|
>M : typeof M
|
|
|
|
n: {};
|
|
>n : {}
|
|
|
|
o: E;
|
|
>o : E
|
|
>E : E
|
|
}
|
|
|
|
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,
|
|
>a : number
|
|
>1 : number
|
|
|
|
b: '',
|
|
>b : string
|
|
>'' : string
|
|
|
|
c: true,
|
|
>c : boolean
|
|
>true : boolean
|
|
|
|
d: {},
|
|
>d : {}
|
|
>{} : {}
|
|
|
|
e: null ,
|
|
>e : null
|
|
>null : null
|
|
|
|
f: [1],
|
|
>f : number[]
|
|
>[1] : number[]
|
|
>1 : number
|
|
|
|
g: {},
|
|
>g : {}
|
|
>{} : {}
|
|
|
|
h: (x: number) => 1,
|
|
>h : (x: number) => number
|
|
>(x: number) => 1 : (x: number) => number
|
|
>x : number
|
|
>1 : number
|
|
|
|
i: <T>(x: T) => x,
|
|
>i : <T>(x: T) => T
|
|
><T>(x: T) => x : <T>(x: T) => T
|
|
>T : T
|
|
>x : T
|
|
>T : T
|
|
>x : T
|
|
|
|
j: <Foo>null,
|
|
>j : Foo
|
|
><Foo>null : Foo
|
|
>Foo : Foo
|
|
>null : null
|
|
|
|
k: new C(),
|
|
>k : C
|
|
>new C() : C
|
|
>C : typeof C
|
|
|
|
l: f1,
|
|
>l : () => void
|
|
>f1 : () => void
|
|
|
|
m: M,
|
|
>m : typeof M
|
|
>M : typeof M
|
|
|
|
n: {},
|
|
>n : {}
|
|
>{} : {}
|
|
|
|
o: E.A
|
|
>o : E
|
|
>E.A : E
|
|
>E : typeof E
|
|
>A : E
|
|
}
|