1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
=== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractInstantiations2.ts ===
class A {
>A : A
// ...
}
abstract class B {
>B : B
foo(): number { return this.bar(); }
>foo : () => number
>this.bar() : number
>this.bar : () => number
>this : this
>bar : () => number
abstract bar() : number;
>bar : () => number
}
new B; // error
>new B : any
>B : typeof B
var BB: typeof B = B;
>BB : typeof B
>B : typeof B
>B : typeof B
var AA: typeof A = BB; // error, AA is not of abstract type.
>AA : typeof A
>A : typeof A
>BB : typeof B
new AA;
>new AA : A
>AA : typeof A
function constructB(Factory : typeof B) {
>constructB : (Factory: typeof B) => void
>Factory : typeof B
>B : typeof B
new Factory; // error -- Factory is of type typeof B.
>new Factory : any
>Factory : typeof B
}
var BB = B;
>BB : typeof B
>B : typeof B
new BB; // error -- BB is of type typeof B.
>new BB : any
>BB : typeof B
var x : any = C;
>x : any
>C : typeof C
new x; // okay -- undefined behavior at runtime
>new x : any
>x : any
class C extends B { } // error -- not declared abstract
>C : C
>B : B
abstract class D extends B { } // okay
>D : D
>B : B
class E extends B { // okay -- implements abstract method
>E : E
>B : B
bar() { return 1; }
>bar : () => number
>1 : 1
}
abstract class F extends B {
>F : F
>B : B
abstract foo() : number;
>foo : () => number
bar() { return 2; }
>bar : () => number
>2 : 2
}
abstract class G {
>G : G
abstract qux(x : number) : string;
>qux : { (x: number): string; (): number; }
>x : number
abstract qux() : number;
>qux : { (x: number): string; (): number; }
y : number;
>y : number
abstract quz(x : number, y : string) : boolean; // error -- declarations must be adjacent
>quz : (x: number, y: string) => boolean
>x : number
>y : string
abstract nom(): boolean;
>nom : { (): boolean; (x: number): boolean; }
nom(x : number): boolean; // error -- use of modifier abstract must match on all overloads.
>nom : { (): boolean; (x: number): boolean; }
>x : number
}
class H { // error -- not declared abstract
>H : H
abstract baz() : number;
>baz : () => number
}
|
