type `nothing` emitted in generated .d.ts files

[mhegazy]

function f() {
    var x: string | undefined = undefined;
    y = 0;
    if (x) {
       var y: typeof x;
    }
    return y; // y has type nothing
}

generates invalid .d.ts file

declare function f(): nothing;

this is a regression introduced by #8340

[ahejlsberg]

I'm tempted to say just don't do that. But I won't. 😉

I definitely don't think the solution is to make nothing a manifest type that you can reference in a type annotation. That leaves rewriting (but to what?) or issuing an error. The error is probably the better option.

[DanielRosenwasser]

I get why {} was not appropriate. But nothing sounds a heck of a lot like what I'd associate void with, so what exactly is the intended difference semantically?

[mihailik]

Can it return any and for those interested in picking at those little tiny details let noImplicitAny generate an error?

[ahejlsberg]

Daniel Rosenwasser (@DanielRosenwasser) There are a couple of important differences between void and nothing.

• The undefined type is assignable to void, but no types are assignable to nothing.
• void can be a constituent of a union type, but nothing disappears in a union type (because it signifies no type at all).

I do agree we have bit of a profusion of nothingness types (undefined, null, void, nothing), but they all have important differences. If anything had to change, we could possibly consider removing the undefined type and having void be the type of the undefined literal. But that would allow silly stuff like assigning the result of a void function to a variable can be undefined, which really should be an error.

[mhegazy]

here is a less artificial example:

function bar() {
    var x: string | undefined;
    if (x) {
        return x;
    }
    throw new Error();
}

[mhegazy]

so for .d.ts purposes, should we 1. write void, 2. undefined, 3. nothing and make it legal to name this type.

[ahejlsberg]

(1) and (2) aren't correct and (3) really doesn't help anyone. I think we should (4) issue an error.

[ahejlsberg]

Adding some rationale for (4): There's really no situation ever where you want nothing to be the declared type of an entity. It is typically an indicator of a logic error, but we don't want to eagerly issue the error because you may be writing "defensive" code that deals with incorrect parameters passed from code that doesn't follow the stated contract (such as plain JavaScript).

[mihailik]

function bar() {
    throw new Error();
}

Under these reasoning this should produce error too.

[mhegazy]

no that is void.

[mihailik]

Exactly, and that's the same code as in your example (sans no-op if).

Do we end-users of the compiler need this level of precision? By all means it may add value internally, but best reduce peculiarity on the outside, coercing nothing to void or unknown in codegen/diagnostic messages.

[mhegazy]

void means it returns no value. nothing means it returned a value, but its type was narrowed down by the compiler to nothing. The assumption is that is never the intention of the user. so if you did not mean for this to happen, so you might want to take a look at the source and see where did the nothing came from, and the error does that.

[aluanhaddad]

Do we end-users of the compiler need this level of precision? By all means it may add value internally, but best reduce peculiarity on the outside, coercing nothing to void or unknown in codegen/diagnostic messages.

The TypeScript compiler is a TypeScript program so I do not think that would be either possible or valuable.

👍 for making it an error.

[mihailik]

Mohamed Hegazy (@mhegazy) unless this detection generates false positives, as Anders Hejlsberg (@ahejlsberg) pointed out above.

function validateType(val: number | string) {
    if (typeof val === 'string') return null;
    else {
        if (typeof val === 'number') return null;
        else return val; // validation fails at runtime, but this code is valid
    }
}

function validateTypeMoreDetails(val: number | string) {
    if (typeof val === 'string') return null;
    else {
        if (typeof val === 'number') return null;
        else return 'Incorrect type ' + typeof val+' ('+val+')'; // should 'nothing' support plus operator with string?
    }
}