mirror of
https://github.com/golang/go.git
synced 2024-09-22 02:48:50 +00:00
cmd/compile/internal/ir: remove unused -G=0 node types
ir.PkgName was only used by the old -G=0 frontend for representing identifiers that refer to a package name. The new types2-based frontends directly resolve the qualified identifier to the respective object during IR construction. Similarly, most of the ir.*Type nodes were only needed for representing types in the IR prior to type checking. The new types2-based frontends directly construct the corresponding types.Type instead. Exception: The internal typecheck.DeclFunc API used for compiler-generated functions still depends on ir.FuncType, so that IR node type is retained for now. (Eventually, we should update typecheck.DeclFunc and callers to not depend on it, but it's not urgent.) Change-Id: I982f1bbd41eef5b42ce0f32676c7dc4a8ab6d0ee Reviewed-on: https://go-review.googlesource.com/c/go/+/388538 Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Trust: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Keith Randall <khr@golang.org>
This commit is contained in:
Matthew Dempsky
parent
0fcb94895f
commit
d6d2ebb7b8
@ -79,7 +79,7 @@ func DeepCopy(pos src.XPos, n Node) Node {
|
||||
var edit func(Node) Node
|
||||
edit = func(x Node) Node {
|
||||
switch x.Op() {
|
||||
case OPACK, ONAME, ONONAME, OLITERAL, ONIL, OTYPE:
|
||||
case ONAME, ONONAME, OLITERAL, ONIL, OTYPE:
|
||||
return x
|
||||
}
|
||||
x = Copy(x)
|
||||
|
||||
@ -202,7 +202,6 @@ var OpPrec = []int{
|
||||
ONIL: 8,
|
||||
ONONAME: 8,
|
||||
OOFFSETOF: 8,
|
||||
OPACK: 8,
|
||||
OPANIC: 8,
|
||||
OPAREN: 8,
|
||||
OPRINTN: 8,
|
||||
@ -213,13 +212,7 @@ var OpPrec = []int{
|
||||
OSTR2BYTES: 8,
|
||||
OSTR2RUNES: 8,
|
||||
OSTRUCTLIT: 8,
|
||||
OTARRAY: 8,
|
||||
OTSLICE: 8,
|
||||
OTCHAN: 8,
|
||||
OTFUNC: 8,
|
||||
OTINTER: 8,
|
||||
OTMAP: 8,
|
||||
OTSTRUCT: 8,
|
||||
OTYPE: 8,
|
||||
OUNSAFEADD: 8,
|
||||
OUNSAFESLICE: 8,
|
||||
@ -640,7 +633,7 @@ func exprFmt(n Node, s fmt.State, prec int) {
|
||||
return
|
||||
}
|
||||
fallthrough
|
||||
case OPACK, ONONAME:
|
||||
case ONONAME:
|
||||
fmt.Fprint(s, n.Sym())
|
||||
|
||||
case OLINKSYMOFFSET:
|
||||
@ -654,49 +647,6 @@ func exprFmt(n Node, s fmt.State, prec int) {
|
||||
}
|
||||
fmt.Fprintf(s, "%v", n.Type())
|
||||
|
||||
case OTSLICE:
|
||||
n := n.(*SliceType)
|
||||
if n.DDD {
|
||||
fmt.Fprintf(s, "...%v", n.Elem)
|
||||
} else {
|
||||
fmt.Fprintf(s, "[]%v", n.Elem) // happens before typecheck
|
||||
}
|
||||
|
||||
case OTARRAY:
|
||||
n := n.(*ArrayType)
|
||||
if n.Len == nil {
|
||||
fmt.Fprintf(s, "[...]%v", n.Elem)
|
||||
} else {
|
||||
fmt.Fprintf(s, "[%v]%v", n.Len, n.Elem)
|
||||
}
|
||||
|
||||
case OTMAP:
|
||||
n := n.(*MapType)
|
||||
fmt.Fprintf(s, "map[%v]%v", n.Key, n.Elem)
|
||||
|
||||
case OTCHAN:
|
||||
n := n.(*ChanType)
|
||||
switch n.Dir {
|
||||
case types.Crecv:
|
||||
fmt.Fprintf(s, "<-chan %v", n.Elem)
|
||||
|
||||
case types.Csend:
|
||||
fmt.Fprintf(s, "chan<- %v", n.Elem)
|
||||
|
||||
default:
|
||||
if n.Elem != nil && n.Elem.Op() == OTCHAN && n.Elem.(*ChanType).Dir == types.Crecv {
|
||||
fmt.Fprintf(s, "chan (%v)", n.Elem)
|
||||
} else {
|
||||
fmt.Fprintf(s, "chan %v", n.Elem)
|
||||
}
|
||||
}
|
||||
|
||||
case OTSTRUCT:
|
||||
fmt.Fprint(s, "<struct>")
|
||||
|
||||
case OTINTER:
|
||||
fmt.Fprint(s, "<inter>")
|
||||
|
||||
case OTFUNC:
|
||||
fmt.Fprint(s, "<func>")
|
||||
|
||||
|
||||
@ -48,7 +48,6 @@ type Name struct {
|
||||
Opt interface{} // for use by escape analysis
|
||||
Embed *[]Embed // list of embedded files, for ONAME var
|
||||
|
||||
PkgName *PkgName // real package for import . names
|
||||
// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
|
||||
// For a closure var, the ONAME node of the outer captured variable.
|
||||
// For the case-local variables of a type switch, the type switch guard (OTYPESW).
|
||||
@ -536,22 +535,3 @@ type Embed struct {
|
||||
Pos src.XPos
|
||||
Patterns []string
|
||||
}
|
||||
|
||||
// A Pack is an identifier referring to an imported package.
|
||||
type PkgName struct {
|
||||
miniNode
|
||||
sym *types.Sym
|
||||
Pkg *types.Pkg
|
||||
Used bool
|
||||
}
|
||||
|
||||
func (p *PkgName) Sym() *types.Sym { return p.sym }
|
||||
|
||||
func (*PkgName) CanBeNtype() {}
|
||||
|
||||
func NewPkgName(pos src.XPos, sym *types.Sym, pkg *types.Pkg) *PkgName {
|
||||
p := &PkgName{sym: sym, Pkg: pkg}
|
||||
p.op = OPACK
|
||||
p.pos = pos
|
||||
return p
|
||||
}
|
||||
|
||||
@ -118,7 +118,6 @@ const (
|
||||
// Also used for a qualified package identifier that hasn't been resolved yet.
|
||||
ONONAME
|
||||
OTYPE // type name
|
||||
OPACK // import
|
||||
OLITERAL // literal
|
||||
ONIL // nil
|
||||
|
||||
@ -291,15 +290,10 @@ const (
|
||||
OFUNCINST // instantiation of a generic function
|
||||
|
||||
// types
|
||||
OTCHAN // chan int
|
||||
OTMAP // map[string]int
|
||||
OTSTRUCT // struct{}
|
||||
OTINTER // interface{}
|
||||
// OTFUNC: func() - Recv is receiver field, Params is list of param fields, Results is
|
||||
// list of result fields.
|
||||
// TODO(mdempsky): Remove.
|
||||
OTFUNC
|
||||
OTARRAY // [8]int or [...]int
|
||||
OTSLICE // []int
|
||||
|
||||
// misc
|
||||
// intermediate representation of an inlined call. Uses Init (assignments
|
||||
@ -533,7 +527,7 @@ func HasNamedResults(fn *Func) bool {
|
||||
// their usage position.
|
||||
func HasUniquePos(n Node) bool {
|
||||
switch n.Op() {
|
||||
case ONAME, OPACK:
|
||||
case ONAME:
|
||||
return false
|
||||
case OLITERAL, ONIL, OTYPE:
|
||||
if n.Sym() != nil {
|
||||
|
||||
@ -59,29 +59,6 @@ func (n *AddrExpr) editChildren(edit func(Node) Node) {
|
||||
}
|
||||
}
|
||||
|
||||
func (n *ArrayType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *ArrayType) copy() Node {
|
||||
c := *n
|
||||
return &c
|
||||
}
|
||||
func (n *ArrayType) doChildren(do func(Node) bool) bool {
|
||||
if n.Len != nil && do(n.Len) {
|
||||
return true
|
||||
}
|
||||
if n.Elem != nil && do(n.Elem) {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
func (n *ArrayType) editChildren(edit func(Node) Node) {
|
||||
if n.Len != nil {
|
||||
n.Len = edit(n.Len).(Node)
|
||||
}
|
||||
if n.Elem != nil {
|
||||
n.Elem = edit(n.Elem).(Ntype)
|
||||
}
|
||||
}
|
||||
|
||||
func (n *AssignListStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *AssignListStmt) copy() Node {
|
||||
c := *n
|
||||
@ -309,23 +286,6 @@ func (n *CaseClause) editChildren(edit func(Node) Node) {
|
||||
editNodes(n.Body, edit)
|
||||
}
|
||||
|
||||
func (n *ChanType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *ChanType) copy() Node {
|
||||
c := *n
|
||||
return &c
|
||||
}
|
||||
func (n *ChanType) doChildren(do func(Node) bool) bool {
|
||||
if n.Elem != nil && do(n.Elem) {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
func (n *ChanType) editChildren(edit func(Node) Node) {
|
||||
if n.Elem != nil {
|
||||
n.Elem = edit(n.Elem).(Ntype)
|
||||
}
|
||||
}
|
||||
|
||||
func (n *ClosureExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *ClosureExpr) copy() Node {
|
||||
c := *n
|
||||
@ -752,22 +712,6 @@ func (n *InstExpr) editChildren(edit func(Node) Node) {
|
||||
editNodes(n.Targs, edit)
|
||||
}
|
||||
|
||||
func (n *InterfaceType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *InterfaceType) copy() Node {
|
||||
c := *n
|
||||
c.Methods = copyFields(c.Methods)
|
||||
return &c
|
||||
}
|
||||
func (n *InterfaceType) doChildren(do func(Node) bool) bool {
|
||||
if doFields(n.Methods, do) {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
func (n *InterfaceType) editChildren(edit func(Node) Node) {
|
||||
editFields(n.Methods, edit)
|
||||
}
|
||||
|
||||
func (n *KeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *KeyExpr) copy() Node {
|
||||
c := *n
|
||||
@ -884,29 +828,6 @@ func (n *MakeExpr) editChildren(edit func(Node) Node) {
|
||||
}
|
||||
}
|
||||
|
||||
func (n *MapType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *MapType) copy() Node {
|
||||
c := *n
|
||||
return &c
|
||||
}
|
||||
func (n *MapType) doChildren(do func(Node) bool) bool {
|
||||
if n.Key != nil && do(n.Key) {
|
||||
return true
|
||||
}
|
||||
if n.Elem != nil && do(n.Elem) {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
func (n *MapType) editChildren(edit func(Node) Node) {
|
||||
if n.Key != nil {
|
||||
n.Key = edit(n.Key).(Ntype)
|
||||
}
|
||||
if n.Elem != nil {
|
||||
n.Elem = edit(n.Elem).(Ntype)
|
||||
}
|
||||
}
|
||||
|
||||
func (n *Name) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
|
||||
func (n *NilExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
@ -947,17 +868,6 @@ func (n *ParenExpr) editChildren(edit func(Node) Node) {
|
||||
}
|
||||
}
|
||||
|
||||
func (n *PkgName) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *PkgName) copy() Node {
|
||||
c := *n
|
||||
return &c
|
||||
}
|
||||
func (n *PkgName) doChildren(do func(Node) bool) bool {
|
||||
return false
|
||||
}
|
||||
func (n *PkgName) editChildren(edit func(Node) Node) {
|
||||
}
|
||||
|
||||
func (n *RangeStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *RangeStmt) copy() Node {
|
||||
c := *n
|
||||
@ -1212,23 +1122,6 @@ func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
|
||||
}
|
||||
}
|
||||
|
||||
func (n *SliceType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *SliceType) copy() Node {
|
||||
c := *n
|
||||
return &c
|
||||
}
|
||||
func (n *SliceType) doChildren(do func(Node) bool) bool {
|
||||
if n.Elem != nil && do(n.Elem) {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
func (n *SliceType) editChildren(edit func(Node) Node) {
|
||||
if n.Elem != nil {
|
||||
n.Elem = edit(n.Elem).(Ntype)
|
||||
}
|
||||
}
|
||||
|
||||
func (n *StarExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *StarExpr) copy() Node {
|
||||
c := *n
|
||||
@ -1273,22 +1166,6 @@ func (n *StructKeyExpr) editChildren(edit func(Node) Node) {
|
||||
}
|
||||
}
|
||||
|
||||
func (n *StructType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *StructType) copy() Node {
|
||||
c := *n
|
||||
c.Fields = copyFields(c.Fields)
|
||||
return &c
|
||||
}
|
||||
func (n *StructType) doChildren(do func(Node) bool) bool {
|
||||
if doFields(n.Fields, do) {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
func (n *StructType) editChildren(edit func(Node) Node) {
|
||||
editFields(n.Fields, edit)
|
||||
}
|
||||
|
||||
func (n *SwitchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
|
||||
func (n *SwitchStmt) copy() Node {
|
||||
c := *n
|
||||
|
||||
@ -12,169 +12,162 @@ func _() {
|
||||
_ = x[ONAME-1]
|
||||
_ = x[ONONAME-2]
|
||||
_ = x[OTYPE-3]
|
||||
_ = x[OPACK-4]
|
||||
_ = x[OLITERAL-5]
|
||||
_ = x[ONIL-6]
|
||||
_ = x[OADD-7]
|
||||
_ = x[OSUB-8]
|
||||
_ = x[OOR-9]
|
||||
_ = x[OXOR-10]
|
||||
_ = x[OADDSTR-11]
|
||||
_ = x[OADDR-12]
|
||||
_ = x[OANDAND-13]
|
||||
_ = x[OAPPEND-14]
|
||||
_ = x[OBYTES2STR-15]
|
||||
_ = x[OBYTES2STRTMP-16]
|
||||
_ = x[ORUNES2STR-17]
|
||||
_ = x[OSTR2BYTES-18]
|
||||
_ = x[OSTR2BYTESTMP-19]
|
||||
_ = x[OSTR2RUNES-20]
|
||||
_ = x[OSLICE2ARRPTR-21]
|
||||
_ = x[OAS-22]
|
||||
_ = x[OAS2-23]
|
||||
_ = x[OAS2DOTTYPE-24]
|
||||
_ = x[OAS2FUNC-25]
|
||||
_ = x[OAS2MAPR-26]
|
||||
_ = x[OAS2RECV-27]
|
||||
_ = x[OASOP-28]
|
||||
_ = x[OCALL-29]
|
||||
_ = x[OCALLFUNC-30]
|
||||
_ = x[OCALLMETH-31]
|
||||
_ = x[OCALLINTER-32]
|
||||
_ = x[OCAP-33]
|
||||
_ = x[OCLOSE-34]
|
||||
_ = x[OCLOSURE-35]
|
||||
_ = x[OCOMPLIT-36]
|
||||
_ = x[OMAPLIT-37]
|
||||
_ = x[OSTRUCTLIT-38]
|
||||
_ = x[OARRAYLIT-39]
|
||||
_ = x[OSLICELIT-40]
|
||||
_ = x[OPTRLIT-41]
|
||||
_ = x[OCONV-42]
|
||||
_ = x[OCONVIFACE-43]
|
||||
_ = x[OCONVIDATA-44]
|
||||
_ = x[OCONVNOP-45]
|
||||
_ = x[OCOPY-46]
|
||||
_ = x[ODCL-47]
|
||||
_ = x[ODCLFUNC-48]
|
||||
_ = x[ODCLCONST-49]
|
||||
_ = x[ODCLTYPE-50]
|
||||
_ = x[ODELETE-51]
|
||||
_ = x[ODOT-52]
|
||||
_ = x[ODOTPTR-53]
|
||||
_ = x[ODOTMETH-54]
|
||||
_ = x[ODOTINTER-55]
|
||||
_ = x[OXDOT-56]
|
||||
_ = x[ODOTTYPE-57]
|
||||
_ = x[ODOTTYPE2-58]
|
||||
_ = x[OEQ-59]
|
||||
_ = x[ONE-60]
|
||||
_ = x[OLT-61]
|
||||
_ = x[OLE-62]
|
||||
_ = x[OGE-63]
|
||||
_ = x[OGT-64]
|
||||
_ = x[ODEREF-65]
|
||||
_ = x[OINDEX-66]
|
||||
_ = x[OINDEXMAP-67]
|
||||
_ = x[OKEY-68]
|
||||
_ = x[OSTRUCTKEY-69]
|
||||
_ = x[OLEN-70]
|
||||
_ = x[OMAKE-71]
|
||||
_ = x[OMAKECHAN-72]
|
||||
_ = x[OMAKEMAP-73]
|
||||
_ = x[OMAKESLICE-74]
|
||||
_ = x[OMAKESLICECOPY-75]
|
||||
_ = x[OMUL-76]
|
||||
_ = x[ODIV-77]
|
||||
_ = x[OMOD-78]
|
||||
_ = x[OLSH-79]
|
||||
_ = x[ORSH-80]
|
||||
_ = x[OAND-81]
|
||||
_ = x[OANDNOT-82]
|
||||
_ = x[ONEW-83]
|
||||
_ = x[ONOT-84]
|
||||
_ = x[OBITNOT-85]
|
||||
_ = x[OPLUS-86]
|
||||
_ = x[ONEG-87]
|
||||
_ = x[OOROR-88]
|
||||
_ = x[OPANIC-89]
|
||||
_ = x[OPRINT-90]
|
||||
_ = x[OPRINTN-91]
|
||||
_ = x[OPAREN-92]
|
||||
_ = x[OSEND-93]
|
||||
_ = x[OSLICE-94]
|
||||
_ = x[OSLICEARR-95]
|
||||
_ = x[OSLICESTR-96]
|
||||
_ = x[OSLICE3-97]
|
||||
_ = x[OSLICE3ARR-98]
|
||||
_ = x[OSLICEHEADER-99]
|
||||
_ = x[ORECOVER-100]
|
||||
_ = x[ORECOVERFP-101]
|
||||
_ = x[ORECV-102]
|
||||
_ = x[ORUNESTR-103]
|
||||
_ = x[OSELRECV2-104]
|
||||
_ = x[OIOTA-105]
|
||||
_ = x[OREAL-106]
|
||||
_ = x[OIMAG-107]
|
||||
_ = x[OCOMPLEX-108]
|
||||
_ = x[OALIGNOF-109]
|
||||
_ = x[OOFFSETOF-110]
|
||||
_ = x[OSIZEOF-111]
|
||||
_ = x[OUNSAFEADD-112]
|
||||
_ = x[OUNSAFESLICE-113]
|
||||
_ = x[OMETHEXPR-114]
|
||||
_ = x[OMETHVALUE-115]
|
||||
_ = x[OBLOCK-116]
|
||||
_ = x[OBREAK-117]
|
||||
_ = x[OCASE-118]
|
||||
_ = x[OCONTINUE-119]
|
||||
_ = x[ODEFER-120]
|
||||
_ = x[OFALL-121]
|
||||
_ = x[OFOR-122]
|
||||
_ = x[OFORUNTIL-123]
|
||||
_ = x[OGOTO-124]
|
||||
_ = x[OIF-125]
|
||||
_ = x[OLABEL-126]
|
||||
_ = x[OGO-127]
|
||||
_ = x[ORANGE-128]
|
||||
_ = x[ORETURN-129]
|
||||
_ = x[OSELECT-130]
|
||||
_ = x[OSWITCH-131]
|
||||
_ = x[OTYPESW-132]
|
||||
_ = x[OFUNCINST-133]
|
||||
_ = x[OTCHAN-134]
|
||||
_ = x[OTMAP-135]
|
||||
_ = x[OTSTRUCT-136]
|
||||
_ = x[OTINTER-137]
|
||||
_ = x[OTFUNC-138]
|
||||
_ = x[OTARRAY-139]
|
||||
_ = x[OTSLICE-140]
|
||||
_ = x[OINLCALL-141]
|
||||
_ = x[OEFACE-142]
|
||||
_ = x[OITAB-143]
|
||||
_ = x[OIDATA-144]
|
||||
_ = x[OSPTR-145]
|
||||
_ = x[OCFUNC-146]
|
||||
_ = x[OCHECKNIL-147]
|
||||
_ = x[OVARDEF-148]
|
||||
_ = x[OVARKILL-149]
|
||||
_ = x[OVARLIVE-150]
|
||||
_ = x[ORESULT-151]
|
||||
_ = x[OINLMARK-152]
|
||||
_ = x[OLINKSYMOFFSET-153]
|
||||
_ = x[ODYNAMICDOTTYPE-154]
|
||||
_ = x[ODYNAMICDOTTYPE2-155]
|
||||
_ = x[ODYNAMICTYPE-156]
|
||||
_ = x[OTAILCALL-157]
|
||||
_ = x[OGETG-158]
|
||||
_ = x[OGETCALLERPC-159]
|
||||
_ = x[OGETCALLERSP-160]
|
||||
_ = x[OEND-161]
|
||||
_ = x[OLITERAL-4]
|
||||
_ = x[ONIL-5]
|
||||
_ = x[OADD-6]
|
||||
_ = x[OSUB-7]
|
||||
_ = x[OOR-8]
|
||||
_ = x[OXOR-9]
|
||||
_ = x[OADDSTR-10]
|
||||
_ = x[OADDR-11]
|
||||
_ = x[OANDAND-12]
|
||||
_ = x[OAPPEND-13]
|
||||
_ = x[OBYTES2STR-14]
|
||||
_ = x[OBYTES2STRTMP-15]
|
||||
_ = x[ORUNES2STR-16]
|
||||
_ = x[OSTR2BYTES-17]
|
||||
_ = x[OSTR2BYTESTMP-18]
|
||||
_ = x[OSTR2RUNES-19]
|
||||
_ = x[OSLICE2ARRPTR-20]
|
||||
_ = x[OAS-21]
|
||||
_ = x[OAS2-22]
|
||||
_ = x[OAS2DOTTYPE-23]
|
||||
_ = x[OAS2FUNC-24]
|
||||
_ = x[OAS2MAPR-25]
|
||||
_ = x[OAS2RECV-26]
|
||||
_ = x[OASOP-27]
|
||||
_ = x[OCALL-28]
|
||||
_ = x[OCALLFUNC-29]
|
||||
_ = x[OCALLMETH-30]
|
||||
_ = x[OCALLINTER-31]
|
||||
_ = x[OCAP-32]
|
||||
_ = x[OCLOSE-33]
|
||||
_ = x[OCLOSURE-34]
|
||||
_ = x[OCOMPLIT-35]
|
||||
_ = x[OMAPLIT-36]
|
||||
_ = x[OSTRUCTLIT-37]
|
||||
_ = x[OARRAYLIT-38]
|
||||
_ = x[OSLICELIT-39]
|
||||
_ = x[OPTRLIT-40]
|
||||
_ = x[OCONV-41]
|
||||
_ = x[OCONVIFACE-42]
|
||||
_ = x[OCONVIDATA-43]
|
||||
_ = x[OCONVNOP-44]
|
||||
_ = x[OCOPY-45]
|
||||
_ = x[ODCL-46]
|
||||
_ = x[ODCLFUNC-47]
|
||||
_ = x[ODCLCONST-48]
|
||||
_ = x[ODCLTYPE-49]
|
||||
_ = x[ODELETE-50]
|
||||
_ = x[ODOT-51]
|
||||
_ = x[ODOTPTR-52]
|
||||
_ = x[ODOTMETH-53]
|
||||
_ = x[ODOTINTER-54]
|
||||
_ = x[OXDOT-55]
|
||||
_ = x[ODOTTYPE-56]
|
||||
_ = x[ODOTTYPE2-57]
|
||||
_ = x[OEQ-58]
|
||||
_ = x[ONE-59]
|
||||
_ = x[OLT-60]
|
||||
_ = x[OLE-61]
|
||||
_ = x[OGE-62]
|
||||
_ = x[OGT-63]
|
||||
_ = x[ODEREF-64]
|
||||
_ = x[OINDEX-65]
|
||||
_ = x[OINDEXMAP-66]
|
||||
_ = x[OKEY-67]
|
||||
_ = x[OSTRUCTKEY-68]
|
||||
_ = x[OLEN-69]
|
||||
_ = x[OMAKE-70]
|
||||
_ = x[OMAKECHAN-71]
|
||||
_ = x[OMAKEMAP-72]
|
||||
_ = x[OMAKESLICE-73]
|
||||
_ = x[OMAKESLICECOPY-74]
|
||||
_ = x[OMUL-75]
|
||||
_ = x[ODIV-76]
|
||||
_ = x[OMOD-77]
|
||||
_ = x[OLSH-78]
|
||||
_ = x[ORSH-79]
|
||||
_ = x[OAND-80]
|
||||
_ = x[OANDNOT-81]
|
||||
_ = x[ONEW-82]
|
||||
_ = x[ONOT-83]
|
||||
_ = x[OBITNOT-84]
|
||||
_ = x[OPLUS-85]
|
||||
_ = x[ONEG-86]
|
||||
_ = x[OOROR-87]
|
||||
_ = x[OPANIC-88]
|
||||
_ = x[OPRINT-89]
|
||||
_ = x[OPRINTN-90]
|
||||
_ = x[OPAREN-91]
|
||||
_ = x[OSEND-92]
|
||||
_ = x[OSLICE-93]
|
||||
_ = x[OSLICEARR-94]
|
||||
_ = x[OSLICESTR-95]
|
||||
_ = x[OSLICE3-96]
|
||||
_ = x[OSLICE3ARR-97]
|
||||
_ = x[OSLICEHEADER-98]
|
||||
_ = x[ORECOVER-99]
|
||||
_ = x[ORECOVERFP-100]
|
||||
_ = x[ORECV-101]
|
||||
_ = x[ORUNESTR-102]
|
||||
_ = x[OSELRECV2-103]
|
||||
_ = x[OIOTA-104]
|
||||
_ = x[OREAL-105]
|
||||
_ = x[OIMAG-106]
|
||||
_ = x[OCOMPLEX-107]
|
||||
_ = x[OALIGNOF-108]
|
||||
_ = x[OOFFSETOF-109]
|
||||
_ = x[OSIZEOF-110]
|
||||
_ = x[OUNSAFEADD-111]
|
||||
_ = x[OUNSAFESLICE-112]
|
||||
_ = x[OMETHEXPR-113]
|
||||
_ = x[OMETHVALUE-114]
|
||||
_ = x[OBLOCK-115]
|
||||
_ = x[OBREAK-116]
|
||||
_ = x[OCASE-117]
|
||||
_ = x[OCONTINUE-118]
|
||||
_ = x[ODEFER-119]
|
||||
_ = x[OFALL-120]
|
||||
_ = x[OFOR-121]
|
||||
_ = x[OFORUNTIL-122]
|
||||
_ = x[OGOTO-123]
|
||||
_ = x[OIF-124]
|
||||
_ = x[OLABEL-125]
|
||||
_ = x[OGO-126]
|
||||
_ = x[ORANGE-127]
|
||||
_ = x[ORETURN-128]
|
||||
_ = x[OSELECT-129]
|
||||
_ = x[OSWITCH-130]
|
||||
_ = x[OTYPESW-131]
|
||||
_ = x[OFUNCINST-132]
|
||||
_ = x[OTFUNC-133]
|
||||
_ = x[OINLCALL-134]
|
||||
_ = x[OEFACE-135]
|
||||
_ = x[OITAB-136]
|
||||
_ = x[OIDATA-137]
|
||||
_ = x[OSPTR-138]
|
||||
_ = x[OCFUNC-139]
|
||||
_ = x[OCHECKNIL-140]
|
||||
_ = x[OVARDEF-141]
|
||||
_ = x[OVARKILL-142]
|
||||
_ = x[OVARLIVE-143]
|
||||
_ = x[ORESULT-144]
|
||||
_ = x[OINLMARK-145]
|
||||
_ = x[OLINKSYMOFFSET-146]
|
||||
_ = x[ODYNAMICDOTTYPE-147]
|
||||
_ = x[ODYNAMICDOTTYPE2-148]
|
||||
_ = x[ODYNAMICTYPE-149]
|
||||
_ = x[OTAILCALL-150]
|
||||
_ = x[OGETG-151]
|
||||
_ = x[OGETCALLERPC-152]
|
||||
_ = x[OGETCALLERSP-153]
|
||||
_ = x[OEND-154]
|
||||
}
|
||||
|
||||
const _Op_name = "XXXNAMENONAMETYPEPACKLITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESSLICE2ARRPTRASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVIDATACONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECOVERFPRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFUNSAFEADDUNSAFESLICEMETHEXPRMETHVALUEBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTCHANTMAPTSTRUCTTINTERTFUNCTARRAYTSLICEINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETDYNAMICDOTTYPEDYNAMICDOTTYPE2DYNAMICTYPETAILCALLGETGGETCALLERPCGETCALLERSPEND"
|
||||
const _Op_name = "XXXNAMENONAMETYPELITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESSLICE2ARRPTRASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCAPCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVIDATACONVNOPCOPYDCLDCLFUNCDCLCONSTDCLTYPEDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERRECOVERRECOVERFPRECVRUNESTRSELRECV2IOTAREALIMAGCOMPLEXALIGNOFOFFSETOFSIZEOFUNSAFEADDUNSAFESLICEMETHEXPRMETHVALUEBLOCKBREAKCASECONTINUEDEFERFALLFORFORUNTILGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWFUNCINSTTFUNCINLCALLEFACEITABIDATASPTRCFUNCCHECKNILVARDEFVARKILLVARLIVERESULTINLMARKLINKSYMOFFSETDYNAMICDOTTYPEDYNAMICDOTTYPE2DYNAMICTYPETAILCALLGETGGETCALLERPCGETCALLERSPEND"
|
||||
|
||||
var _Op_index = [...]uint16{0, 3, 7, 13, 17, 21, 28, 31, 34, 37, 39, 42, 48, 52, 58, 64, 73, 85, 94, 103, 115, 124, 136, 138, 141, 151, 158, 165, 172, 176, 180, 188, 196, 205, 208, 213, 220, 227, 233, 242, 250, 258, 264, 268, 277, 286, 293, 297, 300, 307, 315, 322, 328, 331, 337, 344, 352, 356, 363, 371, 373, 375, 377, 379, 381, 383, 388, 393, 401, 404, 413, 416, 420, 428, 435, 444, 457, 460, 463, 466, 469, 472, 475, 481, 484, 487, 493, 497, 500, 504, 509, 514, 520, 525, 529, 534, 542, 550, 556, 565, 576, 583, 592, 596, 603, 611, 615, 619, 623, 630, 637, 645, 651, 660, 671, 679, 688, 693, 698, 702, 710, 715, 719, 722, 730, 734, 736, 741, 743, 748, 754, 760, 766, 772, 780, 785, 789, 796, 802, 807, 813, 819, 826, 831, 835, 840, 844, 849, 857, 863, 870, 877, 883, 890, 903, 917, 932, 943, 951, 955, 966, 977, 980}
|
||||
var _Op_index = [...]uint16{0, 3, 7, 13, 17, 24, 27, 30, 33, 35, 38, 44, 48, 54, 60, 69, 81, 90, 99, 111, 120, 132, 134, 137, 147, 154, 161, 168, 172, 176, 184, 192, 201, 204, 209, 216, 223, 229, 238, 246, 254, 260, 264, 273, 282, 289, 293, 296, 303, 311, 318, 324, 327, 333, 340, 348, 352, 359, 367, 369, 371, 373, 375, 377, 379, 384, 389, 397, 400, 409, 412, 416, 424, 431, 440, 453, 456, 459, 462, 465, 468, 471, 477, 480, 483, 489, 493, 496, 500, 505, 510, 516, 521, 525, 530, 538, 546, 552, 561, 572, 579, 588, 592, 599, 607, 611, 615, 619, 626, 633, 641, 647, 656, 667, 675, 684, 689, 694, 698, 706, 711, 715, 718, 726, 730, 732, 737, 739, 744, 750, 756, 762, 768, 776, 781, 788, 793, 797, 802, 806, 811, 819, 825, 832, 839, 845, 852, 865, 879, 894, 905, 913, 917, 928, 939, 942}
|
||||
|
||||
func (i Op) String() string {
|
||||
if i >= Op(len(_Op_index)-1) {
|
||||
|
||||
@ -21,7 +21,7 @@ func TestSizeof(t *testing.T) {
|
||||
_64bit uintptr // size on 64bit platforms
|
||||
}{
|
||||
{Func{}, 192, 328},
|
||||
{Name{}, 112, 200},
|
||||
{Name{}, 108, 192},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
|
||||
@ -58,81 +58,6 @@ func (n *miniType) setOTYPE(t *types.Type, self Ntype) {
|
||||
func (n *miniType) Sym() *types.Sym { return nil } // for Format OTYPE
|
||||
func (n *miniType) Implicit() bool { return false } // for Format OTYPE
|
||||
|
||||
// A ChanType represents a chan Elem syntax with the direction Dir.
|
||||
type ChanType struct {
|
||||
miniType
|
||||
Elem Ntype
|
||||
Dir types.ChanDir
|
||||
}
|
||||
|
||||
func NewChanType(pos src.XPos, elem Ntype, dir types.ChanDir) *ChanType {
|
||||
n := &ChanType{Elem: elem, Dir: dir}
|
||||
n.op = OTCHAN
|
||||
n.pos = pos
|
||||
return n
|
||||
}
|
||||
|
||||
func (n *ChanType) SetOTYPE(t *types.Type) {
|
||||
n.setOTYPE(t, n)
|
||||
n.Elem = nil
|
||||
}
|
||||
|
||||
// A MapType represents a map[Key]Value type syntax.
|
||||
type MapType struct {
|
||||
miniType
|
||||
Key Ntype
|
||||
Elem Ntype
|
||||
}
|
||||
|
||||
func NewMapType(pos src.XPos, key, elem Ntype) *MapType {
|
||||
n := &MapType{Key: key, Elem: elem}
|
||||
n.op = OTMAP
|
||||
n.pos = pos
|
||||
return n
|
||||
}
|
||||
|
||||
func (n *MapType) SetOTYPE(t *types.Type) {
|
||||
n.setOTYPE(t, n)
|
||||
n.Key = nil
|
||||
n.Elem = nil
|
||||
}
|
||||
|
||||
// A StructType represents a struct { ... } type syntax.
|
||||
type StructType struct {
|
||||
miniType
|
||||
Fields []*Field
|
||||
}
|
||||
|
||||
func NewStructType(pos src.XPos, fields []*Field) *StructType {
|
||||
n := &StructType{Fields: fields}
|
||||
n.op = OTSTRUCT
|
||||
n.pos = pos
|
||||
return n
|
||||
}
|
||||
|
||||
func (n *StructType) SetOTYPE(t *types.Type) {
|
||||
n.setOTYPE(t, n)
|
||||
n.Fields = nil
|
||||
}
|
||||
|
||||
// An InterfaceType represents a struct { ... } type syntax.
|
||||
type InterfaceType struct {
|
||||
miniType
|
||||
Methods []*Field
|
||||
}
|
||||
|
||||
func NewInterfaceType(pos src.XPos, methods []*Field) *InterfaceType {
|
||||
n := &InterfaceType{Methods: methods}
|
||||
n.op = OTINTER
|
||||
n.pos = pos
|
||||
return n
|
||||
}
|
||||
|
||||
func (n *InterfaceType) SetOTYPE(t *types.Type) {
|
||||
n.setOTYPE(t, n)
|
||||
n.Methods = nil
|
||||
}
|
||||
|
||||
// A FuncType represents a func(Args) Results type syntax.
|
||||
type FuncType struct {
|
||||
miniType
|
||||
@ -240,47 +165,6 @@ func editFields(list []*Field, edit func(Node) Node) {
|
||||
}
|
||||
}
|
||||
|
||||
// A SliceType represents a []Elem type syntax.
|
||||
// If DDD is true, it's the ...Elem at the end of a function list.
|
||||
type SliceType struct {
|
||||
miniType
|
||||
Elem Ntype
|
||||
DDD bool
|
||||
}
|
||||
|
||||
func NewSliceType(pos src.XPos, elem Ntype) *SliceType {
|
||||
n := &SliceType{Elem: elem}
|
||||
n.op = OTSLICE
|
||||
n.pos = pos
|
||||
return n
|
||||
}
|
||||
|
||||
func (n *SliceType) SetOTYPE(t *types.Type) {
|
||||
n.setOTYPE(t, n)
|
||||
n.Elem = nil
|
||||
}
|
||||
|
||||
// An ArrayType represents a [Len]Elem type syntax.
|
||||
// If Len is nil, the type is a [...]Elem in an array literal.
|
||||
type ArrayType struct {
|
||||
miniType
|
||||
Len Node
|
||||
Elem Ntype
|
||||
}
|
||||
|
||||
func NewArrayType(pos src.XPos, len Node, elem Ntype) *ArrayType {
|
||||
n := &ArrayType{Len: len, Elem: elem}
|
||||
n.op = OTARRAY
|
||||
n.pos = pos
|
||||
return n
|
||||
}
|
||||
|
||||
func (n *ArrayType) SetOTYPE(t *types.Type) {
|
||||
n.setOTYPE(t, n)
|
||||
n.Len = nil
|
||||
n.Elem = nil
|
||||
}
|
||||
|
||||
// A typeNode is a Node wrapper for type t.
|
||||
type typeNode struct {
|
||||
miniNode
|
||||
|
||||
@ -185,7 +185,7 @@ func wrapname(pos src.XPos, x ir.Node) ir.Node {
|
||||
break
|
||||
}
|
||||
fallthrough
|
||||
case ir.ONAME, ir.ONONAME, ir.OPACK:
|
||||
case ir.ONAME, ir.ONONAME:
|
||||
p := ir.NewParenExpr(pos, x)
|
||||
p.SetImplicit(true)
|
||||
return p
|
||||
|
||||
@ -1687,7 +1687,7 @@ func wrapName(pos src.XPos, x ir.Node) ir.Node {
|
||||
break
|
||||
}
|
||||
fallthrough
|
||||
case ir.ONAME, ir.ONONAME, ir.OPACK, ir.ONIL:
|
||||
case ir.ONAME, ir.ONONAME, ir.ONIL:
|
||||
p := ir.NewParenExpr(pos, x)
|
||||
p.SetImplicit(true)
|
||||
return p
|
||||
|
||||
@ -521,7 +521,6 @@ func AnySideEffects(n ir.Node) bool {
|
||||
case ir.ONAME,
|
||||
ir.ONONAME,
|
||||
ir.OTYPE,
|
||||
ir.OPACK,
|
||||
ir.OLITERAL,
|
||||
ir.ONIL,
|
||||
ir.OADD,
|
||||
|
||||
@ -220,21 +220,6 @@ func tcCompLit(n *ir.CompLitExpr) (res ir.Node) {
|
||||
|
||||
ir.SetPos(n.Ntype)
|
||||
|
||||
// Need to handle [...]T arrays specially.
|
||||
if array, ok := n.Ntype.(*ir.ArrayType); ok && array.Elem != nil && array.Len == nil {
|
||||
array.Elem = typecheckNtype(array.Elem)
|
||||
elemType := array.Elem.Type()
|
||||
if elemType == nil {
|
||||
n.SetType(nil)
|
||||
return n
|
||||
}
|
||||
length := typecheckarraylit(elemType, -1, n.List, "array literal")
|
||||
n.SetOp(ir.OARRAYLIT)
|
||||
n.SetType(types.NewArray(elemType, length))
|
||||
n.Ntype = nil
|
||||
return n
|
||||
}
|
||||
|
||||
n.Ntype = typecheckNtype(n.Ntype)
|
||||
t := n.Ntype.Type()
|
||||
if t == nil {
|
||||
|
||||
@ -5,72 +5,11 @@
|
||||
package typecheck
|
||||
|
||||
import (
|
||||
"go/constant"
|
||||
|
||||
"cmd/compile/internal/base"
|
||||
"cmd/compile/internal/ir"
|
||||
"cmd/compile/internal/types"
|
||||
)
|
||||
|
||||
// tcArrayType typechecks an OTARRAY node.
|
||||
func tcArrayType(n *ir.ArrayType) ir.Node {
|
||||
n.Elem = typecheckNtype(n.Elem)
|
||||
if n.Elem.Type() == nil {
|
||||
return n
|
||||
}
|
||||
if n.Len == nil { // [...]T
|
||||
if !n.Diag() {
|
||||
n.SetDiag(true)
|
||||
base.Errorf("use of [...] array outside of array literal")
|
||||
}
|
||||
return n
|
||||
}
|
||||
n.Len = indexlit(Expr(n.Len))
|
||||
size := n.Len
|
||||
if ir.ConstType(size) != constant.Int {
|
||||
switch {
|
||||
case size.Type() == nil:
|
||||
// Error already reported elsewhere.
|
||||
case size.Type().IsInteger() && size.Op() != ir.OLITERAL:
|
||||
base.Errorf("non-constant array bound %v", size)
|
||||
default:
|
||||
base.Errorf("invalid array bound %v", size)
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
v := size.Val()
|
||||
if ir.ConstOverflow(v, types.Types[types.TINT]) {
|
||||
base.Errorf("array bound is too large")
|
||||
return n
|
||||
}
|
||||
|
||||
if constant.Sign(v) < 0 {
|
||||
base.Errorf("array bound must be non-negative")
|
||||
return n
|
||||
}
|
||||
|
||||
bound, _ := constant.Int64Val(v)
|
||||
t := types.NewArray(n.Elem.Type(), bound)
|
||||
n.SetOTYPE(t)
|
||||
types.CheckSize(t)
|
||||
return n
|
||||
}
|
||||
|
||||
// tcChanType typechecks an OTCHAN node.
|
||||
func tcChanType(n *ir.ChanType) ir.Node {
|
||||
n.Elem = typecheckNtype(n.Elem)
|
||||
l := n.Elem
|
||||
if l.Type() == nil {
|
||||
return n
|
||||
}
|
||||
if l.Type().NotInHeap() {
|
||||
base.Errorf("chan of incomplete (or unallocatable) type not allowed")
|
||||
}
|
||||
n.SetOTYPE(types.NewChan(l.Type(), n.Dir))
|
||||
return n
|
||||
}
|
||||
|
||||
// tcFuncType typechecks an OTFUNC node.
|
||||
func tcFuncType(n *ir.FuncType) ir.Node {
|
||||
misc := func(f *types.Field, nf *ir.Field) {
|
||||
@ -97,71 +36,6 @@ func tcFuncType(n *ir.FuncType) ir.Node {
|
||||
return n
|
||||
}
|
||||
|
||||
// tcInterfaceType typechecks an OTINTER node.
|
||||
func tcInterfaceType(n *ir.InterfaceType) ir.Node {
|
||||
if len(n.Methods) == 0 {
|
||||
n.SetOTYPE(types.Types[types.TINTER])
|
||||
return n
|
||||
}
|
||||
|
||||
lno := base.Pos
|
||||
methods := tcFields(n.Methods, nil)
|
||||
base.Pos = lno
|
||||
|
||||
n.SetOTYPE(types.NewInterface(types.LocalPkg, methods, false))
|
||||
return n
|
||||
}
|
||||
|
||||
// tcMapType typechecks an OTMAP node.
|
||||
func tcMapType(n *ir.MapType) ir.Node {
|
||||
n.Key = typecheckNtype(n.Key)
|
||||
n.Elem = typecheckNtype(n.Elem)
|
||||
l := n.Key
|
||||
r := n.Elem
|
||||
if l.Type() == nil || r.Type() == nil {
|
||||
return n
|
||||
}
|
||||
if l.Type().NotInHeap() {
|
||||
base.Errorf("incomplete (or unallocatable) map key not allowed")
|
||||
}
|
||||
if r.Type().NotInHeap() {
|
||||
base.Errorf("incomplete (or unallocatable) map value not allowed")
|
||||
}
|
||||
n.SetOTYPE(types.NewMap(l.Type(), r.Type()))
|
||||
mapqueue = append(mapqueue, n) // check map keys when all types are settled
|
||||
return n
|
||||
}
|
||||
|
||||
// tcSliceType typechecks an OTSLICE node.
|
||||
func tcSliceType(n *ir.SliceType) ir.Node {
|
||||
n.Elem = typecheckNtype(n.Elem)
|
||||
if n.Elem.Type() == nil {
|
||||
return n
|
||||
}
|
||||
t := types.NewSlice(n.Elem.Type())
|
||||
n.SetOTYPE(t)
|
||||
types.CheckSize(t)
|
||||
return n
|
||||
}
|
||||
|
||||
// tcStructType typechecks an OTSTRUCT node.
|
||||
func tcStructType(n *ir.StructType) ir.Node {
|
||||
lno := base.Pos
|
||||
|
||||
fields := tcFields(n.Fields, func(f *types.Field, nf *ir.Field) {
|
||||
if nf.Embedded {
|
||||
checkembeddedtype(f.Type)
|
||||
f.Embedded = 1
|
||||
}
|
||||
f.Note = nf.Note
|
||||
})
|
||||
checkdupfields("field", fields)
|
||||
|
||||
base.Pos = lno
|
||||
n.SetOTYPE(types.NewStruct(types.LocalPkg, fields))
|
||||
return n
|
||||
}
|
||||
|
||||
// tcField typechecks a generic Field.
|
||||
// misc can be provided to handle specialized typechecking.
|
||||
func tcField(n *ir.Field, misc func(*types.Field, *ir.Field)) *types.Field {
|
||||
|
||||
@ -290,7 +290,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
|
||||
// But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
|
||||
if n.Typecheck() == 1 || n.Typecheck() == 3 {
|
||||
switch n.Op() {
|
||||
case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.OPACK:
|
||||
case ir.ONAME, ir.OTYPE, ir.OLITERAL:
|
||||
break
|
||||
|
||||
default:
|
||||
@ -522,43 +522,14 @@ func typecheck1(n ir.Node, top int) ir.Node {
|
||||
// type already set
|
||||
return n
|
||||
|
||||
case ir.OPACK:
|
||||
n := n.(*ir.PkgName)
|
||||
base.Errorf("use of package %v without selector", n.Sym())
|
||||
n.SetDiag(true)
|
||||
return n
|
||||
|
||||
// types (ODEREF is with exprs)
|
||||
case ir.OTYPE:
|
||||
return n
|
||||
|
||||
case ir.OTSLICE:
|
||||
n := n.(*ir.SliceType)
|
||||
return tcSliceType(n)
|
||||
|
||||
case ir.OTARRAY:
|
||||
n := n.(*ir.ArrayType)
|
||||
return tcArrayType(n)
|
||||
|
||||
case ir.OTMAP:
|
||||
n := n.(*ir.MapType)
|
||||
return tcMapType(n)
|
||||
|
||||
case ir.OTCHAN:
|
||||
n := n.(*ir.ChanType)
|
||||
return tcChanType(n)
|
||||
|
||||
case ir.OTSTRUCT:
|
||||
n := n.(*ir.StructType)
|
||||
return tcStructType(n)
|
||||
|
||||
case ir.OTINTER:
|
||||
n := n.(*ir.InterfaceType)
|
||||
return tcInterfaceType(n)
|
||||
|
||||
case ir.OTFUNC:
|
||||
n := n.(*ir.FuncType)
|
||||
return tcFuncType(n)
|
||||
|
||||
// type or expr
|
||||
case ir.ODEREF:
|
||||
n := n.(*ir.StarExpr)
|
||||
@ -1722,18 +1693,6 @@ func stringtoruneslit(n *ir.ConvExpr) ir.Node {
|
||||
return Expr(nn)
|
||||
}
|
||||
|
||||
var mapqueue []*ir.MapType
|
||||
|
||||
func CheckMapKeys() {
|
||||
for _, n := range mapqueue {
|
||||
k := n.Type().MapType().Key
|
||||
if !k.Broke() && !types.IsComparable(k) {
|
||||
base.ErrorfAt(n.Pos(), "invalid map key type %v", k)
|
||||
}
|
||||
}
|
||||
mapqueue = nil
|
||||
}
|
||||
|
||||
func typecheckdeftype(n *ir.Name) {
|
||||
if base.EnableTrace && base.Flag.LowerT {
|
||||
defer tracePrint("typecheckdeftype", n)(nil)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user