JSDoc recursive inference not working properly on generic array wrapping

🔎 Search Terms

"jsdoc", "recursive", "inference", "generic"

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about everything.

⏯ Playground Link

https://www.typescriptlang.org/play/?filetype=js#code/PQKhFgCgAIWgBALgUwLYAcA2BDF0DaAKtALzTYB2AngLpSzBQDGOAzq9AMrQDeUUASFARIA2AkRV0yXp2SIAPIQB8AX0ENBreQG5+o4Rrjx02AE7ZUs+UrXRtiI41FMA9hVaIzAVyaJXZgAUDgCUvIICiAAWAJasAHQOpPa6guqQguYWVIFhfKICZvLeZhTQFMgA7lyBFdVyiIH48S3RcYnyNPGo2OiBMShWJMoEA2g0IZM60MDA0EWIJR5cSvg0ayMARt6I0MgAHtJ+yAAmK4Qb0ACEN2lQ6VCGMMaDWLgyRMmUtPTGphZWHgNWyqFKOZ7ONweXasACCZmyyWC8jCw3CogWS3KVRqdS48iaLQ6iC6PT6YyGI3wFImUxmc0xpQ4nFWNBG2A4ByOKBO9x0QA

💻 Code

JS with JSDoc typing:

/**
 * @template [T = any]
 */
class S {

  /**
  * @type {Set<T>}
  */
  set;

  /**
  * @param {Set<T>} set
  */
  constructor(set) {
    this.set = set;
  }

  array() {
    return new S(new Set([...this.set].map(item => [item]))); // returns S<T[][]> but expected S<T[]> !!!
  }
}

/**
 * @template [T = any]
 * @param {Set<T>} set
 */
function sArray(set) {
  return new S(new Set([...set].map(item => [item]))); // returns S<T[]> as expected
};

TS version:

class S<T> {

  set: Set<T>;

  constructor(set: Set<T>) {
    this.set = set;
  }

  array() {
    return new S(new Set([...this.set].map(item => [item]))); // returns S<T[]> as expected
  }
}

function sArray<T>(set: Set<T>) {
  return new S(new Set([...set].map(item => [item]))); // returns S<T[]> as expected
};

Link to TS version: https://www.typescriptlang.org/play/?&filetype=ts#code/MYGwhgzhAEDKA8AVAfNA3gWAFDetCApgC4BccxSyA3NrtMAPYB2ERATgK7BENsAUhUuSKUAlOjp4iACwCWEAHSDoAXnzEaWPAF9aW6GDZswATz7jM+vG2Ic2TaEwIB3OHyevYxPgG0F-mXklYgBdBQBbMAAHPlkiAnDVVB84hJDRDKpoAHps6BsiOxY4JB8Q1EhoAgAPKIJuAgATOl0sVuwAMw4mbllmfABBI1NKAWIyLxEUCzoCoscXNw9hX39gojDImNTElWSd9MycvLn7GAREMoqYGrqG5raqIA

🙁 Actual behavior

In JSDoc types when a class with generic type T has a method that returns an instance of the same class but with the generic T[] it's return type will be inferred as T[][]. The same code written in plain TS will return the expected result.

🙂 Expected behavior

It's expected that the JSDoc version of the code has the same output as the TS version for the method that returns an instance of the class with generic wrapped in T[].

Additional information about the issue

No response

Start with the linked TypeScript Playground reproductions and compare the JSDoc and plain TypeScript versions of class S.array. Investigate generic inference for JSDoc-typed class methods returning a new instance, then verify that the JSDoc method infers S<T[]> rather than S<T[][]> while preserving the existing TypeScript behavior.