microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-05 08:11:30 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Merge pull request #3798 from Microsoft/typeArgumentInferenceClassExpressions

Browse Source 
Type argument inference for class expressions
This commit is contained in:
Jason Freeman 2015-07-09 14:56:49 -07:00
commit 9d6dc36e51
12 changed files with 185 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/compiler/checker.ts
View File

@ -5503,7 +5503,7 @@ namespace ts {
}
}
else if (source.flags & TypeFlags.ObjectType && (target.flags & (TypeFlags.Reference | TypeFlags.Tuple) ||
(target.flags & TypeFlags.Anonymous) && target.symbol && target.symbol.flags & (SymbolFlags.Method | SymbolFlags.TypeLiteral))) {
(target.flags & TypeFlags.Anonymous) && target.symbol && target.symbol.flags & (SymbolFlags.Method | SymbolFlags.TypeLiteral | SymbolFlags.Class))) {
// If source is an object type, and target is a type reference, a tuple type, the type of a method, or a type literal, infer from members
if (isInProcess(source, target)) {
return;

22
tests/baselines/reference/typeArgumentInferenceWithClassExpression1.js Normal file
View File

@ -0,0 +1,22 @@
//// [typeArgumentInferenceWithClassExpression1.ts]
function foo<T>(x = class { static prop: T }): T {
return undefined;
}
foo(class { static prop = "hello" }).length;
//// [typeArgumentInferenceWithClassExpression1.js]
function foo(x) {
if (x === void 0) { x = (function () {
function class_1() {
}
return class_1;
})(); }
return undefined;
}
foo((function () {
function class_2() {
}
class_2.prop = "hello";
return class_2;
})()).length;

19
tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols Normal file
View File

@ -0,0 +1,19 @@
=== tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpression1.ts ===
function foo<T>(x = class { static prop: T }): T {
>foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 0))
>T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 13))
>x : Symbol(x, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 16))
>prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 27))
>T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 13))
>T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 13))
return undefined;
>undefined : Symbol(undefined)
}
foo(class { static prop = "hello" }).length;
>foo(class { static prop = "hello" }).length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 0))
>prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression1.ts, 4, 11))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))

23
tests/baselines/reference/typeArgumentInferenceWithClassExpression1.types Normal file
View File

@ -0,0 +1,23 @@
=== tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpression1.ts ===
function foo<T>(x = class { static prop: T }): T {
>foo : <T>(x?: typeof (Anonymous class)) => T
>T : T
>x : typeof (Anonymous class)
>class { static prop: T } : typeof (Anonymous class)
>prop : T
>T : T
>T : T
return undefined;
>undefined : undefined
}
foo(class { static prop = "hello" }).length;
>foo(class { static prop = "hello" }).length : number
>foo(class { static prop = "hello" }) : string
>foo : <T>(x?: typeof (Anonymous class)) => T
>class { static prop = "hello" } : typeof (Anonymous class)
>prop : string
>"hello" : string
>length : number

16
tests/baselines/reference/typeArgumentInferenceWithClassExpression2.errors.txt Normal file
View File

@ -0,0 +1,16 @@
tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpression2.ts(6,5): error TS2345: Argument of type 'typeof (Anonymous class)' is not assignable to parameter of type 'typeof (Anonymous class)'.
Type '(Anonymous class)' is not assignable to type 'foo<{}>.'.
Property 'prop' is missing in type '(Anonymous class)'.
==== tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpression2.ts (1 errors) ====
function foo<T>(x = class { prop: T }): T {
return undefined;
}
// Should not infer string because it is a static property
foo(class { static prop = "hello" }).length;
~~~~~
!!! error TS2345: Argument of type 'typeof (Anonymous class)' is not assignable to parameter of type 'typeof (Anonymous class)'.
!!! error TS2345: Type '(Anonymous class)' is not assignable to type 'foo<{}>.'.
!!! error TS2345: Property 'prop' is missing in type '(Anonymous class)'.

24
tests/baselines/reference/typeArgumentInferenceWithClassExpression2.js Normal file
View File

@ -0,0 +1,24 @@
//// [typeArgumentInferenceWithClassExpression2.ts]
function foo<T>(x = class { prop: T }): T {
return undefined;
}
// Should not infer string because it is a static property
foo(class { static prop = "hello" }).length;
//// [typeArgumentInferenceWithClassExpression2.js]
function foo(x) {
if (x === void 0) { x = (function () {
function class_1() {
}
return class_1;
})(); }
return undefined;
}
// Should not infer string because it is a static property
foo((function () {
function class_2() {
}
class_2.prop = "hello";
return class_2;
})()).length;

22
tests/baselines/reference/typeArgumentInferenceWithClassExpression3.js Normal file
View File

@ -0,0 +1,22 @@
//// [typeArgumentInferenceWithClassExpression3.ts]
function foo<T>(x = class { prop: T }): T {
return undefined;
}
foo(class { prop = "hello" }).length;
//// [typeArgumentInferenceWithClassExpression3.js]
function foo(x) {
if (x === void 0) { x = (function () {
function class_1() {
}
return class_1;
})(); }
return undefined;
}
foo((function () {
function class_2() {
this.prop = "hello";
}
return class_2;
})()).length;

19
tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols Normal file
View File

@ -0,0 +1,19 @@
=== tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpression3.ts ===
function foo<T>(x = class { prop: T }): T {
>foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 0))
>T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 13))
>x : Symbol(x, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 16))
>prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 27))
>T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 13))
>T : Symbol(T, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 13))
return undefined;
>undefined : Symbol(undefined)
}
foo(class { prop = "hello" }).length;
>foo(class { prop = "hello" }).length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 0))
>prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression3.ts, 4, 11))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))

23
tests/baselines/reference/typeArgumentInferenceWithClassExpression3.types Normal file
View File

@ -0,0 +1,23 @@
=== tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpression3.ts ===
function foo<T>(x = class { prop: T }): T {
>foo : <T>(x?: typeof (Anonymous class)) => T
>T : T
>x : typeof (Anonymous class)
>class { prop: T } : typeof (Anonymous class)
>prop : T
>T : T
>T : T
return undefined;
>undefined : undefined
}
foo(class { prop = "hello" }).length;
>foo(class { prop = "hello" }).length : number
>foo(class { prop = "hello" }) : string
>foo : <T>(x?: typeof (Anonymous class)) => T
>class { prop = "hello" } : typeof (Anonymous class)
>prop : string
>"hello" : string
>length : number

5
tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpression1.ts Normal file
View File

@ -0,0 +1,5 @@
function foo<T>(x = class { static prop: T }): T {
return undefined;
}
foo(class { static prop = "hello" }).length;

6
tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpression2.ts Normal file
View File

@ -0,0 +1,6 @@
function foo<T>(x = class { prop: T }): T {
return undefined;
}
// Should not infer string because it is a static property
foo(class { static prop = "hello" }).length;

5
tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpression3.ts Normal file
View File

@ -0,0 +1,5 @@
function foo<T>(x = class { prop: T }): T {
return undefined;
}
foo(class { prop = "hello" }).length;