cmd/compile/internal/types2: simplify Checker.funcInst

Now that we use square brackets for instantiations, we
can tell type arguments from ordinary arguments without
"guessing" which permits a simpler implementation.

While at it, also fix a minor position error for type
instantiations (now matching the code for function
instantiations).

Change-Id: I20eca51c5b06259703767b5906e89197d6cd595a
Reviewed-on: https://go-review.googlesource.com/c/go/+/306169
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 18737e45a032411a2b259012b5cd4a64f34be303..38e901524891303023bd7fc9b609052901ee76fd 100644 (file)
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -15,39 +15,29 @@ import (
 // funcInst type-checks a function instantiaton inst and returns the result in x.
 // The operand x must be the evaluation of inst.X and its type must be a signature.
 func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
-       args, ok := check.exprOrTypeList(unpackExpr(inst.Index))
-       if !ok {
+       xlist := unpackExpr(inst.Index)
+       targs := check.typeList(xlist)
+       if targs == nil {
                x.mode = invalid
                x.expr = inst
                return
        }
-       if len(args) > 0 && args[0].mode != typexpr {
-               check.errorf(args[0], "%s is not a type", args[0])
-               ok = false
-       }
+       assert(len(targs) == len(xlist))
 
        // check number of type arguments
-       n := len(args)
+       n := len(targs)
        sig := x.typ.(*Signature)
        if !check.conf.InferFromConstraints && n != len(sig.tparams) || n > len(sig.tparams) {
-               check.errorf(args[n-1], "got %d type arguments but want %d", n, len(sig.tparams))
+               check.errorf(xlist[n-1], "got %d type arguments but want %d", n, len(sig.tparams))
                x.mode = invalid
                x.expr = inst
                return
        }
 
-       // collect types
-       targs := make([]Type, n)
+       // determine argument positions (for error reporting)
        poslist := make([]syntax.Pos, n)
-       for i, a := range args {
-               if a.mode != typexpr {
-                       // error was reported earlier
-                       x.mode = invalid
-                       x.expr = inst
-                       return
-               }
-               targs[i] = a.typ
-               poslist[i] = a.Pos()
+       for i, x := range xlist {
+               poslist[i] = syntax.StartPos(x)
        }
 
        // if we don't have enough type arguments, use constraint type inference
@@ -82,14 +72,6 @@ func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
        assert(n == len(sig.tparams))
 
        // instantiate function signature
-       for i, typ := range targs {
-               // some positions may be missing if types are inferred
-               var pos syntax.Pos
-               if i < len(poslist) {
-                       pos = poslist[i]
-               }
-               check.ordinaryType(pos, typ)
-       }
        res := check.instantiate(x.Pos(), sig, targs, poslist).(*Signature)
        assert(res.tparams == nil) // signature is not generic anymore
        if inferred {

diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index f116461403d140d59ba025ed678beaee50630382..ce2fd7797b957648d6b0db6a20ee92219a0899f0 100644 (file)
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -671,7 +671,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targs []syntax.Expr, def *
        // determine argument positions (for error reporting)
        typ.poslist = make([]syntax.Pos, len(targs))
        for i, arg := range targs {
-               typ.poslist[i] = arg.Pos()
+               typ.poslist[i] = syntax.StartPos(arg)
        }
 
        // make sure we check instantiation works at least once