code review 4527091: gc: make merely referencing an outer variable in a clos...

src/cmd/gc/go.h

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include        <u.h>
 #include        <libc.h>
 #include        <bio.h>
 
 #undef OAPPEND
 
@@ skipping 236 matching lines @@
         NodeList*       cvars;  // closure params
         NodeList*       dcl;    // autodcl for this func/closure
 
         // OLITERAL/OREGISTER
         Val     val;
 
         // ONAME
         Node*   ntype;
         Node*   defn;
         Node*   pack;   // real package for import . names
+        Node*   curfn;  // function for local variables
 
         // ONAME func param with PHEAP
         Node*   heapaddr;       // temp holding heap address of param
         Node*   stackparam;     // OPARAM node referring to stack copy of param
         Node*   alloc;  // allocation call
 
         // ONAME closure param with PPARAMREF
         Node*   outer;  // outer PPARAMREF in nested closure
         Node*   closure;        // ONAME/PHEAP <-> ONAME/PPARAMREF
 
@@ skipping 243 matching lines @@
         PPARAM,
         PPARAMOUT,
         PPARAMREF,      // param passed by reference
         PFUNC,
 
         PHEAP = 1<<7,
 };
 
 enum
 {
-        Etop = 1<<1,    // evaluated at statement level
-        Erv = 1<<2,     // evaluated in value context
+        Etop = 1<<1,            // evaluated at statement level
+        Erv = 1<<2,             // evaluated in value context
         Etype = 1<<3,
-        Ecall = 1<<4,   // call-only expressions are ok
+        Ecall = 1<<4,           // call-only expressions are ok
         Efnstruct = 1<<5,       // multivalue function returns are ok
         Eiota = 1<<6,           // iota is ok
         Easgn = 1<<7,           // assigning to expression
         Eindir = 1<<8,          // indirecting through expression
         Eaddr = 1<<9,           // taking address of expression
+        Eproc = 1<<10,          // inside a go statement
 };
 
 #define BITS    5
 #define NVAR    (BITS*sizeof(uint32)*8)
 
 typedef struct  Bits    Bits;
 struct  Bits
 {
         uint32  b[BITS];
 };
@@ skipping 269 matching lines @@
 Bits    bnot(Bits a);
 int     bnum(Bits a);
 Bits    bor(Bits a, Bits b);
 int     bset(Bits a, uint n);
 
 /*
  *      closure.c
  */
 Node*   closurebody(NodeList *body);
 void    closurehdr(Node *ntype);
-void    typecheckclosure(Node *func);
+void    typecheckclosure(Node *func, int top);
 Node*   walkclosure(Node *func, NodeList **init);
 void    walkcallclosure(Node *n, NodeList **init);
 
 /*
  *      const.c
  */
 int     cmpslit(Node *l, Node *r);
 int     consttype(Node *n);
 void    convconst(Node *con, Type *t, Val *val);
 void    convlit(Node **np, Type *t);
@@ skipping 413 matching lines @@
 int     isfat(Type*);
 Plist*  newplist(void);
 Node*   nodarg(Type*, int);
 void    nopout(Prog*);
 void    patch(Prog*, Prog*);
 void    zfile(Biobuf *b, char *p, int n);
 void    zhist(Biobuf *b, int line, vlong offset);
 void    zname(Biobuf *b, Sym *s, int t);
 void    data(void);
 void    text(void);