SA4023, analysis/facts/typedness: with generics, MakeInterface can return untyped nil

Closes gh-1242

(cherry picked from commit e88e689)

Author: dominikh

analysis/facts/typedness/typedness.go

@@ -212,6 +212,15 @@ func impl(pass *analysis.Pass, fn *ir.Function, seenFns map[*ir.Function]struct{
 			}
 			return true
 		case *ir.MakeInterface:
+			terms, err := typeparams.NormalTerms(v.X.Type())
+			if len(terms) == 0 || err != nil {
+				// Type is a type parameter with no type terms (or we couldn't determine the terms). Such a type
+				// _can_ be nil when put in an interface value.
+				//
+				// There is no instruction that can create a guaranteed non-nil instance of a type parameter without
+				// type constraints, so we return false right away, without checking v.X's typedness.
+				return false
+			}
 			return true
 		case *ir.TypeAssert:
 			// type assertions fail for untyped nils. Either we have a

staticcheck/lint.go

@@ -4592,6 +4592,14 @@ func CheckTypedNilInterface(pass *analysis.Pass) (interface{}, error) {
 					default:
 						panic("unreachable")
 					}
+
+					terms, err := typeparams.NormalTerms(x.X.Type())
+					if len(terms) == 0 || err != nil {
+						// Type is a type parameter with no type terms (or we couldn't determine the terms). Such a type
+						// _can_ be nil when put in an interface value.
+						continue
+					}
+
 					if report.HasRange(x.X) {
 						report.Report(pass, binop, fmt.Sprintf("this comparison is %s true", qualifier),
 							report.Related(x.X, "the lhs of the comparison gets its value from here and has a concrete type"))

staticcheck/testdata/src/CheckTypedNilInterface/CheckTypedNilInterface.go

@@ -207,4 +207,7 @@ func test() {
 
 	var v1 interface{} = 0
 	_ = v1 == nil // want `never true; the lhs`
+
+	_ = any((*int)(nil)) == nil // want `never true`
+	_ = any((error)(nil)) == nil
 }

staticcheck/testdata/src/CheckTypedNilInterface/generics.go

@@ -2,11 +2,42 @@
 
 package pkg
 
-func foo[T *int,]() T {
+func tpgen1[T *int,]() T {
 	return (T)(nil)
 }
 
 func bar() {
-	if foo() == nil {
+	if tpgen1() == nil {
 	}
 }
+
+func tpfn1[T any](x T) {
+	if any(x) == nil {
+		// this is entirely possible if baz is instantiated with an interface type for T. For example: baz[error](nil)
+	}
+}
+
+func tpfn2[T ~int](x T) {
+	if any(x) == nil { // want `this comparison is never true`
+		// this is not possible, because T only accepts concrete types
+	}
+}
+
+func tpgen3[T any](x T) any {
+	return any(x)
+}
+
+func tpgen4[T ~*int](x T) any {
+	return any(x)
+}
+
+func tptest() {
+	_ = tpgen1() == nil
+
+	_ = tpgen3[error](nil) == nil
+
+	// ideally we'd flag this, but the analysis is generic-insensitive at the moment.
+	_ = tpgen3[*int](nil) == nil
+
+	_ = tpgen4[*int](nil) == nil // want `never true`
+}