This prevents conversion noise.
No functional changes. Passes toolstash -cmp.
Change-Id: I238adf28680f875217827931a689ce7f19a9b371
Reviewed-on: https://go-review.googlesource.com/8164
Reviewed-by: David Chase <drchase@google.com>
var declare_typegen int
-func declare(n *Node, ctxt int) {
+func declare(n *Node, ctxt uint8) {
if ctxt == PDISCARD {
return
}
autoexport(n, ctxt)
}
-func addvar(n *Node, t *Type, ctxt int) {
+func addvar(n *Node, t *Type, ctxt uint8) {
if n == nil || n.Sym == nil || (n.Op != ONAME && n.Op != ONONAME) || t == nil {
Fatal("addvar: n=%v t=%v nil", Nconv(n, 0), Tconv(t, 0))
}
return sym.Pkg == localpkg && exportname(sym.Name)
}
-func autoexport(n *Node, ctxt int) {
+func autoexport(n *Node, ctxt uint8) {
if n == nil || n.Sym == nil {
return
}
// declaration context
const (
- Pxxx = iota
+ Pxxx = uint8(iota)
PEXTERN // global variable
PAUTO // local variables
PPARAM // input arguments
PDISCARD // discard during parse of duplicate import
- PHEAP = 1 << 7 // an extra bit to identify an escaped variable
+ PHEAP = uint8(1 << 7) // an extra bit to identify an escaped variable
)
const (
var funcsyms *NodeList
-var dclcontext int // PEXTERN/PAUTO
+var dclcontext uint8 // PEXTERN/PAUTO
var incannedimport int
return
}
var a *Node
- var class int
+ var class uint8
for l := fn.Func.Dcl; l != nil; l = l.Next {
a = l.N
- class = int(a.Class) &^ PHEAP
+ class = a.Class &^ PHEAP
if a.Op == ONAME && (class == PPARAM || class == PPARAMOUT) && a == n {
return
}
if isartificial(b) {
return false
}
- class := int(b.Class)
+ class := b.Class
// BUG: we _may_ want to instrument PAUTO sometimes
// e.g. if we've got a local variable/method receiver
// so that reorder3 can fix up conflicts
var rl *NodeList
- var cl int
+ var cl uint8
for ll := Curfn.Func.Dcl; ll != nil; ll = ll.Next {
- cl = int(ll.N.Class) &^ PHEAP
+ cl = ll.N.Class &^ PHEAP
if cl == PAUTO {
break
}