callable interface as parameter allows unknown properties

[eps1lon]

TypeScript Version: 3.9.0-dev.20200215

Search Terms: callable interface

Code

// callable interface
interface Accepted {
  (): void;
  foo: string;
}

function rejected() { }
rejected.foo = "";
rejected.bar = "";

function check(a: Accepted) { }

// desired: should reject unknown properties
// fail: accepts unknown properties
check(rejected);

concrete example

interface ForwardRefRenderFunction<T, P = {}> {
  (props: P, ref: Ref<T>): ReactElement | null;
  displayName?: string;
}

function forwardRef<T, P = {}>(render: ForwardRefRenderFunction<T, P>): ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;

function Component() {
  return null;
}

Component.propTypes = {}

// should be rejected since `propTypes` aren't supported and add a runtime warning
forwardRef(Component);

Expected behavior:

• unknown properties on functions are rejected

Actual behavior:

• unknown properties are accepted

Playground Link:

• using nightly
• using 3.9.0-dev.20200215

Related Issues:

[MartinJohns]

This is intended behavior and due to TypeScripts structural type system. Your rejected function fulfills everything that Accepted demands to be present.

https://github.com/microsoft/TypeScript/wiki/FAQ#what-is-structural-typing

You would need something like #12936 for this to work.

[eps1lon]

Your rejected function fulfills everything that Accepted demands to be present.

Sure. As does the the object. But for objects typescript rejects unknown properties.

So if we're talking with structural typing in mind the behavior between passed objects and functions shouldn't change.

[MartinJohns]

The behavior is the same for objects. If it matches the interface then it's compatible, even if it has additional properties.

You probably confuse this with the excess property checks that happens for objects literals. But you're not creating an object literal here.

[eps1lon]

You probably confuse this with the excess property checks that happens for objects literals. But you're not creating an object literal here.

I was which is why I got confused: checkExact({ foo: '', bar: '1' }) threw while const object = { foo: '', bar: '1' }; checkExact(object) does not.

#12936 is exactly what I'm looking for.