}
func typecheck1(np **Node, top int) {
- var et int
- var aop int
- var op int
- var ptr int
- var l *Node
- var r *Node
- var lo *Node
- var mid *Node
- var hi *Node
- var ok int
- var ntop int
- var t *Type
- var tp *Type
- var missing *Type
- var have *Type
- var badtype *Type
- var v Val
- var why string
- var x int64
-
n := *np
+ defer func() {
+ *np = n
+ }()
if n.Sym != nil {
if n.Op == ONAME && n.Etype != 0 && top&Ecall == 0 {
Yyerror("use of builtin %v not in function call", Sconv(n.Sym, 0))
- goto error
+ n.Type = nil
+ return
}
typecheckdef(n)
if n.Op == ONONAME {
- goto error
+ n.Type = nil
+ return
}
}
- *np = n
-
-reswitch:
- ok = 0
+ ok := 0
+OpSwitch:
switch n.Op {
// until typecheck is complete, do nothing.
default:
if n.Type == nil && n.Val.Ctype == CTSTR {
n.Type = idealstring
}
- goto ret
+ break OpSwitch
case ONONAME:
ok |= Erv
- goto ret
+ break OpSwitch
case ONAME:
if n.Decldepth == 0 {
}
if n.Etype != 0 {
ok |= Ecall
- goto ret
+ break OpSwitch
}
if top&Easgn == 0 {
// not a write to the variable
if isblank(n) {
Yyerror("cannot use _ as value")
- goto error
+ n.Type = nil
+ return
}
n.Used = 1
if top&Ecall == 0 && isunsafebuiltin(n) {
Yyerror("%v is not an expression, must be called", Nconv(n, 0))
- goto error
+ n.Type = nil
+ return
}
ok |= Erv
- goto ret
+ break OpSwitch
case OPACK:
Yyerror("use of package %v without selector", Sconv(n.Sym, 0))
- goto error
+ n.Type = nil
+ return
case ODDD:
break
ok |= Etype
if n.Type == nil {
- goto error
+ n.Type = nil
+ return
}
case OTARRAY:
ok |= Etype
- t = typ(TARRAY)
- l = n.Left
- r = n.Right
+ t := typ(TARRAY)
+ l := n.Left
+ r := n.Right
if l == nil {
t.Bound = -1 // slice
} else if l.Op == ODDD {
Yyerror("use of [...] array outside of array literal")
}
} else {
- l = typecheck(&n.Left, Erv)
+ l := typecheck(&n.Left, Erv)
+ var v Val
switch consttype(l) {
case CTINT,
CTRUNE:
} else {
Yyerror("invalid array bound %v", Nconv(l, 0))
}
- goto error
+ n.Type = nil
+ return
}
t.Bound = Mpgetfix(v.U.Xval)
if doesoverflow(v, Types[TINT]) {
Yyerror("array bound is too large")
- goto error
+ n.Type = nil
+ return
} else if t.Bound < 0 {
Yyerror("array bound must be non-negative")
- goto error
+ n.Type = nil
+ return
}
}
typecheck(&r, Etype)
if r.Type == nil {
- goto error
+ n.Type = nil
+ return
}
t.Type = r.Type
n.Op = OTYPE
case OTMAP:
ok |= Etype
- l = typecheck(&n.Left, Etype)
- r = typecheck(&n.Right, Etype)
+ l := typecheck(&n.Left, Etype)
+ r := typecheck(&n.Right, Etype)
if l.Type == nil || r.Type == nil {
- goto error
+ n.Type = nil
+ return
}
n.Op = OTYPE
n.Type = maptype(l.Type, r.Type)
case OTCHAN:
ok |= Etype
- l = typecheck(&n.Left, Etype)
+ l := typecheck(&n.Left, Etype)
if l.Type == nil {
- goto error
+ n.Type = nil
+ return
}
- t = typ(TCHAN)
+ t := typ(TCHAN)
t.Type = l.Type
t.Chan = n.Etype
n.Op = OTYPE
n.Op = OTYPE
n.Type = tostruct(n.List)
if n.Type == nil || n.Type.Broke != 0 {
- goto error
+ n.Type = nil
+ return
}
n.List = nil
n.Op = OTYPE
n.Type = tointerface(n.List)
if n.Type == nil {
- goto error
+ n.Type = nil
+ return
}
case OTFUNC:
n.Op = OTYPE
n.Type = functype(n.Left, n.List, n.Rlist)
if n.Type == nil {
- goto error
+ n.Type = nil
+ return
}
/*
* type or expr
*/
case OIND:
- ntop = Erv | Etype
+ ntop := Erv | Etype
if top&Eaddr == 0 {
ntop |= Eindir
}
ntop |= top & Ecomplit
- l = typecheck(&n.Left, ntop)
- t = l.Type
+ l := typecheck(&n.Left, ntop)
+ t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
if l.Op == OTYPE {
ok |= Etype
n.Op = OTYPE
n.Type = Ptrto(l.Type)
n.Left = nil
- goto ret
+ break OpSwitch
}
if !Isptr[t.Etype] {
if top&(Erv|Etop) != 0 {
Yyerror("invalid indirect of %v", Nconv(n.Left, obj.FmtLong))
- goto error
+ n.Type = nil
+ return
}
- goto ret
+ break OpSwitch
}
ok |= Erv
n.Type = t.Type
- goto ret
+ break OpSwitch
/*
* arithmetic exprs
*/
- case OASOP:
- ok |= Etop
-
- l = typecheck(&n.Left, Erv)
- r = typecheck(&n.Right, Erv)
- checkassign(n, n.Left)
- if l.Type == nil || r.Type == nil {
- goto error
- }
- op = int(n.Etype)
- goto arith
-
- case OADD,
+ case OASOP,
+ OADD,
OAND,
OANDAND,
OANDNOT,
OOROR,
OSUB,
OXOR:
- ok |= Erv
- l = typecheck(&n.Left, Erv|top&Eiota)
- r = typecheck(&n.Right, Erv|top&Eiota)
+ var l *Node
+ var op int
+ var r *Node
+ if n.Op == OASOP {
+ ok |= Etop
+ l = typecheck(&n.Left, Erv)
+ r = typecheck(&n.Right, Erv)
+ checkassign(n, n.Left)
+ if l.Type == nil || r.Type == nil {
+ n.Type = nil
+ return
+ }
+ op = int(n.Etype)
+ } else {
+ ok |= Erv
+ l = typecheck(&n.Left, Erv|top&Eiota)
+ r = typecheck(&n.Right, Erv|top&Eiota)
+ if l.Type == nil || r.Type == nil {
+ n.Type = nil
+ return
+ }
+ op = int(n.Op)
+ }
+ if op == OLSH || op == ORSH {
+ defaultlit(&r, Types[TUINT])
+ n.Right = r
+ t := r.Type
+ if !Isint[t.Etype] || Issigned[t.Etype] {
+ Yyerror("invalid operation: %v (shift count type %v, must be unsigned integer)", Nconv(n, 0), Tconv(r.Type, 0))
+ n.Type = nil
+ return
+ }
+
+ t = l.Type
+ if t != nil && t.Etype != TIDEAL && !Isint[t.Etype] {
+ Yyerror("invalid operation: %v (shift of type %v)", Nconv(n, 0), Tconv(t, 0))
+ n.Type = nil
+ return
+ }
+
+ // no defaultlit for left
+ // the outer context gives the type
+ n.Type = l.Type
+
+ break OpSwitch
+ }
+
+ // ideal mixed with non-ideal
+ defaultlit2(&l, &r, 0)
+
+ n.Left = l
+ n.Right = r
if l.Type == nil || r.Type == nil {
- goto error
+ n.Type = nil
+ return
+ }
+ t := l.Type
+ if t.Etype == TIDEAL {
+ t = r.Type
+ }
+ et := int(t.Etype)
+ if et == TIDEAL {
+ et = TINT
+ }
+ aop := 0
+ if iscmp[n.Op] && t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
+ // comparison is okay as long as one side is
+ // assignable to the other. convert so they have
+ // the same type.
+ //
+ // the only conversion that isn't a no-op is concrete == interface.
+ // in that case, check comparability of the concrete type.
+ // The conversion allocates, so only do it if the concrete type is huge.
+ if r.Type.Etype != TBLANK {
+ aop = assignop(l.Type, r.Type, nil)
+ if aop != 0 {
+ if Isinter(r.Type) && !Isinter(l.Type) && algtype1(l.Type, nil) == ANOEQ {
+ Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(l.Type))
+ n.Type = nil
+ return
+ }
+
+ dowidth(l.Type)
+ if Isinter(r.Type) == Isinter(l.Type) || l.Type.Width >= 1<<16 {
+ l = Nod(aop, l, nil)
+ l.Type = r.Type
+ l.Typecheck = 1
+ n.Left = l
+ }
+
+ t = r.Type
+ goto converted
+ }
+ }
+
+ if l.Type.Etype != TBLANK {
+ aop = assignop(r.Type, l.Type, nil)
+ if aop != 0 {
+ if Isinter(l.Type) && !Isinter(r.Type) && algtype1(r.Type, nil) == ANOEQ {
+ Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(r.Type))
+ n.Type = nil
+ return
+ }
+
+ dowidth(r.Type)
+ if Isinter(r.Type) == Isinter(l.Type) || r.Type.Width >= 1<<16 {
+ r = Nod(aop, r, nil)
+ r.Type = l.Type
+ r.Typecheck = 1
+ n.Right = r
+ }
+
+ t = l.Type
+ }
+ }
+
+ converted:
+ et = int(t.Etype)
+ }
+
+ if t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
+ defaultlit2(&l, &r, 1)
+ if n.Op == OASOP && n.Implicit != 0 {
+ Yyerror("invalid operation: %v (non-numeric type %v)", Nconv(n, 0), Tconv(l.Type, 0))
+ n.Type = nil
+ return
+ }
+
+ if Isinter(r.Type) == Isinter(l.Type) || aop == 0 {
+ Yyerror("invalid operation: %v (mismatched types %v and %v)", Nconv(n, 0), Tconv(l.Type, 0), Tconv(r.Type, 0))
+ n.Type = nil
+ return
+ }
+ }
+
+ if !okfor[op][et] {
+ Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(t))
+ n.Type = nil
+ return
+ }
+
+ // okfor allows any array == array, map == map, func == func.
+ // restrict to slice/map/func == nil and nil == slice/map/func.
+ if Isfixedarray(l.Type) && algtype1(l.Type, nil) == ANOEQ {
+ Yyerror("invalid operation: %v (%v cannot be compared)", Nconv(n, 0), Tconv(l.Type, 0))
+ n.Type = nil
+ return
+ }
+
+ if Isslice(l.Type) && !isnil(l) && !isnil(r) {
+ Yyerror("invalid operation: %v (slice can only be compared to nil)", Nconv(n, 0))
+ n.Type = nil
+ return
+ }
+
+ if l.Type.Etype == TMAP && !isnil(l) && !isnil(r) {
+ Yyerror("invalid operation: %v (map can only be compared to nil)", Nconv(n, 0))
+ n.Type = nil
+ return
+ }
+
+ if l.Type.Etype == TFUNC && !isnil(l) && !isnil(r) {
+ Yyerror("invalid operation: %v (func can only be compared to nil)", Nconv(n, 0))
+ n.Type = nil
+ return
+ }
+
+ var badtype *Type
+ if l.Type.Etype == TSTRUCT && algtype1(l.Type, &badtype) == ANOEQ {
+ Yyerror("invalid operation: %v (struct containing %v cannot be compared)", Nconv(n, 0), Tconv(badtype, 0))
+ n.Type = nil
+ return
+ }
+
+ t = l.Type
+ if iscmp[n.Op] {
+ evconst(n)
+ t = idealbool
+ if n.Op != OLITERAL {
+ defaultlit2(&l, &r, 1)
+ n.Left = l
+ n.Right = r
+ }
+ } else if n.Op == OANDAND || n.Op == OOROR {
+ if l.Type == r.Type {
+ t = l.Type
+ } else if l.Type == idealbool {
+ t = r.Type
+ } else if r.Type == idealbool {
+ t = l.Type
+ }
+ } else
+ // non-comparison operators on ideal bools should make them lose their ideal-ness
+ if t == idealbool {
+ t = Types[TBOOL]
+ }
+
+ if et == TSTRING {
+ if iscmp[n.Op] {
+ n.Etype = n.Op
+ n.Op = OCMPSTR
+ } else if n.Op == OADD {
+ // create OADDSTR node with list of strings in x + y + z + (w + v) + ...
+ n.Op = OADDSTR
+
+ if l.Op == OADDSTR {
+ n.List = l.List
+ } else {
+ n.List = list1(l)
+ }
+ if r.Op == OADDSTR {
+ n.List = concat(n.List, r.List)
+ } else {
+ n.List = list(n.List, r)
+ }
+ n.Left = nil
+ n.Right = nil
+ }
+ }
+
+ if et == TINTER {
+ if l.Op == OLITERAL && l.Val.Ctype == CTNIL {
+ // swap for back end
+ n.Left = r
+
+ n.Right = l
+ } else if r.Op == OLITERAL && r.Val.Ctype == CTNIL {
+ } else // leave alone for back end
+ if Isinter(r.Type) == Isinter(l.Type) {
+ n.Etype = n.Op
+ n.Op = OCMPIFACE
+ }
}
- op = int(n.Op)
- goto arith
+
+ if (op == ODIV || op == OMOD) && Isconst(r, CTINT) {
+ if mpcmpfixc(r.Val.U.Xval, 0) == 0 {
+ Yyerror("division by zero")
+ n.Type = nil
+ return
+ }
+ }
+
+ n.Type = t
+ break OpSwitch
case OCOM,
OMINUS,
ONOT,
OPLUS:
ok |= Erv
- l = typecheck(&n.Left, Erv|top&Eiota)
- t = l.Type
+ l := typecheck(&n.Left, Erv|top&Eiota)
+ t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
if !okfor[n.Op][t.Etype] {
Yyerror("invalid operation: %v %v", Oconv(int(n.Op), 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
n.Type = t
- goto ret
+ break OpSwitch
/*
* exprs
typecheck(&n.Left, Erv|Eaddr)
if n.Left.Type == nil {
- goto error
+ n.Type = nil
+ return
}
checklvalue(n.Left, "take the address of")
- r = outervalue(n.Left)
+ r := outervalue(n.Left)
+ var l *Node
for l = n.Left; l != r; l = l.Left {
l.Addrtaken = 1
if l.Closure != nil {
}
defaultlit(&n.Left, nil)
l = n.Left
- t = l.Type
+ t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
n.Type = Ptrto(t)
- goto ret
+ break OpSwitch
case OCOMPLIT:
ok |= Erv
typecheckcomplit(&n)
if n.Type == nil {
- goto error
+ n.Type = nil
+ return
}
- goto ret
+ break OpSwitch
- case OXDOT:
- n = adddot(n)
- n.Op = ODOT
- if n.Left == nil {
- goto error
+ case OXDOT, ODOT:
+ if n.Op == OXDOT {
+ n = adddot(n)
+ n.Op = ODOT
+ if n.Left == nil {
+ n.Type = nil
+ return
+ }
}
- fallthrough
- // fall through
- case ODOT:
typecheck(&n.Left, Erv|Etype)
defaultlit(&n.Left, nil)
if n.Right.Op != ONAME {
Yyerror("rhs of . must be a name") // impossible
- goto error
+ n.Type = nil
+ return
}
- t = n.Left.Type
+ t := n.Left.Type
if t == nil {
adderrorname(n)
- goto error
+ n.Type = nil
+ return
}
- r = n.Right
+ r := n.Right
if n.Left.Op == OTYPE {
if !looktypedot(n, t, 0) {
} else {
Yyerror("%v undefined (type %v has no method %v)", Nconv(n, 0), Tconv(t, 0), Sconv(n.Right.Sym, 0))
}
- goto error
+ n.Type = nil
+ return
}
if n.Type.Etype != TFUNC || n.Type.Thistuple != 1 {
Yyerror("type %v has no method %v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort))
n.Type = nil
- goto error
+ n.Type = nil
+ return
}
n.Op = ONAME
n.Xoffset = 0
n.Class = PFUNC
ok = Erv
- goto ret
+ break OpSwitch
}
if Isptr[t.Etype] && t.Type.Etype != TINTER {
t = t.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
n.Op = ODOTPTR
checkwidth(t)
if isblank(n.Right) {
Yyerror("cannot refer to blank field or method")
- goto error
+ n.Type = nil
+ return
}
if !lookdot(n, t, 0) {
} else {
Yyerror("%v undefined (type %v has no field or method %v)", Nconv(n, 0), Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, 0))
}
- goto error
+ n.Type = nil
+ return
}
switch n.Op {
ok |= Erv
}
- goto ret
+ break OpSwitch
case ODOTTYPE:
ok |= Erv
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
- l = n.Left
- t = l.Type
+ l := n.Left
+ t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
if !Isinter(t) {
Yyerror("invalid type assertion: %v (non-interface type %v on left)", Nconv(n, 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
if n.Right != nil {
n.Type = n.Right.Type
n.Right = nil
if n.Type == nil {
- goto error
+ n.Type = nil
+ return
}
}
if n.Type != nil && n.Type.Etype != TINTER {
+ var have *Type
+ var missing *Type
+ var ptr int
if !implements(n.Type, t, &missing, &have, &ptr) {
if have != nil && have.Sym == missing.Sym {
Yyerror("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+"\t\thave %v%v\n\t\twant %v%v", Tconv(n.Type, 0), Tconv(t, 0), Sconv(missing.Sym, 0), Sconv(have.Sym, 0), Tconv(have.Type, obj.FmtShort|obj.FmtByte), Sconv(missing.Sym, 0), Tconv(missing.Type, obj.FmtShort|obj.FmtByte))
} else {
Yyerror("impossible type assertion:\n\t%v does not implement %v (missing %v method)", Tconv(n.Type, 0), Tconv(t, 0), Sconv(missing.Sym, 0))
}
- goto error
+ n.Type = nil
+ return
}
}
- goto ret
+ break OpSwitch
case OINDEX:
ok |= Erv
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
implicitstar(&n.Left)
- l = n.Left
+ l := n.Left
typecheck(&n.Right, Erv)
- r = n.Right
- t = l.Type
+ r := n.Right
+ t := l.Type
if t == nil || r.Type == nil {
- goto error
+ n.Type = nil
+ return
}
switch t.Etype {
default:
Yyerror("invalid operation: %v (type %v does not support indexing)", Nconv(n, 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
case TSTRING,
TARRAY:
} else {
n.Type = t.Type
}
- why = "string"
+ why := "string"
if t.Etype == TARRAY {
if Isfixedarray(t) {
why = "array"
}
if Isconst(n.Right, CTINT) {
- x = Mpgetfix(n.Right.Val.U.Xval)
+ x := Mpgetfix(n.Right.Val.U.Xval)
if x < 0 {
Yyerror("invalid %s index %v (index must be non-negative)", why, Nconv(n.Right, 0))
} else if Isfixedarray(t) && t.Bound > 0 && x >= t.Bound {
n.Op = OINDEXMAP
}
- goto ret
+ break OpSwitch
case ORECV:
ok |= Etop | Erv
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
- l = n.Left
- t = l.Type
+ l := n.Left
+ t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
if t.Etype != TCHAN {
Yyerror("invalid operation: %v (receive from non-chan type %v)", Nconv(n, 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
if t.Chan&Crecv == 0 {
Yyerror("invalid operation: %v (receive from send-only type %v)", Nconv(n, 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
n.Type = t.Type
- goto ret
+ break OpSwitch
case OSEND:
ok |= Etop
- l = typecheck(&n.Left, Erv)
+ l := typecheck(&n.Left, Erv)
typecheck(&n.Right, Erv)
defaultlit(&n.Left, nil)
l = n.Left
- t = l.Type
+ t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
if t.Etype != TCHAN {
Yyerror("invalid operation: %v (send to non-chan type %v)", Nconv(n, 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
if t.Chan&Csend == 0 {
Yyerror("invalid operation: %v (send to receive-only type %v)", Nconv(n, 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
defaultlit(&n.Right, t.Type)
- r = n.Right
+ r := n.Right
if r.Type == nil {
- goto error
+ n.Type = nil
+ return
}
n.Right = assignconv(r, l.Type.Type, "send")
n.Etype = 0
n.Type = nil
- goto ret
+ break OpSwitch
case OSLICE:
ok |= Erv
defaultlit(&n.Left, nil)
indexlit(&n.Right.Left)
indexlit(&n.Right.Right)
- l = n.Left
+ l := n.Left
if Isfixedarray(l.Type) {
if !islvalue(n.Left) {
Yyerror("invalid operation %v (slice of unaddressable value)", Nconv(n, 0))
- goto error
+ n.Type = nil
+ return
}
n.Left = Nod(OADDR, n.Left, nil)
l = n.Left
}
- t = l.Type
+ t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
- tp = nil
+ var tp *Type
if Istype(t, TSTRING) {
n.Type = t
n.Op = OSLICESTR
n.Type = t
} else {
Yyerror("cannot slice %v (type %v)", Nconv(l, 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
- lo = n.Right.Left
+ lo := n.Right.Left
if lo != nil && checksliceindex(l, lo, tp) < 0 {
- goto error
+ n.Type = nil
+ return
}
- hi = n.Right.Right
+ hi := n.Right.Right
if hi != nil && checksliceindex(l, hi, tp) < 0 {
- goto error
+ n.Type = nil
+ return
}
if checksliceconst(lo, hi) < 0 {
- goto error
+ n.Type = nil
+ return
}
- goto ret
+ break OpSwitch
case OSLICE3:
ok |= Erv
indexlit(&n.Right.Left)
indexlit(&n.Right.Right.Left)
indexlit(&n.Right.Right.Right)
- l = n.Left
+ l := n.Left
if Isfixedarray(l.Type) {
if !islvalue(n.Left) {
Yyerror("invalid operation %v (slice of unaddressable value)", Nconv(n, 0))
- goto error
+ n.Type = nil
+ return
}
n.Left = Nod(OADDR, n.Left, nil)
l = n.Left
}
- t = l.Type
+ t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
- tp = nil
if Istype(t, TSTRING) {
Yyerror("invalid operation %v (3-index slice of string)", Nconv(n, 0))
- goto error
+ n.Type = nil
+ return
}
+ var tp *Type
if Isptr[t.Etype] && Isfixedarray(t.Type) {
tp = t.Type
n.Type = typ(TARRAY)
n.Type = t
} else {
Yyerror("cannot slice %v (type %v)", Nconv(l, 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
- lo = n.Right.Left
+ lo := n.Right.Left
if lo != nil && checksliceindex(l, lo, tp) < 0 {
- goto error
+ n.Type = nil
+ return
}
- mid = n.Right.Right.Left
+ mid := n.Right.Right.Left
if mid != nil && checksliceindex(l, mid, tp) < 0 {
- goto error
+ n.Type = nil
+ return
}
- hi = n.Right.Right.Right
+ hi := n.Right.Right.Right
if hi != nil && checksliceindex(l, hi, tp) < 0 {
- goto error
+ n.Type = nil
+ return
}
if checksliceconst(lo, hi) < 0 || checksliceconst(lo, mid) < 0 || checksliceconst(mid, hi) < 0 {
- goto error
+ n.Type = nil
+ return
}
- goto ret
+ break OpSwitch
/*
* call and call like
*/
case OCALL:
- l = n.Left
+ l := n.Left
if l.Op == ONAME {
- r = unsafenmagic(n)
+ r := unsafenmagic(n)
if r != nil {
if n.Isddd != 0 {
Yyerror("invalid use of ... with builtin %v", Nconv(l, 0))
}
n = r
- goto reswitch
+ typecheck1(&n, top)
+ return
}
}
n.Left = n.Right
n.Right = nil
- goto reswitch
+ typecheck1(&n, top)
+ return
}
defaultlit(&n.Left, nil)
- l := n.Left
+ l = n.Left
if l.Op == OTYPE {
if n.Isddd != 0 || l.Type.Bound == -100 {
if l.Type.Broke == 0 {
n.Op = OCONV
n.Type = l.Type
if onearg(n, "conversion to %v", Tconv(l.Type, 0)) < 0 {
- goto error
+ n.Type = nil
+ return
}
- goto doconv
+ typecheck1(&n, top)
+ return
}
if count(n.List) == 1 && n.Isddd == 0 {
}
t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
checkwidth(t)
n.Op = OCALLFUNC
if t.Etype != TFUNC {
Yyerror("cannot call non-function %v (type %v)", Nconv(l, 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
}
typecheckaste(OCALL, n.Left, int(n.Isddd), getinargx(t), n.List, desc)
ok |= Etop
if t.Outtuple == 0 {
- goto ret
+ break OpSwitch
}
ok |= Erv
if t.Outtuple == 1 {
t := getoutargx(l.Type).Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
if t.Etype == TFIELD {
t = t.Type
}
n.Type = t
- goto ret
+ break OpSwitch
}
// multiple return
if top&(Efnstruct|Etop) == 0 {
Yyerror("multiple-value %v() in single-value context", Nconv(l, 0))
- goto ret
+ break OpSwitch
}
n.Type = getoutargx(l.Type)
- goto ret
+ break OpSwitch
case OCAP,
OLEN,
OIMAG:
ok |= Erv
if onearg(n, "%v", Oconv(int(n.Op), 0)) < 0 {
- goto error
+ n.Type = nil
+ return
}
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
l := n.Left
t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
switch n.Op {
case OCAP:
}
n.Type = Types[cplxsubtype(int(t.Etype))]
- goto ret
+ break OpSwitch
}
// might be constant
}
n.Type = Types[TINT]
- goto ret
+ break OpSwitch
+
+ badcall1:
+ Yyerror("invalid argument %v for %v", Nconv(n.Left, obj.FmtLong), Oconv(int(n.Op), 0))
+ n.Type = nil
+ return
case OCOMPLEX:
ok |= Erv
typechecklist(n.List, Efnstruct)
if n.List.N.Op != OCALLFUNC && n.List.N.Op != OCALLMETH {
Yyerror("invalid operation: complex expects two arguments")
- goto error
+ n.Type = nil
+ return
}
t := n.List.N.Left.Type
if t.Outtuple != 2 {
Yyerror("invalid operation: complex expects two arguments, %v returns %d results", Nconv(n.List.N, 0), t.Outtuple)
- goto error
+ n.Type = nil
+ return
}
t = n.List.N.Type.Type
r = t.Down.Nname
} else {
if twoarg(n) < 0 {
- goto error
+ n.Type = nil
+ return
}
l = typecheck(&n.Left, Erv|top&Eiota)
r = typecheck(&n.Right, Erv|top&Eiota)
if l.Type == nil || r.Type == nil {
- goto error
+ n.Type = nil
+ return
}
defaultlit2(&l, &r, 0)
if l.Type == nil || r.Type == nil {
- goto error
+ n.Type = nil
+ return
}
n.Left = l
n.Right = r
if !Eqtype(l.Type, r.Type) {
Yyerror("invalid operation: %v (mismatched types %v and %v)", Nconv(n, 0), Tconv(l.Type, 0), Tconv(r.Type, 0))
- goto error
+ n.Type = nil
+ return
}
var t *Type
switch l.Type.Etype {
default:
Yyerror("invalid operation: %v (arguments have type %v, expected floating-point)", Nconv(n, 0), Tconv(l.Type, 0), r.Type)
- goto error
+ n.Type = nil
+ return
case TIDEAL:
t = Types[TIDEAL]
}
n.Type = t
- goto ret
+ break OpSwitch
case OCLOSE:
if onearg(n, "%v", Oconv(int(n.Op), 0)) < 0 {
- goto error
+ n.Type = nil
+ return
}
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
l := n.Left
t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
if t.Etype != TCHAN {
Yyerror("invalid operation: %v (non-chan type %v)", Nconv(n, 0), Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
if t.Chan&Csend == 0 {
Yyerror("invalid operation: %v (cannot close receive-only channel)", Nconv(n, 0))
- goto error
+ n.Type = nil
+ return
}
ok |= Etop
- goto ret
+ break OpSwitch
case ODELETE:
args := n.List
if args == nil {
Yyerror("missing arguments to delete")
- goto error
+ n.Type = nil
+ return
}
if args.Next == nil {
Yyerror("missing second (key) argument to delete")
- goto error
+ n.Type = nil
+ return
}
if args.Next.Next != nil {
Yyerror("too many arguments to delete")
- goto error
+ n.Type = nil
+ return
}
ok |= Etop
r := args.Next.N
if l.Type != nil && l.Type.Etype != TMAP {
Yyerror("first argument to delete must be map; have %v", Tconv(l.Type, obj.FmtLong))
- goto error
+ n.Type = nil
+ return
}
args.Next.N = assignconv(r, l.Type.Down, "delete")
- goto ret
+ break OpSwitch
case OAPPEND:
ok |= Erv
args := n.List
if args == nil {
Yyerror("missing arguments to append")
- goto error
+ n.Type = nil
+ return
}
if count(args) == 1 && n.Isddd == 0 {
t := args.N.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
// Unpack multiple-return result before type-checking.
if !Isslice(t) {
if Isconst(args.N, CTNIL) {
Yyerror("first argument to append must be typed slice; have untyped nil", t)
- goto error
+ n.Type = nil
+ return
}
Yyerror("first argument to append must be slice; have %v", Tconv(t, obj.FmtLong))
- goto error
+ n.Type = nil
+ return
}
if n.Isddd != 0 {
if args.Next == nil {
Yyerror("cannot use ... on first argument to append")
- goto error
+ n.Type = nil
+ return
}
if args.Next.Next != nil {
Yyerror("too many arguments to append")
- goto error
+ n.Type = nil
+ return
}
if Istype(t.Type, TUINT8) && Istype(args.Next.N.Type, TSTRING) {
defaultlit(&args.Next.N, Types[TSTRING])
- goto ret
+ break OpSwitch
}
args.Next.N = assignconv(args.Next.N, t.Orig, "append")
- goto ret
+ break OpSwitch
}
for args = args.Next; args != nil; args = args.Next {
args.N = assignconv(args.N, t.Type, "append")
}
- goto ret
+ break OpSwitch
case OCOPY:
ok |= Etop | Erv
args := n.List
if args == nil || args.Next == nil {
Yyerror("missing arguments to copy")
- goto error
+ n.Type = nil
+ return
}
if args.Next.Next != nil {
Yyerror("too many arguments to copy")
- goto error
+ n.Type = nil
+ return
}
n.Left = args.N
typecheck(&n.Left, Erv)
typecheck(&n.Right, Erv)
if n.Left.Type == nil || n.Right.Type == nil {
- goto error
+ n.Type = nil
+ return
}
defaultlit(&n.Left, nil)
defaultlit(&n.Right, nil)
if n.Left.Type == nil || n.Right.Type == nil {
- goto error
+ n.Type = nil
+ return
}
// copy([]byte, string)
if Isslice(n.Left.Type) && n.Right.Type.Etype == TSTRING {
if Eqtype(n.Left.Type.Type, bytetype) {
- goto ret
+ break OpSwitch
}
Yyerror("arguments to copy have different element types: %v and string", Tconv(n.Left.Type, obj.FmtLong))
- goto error
+ n.Type = nil
+ return
}
if !Isslice(n.Left.Type) || !Isslice(n.Right.Type) {
} else {
Yyerror("second argument to copy should be slice or string; have %v", Tconv(n.Right.Type, obj.FmtLong))
}
- goto error
+ n.Type = nil
+ return
}
if !Eqtype(n.Left.Type.Type, n.Right.Type.Type) {
Yyerror("arguments to copy have different element types: %v and %v", Tconv(n.Left.Type, obj.FmtLong), Tconv(n.Right.Type, obj.FmtLong))
- goto error
+ n.Type = nil
+ return
}
- goto ret
+ break OpSwitch
case OCONV:
- goto doconv
+ {
+ ok |= Erv
+ saveorignode(n)
+ typecheck(&n.Left, Erv|top&(Eindir|Eiota))
+ convlit1(&n.Left, n.Type, true)
+ t := n.Left.Type
+ if t == nil || n.Type == nil {
+ n.Type = nil
+ return
+ }
+ var why string
+ n.Op = uint8(convertop(t, n.Type, &why))
+ if (n.Op) == 0 {
+ if n.Diag == 0 && n.Type.Broke == 0 {
+ Yyerror("cannot convert %v to type %v%s", Nconv(n.Left, obj.FmtLong), Tconv(n.Type, 0), why)
+ n.Diag = 1
+ }
+
+ n.Op = OCONV
+ }
+
+ switch n.Op {
+ case OCONVNOP:
+ if n.Left.Op == OLITERAL && n.Type != Types[TBOOL] {
+ r := Nod(OXXX, nil, nil)
+ n.Op = OCONV
+ n.Orig = r
+ *r = *n
+ n.Op = OLITERAL
+ n.Val = n.Left.Val
+ }
+
+ // do not use stringtoarraylit.
+ // generated code and compiler memory footprint is better without it.
+ case OSTRARRAYBYTE:
+ break
+
+ case OSTRARRAYRUNE:
+ if n.Left.Op == OLITERAL {
+ stringtoarraylit(&n)
+ }
+ }
+
+ break OpSwitch
+ }
+ break OpSwitch
case OMAKE:
ok |= Erv
args := n.List
if args == nil {
Yyerror("missing argument to make")
- goto error
+ n.Type = nil
+ return
}
n.List = nil
typecheck(&l, Etype)
t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
switch t.Etype {
default:
Yyerror("cannot make type %v", Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
case TARRAY:
if !Isslice(t) {
Yyerror("cannot make type %v", Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
if args == nil {
Yyerror("missing len argument to make(%v)", Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
l = args.N
}
if l.Type == nil || (r != nil && r.Type == nil) {
- goto error
+ n.Type = nil
+ return
}
et := bool2int(checkmake(t, "len", l) < 0)
et |= bool2int(r != nil && checkmake(t, "cap", r) < 0)
if et != 0 {
- goto error
+ n.Type = nil
+ return
}
if Isconst(l, CTINT) && r != nil && Isconst(r, CTINT) && Mpcmpfixfix(l.Val.U.Xval, r.Val.U.Xval) > 0 {
Yyerror("len larger than cap in make(%v)", Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
n.Left = l
typecheck(&l, Erv)
defaultlit(&l, Types[TINT])
if l.Type == nil {
- goto error
+ n.Type = nil
+ return
}
if checkmake(t, "size", l) < 0 {
- goto error
+ n.Type = nil
+ return
}
n.Left = l
} else {
typecheck(&l, Erv)
defaultlit(&l, Types[TINT])
if l.Type == nil {
- goto error
+ n.Type = nil
+ return
}
if checkmake(t, "buffer", l) < 0 {
- goto error
+ n.Type = nil
+ return
}
n.Left = l
} else {
if args != nil {
Yyerror("too many arguments to make(%v)", Tconv(t, 0))
n.Op = OMAKE
- goto error
+ n.Type = nil
+ return
}
n.Type = t
- goto ret
+ break OpSwitch
case ONEW:
ok |= Erv
args := n.List
if args == nil {
Yyerror("missing argument to new")
- goto error
+ n.Type = nil
+ return
}
l := args.N
typecheck(&l, Etype)
t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
if args.Next != nil {
Yyerror("too many arguments to new(%v)", Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
n.Left = l
n.Type = Ptrto(t)
- goto ret
+ break OpSwitch
case OPRINT,
OPRINTN:
}
}
- goto ret
+ break OpSwitch
case OPANIC:
ok |= Etop
if onearg(n, "panic") < 0 {
- goto error
+ n.Type = nil
+ return
}
typecheck(&n.Left, Erv)
defaultlit(&n.Left, Types[TINTER])
if n.Left.Type == nil {
- goto error
+ n.Type = nil
+ return
}
- goto ret
+ break OpSwitch
case ORECOVER:
ok |= Erv | Etop
if n.List != nil {
Yyerror("too many arguments to recover")
- goto error
+ n.Type = nil
+ return
}
n.Type = Types[TINTER]
- goto ret
+ break OpSwitch
case OCLOSURE:
ok |= Erv
typecheckclosure(n, top)
if n.Type == nil {
- goto error
+ n.Type = nil
+ return
}
- goto ret
+ break OpSwitch
case OITAB:
ok |= Erv
typecheck(&n.Left, Erv)
t := n.Left.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
if t.Etype != TINTER {
Fatal("OITAB of %v", Tconv(t, 0))
}
n.Type = Ptrto(Types[TUINTPTR])
- goto ret
+ break OpSwitch
case OSPTR:
ok |= Erv
typecheck(&n.Left, Erv)
t := n.Left.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
if !Isslice(t) && t.Etype != TSTRING {
Fatal("OSPTR of %v", Tconv(t, 0))
} else {
n.Type = Ptrto(t.Type)
}
- goto ret
+ break OpSwitch
case OCLOSUREVAR:
ok |= Erv
- goto ret
+ break OpSwitch
case OCFUNC:
ok |= Erv
typecheck(&n.Left, Erv)
n.Type = Types[TUINTPTR]
- goto ret
+ break OpSwitch
case OCONVNOP:
ok |= Erv
typecheck(&n.Left, Erv)
- goto ret
+ break OpSwitch
/*
* statements
if n.Left.Op == ONAME && strings.HasPrefix(n.Left.Sym.Name, "autotmp_") {
n.Left.Defn = n
}
- goto ret
+ break OpSwitch
case OAS2:
ok |= Etop
typecheckas2(n)
- goto ret
+ break OpSwitch
case OBREAK,
OCONTINUE,
OXFALL,
OVARKILL:
ok |= Etop
- goto ret
+ break OpSwitch
case OLABEL:
ok |= Etop
decldepth++
- goto ret
+ break OpSwitch
case ODEFER:
ok |= Etop
if n.Left.Diag == 0 {
checkdefergo(n)
}
- goto ret
+ break OpSwitch
case OPROC:
ok |= Etop
typecheck(&n.Left, Etop|Eproc|Erv)
checkdefergo(n)
- goto ret
+ break OpSwitch
case OFOR:
ok |= Etop
typecheck(&n.Nincr, Etop)
typechecklist(n.Nbody, Etop)
decldepth--
- goto ret
+ break OpSwitch
case OIF:
ok |= Etop
}
typechecklist(n.Nbody, Etop)
typechecklist(n.Nelse, Etop)
- goto ret
+ break OpSwitch
case ORETURN:
ok |= Etop
}
if Curfn == nil {
Yyerror("return outside function")
- goto error
+ n.Type = nil
+ return
}
if Curfn.Type.Outnamed != 0 && n.List == nil {
- goto ret
+ break OpSwitch
}
typecheckaste(ORETURN, nil, 0, getoutargx(Curfn.Type), n.List, "return argument")
- goto ret
+ break OpSwitch
case ORETJMP:
ok |= Etop
- goto ret
+ break OpSwitch
case OSELECT:
ok |= Etop
typecheckselect(n)
- goto ret
+ break OpSwitch
case OSWITCH:
ok |= Etop
typecheckswitch(n)
- goto ret
+ break OpSwitch
case ORANGE:
ok |= Etop
typecheckrange(n)
- goto ret
+ break OpSwitch
case OTYPESW:
Yyerror("use of .(type) outside type switch")
- goto error
+ n.Type = nil
+ return
case OXCASE:
ok |= Etop
typechecklist(n.List, Erv)
typechecklist(n.Nbody, Etop)
- goto ret
+ break OpSwitch
case ODCLFUNC:
ok |= Etop
typecheckfunc(n)
- goto ret
+ break OpSwitch
case ODCLCONST:
ok |= Etop
typecheck(&n.Left, Erv)
- goto ret
+ break OpSwitch
case ODCLTYPE:
ok |= Etop
if incannedimport == 0 {
checkwidth(n.Left.Type)
}
- goto ret
+ break OpSwitch
}
- goto ret
-
-arith:
- if op == OLSH || op == ORSH {
- defaultlit(&r, Types[TUINT])
- n.Right = r
- t := r.Type
- if !Isint[t.Etype] || Issigned[t.Etype] {
- Yyerror("invalid operation: %v (shift count type %v, must be unsigned integer)", Nconv(n, 0), Tconv(r.Type, 0))
- goto error
- }
-
- t = l.Type
- if t != nil && t.Etype != TIDEAL && !Isint[t.Etype] {
- Yyerror("invalid operation: %v (shift of type %v)", Nconv(n, 0), Tconv(t, 0))
- goto error
- }
-
- // no defaultlit for left
- // the outer context gives the type
- n.Type = l.Type
-
- goto ret
- }
-
- // ideal mixed with non-ideal
- defaultlit2(&l, &r, 0)
-
- n.Left = l
- n.Right = r
- if l.Type == nil || r.Type == nil {
- goto error
- }
- t = l.Type
- if t.Etype == TIDEAL {
- t = r.Type
- }
- et = int(t.Etype)
- if et == TIDEAL {
- et = TINT
- }
- aop = 0
- if iscmp[n.Op] && t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
- // comparison is okay as long as one side is
- // assignable to the other. convert so they have
- // the same type.
- //
- // the only conversion that isn't a no-op is concrete == interface.
- // in that case, check comparability of the concrete type.
- // The conversion allocates, so only do it if the concrete type is huge.
- if r.Type.Etype != TBLANK {
- aop = assignop(l.Type, r.Type, nil)
- if aop != 0 {
- if Isinter(r.Type) && !Isinter(l.Type) && algtype1(l.Type, nil) == ANOEQ {
- Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(l.Type))
- goto error
- }
-
- dowidth(l.Type)
- if Isinter(r.Type) == Isinter(l.Type) || l.Type.Width >= 1<<16 {
- l = Nod(aop, l, nil)
- l.Type = r.Type
- l.Typecheck = 1
- n.Left = l
- }
-
- t = r.Type
- goto converted
- }
- }
-
- if l.Type.Etype != TBLANK {
- aop = assignop(r.Type, l.Type, nil)
- if aop != 0 {
- if Isinter(l.Type) && !Isinter(r.Type) && algtype1(r.Type, nil) == ANOEQ {
- Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(r.Type))
- goto error
- }
-
- dowidth(r.Type)
- if Isinter(r.Type) == Isinter(l.Type) || r.Type.Width >= 1<<16 {
- r = Nod(aop, r, nil)
- r.Type = l.Type
- r.Typecheck = 1
- n.Right = r
- }
-
- t = l.Type
- }
- }
-
- converted:
- et = int(t.Etype)
- }
-
- if t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
- defaultlit2(&l, &r, 1)
- if n.Op == OASOP && n.Implicit != 0 {
- Yyerror("invalid operation: %v (non-numeric type %v)", Nconv(n, 0), Tconv(l.Type, 0))
- goto error
- }
-
- if Isinter(r.Type) == Isinter(l.Type) || aop == 0 {
- Yyerror("invalid operation: %v (mismatched types %v and %v)", Nconv(n, 0), Tconv(l.Type, 0), Tconv(r.Type, 0))
- goto error
- }
- }
-
- if !okfor[op][et] {
- Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(t))
- goto error
- }
-
- // okfor allows any array == array, map == map, func == func.
- // restrict to slice/map/func == nil and nil == slice/map/func.
- if Isfixedarray(l.Type) && algtype1(l.Type, nil) == ANOEQ {
- Yyerror("invalid operation: %v (%v cannot be compared)", Nconv(n, 0), Tconv(l.Type, 0))
- goto error
- }
-
- if Isslice(l.Type) && !isnil(l) && !isnil(r) {
- Yyerror("invalid operation: %v (slice can only be compared to nil)", Nconv(n, 0))
- goto error
- }
-
- if l.Type.Etype == TMAP && !isnil(l) && !isnil(r) {
- Yyerror("invalid operation: %v (map can only be compared to nil)", Nconv(n, 0))
- goto error
- }
-
- if l.Type.Etype == TFUNC && !isnil(l) && !isnil(r) {
- Yyerror("invalid operation: %v (func can only be compared to nil)", Nconv(n, 0))
- goto error
- }
-
- if l.Type.Etype == TSTRUCT && algtype1(l.Type, &badtype) == ANOEQ {
- Yyerror("invalid operation: %v (struct containing %v cannot be compared)", Nconv(n, 0), Tconv(badtype, 0))
- goto error
- }
-
- t = l.Type
- if iscmp[n.Op] {
- evconst(n)
- t = idealbool
- if n.Op != OLITERAL {
- defaultlit2(&l, &r, 1)
- n.Left = l
- n.Right = r
- }
- } else if n.Op == OANDAND || n.Op == OOROR {
- if l.Type == r.Type {
- t = l.Type
- } else if l.Type == idealbool {
- t = r.Type
- } else if r.Type == idealbool {
- t = l.Type
- }
- } else
- // non-comparison operators on ideal bools should make them lose their ideal-ness
- if t == idealbool {
- t = Types[TBOOL]
- }
-
- if et == TSTRING {
- if iscmp[n.Op] {
- n.Etype = n.Op
- n.Op = OCMPSTR
- } else if n.Op == OADD {
- // create OADDSTR node with list of strings in x + y + z + (w + v) + ...
- n.Op = OADDSTR
-
- if l.Op == OADDSTR {
- n.List = l.List
- } else {
- n.List = list1(l)
- }
- if r.Op == OADDSTR {
- n.List = concat(n.List, r.List)
- } else {
- n.List = list(n.List, r)
- }
- n.Left = nil
- n.Right = nil
- }
- }
-
- if et == TINTER {
- if l.Op == OLITERAL && l.Val.Ctype == CTNIL {
- // swap for back end
- n.Left = r
-
- n.Right = l
- } else if r.Op == OLITERAL && r.Val.Ctype == CTNIL {
- } else // leave alone for back end
- if Isinter(r.Type) == Isinter(l.Type) {
- n.Etype = n.Op
- n.Op = OCMPIFACE
- }
- }
-
- if (op == ODIV || op == OMOD) && Isconst(r, CTINT) {
- if mpcmpfixc(r.Val.U.Xval, 0) == 0 {
- Yyerror("division by zero")
- goto error
- }
- }
-
- n.Type = t
- goto ret
-
-doconv:
- ok |= Erv
- saveorignode(n)
- typecheck(&n.Left, Erv|top&(Eindir|Eiota))
- convlit1(&n.Left, n.Type, true)
- t = n.Left.Type
- if t == nil || n.Type == nil {
- goto error
- }
- n.Op = uint8(convertop(t, n.Type, &why))
- if (n.Op) == 0 {
- if n.Diag == 0 && n.Type.Broke == 0 {
- Yyerror("cannot convert %v to type %v%s", Nconv(n.Left, obj.FmtLong), Tconv(n.Type, 0), why)
- n.Diag = 1
- }
-
- n.Op = OCONV
- }
-
- switch n.Op {
- case OCONVNOP:
- if n.Left.Op == OLITERAL && n.Type != Types[TBOOL] {
- r := Nod(OXXX, nil, nil)
- n.Op = OCONV
- n.Orig = r
- *r = *n
- n.Op = OLITERAL
- n.Val = n.Left.Val
- }
-
- // do not use stringtoarraylit.
- // generated code and compiler memory footprint is better without it.
- case OSTRARRAYBYTE:
- break
-
- case OSTRARRAYRUNE:
- if n.Left.Op == OLITERAL {
- stringtoarraylit(&n)
- }
- }
-
- goto ret
-
-ret:
- t = n.Type
+ t := n.Type
if t != nil && t.Funarg == 0 && n.Op != OTYPE {
switch t.Etype {
case TFUNC, // might have TANY; wait until its called
evconst(n)
if n.Op == OTYPE && top&Etype == 0 {
Yyerror("type %v is not an expression", Tconv(n.Type, 0))
- goto error
+ n.Type = nil
+ return
}
if top&(Erv|Etype) == Etype && n.Op != OTYPE {
Yyerror("%v is not a type", Nconv(n, 0))
- goto error
+ n.Type = nil
+ return
}
// TODO(rsc): simplify
if (top&(Ecall|Erv|Etype) != 0) && top&Etop == 0 && ok&(Erv|Etype|Ecall) == 0 {
Yyerror("%v used as value", Nconv(n, 0))
- goto error
+ n.Type = nil
+ return
}
if (top&Etop != 0) && top&(Ecall|Erv|Etype) == 0 && ok&Etop == 0 {
n.Diag = 1
}
- goto error
+ n.Type = nil
+ return
}
/* TODO
if(n->type == T)
fatal("typecheck nil type");
*/
- goto out
-
-badcall1:
- Yyerror("invalid argument %v for %v", Nconv(n.Left, obj.FmtLong), Oconv(int(n.Op), 0))
- goto error
-
-error:
- n.Type = nil
-
-out:
- *np = n
}
func checksliceindex(l *Node, r *Node, tp *Type) int {
}
func typecheckcomplit(np **Node) {
- var nerr int
- var l *Node
- var norig *Node
- var r *Node
- var t *Type
-
n := *np
lno := lineno
+ defer func() {
+ lineno = lno
+ *np = n
+ }()
if n.Right == nil {
if n.List != nil {
setlineno(n.List.N)
}
Yyerror("missing type in composite literal")
- goto error
+ n.Type = nil
+ return
}
// Save original node (including n->right)
- norig = Nod(int(n.Op), nil, nil)
+ norig := Nod(int(n.Op), nil, nil)
*norig = *n
setlineno(n.Right)
- l = typecheck(&n.Right, Etype|Ecomplit) /* sic */
- t = l.Type
+ l := typecheck(&n.Right, Etype|Ecomplit) /* sic */
+ t := l.Type
if t == nil {
- goto error
+ n.Type = nil
+ return
}
- nerr = nerrors
+ nerr := nerrors
n.Type = t
if Isptr[t.Etype] {
// except when using the &T syntax, which sets implicit on the OIND.
if n.Right.Implicit == 0 {
Yyerror("invalid pointer type %v for composite literal (use &%v instead)", Tconv(t, 0), Tconv(t.Type, 0))
- goto error
+ n.Type = nil
+ return
}
// Also, the underlying type must be a struct, map, slice, or array.
if !iscomptype(t) {
Yyerror("invalid pointer type %v for composite literal", Tconv(t, 0))
- goto error
+ n.Type = nil
+ return
}
t = t.Type
}
+ var r *Node
switch t.Etype {
default:
Yyerror("invalid type for composite literal: %v", Tconv(t, 0))
}
if nerr != nerrors {
- goto error
+ n.Type = nil
+ return
}
n.Orig = norig
}
n.Orig = norig
- *np = n
- lineno = lno
return
-
-error:
- n.Type = nil
- *np = n
- lineno = lno
}
/*