Go: Only output origin constraints for methods

Author: jketema

go/extractor/extractor.go

@@ -40,6 +40,8 @@ type typeParamParentEntry struct {
 
 var typeParamParent map[*types.TypeParam]typeParamParentEntry = make(map[*types.TypeParam]typeParamParentEntry)
 
+var typeParamOrigin map[*types.TypeParam]*types.TypeParam = make(map[*types.TypeParam]*types.TypeParam)
+
 func init() {
 	// this sets the number of threads that the Go runtime will spawn; this is separate
 	// from the number of goroutines that the program spawns, which are scheduled into
@@ -1658,29 +1660,8 @@ func extractType(tw *trap.Writer, tp types.Type) trap.Label {
 			for i := 0; i < origintp.NumMethods(); i++ {
 				meth := origintp.Method(i).Origin()
 				extractMethod(tw, meth)
+				populateTypeParamOrigin(tp, i, meth)
 
-				// Consider a generic struct and a generic method:
-				//
-				//   type S[P any] struct{}
-				//   func (*S[P]) m[Q any](x Q) {}
-				//
-				// If we have a variable 's' of type 'S[int]' and the expression
-				// 's.m[string]("")', then the type of the selector expression 's.m'
-				// is '	func(Q)'. The method 'm' here is an instantiation of the
-				// declaration, which has its own type with type parameter 'Q'.
-				// As we do not extract method instantiations, 'populateTypeParamParents'
-				// does not automatically get called for the type parameter 'Q'
-				// from the instantiation of 'm'. To compensate, we add the type
-				// parameters here.
-				//
-				// As a parent we use the origin method. This suffices, as the name
-				// and index of the type parameter in the instantiation will be
-				// identical to those of the uninstantiated method, and as only
-				// these two properties will be extracted for a type parameter.
-				if tp.Method(i) != meth {
-					signature := tp.Method(i).Type().(*types.Signature)
-					populateTypeParamParents(signature.TypeParams(), meth, false)
-				}
 			}
 
 			underlyingInterface, underlyingIsInterface := underlying.(*types.Interface)
@@ -1704,7 +1685,8 @@ func extractType(tw *trap.Writer, tp types.Type) trap.Label {
 		case *types.TypeParam:
 			kind = dbscheme.TypeParamType.Index()
 			parentlbl, isReceiverChild := getTypeParamParentLabel(tw, tp)
-			constraintLabel := extractType(tw, tp.Constraint())
+			constraint := getTypeParamOrigin(tp).Constraint()
+			constraintLabel := extractType(tw, constraint)
 			dbscheme.TypeParamTable.Emit(tw, lbl, tp.Obj().Name(), constraintLabel, parentlbl, tp.Index(), isReceiverChild)
 		case *types.Union:
 			kind = dbscheme.TypeSetLiteral.Index()
@@ -2121,3 +2103,48 @@ func checkObjectNotSpecialized(obj types.Object) {
 		}
 	}
 }
+
+// getTypeParamOrigin return the origin type param for a type param from
+// an instantiated method.
+func getTypeParamOrigin(tp *types.TypeParam) *types.TypeParam {
+	if origin, exists := typeParamOrigin[tp]; exists {
+		return origin
+	}
+	return tp
+}
+
+// populateTypeParamOrigin records for each type param of a method the type
+// param as it occurs in the source code. This allows us to record a unique
+// constraint as part of `typeparams`.
+//
+// Consider a generic struct and a generic method:
+//
+//	type S[P any] struct{}
+//	func (*S[P]) m[Q ~P](x Q) {}
+//
+// If we have a variable 's' of type 'S[int]' and the expression 's.m[int](42)',
+// then the type of the selector expression 's.m' is 'func[Q ~int](Q)'. The
+// method 'm' here is an instantiation of the declaration, which has its own
+// type with type parameter 'Q' with constraint 'interface { ~int }'. As we
+// so not extract method instantiations, but only their origins, we want to
+// match this behavior for the constraints of instantiations. To achieve this
+// function records a mapping between the type parameters from a method
+// instantiation and the type parameters from its origin.
+func populateTypeParamOrigin(tp *types.Named, i int, meth *types.Func) {
+	if tp.Method(i) == meth {
+		return
+	}
+
+	instantiatedParams := tp.Method(i).Type().(*types.Signature).TypeParams()
+	originParams := meth.Type().(*types.Signature).TypeParams()
+
+	if instantiatedParams.Len() != originParams.Len() {
+		log.Fatalf("Method instantiation %s has %d type parameters, origin has %d", tp.Method(i), instantiatedParams.Len(), originParams.Len())
+	}
+
+	for j := 0; j < instantiatedParams.Len(); j++ {
+		instantiatedParam := instantiatedParams.At(j)
+		setTypeParamParent(instantiatedParam, meth, false)
+		typeParamOrigin[instantiatedParam] = originParams.At(j)
+	}
+}

go/ql/test/library-tests/semmle/go/Function/TypeParamType.expected

@@ -55,8 +55,6 @@ numberOfTypeParameters
 | codeql-go-tests/function.StructForGenericMethod2.GenericMethod2 | 0 | from receiver | P3 | interface { } |
 | codeql-go-tests/function.StructWithDependentBound | 0 |  | P5 | interface { } |
 | codeql-go-tests/function.StructWithDependentBound.GenericMethodWithDependentBound | 0 |  | P7 | interface { ~[]P6 } |
-| codeql-go-tests/function.StructWithDependentBound.GenericMethodWithDependentBound | 0 |  | P7 | interface { ~[]int } |
-| codeql-go-tests/function.StructWithDependentBound.GenericMethodWithDependentBound | 0 |  | P7 | interface { ~[]string } |
 | codeql-go-tests/function.StructWithDependentBound.GenericMethodWithDependentBound | 0 | from receiver | P6 | interface { } |
 | codeql-go-tests/function.multipleAnonymousTypeParamsFunc | 0 |  | _ | interface { } |
 | codeql-go-tests/function.multipleAnonymousTypeParamsFunc | 1 |  | _ | interface { string } |