Body

I prefer to follow as many rules as possible without closing them, in order to better ensure the robustness of the code, so this discussion is based on the premise of not closing this rule.

When I enabled the strictTypeChecked rule and encountered this issue in a JSON parse function, There is codes:

function parseJSON<T>(str: string): T | null {
  try {
    return JSON.parse(str) as T | null
  } catch (err: unknown) {
    return null
  }
}

// usage
const data = parseJSON<User>(localStorage.getItem('key') || '')

If you want to follow the rules, you must use as to determine the type when calling the function:

function parseJSON(str: string): unknown {
  try {
    return JSON.parse(str)
  } catch (err: unknown) {
    return null
  }
}

// usage
const data = parseJSON(localStorage.getItem('key') || '') as User | null

However, it is not guaranteed that all developers will not miss | null when calling functions, so sometimes this code may appear:

const data = parseJSON(localStorage.getItem('key') || '') as User

Most importantly, the return value here may be null but ESLint cannot detect this type error.

So I wonder if it's possible to add some options or allow this case?

For example, when the return value extends a type parameter, it is not considered an error? In the above example, the type parameter T is only used once, but the function return value is modified to T | null is no longer considered an error at this time.

Additional Info

Any additional info...

Before you submit your discussion, please confirm the following. If any of these required steps are not taken, we may not be able to review your RFC. Help us to help you!

• I have read the discussions guidelines and per those guidelines, this fits a discussion category, not a help request or standard issue.
• I have searched for related discussions and searched for related issues and found none that match my proposal.
• I have read the FAQ and my problem is not listed.