}
case ir.OXDOT:
- // Finish the transformation of an OXDOT, unless this was a
- // bound call (a direct call on a type param). A bound call
- // will be transformed during the dictPass. Otherwise, m
- // will be transformed to an OMETHVALUE node. It will be
- // transformed to an ODOTMETH or ODOTINTER node if we find in
- // the OCALL case below that the method value is actually
- // called.
+ // Finish the transformation of an OXDOT, unless this is
+ // bound call or field access on a type param. A bound call
+ // or field access on a type param will be transformed during
+ // the dictPass. Otherwise, m will be transformed to an
+ // OMETHVALUE node. It will be transformed to an ODOTMETH or
+ // ODOTINTER node if we find in the OCALL case below that the
+ // method value is actually called.
mse := m.(*ir.SelectorExpr)
if src := mse.X.Type(); !src.IsShape() {
transformDot(mse, false)
transformEarlyCall(call)
case ir.OXDOT:
- // This is the case of a bound call on a typeparam,
- // which will be handled in the dictPass.
- // As with OFUNCINST, we must transform the arguments of the call now,
- // so any needed CONVIFACE nodes are exposed.
+ // This is the case of a bound call or a field access
+ // on a typeparam, which will be handled in the
+ // dictPass. As with OFUNCINST, we must transform the
+ // arguments of the call now, so any needed CONVIFACE
+ // nodes are exposed.
transformEarlyCall(call)
case ir.ODOTTYPE, ir.ODOTTYPE2:
// No need for transformDot - buildClosure2 has already
// transformed to OCALLINTER/ODOTINTER.
} else {
- dst := info.dictInfo.shapeToBound[m.(*ir.SelectorExpr).X.Type()]
// If we can't find the selected method in the
// AllMethods of the bound, then this must be an access
// to a field of a structural type. If so, we skip the
// dictionary lookups - transformDot() will convert to
// the desired direct field access.
- if typecheck.Lookdot1(mse, mse.Sel, dst, dst.AllMethods(), 1) != nil {
+ if isBoundMethod(info.dictInfo, mse) {
+ dst := info.dictInfo.shapeToBound[mse.X.Type()]
// Implement x.M as a conversion-to-bound-interface
// 1) convert x to the bound interface
// 2) call M on that interface
info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: ce.X})
}
}
- if ce.X.Op() == ir.OXDOT &&
- isShapeDeref(ce.X.(*ir.SelectorExpr).X.Type()) {
+ // Note: this XDOT code is not actually needed as long as we
+ // continue to disable type parameters on RHS of type
+ // declarations (#45639).
+ if ce.X.Op() == ir.OXDOT {
callMap[ce.X] = true
- infoPrint(" Optional subdictionary at generic bound call: %v\n", n)
- info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: nil})
+ if isBoundMethod(info, ce.X.(*ir.SelectorExpr)) {
+ infoPrint(" Optional subdictionary at generic bound call: %v\n", n)
+ info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: nil})
+ }
}
case ir.OCALLMETH:
ce := n.(*ir.CallExpr)
info.itabConvs = append(info.itabConvs, n)
}
case ir.OXDOT:
- if n.(*ir.SelectorExpr).X.Type().IsShape() {
+ se := n.(*ir.SelectorExpr)
+ if isBoundMethod(info, se) {
infoPrint(" Itab for bound call: %v\n", n)
info.itabConvs = append(info.itabConvs, n)
}
info.dictLen = len(info.shapeParams) + len(info.derivedTypes) + len(info.subDictCalls) + len(info.itabConvs)
}
-// isShapeDeref returns true if t is either a shape or a pointer to a shape. (We
-// can't just use deref(t).IsShape(), since a shape type is a complex type and may
-// have a pointer as part of its shape.)
-func isShapeDeref(t *types.Type) bool {
- return t.IsShape() || t.IsPtr() && t.Elem().IsShape()
+// isBoundMethod returns true if the selection indicated by se is a bound method of
+// se.X. se.X must be a shape type (i.e. substituted directly from a type param). If
+// isBoundMethod returns false, then the selection must be a field access of a
+// structural type.
+func isBoundMethod(info *dictInfo, se *ir.SelectorExpr) bool {
+ bound := info.shapeToBound[se.X.Type()]
+ return typecheck.Lookdot1(se, se.Sel, bound, bound.AllMethods(), 1) != nil
}
// addType adds t to info.derivedTypes if it is parameterized type (which is not
--- /dev/null
+// run -gcflags=-G=3
+
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+)
+
+// Numeric expresses a type constraint satisfied by any numeric type.
+type Numeric interface {
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
+ ~int | ~int8 | ~int16 | ~int32 | ~int64 |
+ ~float32 | ~float64 |
+ ~complex64 | ~complex128
+}
+
+// Sum returns the sum of the provided arguments.
+func Sum[T Numeric](args ...T) T {
+ var sum T
+ for i := 0; i < len(args); i++ {
+ sum += args[i]
+ }
+ return sum
+}
+
+// Ledger is an identifiable, financial record.
+type Ledger[T ~string, K Numeric] struct {
+
+ // ID identifies the ledger.
+ ID T
+
+ // Amounts is a list of monies associated with this ledger.
+ Amounts []K
+
+ // SumFn is a function that can be used to sum the amounts
+ // in this ledger.
+ SumFn func(...K) K
+}
+
+func PrintLedger[
+ T ~string,
+ K Numeric,
+ L ~struct {
+ ID T
+ Amounts []K
+ SumFn func(...K) K
+ },
+](l L) {
+ fmt.Printf("%s has a sum of %v\n", l.ID, l.SumFn(l.Amounts...))
+}
+
+func main() {
+ PrintLedger(Ledger[string, int]{
+ ID: "fake",
+ Amounts: []int{1, 2, 3},
+ SumFn: Sum[int],
+ })
+}