Don't widen return types of function expressions

Jason Freeman (@JsonFreeman)

This change courtesy Jason Freeman (@JsonFreeman) who is trying it out

(context elided: widening of function expression return types)

The problem with this widening is observable in type argument inference and no implicit any. For type argument inference, we are prone to infer an any, where we should not:

function f<T>(x: T, y: T): T { }
f(1, null); // returns number
f(() => 1, () => null); // returns () => any, but should return () => number

So after we get to parity, I propose we do the following. We do not widen function expressions. A function is simply given a function type. However, a function declaration (and a named function expression) introduces a name whose type is the widened form of the type of the function. Very simple to explain and simple to implement.

I’ve been told that this would be a breaking change, because types that used to be any are now more specific types. But here are some reasons why it would be okay:

In the places where you actually need the type to be any (because there are no other inference candidates), you would still get any as a result
In places where there was a better (more specific) type to infer, you’d get the better type.
With the noImplicitAny flag, you’d get fewer errors because there are actually fewer implicit anys

Questions:

Is a principle of design changes going forward to not switch from 'any' to a more precise type because it can be a breaking change?

Going with 'not a breaking change' here because this is unlikely to break working code, but we need to verify this.

Would this manufacture two types?

In essence, we already have two types: The original and the widened type. So by that measure this is not really a change

Has someone tried it?

Jason willing to try it out and report back

Correct contextual typing with union types

Bumping this since we ran into a situation with a leaked any in our own compiler. Minimal example:

function forEach<T, U>(array: T[], callback: (element: T, index: number) => U): U {
    if (array) {
        for (let i = 0, len = array.length; i < len; i++) {
            let result = callback(array[i], i);
            if (result) {
                return result;
            }
        }
    }
    return undefined;
}


forEach([1, 2, 3, 4], () => { 
    // do stuff
    if (blah) {
        // bam! accidental any
        return undefined;
    }
});

We need an implementation proposal for this one.

What if we just did this:

Don't widen when you type a function body
When you widen a type, and it's a function type, you widen the return type
When you resolveName and it's a function expression or function declaration, you widen its type

I've arrived here via #7220. Would appreciate some guidance on whether the following is expected behaviour or not (playground):

interface G<K, R> {
    (v: K): R;
}

function F<T>(v: T): T {
    return v;
}

interface A {
    __Type: "A";
}

interface B {
    __Type: "B";
}

let a: A;
let b: B;

a = b; // OK: error as expected, B is not assignable to A
b = a; // OK: error as expected, A is not assignable to B

let x: G<A, B> = F;  // How is this possible?

It's the final assignment I cannot understand... because the compiler does not complain.

During assignment checking, type parameters are replaced with any. So the effective signature of F here is (a: any) => any

Paul Jolly (@myitcv)

Paul Jolly (@myitcv) See #138

Hey everyone, I opened #40311 a couple of days ago which I think should fix most of the issues that have brought people here. If you'd like to give it a try, we have a build available over at #40311 (comment).

Daniel Rosenwasser (@DanielRosenwasser)

Hey Daniel Rosenwasser (@DanielRosenwasser), what's the status of your pull request? I suppose I don't have to list any reasons for wanting this feature (there are many discussions), so I'm only curious if there's been any progress recently

+1 to consider this or adding it as a compiler flag.

I ran into problems with some .map() calls, which seems related to the issue described.

Is this still being worked on?

Hi!

Is return type widening a possible cause for the lack of errors in this case?

type T = { foo: number };
type F = () => T

// no type error
const a: F = () => ({
  foo: 1,
  bar: 2,
})

Or is it because of the covariance rule on function subtyping?

Happens for .map()

interface IUser {
  id: number;
}
// No errors
const users: Array<IUser> = [].map<IUser>(() => ({
  id: 1,
  unknownProperty: 'unknownProperty',
}));

// Property 'id' is missing in type '{ unknownProperty: string; }' but required in type 'IUser'.ts(2741)
const users1: Array<IUser> = [].map<IUser>(() => ({
  unknownProperty: 'unknownProperty',
}));
console.log(users);
console.log(users1);

Add lint rule to prefer `map((): T => {})` over `map<T>(() => {})` (#…

This issue is also present when writing GraphQL resolvers:

const resolvers: Resolvers = {
  Query: {
    someField: () => ({
      requiredField: 'some value',
      // @ts-expect-error
      optionalFieldWithTyppo: 'some value',
    })
  }
}

As we can see in this example TS is not doing its job of catching the type issue introduced by the typo on the optional field name.

Playground | Other example

AFAIK there is no real workaround (except explicitly putting the return type on the function which defeats the purpose of putting the type in the first place). Is this issue still on the radar of the TypeScript team?

This issue seems to be the cause of this error:

type MyResponse = {
  my: string;
  response: string;
};

const myFunc = (param: string): MyResponse => {
  const myResponse = {
    my: 'my',
    response: 'response',
    extra: 'extra', // no error here
  };
  return myResponse;
};

const myFunc2 = (param: string): MyResponse => {
  return {
    my: 'my',
    response: 'response',
    extra: 'extra', // error here
  };
};

What are the action items here?

Yam Borodetsky (@yamcodes)

Having same issue as Yam Borodetsky (@yamcodes)

Ryan Cavanaugh (@RyanCavanaugh)

Ryan Cavanaugh (@RyanCavanaugh) Daniel Rosenwasser (@DanielRosenwasser) I also noticed that when using object spread in the return statement of a function, no error is reported for additional properties that don’t exist in the target type.

For example:

✅ Type error is correctly raised here:

type MyResponse = {
  my: string;
  response: string;
};

const myFunc1 = (param: string): MyResponse => {
  return {
    my: 'my',
    response: 'response',
    extra: 'extra', // error here, as 'extra' is not part of 'MyResponse'
  };
};

❌ However, no error is raised in the following cases:

When assigning the object to a variable first:

const myFunc2 = (param: string): MyResponse => {
  const myResponse = {
    my: 'my',
    response: 'response',
    extra: 'extra', // no error here, even though 'extra' is not part of 'MyResponse'
  };

  return myResponse;
};

When using object spread:

const myFunc3 = (param: string): MyResponse => {
 const myResponse = {
    my: 'my',
    response: 'response',
    extra: 'extra', // no error here either
  };

  return { ...myResponse };
};

In both scenarios, TypeScript is allowing extra properties without raising an error even though it knows the final shape is inconsistent with the type annotations.

Extra properties are allowed in typescript. Excess property checks only apply to the type in effect at the point of declaration (if any). This is generally considered a linting feature to catch typos, not a type correctness feature.

Outside that specific scenario, extra properties are not an error. Consider if you wanted to assign a value {a: A, B: B} to a variable typed {a: A}. The value satisfies the type.

When the constant declaration is a step removed from where the value is used, EPC does not come into play.

Navigation Menu

Repository navigation

Don't widen return types of function expressions #241

Questions:

43 remaining items

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Don't widen return types of function expressions #241

Description

Questions:

Activity

DanielRosenwasser commented on Mar 19, 2015

mhegazy commented on Jul 27, 2015

JsonFreeman commented on Mar 22, 2016

myitcv commented on Apr 8, 2016

RyanCavanaugh commented on Apr 8, 2016

JsonFreeman commented on Apr 8, 2016

43 remaining items

DanielRosenwasser commented on Sep 2, 2020

mrlubos commented on May 17, 2021

jdanielson-indeed commented on Sep 14, 2021

EddyVinck commented on May 16, 2022

folex commented on May 19, 2022

MaksimKlepikov commented on May 30, 2022

Akryum commented on Oct 26, 2023

yamcodes commented on Aug 23, 2024

ernestostifano commented on Sep 21, 2024

alvis commented on Oct 6, 2024

snarbies commented on Oct 7, 2024

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions