Activity

1. Ryan Cavanaugh (RyanCavanaugh)

   added

   BugA bug in TypeScriptA bug in TypeScript

   on Aug 9, 2021
2. Ryan Cavanaugh (RyanCavanaugh)

   added this to the Backlog milestone on Aug 9, 2021
3. S0AndS0 commented on Dec 31, 2021

   

   S0AndS0

   on Dec 31, 2021

   More actions

   I recently ran into this error too, and worked around it by hinting the type via the as keyword, eg.

   function mergeDictionaries(...dictionaries: { [key: string]: unknown }[]): {
     [key: string]: unknown;
   } {
     return Object.assign(
       ...(dictionaries.map((dictionary) => {
         return JSON.parse(JSON.stringify(dictionary));
       }) as [{ [key: string]: unknown }])
     );
   }

   ... without the [{ [key: string]: unknown }]) bit, an error similar to the following pops;

   <file>.ts|<C> col <L> error| A spread argument must either have a tuple type or be passed to a rest parameter.
   

   What I find somewhat trubling, beyond TypeScript loosing the plot in the first place, is that Array<T> will produce the same error, eg.

   function mergeDictionaries(...dictionaries: { [key: string]: unknown }[]): {
     [key: string]: unknown;
   } {
     return Object.assign(
       ...(dictionaries.map((dictionary) => { /* ← Error on this line */
         return JSON.parse(JSON.stringify(dictionary));
       }) as Array<{ [key: string]: unknown }>) /* ← Why is [{}] required? */
     );
   }
4. Dionysusnu commented on Dec 31, 2021

   

   Dion (Dionysusnu)

   on Dec 31, 2021

   Last edited by Dionysusnu

   Author

   More actions

   What I find somewhat trubling, beyond TypeScript loosing the plot in the first place, is that Array<T> will produce the same error, eg.

   This usually makes sense, because you don't know the Array's length, which is why it's (as the correct behaviour) not considered a tuple.
   That's part 1, and then part 2, I believe this not working in this case is a separate missing behaviour, which is that normal parameters need to be filled manually, not being considered to be part of the rest parameter. What I mean by that is that a function like a(obj: object, ...other: object[]) will not allow a call like a(...objects) where objects is Array<object>, despite this being type-compatible.

   👍React with 👍1Reacted by S0AndS0
5. S0AndS0 commented on Jan 1, 2022

   

   S0AndS0

   on Jan 1, 2022

   More actions

   Hmm, I supose I'll have to dig deeper into how TypeScript parses things. Because I'm still a bit befuddled that as Array<{ [key: string]: unknown }> throws errors but using the same hint for a parameter doesn't present issues, eg.

   function mergeDictionaries(
     ...dictionaries: Array<{ [key: string]: unknown }>  /* ← Totally okay */
     // ...dictionaries: [{ [key: string]: unknown }]    /* ← this is fine too */
   ): {
     [key: string]: unknown;
   } {
     return Object.assign(
       ...(dictionaries.map((dictionary) => {
         return JSON.parse(JSON.stringify(dictionary));
       }) as [{ [key: string]: unknown }])
       // }) as { [key: string]: unknown }[])       /* ← Nope */
       // }) as Array<{ [key: string]: unknown }>)  /* ← no joy either */
     );
   }
6. darklight9811 commented on Jan 12, 2022

   

   Rafael Corrêa Chaves (darklight9811)

   on Jan 12, 2022

   More actions

   I'm mapping a dispatch into a object and this is freaking my mind.

   // not actual example but close
   Object.fromEntries(
     Object.entries(actions)
       .map(entry => [
         entry[0],
         (...args: Parameters<typeof entry[1]>) => dispatch(entry[1](...args))
       ])
   )

   There is no reason for that be a problem, mainly because not allowing arrays as spread arguments should be a linter problem, not a compiler problem.
7. Dionysusnu commented on Jan 13, 2022

   

   Dion (Dionysusnu)

   on Jan 13, 2022

   Author

   More actions

   Made a Playground Link for your code example, and I'm failing to spot any issue in this. In any case, it's probably similar to the above comment by S0AndS0, and as explained not a related problem.
8. scottwillmoore commented on Apr 23, 2022

   

   Scott Moore (scottwillmoore)

   on Apr 23, 2022

   More actions

   I am not sure if this is related, or supposed to occur... However, when attempting to brand or flavor a tuple it appears that TypeScript is no longer able to restrict property access past the length of the tuple.

   Example

   declare const id: unique symbol;
   type Id<T> = { readonly [id]: T };
   
   type Brand<T, U> = T & Id<U>;
   type PartialBrand<T, U> = T & Partial<Id<U>>; // Also known as Flavor.
   
   declare const pointId: unique symbol;
   type Point = PartialBrand<[number, number], typeof pointId>;
   
   const point = (x: number = 0, y: number = 0): Point => [x, y];
   
   const add = (a: Point, b: Point, c: Point = point()): Point => {
     c[0] = a[0] + b[0];
     c[1] = a[1] + b[1];
     return c;
   };
   
   const a = point(0, 1);
   const b = point(2, 3);
   const c = add(a, b);
   
   console.log(c);
   
   c[0] = 4;
   c[1] = 5;
   c[2] = 6; // Should be an error!
   
   console.log(c);

   Playground Link

   It appears that the expansion of the type includes [x: number]: number. Maybe I should open this a separate issue?

   type DeepExpand<T> = T extends object ? T extends infer O ? { [K in keyof O]: DeepExpand<O[K]> } : never : T;
   type ExpandPoint = DeepExpand<Point>;
   
   // type ExpandPoint = {
   //   [x: number]: number;
   //   ...
   // }
9. TomRaaff commented on Aug 21, 2023

   

   TomRaaff (TomRaaff)

   on Aug 21, 2023

   More actions

   Here is another instance of (probably) the same error:
   Playground link

   A TS2556 (A spread argument must either have a tuple type or be passed to a rest parameter.) error is thrown whenever I try to spread the contents of a tuple into another function. Even though that tuple is inferred as the correct type.

   I have tested this on all versions available in the playground.
10. RA80533 commented on Feb 21, 2024

    

    RA80533

    on Feb 21, 2024

    Last edited by RA80533

    More actions

    It appears that the expansion of the type includes [x: number]: number. Maybe I should open this a separate issue?

    Scott Moore (@scottwillmoore) Good observation. Once the index signature is removed, the tuple behaves as expected.

    // https://stackoverflow.com/a/66252656
    type RemoveIndex<T> = {
      [ K in keyof T as
        string extends K
        ? never
        : number extends K
        ? never
        : symbol extends K
        ? never
        : K
      ] : T[K];
    };
    
    // -snip-
    type PartialBrand<T, U> = RemoveIndex<T> & Partial<Id<U>>; // Also known as Flavor.
    //                        ^^^^^^^^^^^

    Playground link

    // -snip-
    type Point = PartialBrand<RemoveIndex<[number, number]>, typeof pointId>;
    //                        ^^^^^^^^^^^

    Playground link
11. Ryan Cavanaugh (RyanCavanaugh)

    added

    Domain: IntersectionIncorrect behavior under `T & U` constructsIncorrect behavior under `T & U` constructs

    on Oct 16, 2025