Skip to content

Commit 6529951

Browse files
JsonFreemanJsonFreeman
committed
Add tests for inferential typing
1 parent 98de611 commit 6529951

12 files changed

+348
-0
lines changed

‎tests/baselines/reference/inferentialTypingUsingApparentType1.js

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
//// [inferentialTypingUsingApparentType1.ts]
2+
function foo<T extends (p: string) => number>(x: T): T {
3+
return undefined;
4+
}
5+
6+
foo(x => x.length);
7+
8+
//// [inferentialTypingUsingApparentType1.js]
9+
function foo(x) {
10+
return undefined;
11+
}
12+
foo(function (x) { return x.length; });

‎tests/baselines/reference/inferentialTypingUsingApparentType1.symbols

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
=== tests/cases/compiler/inferentialTypingUsingApparentType1.ts ===
2+
function foo<T extends (p: string) => number>(x: T): T {
3+
>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType1.ts, 0, 0))
4+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType1.ts, 0, 13))
5+
>p : Symbol(p, Decl(inferentialTypingUsingApparentType1.ts, 0, 24))
6+
>x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 0, 46))
7+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType1.ts, 0, 13))
8+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType1.ts, 0, 13))
9+
10+
return undefined;
11+
>undefined : Symbol(undefined)
12+
}
13+
14+
foo(x => x.length);
15+
>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType1.ts, 0, 0))
16+
>x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 4, 4))
17+
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
18+
>x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 4, 4))
19+
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
20+

‎tests/baselines/reference/inferentialTypingUsingApparentType1.types

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
=== tests/cases/compiler/inferentialTypingUsingApparentType1.ts ===
2+
function foo<T extends (p: string) => number>(x: T): T {
3+
>foo : <T extends (p: string) => number>(x: T) => T
4+
>T : T
5+
>p : string
6+
>x : T
7+
>T : T
8+
>T : T
9+
10+
return undefined;
11+
>undefined : undefined
12+
}
13+
14+
foo(x => x.length);
15+
>foo(x => x.length) : (x: string) => number
16+
>foo : <T extends (p: string) => number>(x: T) => T
17+
>x => x.length : (x: string) => number
18+
>x : string
19+
>x.length : number
20+
>x : string
21+
>length : number
22+

‎tests/baselines/reference/inferentialTypingUsingApparentType2.js

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
//// [inferentialTypingUsingApparentType2.ts]
2+
function foo<T extends { m(p: string): number }>(x: T): T {
3+
return undefined;
4+
}
5+
6+
foo({ m(x) { return x.length } });
7+
8+
//// [inferentialTypingUsingApparentType2.js]
9+
function foo(x) {
10+
return undefined;
11+
}
12+
foo({ m: function (x) { return x.length; } });

‎tests/baselines/reference/inferentialTypingUsingApparentType2.symbols

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
=== tests/cases/compiler/inferentialTypingUsingApparentType2.ts ===
2+
function foo<T extends { m(p: string): number }>(x: T): T {
3+
>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType2.ts, 0, 0))
4+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType2.ts, 0, 13))
5+
>m : Symbol(m, Decl(inferentialTypingUsingApparentType2.ts, 0, 24))
6+
>p : Symbol(p, Decl(inferentialTypingUsingApparentType2.ts, 0, 27))
7+
>x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 0, 49))
8+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType2.ts, 0, 13))
9+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType2.ts, 0, 13))
10+
11+
return undefined;
12+
>undefined : Symbol(undefined)
13+
}
14+
15+
foo({ m(x) { return x.length } });
16+
>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType2.ts, 0, 0))
17+
>m : Symbol(m, Decl(inferentialTypingUsingApparentType2.ts, 4, 5))
18+
>x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 4, 8))
19+
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
20+
>x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 4, 8))
21+
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
22+

‎tests/baselines/reference/inferentialTypingUsingApparentType2.types

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
=== tests/cases/compiler/inferentialTypingUsingApparentType2.ts ===
2+
function foo<T extends { m(p: string): number }>(x: T): T {
3+
>foo : <T extends { m(p: string): number; }>(x: T) => T
4+
>T : T
5+
>m : (p: string) => number
6+
>p : string
7+
>x : T
8+
>T : T
9+
>T : T
10+
11+
return undefined;
12+
>undefined : undefined
13+
}
14+
15+
foo({ m(x) { return x.length } });
16+
>foo({ m(x) { return x.length } }) : { }
17+
>foo : <T extends { m(p: string): number; }>(x: T) => T
18+
>{ m(x) { return x.length } } : { m(x: string): number; }
19+
>m : (x: string) => number
20+
>x : string
21+
>x.length : number
22+
>x : string
23+
>length : number
24+

‎tests/baselines/reference/inferentialTypingUsingApparentType3.js

Lines changed: 56 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
//// [inferentialTypingUsingApparentType3.ts]
2+
interface Field<T> {
3+
clean(input: T): T
4+
}
5+
6+
class CharField implements Field<string> {
7+
clean(input: string) {
8+
return "Yup";
9+
}
10+
}
11+
12+
class NumberField implements Field<number> {
13+
clean(input: number) {
14+
return 123;
15+
}
16+
}
17+
18+
class ObjectField<A, T extends { [name: string]: Field<any> }> {
19+
constructor(public fields: T) { }
20+
}
21+
22+
var person = new ObjectField({
23+
id: new NumberField(),
24+
name: new CharField()
25+
});
26+
27+
person.fields.id;
28+
29+
//// [inferentialTypingUsingApparentType3.js]
30+
var CharField = (function () {
31+
function CharField() {
32+
}
33+
CharField.prototype.clean = function (input) {
34+
return "Yup";
35+
};
36+
return CharField;
37+
})();
38+
var NumberField = (function () {
39+
function NumberField() {
40+
}
41+
NumberField.prototype.clean = function (input) {
42+
return 123;
43+
};
44+
return NumberField;
45+
})();
46+
var ObjectField = (function () {
47+
function ObjectField(fields) {
48+
this.fields = fields;
49+
}
50+
return ObjectField;
51+
})();
52+
var person = new ObjectField({
53+
id: new NumberField(),
54+
name: new CharField()
55+
});
56+
person.fields.id;

‎tests/baselines/reference/inferentialTypingUsingApparentType3.symbols

Lines changed: 69 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
=== tests/cases/compiler/inferentialTypingUsingApparentType3.ts ===
2+
interface Field<T> {
3+
>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0))
4+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 0, 16))
5+
6+
clean(input: T): T
7+
>clean : Symbol(clean, Decl(inferentialTypingUsingApparentType3.ts, 0, 20))
8+
>input : Symbol(input, Decl(inferentialTypingUsingApparentType3.ts, 1, 10))
9+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 0, 16))
10+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 0, 16))
11+
}
12+
13+
class CharField implements Field<string> {
14+
>CharField : Symbol(CharField, Decl(inferentialTypingUsingApparentType3.ts, 2, 1))
15+
>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0))
16+
17+
clean(input: string) {
18+
>clean : Symbol(clean, Decl(inferentialTypingUsingApparentType3.ts, 4, 42))
19+
>input : Symbol(input, Decl(inferentialTypingUsingApparentType3.ts, 5, 10))
20+
21+
return "Yup";
22+
}
23+
}
24+
25+
class NumberField implements Field<number> {
26+
>NumberField : Symbol(NumberField, Decl(inferentialTypingUsingApparentType3.ts, 8, 1))
27+
>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0))
28+
29+
clean(input: number) {
30+
>clean : Symbol(clean, Decl(inferentialTypingUsingApparentType3.ts, 10, 44))
31+
>input : Symbol(input, Decl(inferentialTypingUsingApparentType3.ts, 11, 10))
32+
33+
return 123;
34+
}
35+
}
36+
37+
class ObjectField<A, T extends { [name: string]: Field<any> }> {
38+
>ObjectField : Symbol(ObjectField, Decl(inferentialTypingUsingApparentType3.ts, 14, 1))
39+
>A : Symbol(A, Decl(inferentialTypingUsingApparentType3.ts, 16, 18))
40+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 16, 20))
41+
>name : Symbol(name, Decl(inferentialTypingUsingApparentType3.ts, 16, 34))
42+
>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0))
43+
44+
constructor(public fields: T) { }
45+
>fields : Symbol(fields, Decl(inferentialTypingUsingApparentType3.ts, 17, 16))
46+
>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 16, 20))
47+
}
48+
49+
var person = new ObjectField({
50+
>person : Symbol(person, Decl(inferentialTypingUsingApparentType3.ts, 20, 3))
51+
>ObjectField : Symbol(ObjectField, Decl(inferentialTypingUsingApparentType3.ts, 14, 1))
52+
53+
id: new NumberField(),
54+
>id : Symbol(id, Decl(inferentialTypingUsingApparentType3.ts, 20, 30))
55+
>NumberField : Symbol(NumberField, Decl(inferentialTypingUsingApparentType3.ts, 8, 1))
56+
57+
name: new CharField()
58+
>name : Symbol(name, Decl(inferentialTypingUsingApparentType3.ts, 21, 26))
59+
>CharField : Symbol(CharField, Decl(inferentialTypingUsingApparentType3.ts, 2, 1))
60+
61+
});
62+
63+
person.fields.id;
64+
>person.fields.id : Symbol(id, Decl(inferentialTypingUsingApparentType3.ts, 20, 30))
65+
>person.fields : Symbol(ObjectField.fields, Decl(inferentialTypingUsingApparentType3.ts, 17, 16))
66+
>person : Symbol(person, Decl(inferentialTypingUsingApparentType3.ts, 20, 3))
67+
>fields : Symbol(ObjectField.fields, Decl(inferentialTypingUsingApparentType3.ts, 17, 16))
68+
>id : Symbol(id, Decl(inferentialTypingUsingApparentType3.ts, 20, 30))
69+

‎tests/baselines/reference/inferentialTypingUsingApparentType3.types

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,75 @@
1+
=== tests/cases/compiler/inferentialTypingUsingApparentType3.ts ===
2+
interface Field<T> {
3+
>Field : Field<T>
4+
>T : T
5+
6+
clean(input: T): T
7+
>clean : (input: T) => T
8+
>input : T
9+
>T : T
10+
>T : T
11+
}
12+
13+
class CharField implements Field<string> {
14+
>CharField : CharField
15+
>Field : Field<T>
16+
17+
clean(input: string) {
18+
>clean : (input: string) => string
19+
>input : string
20+
21+
return "Yup";
22+
>"Yup" : string
23+
}
24+
}
25+
26+
class NumberField implements Field<number> {
27+
>NumberField : NumberField
28+
>Field : Field<T>
29+
30+
clean(input: number) {
31+
>clean : (input: number) => number
32+
>input : number
33+
34+
return 123;
35+
>123 : number
36+
}
37+
}
38+
39+
class ObjectField<A, T extends { [name: string]: Field<any> }> {
40+
>ObjectField : ObjectField<A, T>
41+
>A : A
42+
>T : T
43+
>name : string
44+
>Field : Field<T>
45+
46+
constructor(public fields: T) { }
47+
>fields : T
48+
>T : T
49+
}
50+
51+
var person = new ObjectField({
52+
>person : ObjectField<{}, { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }>
53+
>new ObjectField({ id: new NumberField(), name: new CharField()}) : ObjectField<{}, { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }>
54+
>ObjectField : typeof ObjectField
55+
>{ id: new NumberField(), name: new CharField()} : { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }
56+
57+
id: new NumberField(),
58+
>id : NumberField
59+
>new NumberField() : NumberField
60+
>NumberField : typeof NumberField
61+
62+
name: new CharField()
63+
>name : CharField
64+
>new CharField() : CharField
65+
>CharField : typeof CharField
66+
67+
});
68+
69+
person.fields.id;
70+
>person.fields.id : NumberField
71+
>person.fields : { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }
72+
>person : ObjectField<{}, { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }>
73+
>fields : { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }
74+
>id : NumberField
75+

‎tests/cases/compiler/inferentialTypingUsingApparentType1.ts

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
function foo<T extends (p: string) => number>(x: T): T {
2+
return undefined;
3+
}
4+
5+
foo(x => x.length);

0 commit comments

Comments
 (0)