[strict-boolean-expressions] False negative for generic parameters

[RunDevelopment]

• I have tried restarting my IDE and the issue persists.
• I have updated to the latest version of the packages.
• I have read the FAQ and my problem is not listed.

Repro

{
  "rules": {
    "@typescript-eslint/strict-boolean-expressions": "warn"
  }
}

function test<S>(): void {
	const foo = getEmptyArray<S>();
	if (foo.pop()) {
		throw new Error();
	}

	const bar = getEmptyArray<boolean>();
	if (bar.pop()) {
		throw new Error();
	}
}
function getEmptyArray<S>(): S[] {
	return [];
}

Expected Result

Both if (foo.pop()) and if (bar.pop()) should produce warnings. Both are potentially undefined and most likely not booleans. foo.pop() has the return type S | undefined and bar has number | undefined.

Actual Result

if (foo.pop()) does not produce a warning despite almost certainly not being a boolean.

I found that if the condition is a union with a type parameter (S | anything), then strict-boolean-expressions won't report anything. This is a problem because that means that the rule cannot check all conditions inside generic functions.

Additional Info

Versions

package	version
@typescript-eslint/eslint-plugin	4.28.4
@typescript-eslint/parser	4.23.0
TypeScript	4.2.4
ESLint	7.26.0
node	14.15.4

[bradzacher]

The rule sees the type S and doesn't know what type it is (because it's an unconstrained generic) - so it just treats it as if it were the object type.
So the return type of foo.pop() is essentially seen as object | undefined.

By the default configuration of the rule, allowNullableObject is turned on - meaning this case is ignored by the rule.

[RunDevelopment]

so it just treats it as if it were the object type.

That's a big assumption especially because allowNullableObject is enabled by default. I fixed a bug today that could have been prevented had had this rule not made that assumption.

allowNullableObject is too useful to disable. Could we add something like an option or setting to tell the rule to treat S as unknown instead?

[bradzacher]

I'd be happy if the rule were updated to do the following:

1. Before calling inspectVariantTypes (

   typescript-eslint/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts

   Line 229 in 84fff35

   const types = inspectVariantTypes(tsutils.unionTypeParts(type));

   ), run each type through checker.getBaseConstraintOfType in order to attempt to refine a generic type to its constraint.

2. In inspectVariantTypes. If one of the types is a generic param (the TypeFlags.TypeVariable flag is set) then handle it appropriately -- eg exclude it from this check, and push a new "variant type" to the set

3. add handling to checkNode so that it appropriately handles the new "variant type".

no need for an option or anything here, as I think this is just a logical improvement to the rule's logic.