From e633f343ba791e770c6a6c2f8ff3640d2e8ff079 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Tue, 2 Feb 2021 12:17:57 -0800 Subject: [dev.typeparams] cmd/compile: add OFUNCINST/OTYPEINST nodes for generic func/type instantiation Expresses things more clearly, especially in cases like 'f := min[int]' where we create a xsgeneric function instantiation, but don't immediately call it. min[int](2, 3) now looks like: . CALLFUNC tc(1) Use:1 int # min1.go:11 int . . FUNCINST tc(1) FUNC-func(int, int) int # min1.go:11 FUNC-func(int, int) int . . . NAME-main.min tc(1) Class:PFUNC Offset:0 Used FUNC-func[T](T, T) T # min1.go:3 . . FUNCINST-Targs . . . TYPE .int Offset:0 type int . CALLFUNC-Args . . LITERAL-2 tc(1) int # min1.go:11 . . LITERAL-3 tc(1) int # min1.go:11 Remove the targs parameter from ir.NewCallExpr(), not needed anymore, since type arguments are included in the FUNCINST. Change-Id: I23438b75288330475294d7ace239ba64acfa641e Reviewed-on: https://go-review.googlesource.com/c/go/+/288951 Run-TryBot: Dan Scales TryBot-Result: Go Bot Trust: Dan Scales Trust: Robert Griesemer Reviewed-by: Robert Griesemer --- src/cmd/compile/internal/noder/expr.go | 31 ++++++++++++++++++------------- 1 file changed, 18 insertions(+), 13 deletions(-) (limited to 'src/cmd/compile/internal/noder/expr.go') diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go index 41d54441d4..3c18bdcc24 100644 --- a/src/cmd/compile/internal/noder/expr.go +++ b/src/cmd/compile/internal/noder/expr.go @@ -99,23 +99,28 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node { } return Call(pos, g.typ(typ), g.expr(expr.Fun), g.exprs(expr.ArgList), expr.HasDots) case *syntax.IndexExpr: - var index ir.Node - - // We are using IndexExpr in two ways, as an standard index - // operation (with expression) and as a function/type - // instantiation (with a type list). We will soon make this - // clearer by having separate function/type instantiation nodes. + var targs []ir.Node if _, ok := expr.Index.(*syntax.ListExpr); ok { - // List of types for a generic function call or type instantiation - index = ir.NewListExpr(pos, g.exprList(expr.Index)) + targs = g.exprList(expr.Index) } else { - index = g.expr(expr.Index) - if index.Op() == ir.OTYPE { - // Single type for a generic function call or type instantiation - index = ir.NewListExpr(pos, []ir.Node{index}) + index := g.expr(expr.Index) + if index.Op() != ir.OTYPE { + // This is just a normal index expression + return Index(pos, g.expr(expr.X), index) } + // This is generic function instantiation with a single type + targs = []ir.Node{index} + } + // This is a generic function instantiation + x := g.expr(expr.X) + if x.Op() != ir.ONAME || x.Type().Kind() != types.TFUNC { + panic("Incorrect argument for generic func instantiation") } - return Index(pos, g.typ(typ), g.expr(expr.X), index) + // This could also be an OTYPEINST once we can handle those examples. + n := ir.NewInstExpr(pos, ir.OFUNCINST, x, targs) + typed(g.typ(typ), n) + return n + case *syntax.ParenExpr: return g.expr(expr.X) // skip parens; unneeded after parse+typecheck case *syntax.SelectorExpr: -- cgit v1.3