Function return value constraints

[knazeri]

TypeScript compiler allows to define a function marked explicitly with a return type, with code branches which lead to an inconclusive return value!

I know It is valid in JavaScript function not to return a value on all code path, however in TypeScript being a javascript typed superset, I can imagine having a poor written function [without return value on all code path] could potentially break other codes and I'm talking null-references, type mismatch, NaN, ...
I believe when using TypeScript code in an explicitly typed expression, no-one needs all the ugly plumbings, input or type validation, undefined checking, ... One needs to be sure to write a code that couldn't break the way a dynamic language like javascript could!

The following is a valid JavaScript code and it could compile within TypeScript:

function SomeMethod() { }

When you explicitly mention that the method has a return value, the compiler throw an error:

function SomeMethod(): number { }

However it is not the case when the function does not return in all code path, and I don't understand if this is by design why bother preventing above code from compiling in the first place!

The followings are all wrong in a typed context yet the compiler ignores them as a valid code:

function SomeMethod(): number {
 return;
}

function SomeMethod(): number {
 return null;
}

function SomeMethod(): number {
 if (false)
 return 1;
}

function SomeMethod(): number {
 try {
 return 0;
 }
 catch (ex) {
 }
}

[ahejlsberg]

This is an issue we have discussed a lot. The reasoning behind the current behavior is that a function with an explicitly declared non-void return type and no return statements is clearly suspicious (and therefore should be an error), but otherwise the function might simply be relying on the fact that JavaScript returns undefined when a function doesn't explicitly return a value. We would turn a lot of existing (and technically correct) JavaScript code into errors if we tightened this, so it would definitely have to be an opt-in similar to noImplicitAny.

[knazeri]

Thank you for the response Anders.
Having an option to warn on functions with no return value of all code path by the compiler would be great, I can imagine this should be the default behavior of the compiler given that the problem at hand is with the existing js code.

[DanielRosenwasser]

Also related is #162, which would also be a breaking change if amended.

[RyanCavanaugh]

Linking this to #274. I'd like to see some set of nailed-down rules. Specifically:

• Does this apply to contextually-typed functions as well?
• Do we enforce that "all or none" return statements have expressions?
• Is this intermixable with a "must return on all codepaths" rule?

[teobugslayer]

This check is very important when working with promises, because people sometimes forget to return a promise, thus breaking a promise chain. Consider this sample:

var q = require("q");
var d = q.defer();

function f1(){return q("the first value")}

function f2(){
 process.nextTick(() =>{
 d.resolve(); 
 console.log("2");
 });
 return d.promise;
}

f1()
.finally(function(){
 return f2();
})
.then(x => console.log("end: " + x));
console.log("1");

If you execute it, the result is:

1
2
end: the first value

Now, lets assume, a programmer makes a mistake and forgets to return the result of f2:

.finally(function(){
 f2();
})

The result is

1
end: the first value
2

This mistake is very unfortunate. It is very easy to be made, especially when coding under pressure; is very easy to be missed on code reviews; tslint and friends does not complain; and its asynchronous nature allows it to slip through the manual and automated testing. The code even mostly works in production, except when it mysteriously does not. Considering how important promises and async/await become, I think it is worthy implementing this check behind an opt-in flag.

[nadyaA]

👍 for @teobugslayer 's suggestion

[vladima]

your wish is my command

declare function foo(s: (x: boolean) => number);

foo((x): number => {
 if (x) return 1;
})

compiling with current master bits

v2m@v2m-ThinkPad-W520:~/sources/TypeScript$ node built/local/tsc.js test.ts --noImplicitReturns
test.ts(3,10): error TS7030: Not all code paths return a value.

[teobugslayer]

@vladima, I assume this will be released in typescript 1.8, is this correct?

[vladima]

Yes

[teobugslayer]

Great news, thanks you!