425 lines
7.6 KiB
Plaintext
425 lines
7.6 KiB
Plaintext
=== tests/cases/conformance/types/specifyingTypes/typeQueries/typeofThis.ts ===
|
|
class Test {
|
|
>Test : Test
|
|
|
|
data = {};
|
|
>data : {}
|
|
>{} : {}
|
|
|
|
constructor() {
|
|
var copy: typeof this.data = {};
|
|
>copy : {}
|
|
>this.data : {}
|
|
>this : any
|
|
>data : {}
|
|
>{} : {}
|
|
}
|
|
}
|
|
|
|
class Test1 {
|
|
>Test1 : Test1
|
|
|
|
data = { foo: '' };
|
|
>data : { foo: string; }
|
|
>{ foo: '' } : { foo: string; }
|
|
>foo : string
|
|
>'' : ""
|
|
|
|
['this'] = '';
|
|
>['this'] : string
|
|
>'this' : "this"
|
|
>'' : ""
|
|
|
|
constructor() {
|
|
var copy: typeof this.data = { foo: '' };
|
|
>copy : { foo: string; }
|
|
>this.data : { foo: string; }
|
|
>this : any
|
|
>data : { foo: string; }
|
|
>{ foo: '' } : { foo: string; }
|
|
>foo : string
|
|
>'' : ""
|
|
|
|
var foo: typeof this.data.foo = '';
|
|
>foo : string
|
|
>this.data.foo : string
|
|
>this.data : { foo: string; }
|
|
>this : any
|
|
>data : { foo: string; }
|
|
>foo : string
|
|
>'' : ""
|
|
|
|
var self: typeof this = this;
|
|
>self : this
|
|
>this : any
|
|
>this : this
|
|
|
|
self.data;
|
|
>self.data : { foo: string; }
|
|
>self : this
|
|
>data : { foo: string; }
|
|
|
|
var str: typeof this.this = '';
|
|
>str : string
|
|
>this.this : string
|
|
>this : any
|
|
>this : string
|
|
>'' : ""
|
|
}
|
|
}
|
|
|
|
|
|
function Test2() {
|
|
>Test2 : () => void
|
|
|
|
let x: typeof this.no = 1;
|
|
>x : any
|
|
>this.no : any
|
|
>this : any
|
|
>no : any
|
|
>1 : 1
|
|
}
|
|
|
|
function Test3(this: { no: number }) {
|
|
>Test3 : (this: { no: number;}) => void
|
|
>this : { no: number; }
|
|
>no : number
|
|
|
|
let x: typeof this.no = 1;
|
|
>x : number
|
|
>this.no : number
|
|
>this : { no: number; }
|
|
>no : number
|
|
>1 : 1
|
|
}
|
|
|
|
function Test4(this: { no: number } | undefined) {
|
|
>Test4 : (this: { no: number;} | undefined) => void
|
|
>this : { no: number; } | undefined
|
|
>no : number
|
|
|
|
let x: typeof this.no = 1;
|
|
>x : number
|
|
>this.no : number
|
|
>this : { no: number; } | undefined
|
|
>no : number
|
|
>1 : 1
|
|
}
|
|
|
|
class Test5 {
|
|
>Test5 : Test5
|
|
|
|
no = 1;
|
|
>no : number
|
|
>1 : 1
|
|
|
|
f = () => {
|
|
>f : () => void
|
|
>() => { // should not capture this. let x: typeof this.no = 1; } : () => void
|
|
|
|
// should not capture this.
|
|
let x: typeof this.no = 1;
|
|
>x : number
|
|
>this.no : number
|
|
>this : any
|
|
>no : number
|
|
>1 : 1
|
|
}
|
|
}
|
|
|
|
namespace Test6 {
|
|
>Test6 : typeof Test6
|
|
|
|
export let f = () => {
|
|
>f : () => void
|
|
>() => { let x: typeof this.no = 1; } : () => void
|
|
|
|
let x: typeof this.no = 1;
|
|
>x : any
|
|
>this.no : any
|
|
>this : any
|
|
>no : any
|
|
>1 : 1
|
|
}
|
|
}
|
|
|
|
module Test7 {
|
|
>Test7 : typeof Test7
|
|
|
|
export let f = () => {
|
|
>f : () => void
|
|
>() => { let x: typeof this.no = 1; } : () => void
|
|
|
|
let x: typeof this.no = 1;
|
|
>x : any
|
|
>this.no : any
|
|
>this : any
|
|
>no : any
|
|
>1 : 1
|
|
}
|
|
}
|
|
|
|
const Test8 = () => {
|
|
>Test8 : () => void
|
|
>() => { let x: typeof this.no = 1;} : () => void
|
|
|
|
let x: typeof this.no = 1;
|
|
>x : any
|
|
>this.no : any
|
|
>this : any
|
|
>no : any
|
|
>1 : 1
|
|
}
|
|
|
|
class Test9 {
|
|
>Test9 : Test9
|
|
|
|
no = 0;
|
|
>no : number
|
|
>0 : 0
|
|
|
|
this = 0;
|
|
>this : number
|
|
>0 : 0
|
|
|
|
f() {
|
|
>f : () => void
|
|
|
|
if (this instanceof Test9D1) {
|
|
>this instanceof Test9D1 : boolean
|
|
>this : this
|
|
>Test9D1 : typeof Test9D1
|
|
|
|
const d1: typeof this = this;
|
|
>d1 : this & Test9D1
|
|
>this : any
|
|
>this : this & Test9D1
|
|
|
|
d1.f1();
|
|
>d1.f1() : void
|
|
>d1.f1 : () => void
|
|
>d1 : this & Test9D1
|
|
>f1 : () => void
|
|
}
|
|
|
|
if (this instanceof Test9D2) {
|
|
>this instanceof Test9D2 : boolean
|
|
>this : this
|
|
>Test9D2 : typeof Test9D2
|
|
|
|
const d2: typeof this = this;
|
|
>d2 : this & Test9D2
|
|
>this : any
|
|
>this : this & Test9D2
|
|
|
|
d2.f2();
|
|
>d2.f2() : void
|
|
>d2.f2 : () => void
|
|
>d2 : this & Test9D2
|
|
>f2 : () => void
|
|
}
|
|
}
|
|
|
|
g() {
|
|
>g : () => void
|
|
|
|
if (this.no === 1) {
|
|
>this.no === 1 : boolean
|
|
>this.no : number
|
|
>this : this
|
|
>no : number
|
|
>1 : 1
|
|
|
|
const no: typeof this.no = this.no;
|
|
>no : 1
|
|
>this.no : 1
|
|
>this : any
|
|
>no : 1
|
|
>this.no : 1
|
|
>this : this
|
|
>no : 1
|
|
}
|
|
|
|
if (this.this === 1) {
|
|
>this.this === 1 : boolean
|
|
>this.this : number
|
|
>this : this
|
|
>this : number
|
|
>1 : 1
|
|
|
|
const no: typeof this.this = this.this;
|
|
>no : 1
|
|
>this.this : 1
|
|
>this : any
|
|
>this : 1
|
|
>this.this : 1
|
|
>this : this
|
|
>this : 1
|
|
}
|
|
}
|
|
}
|
|
|
|
class Test9D1 {
|
|
>Test9D1 : Test9D1
|
|
|
|
f1() {}
|
|
>f1 : () => void
|
|
}
|
|
|
|
class Test9D2 {
|
|
>Test9D2 : Test9D2
|
|
|
|
f2() {}
|
|
>f2 : () => void
|
|
}
|
|
|
|
class Test10 {
|
|
>Test10 : Test10
|
|
|
|
a?: { b?: string }
|
|
>a : { b?: string | undefined; } | undefined
|
|
>b : string | undefined
|
|
|
|
foo() {
|
|
>foo : () => void
|
|
|
|
let a: typeof this.a = undefined as any;
|
|
>a : { b?: string | undefined; } | undefined
|
|
>this.a : { b?: string | undefined; } | undefined
|
|
>this : any
|
|
>a : { b?: string | undefined; } | undefined
|
|
>undefined as any : any
|
|
>undefined : undefined
|
|
|
|
if (this.a) {
|
|
>this.a : { b?: string | undefined; } | undefined
|
|
>this : this
|
|
>a : { b?: string | undefined; } | undefined
|
|
|
|
let a: typeof this.a = undefined as any; // should narrow to { b?: string }
|
|
>a : { b?: string | undefined; }
|
|
>this.a : { b?: string | undefined; }
|
|
>this : any
|
|
>a : { b?: string | undefined; }
|
|
>undefined as any : any
|
|
>undefined : undefined
|
|
|
|
let b: typeof this.a.b = undefined as any;
|
|
>b : string | undefined
|
|
>this.a.b : string | undefined
|
|
>this.a : { b?: string | undefined; }
|
|
>this : any
|
|
>a : { b?: string | undefined; }
|
|
>b : string | undefined
|
|
>undefined as any : any
|
|
>undefined : undefined
|
|
|
|
if (this.a.b) {
|
|
>this.a.b : string | undefined
|
|
>this.a : { b?: string | undefined; }
|
|
>this : this
|
|
>a : { b?: string | undefined; }
|
|
>b : string | undefined
|
|
|
|
let b: typeof this.a.b = undefined as any; // should narrow to string
|
|
>b : string
|
|
>this.a.b : string
|
|
>this.a : { b?: string | undefined; }
|
|
>this : any
|
|
>a : { b?: string | undefined; }
|
|
>b : string
|
|
>undefined as any : any
|
|
>undefined : undefined
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class Test11 {
|
|
>Test11 : Test11
|
|
|
|
this?: { x?: string };
|
|
>this : { x?: string | undefined; } | undefined
|
|
>x : string | undefined
|
|
|
|
foo() {
|
|
>foo : () => void
|
|
|
|
const o = this;
|
|
>o : this
|
|
>this : this
|
|
|
|
let bar: typeof o.this = {};
|
|
>bar : { x?: string | undefined; } | undefined
|
|
>o.this : { x?: string | undefined; } | undefined
|
|
>o : this
|
|
>this : { x?: string | undefined; } | undefined
|
|
>{} : {}
|
|
|
|
if (o.this && o.this.x) {
|
|
>o.this && o.this.x : string | undefined
|
|
>o.this : { x?: string | undefined; } | undefined
|
|
>o : this
|
|
>this : { x?: string | undefined; } | undefined
|
|
>o.this.x : string | undefined
|
|
>o.this : { x?: string | undefined; }
|
|
>o : this
|
|
>this : { x?: string | undefined; }
|
|
>x : string | undefined
|
|
|
|
let y: string = o.this.x; // should narrow to string
|
|
>y : string
|
|
>o.this.x : string
|
|
>o.this : { x?: string | undefined; }
|
|
>o : this
|
|
>this : { x?: string | undefined; }
|
|
>x : string
|
|
}
|
|
}
|
|
}
|
|
|
|
class Tests12 {
|
|
>Tests12 : Tests12
|
|
|
|
test1() { // OK
|
|
>test1 : () => void
|
|
|
|
type Test = typeof this;
|
|
>Test : this
|
|
>this : any
|
|
}
|
|
|
|
test2() { // OK
|
|
>test2 : () => void
|
|
|
|
for (;;) {}
|
|
type Test = typeof this;
|
|
>Test : this
|
|
>this : any
|
|
}
|
|
|
|
test3() { // expected no compile errors
|
|
>test3 : () => void
|
|
|
|
for (const dummy in []) {}
|
|
>dummy : string
|
|
>[] : never[]
|
|
|
|
type Test = typeof this;
|
|
>Test : this
|
|
>this : any
|
|
}
|
|
|
|
test4() { // expected no compile errors
|
|
>test4 : () => void
|
|
|
|
for (const dummy of []) {}
|
|
>dummy : never
|
|
>[] : never[]
|
|
|
|
type Test = typeof this;
|
|
>Test : this
|
|
>this : any
|
|
}
|
|
}
|