qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-22 20:40:03 -07:00
Code Releases Activity

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

Browse Source 
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>
This commit is contained in:
Robert Griesemer 2021-03-30 22:07:26 -07:00
parent 93466cc1b6
commit 3a30381b21
2 changed files with 10 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
src/cmd/compile/internal/types2/call.go
View File

@ -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 {

2
src/cmd/compile/internal/types2/typexpr.go
View File

@ -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