9d31631fd7
if f is a contextually typed function expression (section 4.9.3), the inferred return type is the union type (section 3.3.4) of the types of the return statement expressions in the function body, ignoring return statements with no expressions. Otherwise, the inferred return type is the first of the types of the return statement expressions in the function body that is a supertype (section 3.8.3) of each of the others, ignoring return statements with no expressions. A compile-time error occurs if no return statement expression has a type that is a supertype of each of the others.
403 lines
9.9 KiB
Plaintext
403 lines
9.9 KiB
Plaintext
=== tests/cases/conformance/functions/functionImplementations.ts ===
|
|
// FunctionExpression with no return type annotation and no return statement returns void
|
|
var v: void = function () { } ();
|
|
>v : void
|
|
>function () { } () : void
|
|
>function () { } : () => void
|
|
|
|
// FunctionExpression f with no return type annotation and directly references f in its body returns any
|
|
var a: any = function f() {
|
|
>a : any
|
|
>function f() { return f;} : () => any
|
|
>f : () => any
|
|
|
|
return f;
|
|
>f : () => any
|
|
|
|
};
|
|
var a: any = function f() {
|
|
>a : any
|
|
>function f() { return f();} : () => any
|
|
>f : () => any
|
|
|
|
return f();
|
|
>f() : any
|
|
>f : () => any
|
|
|
|
};
|
|
|
|
// FunctionExpression f with no return type annotation and indirectly references f in its body returns any
|
|
var a: any = function f() {
|
|
>a : any
|
|
>function f() { var x = f; return x;} : () => any
|
|
>f : () => any
|
|
|
|
var x = f;
|
|
>x : () => any
|
|
>f : () => any
|
|
|
|
return x;
|
|
>x : () => any
|
|
|
|
};
|
|
|
|
// Two mutually recursive function implementations with no return type annotations
|
|
function rec1() {
|
|
>rec1 : () => any
|
|
|
|
return rec2();
|
|
>rec2() : any
|
|
>rec2 : () => any
|
|
}
|
|
function rec2() {
|
|
>rec2 : () => any
|
|
|
|
return rec1();
|
|
>rec1() : any
|
|
>rec1 : () => any
|
|
}
|
|
var a = rec1();
|
|
>a : any
|
|
>rec1() : any
|
|
>rec1 : () => any
|
|
|
|
var a = rec2();
|
|
>a : any
|
|
>rec2() : any
|
|
>rec2 : () => any
|
|
|
|
// Two mutually recursive function implementations with return type annotation in one
|
|
function rec3(): number {
|
|
>rec3 : () => number
|
|
|
|
return rec4();
|
|
>rec4() : number
|
|
>rec4 : () => number
|
|
}
|
|
function rec4() {
|
|
>rec4 : () => number
|
|
|
|
return rec3();
|
|
>rec3() : number
|
|
>rec3 : () => number
|
|
}
|
|
var n: number;
|
|
>n : number
|
|
|
|
var n = rec3();
|
|
>n : number
|
|
>rec3() : number
|
|
>rec3 : () => number
|
|
|
|
var n = rec4();
|
|
>n : number
|
|
>rec4() : number
|
|
>rec4 : () => number
|
|
|
|
// FunctionExpression with no return type annotation and returns a number
|
|
var n = function () {
|
|
>n : number
|
|
>function () { return 3;} () : number
|
|
>function () { return 3;} : () => number
|
|
|
|
return 3;
|
|
} ();
|
|
|
|
// FunctionExpression with no return type annotation and returns null
|
|
var nu = null;
|
|
>nu : any
|
|
|
|
var nu = function () {
|
|
>nu : any
|
|
>function () { return null;} () : any
|
|
>function () { return null;} : () => any
|
|
|
|
return null;
|
|
} ();
|
|
|
|
// FunctionExpression with no return type annotation and returns undefined
|
|
var un = undefined;
|
|
>un : any
|
|
>undefined : undefined
|
|
|
|
var un = function () {
|
|
>un : any
|
|
>function () { return undefined;} () : any
|
|
>function () { return undefined;} : () => any
|
|
|
|
return undefined;
|
|
>undefined : undefined
|
|
|
|
} ();
|
|
|
|
// FunctionExpression with no return type annotation and returns a type parameter type
|
|
var n = function <T>(x: T) {
|
|
>n : number
|
|
>function <T>(x: T) { return x;} (4) : number
|
|
>function <T>(x: T) { return x;} : <T>(x: T) => T
|
|
>T : T
|
|
>x : T
|
|
>T : T
|
|
|
|
return x;
|
|
>x : T
|
|
|
|
} (4);
|
|
|
|
// FunctionExpression with no return type annotation and returns a constrained type parameter type
|
|
var n = function <T extends {}>(x: T) {
|
|
>n : number
|
|
>function <T extends {}>(x: T) { return x;} (4) : number
|
|
>function <T extends {}>(x: T) { return x;} : <T extends {}>(x: T) => T
|
|
>T : T
|
|
>x : T
|
|
>T : T
|
|
|
|
return x;
|
|
>x : T
|
|
|
|
} (4);
|
|
|
|
// FunctionExpression with no return type annotation with multiple return statements with identical types
|
|
var n = function () {
|
|
>n : number
|
|
>function () { return 3; return 5;}() : number
|
|
>function () { return 3; return 5;} : () => number
|
|
|
|
return 3;
|
|
return 5;
|
|
}();
|
|
|
|
// Otherwise, the inferred return type is the first of the types of the return statement expressions
|
|
// in the function body that is a supertype of each of the others,
|
|
// ignoring return statements with no expressions.
|
|
// A compile - time error occurs if no return statement expression has a type that is a supertype of each of the others.
|
|
// FunctionExpression with no return type annotation with multiple return statements with subtype relation between returns
|
|
class Base { private m; }
|
|
>Base : Base
|
|
>m : any
|
|
|
|
class Derived extends Base { private q; }
|
|
>Derived : Derived
|
|
>Base : Base
|
|
>q : any
|
|
|
|
var b: Base;
|
|
>b : Base
|
|
>Base : Base
|
|
|
|
var b = function () {
|
|
>b : Base
|
|
>function () { return new Base(); return new Derived();} () : Base
|
|
>function () { return new Base(); return new Derived();} : () => Base
|
|
|
|
return new Base(); return new Derived();
|
|
>new Base() : Base
|
|
>Base : typeof Base
|
|
>new Derived() : Derived
|
|
>Derived : typeof Derived
|
|
|
|
} ();
|
|
|
|
// FunctionExpression with no return type annotation with multiple return statements with one a recursive call
|
|
var a = function f() {
|
|
>a : any
|
|
>function f() { return new Base(); return new Derived(); return f(); // ?} () : any
|
|
>function f() { return new Base(); return new Derived(); return f(); // ?} : () => any
|
|
>f : () => any
|
|
|
|
return new Base(); return new Derived(); return f(); // ?
|
|
>new Base() : Base
|
|
>Base : typeof Base
|
|
>new Derived() : Derived
|
|
>Derived : typeof Derived
|
|
>f() : any
|
|
>f : () => any
|
|
|
|
} ();
|
|
|
|
// FunctionExpression with non -void return type annotation with a single throw statement
|
|
undefined === function (): number {
|
|
>undefined === function (): number { throw undefined;} : boolean
|
|
>undefined : undefined
|
|
>function (): number { throw undefined;} : () => number
|
|
|
|
throw undefined;
|
|
>undefined : undefined
|
|
|
|
};
|
|
|
|
// Type of 'this' in function implementation is 'any'
|
|
function thisFunc() {
|
|
>thisFunc : () => void
|
|
|
|
var x = this;
|
|
>x : any
|
|
>this : any
|
|
|
|
var x: any;
|
|
>x : any
|
|
}
|
|
|
|
// Function signature with optional parameter, no type annotation and initializer has initializer's type
|
|
function opt1(n = 4) {
|
|
>opt1 : (n?: number) => void
|
|
>n : number
|
|
|
|
var m = n;
|
|
>m : number
|
|
>n : number
|
|
|
|
var m: number;
|
|
>m : number
|
|
}
|
|
|
|
// Function signature with optional parameter, no type annotation and initializer has initializer's widened type
|
|
function opt2(n = { x: null, y: undefined }) {
|
|
>opt2 : (n?: { x: any; y: any; }) => void
|
|
>n : { x: any; y: any; }
|
|
>{ x: null, y: undefined } : { x: null; y: undefined; }
|
|
>x : null
|
|
>y : undefined
|
|
>undefined : undefined
|
|
|
|
var m = n;
|
|
>m : { x: any; y: any; }
|
|
>n : { x: any; y: any; }
|
|
|
|
var m: { x: any; y: any };
|
|
>m : { x: any; y: any; }
|
|
>x : any
|
|
>y : any
|
|
}
|
|
|
|
// Function signature with initializer referencing other parameter to the left
|
|
function opt3(n: number, m = n) {
|
|
>opt3 : (n: number, m?: number) => void
|
|
>n : number
|
|
>m : number
|
|
>n : number
|
|
|
|
var y = m;
|
|
>y : number
|
|
>m : number
|
|
|
|
var y: number;
|
|
>y : number
|
|
}
|
|
|
|
// Function signature with optional parameter has correct codegen
|
|
// (tested above)
|
|
|
|
// FunctionExpression with non -void return type annotation return with no expression
|
|
function f6(): number {
|
|
>f6 : () => number
|
|
|
|
return;
|
|
}
|
|
|
|
class Derived2 extends Base { private r: string; }
|
|
>Derived2 : Derived2
|
|
>Base : Base
|
|
>r : string
|
|
|
|
class AnotherClass { private x }
|
|
>AnotherClass : AnotherClass
|
|
>x : any
|
|
|
|
// if f is a contextually typed function expression, the inferred return type is the union type
|
|
// of the types of the return statement expressions in the function body,
|
|
// ignoring return statements with no expressions.
|
|
var f7: (x: number) => string | number = x => { // should be (x: number) => number | string
|
|
>f7 : (x: number) => string | number
|
|
>x : number
|
|
>x => { // should be (x: number) => number | string if (x < 0) { return x; } return x.toString();} : (x: number) => string | number
|
|
>x : number
|
|
|
|
if (x < 0) { return x; }
|
|
>x < 0 : boolean
|
|
>x : number
|
|
>x : number
|
|
|
|
return x.toString();
|
|
>x.toString() : string
|
|
>x.toString : (radix?: number) => string
|
|
>x : number
|
|
>toString : (radix?: number) => string
|
|
}
|
|
var f8: (x: number) => any = x => { // should be (x: number) => Base
|
|
>f8 : (x: number) => any
|
|
>x : number
|
|
>x => { // should be (x: number) => Base return new Base(); return new Derived2();} : (x: number) => Base
|
|
>x : number
|
|
|
|
return new Base();
|
|
>new Base() : Base
|
|
>Base : typeof Base
|
|
|
|
return new Derived2();
|
|
>new Derived2() : Derived2
|
|
>Derived2 : typeof Derived2
|
|
}
|
|
var f9: (x: number) => any = x => { // should be (x: number) => Base
|
|
>f9 : (x: number) => any
|
|
>x : number
|
|
>x => { // should be (x: number) => Base return new Base(); return new Derived(); return new Derived2();} : (x: number) => Base
|
|
>x : number
|
|
|
|
return new Base();
|
|
>new Base() : Base
|
|
>Base : typeof Base
|
|
|
|
return new Derived();
|
|
>new Derived() : Derived
|
|
>Derived : typeof Derived
|
|
|
|
return new Derived2();
|
|
>new Derived2() : Derived2
|
|
>Derived2 : typeof Derived2
|
|
}
|
|
var f10: (x: number) => any = x => { // should be (x: number) => Derived | Derived1
|
|
>f10 : (x: number) => any
|
|
>x : number
|
|
>x => { // should be (x: number) => Derived | Derived1 return new Derived(); return new Derived2();} : (x: number) => Derived | Derived2
|
|
>x : number
|
|
|
|
return new Derived();
|
|
>new Derived() : Derived
|
|
>Derived : typeof Derived
|
|
|
|
return new Derived2();
|
|
>new Derived2() : Derived2
|
|
>Derived2 : typeof Derived2
|
|
}
|
|
var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
|
|
>f11 : (x: number) => any
|
|
>x : number
|
|
>x => { // should be (x: number) => Base | AnotherClass return new Base(); return new AnotherClass();} : (x: number) => Base | AnotherClass
|
|
>x : number
|
|
|
|
return new Base();
|
|
>new Base() : Base
|
|
>Base : typeof Base
|
|
|
|
return new AnotherClass();
|
|
>new AnotherClass() : AnotherClass
|
|
>AnotherClass : typeof AnotherClass
|
|
}
|
|
var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
|
|
>f12 : (x: number) => any
|
|
>x : number
|
|
>x => { // should be (x: number) => Base | AnotherClass return new Base(); return; // should be ignored return new AnotherClass();} : (x: number) => Base | AnotherClass
|
|
>x : number
|
|
|
|
return new Base();
|
|
>new Base() : Base
|
|
>Base : typeof Base
|
|
|
|
return; // should be ignored
|
|
return new AnotherClass();
|
|
>new AnotherClass() : AnotherClass
|
|
>AnotherClass : typeof AnotherClass
|
|
}
|