Array.map typechecking issues, doesn't typecheck what the .map callback returns

[benoitgrelard]

TypeScript Version: reproducible in at least 3.3.3333 and above

Search Terms: Array map generic extra property

Code

type Token = {
    value: string
}

const things = ['one', 'two'];

// using .map generic — doesn't fail typechecking
function getTokens1() {
    return things.map<Token>(thing => ({
        value: thing,
        // should say `somethingElse` does not exist on type `Token`
        somethingElse: true
    }));
}

// using return type — doesn't fail typechecking
function getTokens2(): Token[] {
    const tokens = things.map(thing => ({
        value: thing,
        // should say `somethingElse` does not exist on type `Token`
        somethingElse: true
    }));

    // type of tokens is reported as `{ value: string; somethingElse: boolean; }[]`
    // so how could it be compatible with `Token[]`?
    return tokens;
}


// following use cases as working proofs and potential workarounds

// fails typechecking correctly
const token: Token = {
    value: 'one',
    somethingElse: true // `somethingElse` does not exist on type `Token`
};

// fails typechecking correctly — potential workaround
function getTokens3() {
    // note the `Token` inline return type
    return things.map((thing): Token => ({
        value: thing,
        somethingElse: true // `somethingElse` does not exist on type `Token`
    }));
}

Expected behavior:

I would expect in getTokens1 using the .map<U> generic form that it would typecheck what .map returns. Similarly, I would expect in getTokens2 that it would complain as I am precising the return type of the function and the inference itself seems to show an incompatible type.

Actual behavior:

It doesn't seem to typecheck properly when using Array.map.

Playground Link: See above example in playground

Related Issues:

[benoitgrelard]

https://medium.com/@lemoine.benoit/why-does-typescript-sometimes-fails-to-type-check-extra-properties-fd230ebbc295

Not a bug then?

[fatcerberus]

I’m not sure why the first case isn’t an error (it seems like it should be, you’ve explicitly provided the result type for map and the object literal is still fresh when returned), but the second case is expected. See my comment here re: structural typing: #31412 (comment)

Also see - https://github.com/basarat/typescript-book/blob/master/docs/types/freshness.md#freshness

[RyanCavanaugh]

Duplicate #241

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.