Check types with TypeScript in JavaScript project

[regseb]

Hello,

In my JavaScript project, I check types with TypeScript (and JSDoc). With this use of fast-check:

fc.assert(fc.property(fc.string(), (str) => {
  // Do something.
}));

TypeScript report error: Argument of type '[(str: string) => void]' is not assignable to parameter of type '[...Arbitrary<unknown>[], predicate: (args_0: unknown, ...args: unknown[]) => boolean | void]'.

Do you have a tip for fixing this error?

---

Files to reproduce the problem:

• package.json

  {
    "name": "testcase",
    "version": "0.0.0",
    "dependencies": {
      "fast-check": "3.23.2",
      "typescript": "5.7.3"
    }
  }

• index.js

  import fc from "fast-check";
  
  fc.assert(fc.property(
      fc.string(),
      (str) => {
          // Do something.
      },
  ));

1. npm install
2. npx tsc index.js --strict --module nodenext --checkJs --noEmit

index.js:5:5 - error TS2345: Argument of type '[(str: string) => void]' is not assignable to parameter of type '[...Arbitrary<unknown>[], predicate: (args_0: unknown, ...args: unknown[]) => boolean | void]'.
  Type at position 0 in source is not compatible with type at position 1 in target.
    Type '(str: string) => void' is not assignable to type '(args_0: unknown, ...args: unknown[]) => boolean | void'.
      Types of parameters 'str' and 'args_0' are incompatible.
        Type 'unknown' is not assignable to type 'string'.

5     (str) => {
      ~~~~~~~~~~


Found 1 error in index.js:5

---

I've tried forcing the types, but there's always the error.

import fc from "fast-check";

/**
 * @import { Arbitrary } from "fast-check"
 */

fc.assert(fc.property(
    /** @type {Arbitrary<string>} */ (fc.string()),
    (/** @type {string} */ str) => {
        // Do something.
    },
));

[gruhn]

That's indeed quite surprising. I'm cautiously starting to believe that you discovered a Typescript bug. Here is an even simpler reproduction, without fast-check dependency:

lib.ts:

export declare function property<Ts extends [unknown, ...unknown[]]>(
  ...args: [
    ...arbitraries: { [K in keyof Ts]: Ts[K]; },
    predicate: (...args: Ts) => void
  ]
): void;

index.js:

import { property } from './lib'

property(
    2,
    [3],
    "hello",
    (num, numArr, str) => {
        // Do something.
    },
);

Then run ( --strictFunctionTypes is enough over --strict):

npx tsc index.js --strictFunctionTypes --module nodenext --checkJs --noEmit

index.js:5:5 - error TS2345: Argument of type '[number[], string, (num: number, numArr: number[], str: string) => void]' is not assignable to parameter of type '[...unknown[], predicate: (args_0: unknown, ...args: unknown[]) => void]'.
  Type at position 2 in source is not compatible with type at position 1 in target.
    Type '(num: number, numArr: number[], str: string) => void' is not assignable to type '(args_0: unknown, ...args: unknown[]) => void'.
      Types of parameters 'num' and 'args_0' are incompatible.
        Type 'unknown' is not assignable to type 'number'.

  5     [3],
        ~~~~
  6     "hello",
    ~~~~~~~~~~~~
... 
  8         // Do something.
    ~~~~~~~~~~~~~~~~~~~~~~~~
  9     },
    ~~~~~

It seems like TypeScript is using two different instantiations of the type variable Ts, that then come into conflict. One the one hand,
the line [number[], string, (num: number, numArr: number[], str: string) => void]' shows that TypeScript instantiates Ts with the narrow types suggested by the literal arguments. But then there is also [...unknown[], predicate: (args_0: unknown, ...args: unknown[]) => void] which sounds like TypeScript just defaulted to unknown[].

I can't reproduce it without --strictFunctionTypes. I also can't reproduce it if I turn index.js into a proper ts file. Also, if I go into the type definition of property and change:

...arbitraries: { [K in keyof Ts]: Ts[K]; },

to just:

...arbitraries: Ts,

(which should be equivalent, right?) then the problem also goes away. So it seems that all these conditions must come together. If this is really a TypeScript bug, it's nothing new. I downgraded all the way to TypeScript 5.2 and can still reproduce this.

[gruhn]

Maybe this TypeScript issue is related (open since 2022). This person also observes a discrepancy between JS and TS type checking and also uses a combination of generics, mapped types, strict mode.

[regseb]

Thanks for the feedback. I added a comment in the issue with a simpler snippet: microsoft/TypeScript#52042 (comment)

I agree that { [K in keyof Ts]: Ts[K]; } and Ts are the same. Maybe TypeScript gets lost with the complex syntax.