microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-20 10:29:36 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Add tests for inferential typing

Browse Source
This commit is contained in:
Jason Freeman 2015-07-02 15:21:43 -07:00
parent 98de6117f1
commit 652995181e
12 changed files with 348 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
tests/baselines/reference/inferentialTypingUsingApparentType1.js Normal file
View File

@ -0,0 +1,12 @@
//// [inferentialTypingUsingApparentType1.ts]
function foo<T extends (p: string) => number>(x: T): T {
return undefined;
}
foo(x => x.length);
//// [inferentialTypingUsingApparentType1.js]
function foo(x) {
return undefined;
}
foo(function (x) { return x.length; });

20
tests/baselines/reference/inferentialTypingUsingApparentType1.symbols Normal file
View File

@ -0,0 +1,20 @@
=== tests/cases/compiler/inferentialTypingUsingApparentType1.ts ===
function foo<T extends (p: string) => number>(x: T): T {
>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType1.ts, 0, 0))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType1.ts, 0, 13))
>p : Symbol(p, Decl(inferentialTypingUsingApparentType1.ts, 0, 24))
>x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 0, 46))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType1.ts, 0, 13))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType1.ts, 0, 13))
return undefined;
>undefined : Symbol(undefined)
}
foo(x => x.length);
>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType1.ts, 0, 0))
>x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 4, 4))
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 4, 4))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))

22
tests/baselines/reference/inferentialTypingUsingApparentType1.types Normal file
View File

@ -0,0 +1,22 @@
=== tests/cases/compiler/inferentialTypingUsingApparentType1.ts ===
function foo<T extends (p: string) => number>(x: T): T {
>foo : <T extends (p: string) => number>(x: T) => T
>T : T
>p : string
>x : T
>T : T
>T : T
return undefined;
>undefined : undefined
}
foo(x => x.length);
>foo(x => x.length) : (x: string) => number
>foo : <T extends (p: string) => number>(x: T) => T
>x => x.length : (x: string) => number
>x : string
>x.length : number
>x : string
>length : number

12
tests/baselines/reference/inferentialTypingUsingApparentType2.js Normal file
View File

@ -0,0 +1,12 @@
//// [inferentialTypingUsingApparentType2.ts]
function foo<T extends { m(p: string): number }>(x: T): T {
return undefined;
}
foo({ m(x) { return x.length } });
//// [inferentialTypingUsingApparentType2.js]
function foo(x) {
return undefined;
}
foo({ m: function (x) { return x.length; } });

22
tests/baselines/reference/inferentialTypingUsingApparentType2.symbols Normal file
View File

@ -0,0 +1,22 @@
=== tests/cases/compiler/inferentialTypingUsingApparentType2.ts ===
function foo<T extends { m(p: string): number }>(x: T): T {
>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType2.ts, 0, 0))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType2.ts, 0, 13))
>m : Symbol(m, Decl(inferentialTypingUsingApparentType2.ts, 0, 24))
>p : Symbol(p, Decl(inferentialTypingUsingApparentType2.ts, 0, 27))
>x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 0, 49))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType2.ts, 0, 13))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType2.ts, 0, 13))
return undefined;
>undefined : Symbol(undefined)
}
foo({ m(x) { return x.length } });
>foo : Symbol(foo, Decl(inferentialTypingUsingApparentType2.ts, 0, 0))
>m : Symbol(m, Decl(inferentialTypingUsingApparentType2.ts, 4, 5))
>x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 4, 8))
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 4, 8))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))

24
tests/baselines/reference/inferentialTypingUsingApparentType2.types Normal file
View File

@ -0,0 +1,24 @@
=== tests/cases/compiler/inferentialTypingUsingApparentType2.ts ===
function foo<T extends { m(p: string): number }>(x: T): T {
>foo : <T extends { m(p: string): number; }>(x: T) => T
>T : T
>m : (p: string) => number
>p : string
>x : T
>T : T
>T : T
return undefined;
>undefined : undefined
}
foo({ m(x) { return x.length } });
>foo({ m(x) { return x.length } }) : { }
>foo : <T extends { m(p: string): number; }>(x: T) => T
>{ m(x) { return x.length } } : { m(x: string): number; }
>m : (x: string) => number
>x : string
>x.length : number
>x : string
>length : number

56
tests/baselines/reference/inferentialTypingUsingApparentType3.js Normal file
View File

@ -0,0 +1,56 @@
//// [inferentialTypingUsingApparentType3.ts]
interface Field<T> {
clean(input: T): T
}
class CharField implements Field<string> {
clean(input: string) {
return "Yup";
}
}
class NumberField implements Field<number> {
clean(input: number) {
return 123;
}
}
class ObjectField<A, T extends { [name: string]: Field<any> }> {
constructor(public fields: T) { }
}
var person = new ObjectField({
id: new NumberField(),
name: new CharField()
});
person.fields.id;
//// [inferentialTypingUsingApparentType3.js]
var CharField = (function () {
function CharField() {
}
CharField.prototype.clean = function (input) {
return "Yup";
};
return CharField;
})();
var NumberField = (function () {
function NumberField() {
}
NumberField.prototype.clean = function (input) {
return 123;
};
return NumberField;
})();
var ObjectField = (function () {
function ObjectField(fields) {
this.fields = fields;
}
return ObjectField;
})();
var person = new ObjectField({
id: new NumberField(),
name: new CharField()
});
person.fields.id;

69
tests/baselines/reference/inferentialTypingUsingApparentType3.symbols Normal file
View File

@ -0,0 +1,69 @@
=== tests/cases/compiler/inferentialTypingUsingApparentType3.ts ===
interface Field<T> {
>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 0, 16))
clean(input: T): T
>clean : Symbol(clean, Decl(inferentialTypingUsingApparentType3.ts, 0, 20))
>input : Symbol(input, Decl(inferentialTypingUsingApparentType3.ts, 1, 10))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 0, 16))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 0, 16))
}
class CharField implements Field<string> {
>CharField : Symbol(CharField, Decl(inferentialTypingUsingApparentType3.ts, 2, 1))
>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0))
clean(input: string) {
>clean : Symbol(clean, Decl(inferentialTypingUsingApparentType3.ts, 4, 42))
>input : Symbol(input, Decl(inferentialTypingUsingApparentType3.ts, 5, 10))
return "Yup";
}
}
class NumberField implements Field<number> {
>NumberField : Symbol(NumberField, Decl(inferentialTypingUsingApparentType3.ts, 8, 1))
>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0))
clean(input: number) {
>clean : Symbol(clean, Decl(inferentialTypingUsingApparentType3.ts, 10, 44))
>input : Symbol(input, Decl(inferentialTypingUsingApparentType3.ts, 11, 10))
return 123;
}
}
class ObjectField<A, T extends { [name: string]: Field<any> }> {
>ObjectField : Symbol(ObjectField, Decl(inferentialTypingUsingApparentType3.ts, 14, 1))
>A : Symbol(A, Decl(inferentialTypingUsingApparentType3.ts, 16, 18))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 16, 20))
>name : Symbol(name, Decl(inferentialTypingUsingApparentType3.ts, 16, 34))
>Field : Symbol(Field, Decl(inferentialTypingUsingApparentType3.ts, 0, 0))
constructor(public fields: T) { }
>fields : Symbol(fields, Decl(inferentialTypingUsingApparentType3.ts, 17, 16))
>T : Symbol(T, Decl(inferentialTypingUsingApparentType3.ts, 16, 20))
}
var person = new ObjectField({
>person : Symbol(person, Decl(inferentialTypingUsingApparentType3.ts, 20, 3))
>ObjectField : Symbol(ObjectField, Decl(inferentialTypingUsingApparentType3.ts, 14, 1))
id: new NumberField(),
>id : Symbol(id, Decl(inferentialTypingUsingApparentType3.ts, 20, 30))
>NumberField : Symbol(NumberField, Decl(inferentialTypingUsingApparentType3.ts, 8, 1))
name: new CharField()
>name : Symbol(name, Decl(inferentialTypingUsingApparentType3.ts, 21, 26))
>CharField : Symbol(CharField, Decl(inferentialTypingUsingApparentType3.ts, 2, 1))
});
person.fields.id;
>person.fields.id : Symbol(id, Decl(inferentialTypingUsingApparentType3.ts, 20, 30))
>person.fields : Symbol(ObjectField.fields, Decl(inferentialTypingUsingApparentType3.ts, 17, 16))
>person : Symbol(person, Decl(inferentialTypingUsingApparentType3.ts, 20, 3))
>fields : Symbol(ObjectField.fields, Decl(inferentialTypingUsingApparentType3.ts, 17, 16))
>id : Symbol(id, Decl(inferentialTypingUsingApparentType3.ts, 20, 30))

75
tests/baselines/reference/inferentialTypingUsingApparentType3.types Normal file
View File

@ -0,0 +1,75 @@
=== tests/cases/compiler/inferentialTypingUsingApparentType3.ts ===
interface Field<T> {
>Field : Field<T>
>T : T
clean(input: T): T
>clean : (input: T) => T
>input : T
>T : T
>T : T
}
class CharField implements Field<string> {
>CharField : CharField
>Field : Field<T>
clean(input: string) {
>clean : (input: string) => string
>input : string
return "Yup";
>"Yup" : string
}
}
class NumberField implements Field<number> {
>NumberField : NumberField
>Field : Field<T>
clean(input: number) {
>clean : (input: number) => number
>input : number
return 123;
>123 : number
}
}
class ObjectField<A, T extends { [name: string]: Field<any> }> {
>ObjectField : ObjectField<A, T>
>A : A
>T : T
>name : string
>Field : Field<T>
constructor(public fields: T) { }
>fields : T
>T : T
}
var person = new ObjectField({
>person : ObjectField<{}, { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }>
>new ObjectField({ id: new NumberField(), name: new CharField()}) : ObjectField<{}, { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }>
>ObjectField : typeof ObjectField
>{ id: new NumberField(), name: new CharField()} : { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }
id: new NumberField(),
>id : NumberField
>new NumberField() : NumberField
>NumberField : typeof NumberField
name: new CharField()
>name : CharField
>new CharField() : CharField
>CharField : typeof CharField
});
person.fields.id;
>person.fields.id : NumberField
>person.fields : { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }
>person : ObjectField<{}, { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }>
>fields : { [x: string]: CharField | NumberField; id: NumberField; name: CharField; }
>id : NumberField

5
tests/cases/compiler/inferentialTypingUsingApparentType1.ts Normal file
View File

@ -0,0 +1,5 @@
function foo<T extends (p: string) => number>(x: T): T {
return undefined;
}
foo(x => x.length);

5
tests/cases/compiler/inferentialTypingUsingApparentType2.ts Normal file
View File

@ -0,0 +1,5 @@
function foo<T extends { m(p: string): number }>(x: T): T {
return undefined;
}
foo({ m(x) { return x.length } });

26
tests/cases/compiler/inferentialTypingUsingApparentType3.ts Normal file
View File

@ -0,0 +1,26 @@
interface Field<T> {
clean(input: T): T
}
class CharField implements Field<string> {
clean(input: string) {
return "Yup";
}
}
class NumberField implements Field<number> {
clean(input: number) {
return 123;
}
}
class ObjectField<A, T extends { [name: string]: Field<any> }> {
constructor(public fields: T) { }
}
var person = new ObjectField({
id: new NumberField(),
name: new CharField()
});
person.fields.id;