code review 4634073: gc: Escape analysis.

src/cmd/gc/typecheck.c

 // 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.
 
 /*
  * type check the whole tree of an expression.
  * calculates expression types.
  * evaluates compile time constants.
  * marks variables that escape the local frame.
  * rewrites n->op to be more specific in some cases.
@@ skipping 105 matching lines @@
         Val v;
         char *why;
 
         // cannot type check until all the source has been parsed
         if(!typecheckok)
                 fatal("early typecheck");
 
         n = *np;
         if(n == N)
                 return N;
+········
+        lno = setlineno(n);
+
+        // Skip over parens.
+        while(n->op == OPAREN)
+                n = n->left;
 
         // Resolve definition of name and value of iota lazily.
         n = resolve(n);
+
         *np = n;
 
         // Skip typecheck if already done.
         // But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
         if(n->typecheck == 1) {
                 switch(n->op) {
                 case ONAME:
                 case OTYPE:
                 case OLITERAL:
                 case OPACK:
                         break;
                 default:
+                        lineno = lno;
                         return n;
                 }
         }
 
         if(n->typecheck == 2) {
                 yyerror("typechecking loop");
+                lineno = lno;
                 return n;
         }
         n->typecheck = 2;
 
-        lno = setlineno(n);
         if(n->sym) {
                 if(n->op == ONAME && n->etype != 0 && !(top & Ecall)) {
                         yyerror("use of builtin %S not in function call", n->sym);
                         goto error;
                 }
 
                 // a dance to handle forward-declared recursive pointer types.
                 if(n->op == OTYPE && (ft = getforwtype(n->ntype)) != T)
                         defertypecopy(n, ft);
 
@@ skipping 69 matching lines @@
 ········
         case OTARRAY:
                 ok |= Etype;
                 t = typ(TARRAY);
                 l = n->left;
                 r = n->right;
                 if(l == nil) {
                         t->bound = -1;  // slice
                 } else if(l->op == ODDD) {
                         t->bound = -100;        // to be filled in
+                        if(!(top&Ecomplit))
+                                yyerror("use of [...] array outside of array literal");
                 } else {
                         l = typecheck(&n->left, Erv);
                         switch(consttype(l)) {
                         case CTINT:
                                 v = l->val;
                                 break;
                         case CTFLT:
                                 v = toint(l->val);
                                 break;
                         default:
@@ skipping 773 matching lines @@
                 n->type = types[TINT];
                 typecheck(&n->left, Erv);
                 typecheck(&n->right, Erv);
                 if(n->left->type == T || n->right->type == T)
                         goto error;
                 defaultlit(&n->left, T);
                 defaultlit(&n->right, T);
 ················
                 // copy([]byte, string)
                 if(isslice(n->left->type) && n->right->type->etype == TSTRING) {
-                        if (n->left->type->type == types[TUINT8])
+                        if(n->left->type->type == types[TUINT8])
                                 goto ret;
                         yyerror("arguments to copy have different element types: %lT and string", n->left->type);
                         goto error;
                 }
 ·······························
                 if(!isslice(n->left->type) || !isslice(n->right->type)) {
                         if(!isslice(n->left->type) && !isslice(n->right->type))
                                 yyerror("arguments to copy must be slices; have %lT, %lT", n->left->type, n->right->type);
                         else if(!isslice(n->left->type))
                                 yyerror("first argument to copy should be slice; have %lT", n->left->type);
@@ skipping 293 matching lines @@
         t = n->type;
         if(t && !t->funarg && n->op != OTYPE) {
                 switch(t->etype) {
                 case TFUNC:     // might have TANY; wait until its called
                 case TANY:
                 case TFORW:
                 case TIDEAL:
                 case TNIL:
                 case TBLANK:
                         break;
-                case TARRAY:
-                        if(t->bound == -100) {
-                                yyerror("use of [...] array outside of array literal");
-                                t->bound = 1;
-                        }
                 default:
                         checkwidth(t);
                 }
         }
 
         // TODO(rsc): should not need to check importpkg,
         // but reflect mentions unsafe.Pointer.
         if(safemode && !incannedimport && !importpkg && t && t->etype == TUNSAFEPTR)
                 yyerror("cannot use unsafe.Pointer");
 
@@ skipping 230 matching lines @@
                 return 1;
         }
 
         if(f2 != T) {
                 tt = n->left->type;
                 dowidth(tt);
                 rcvr = getthisx(f2->type)->type->type;
                 if(!eqtype(rcvr, tt)) {
                         if(rcvr->etype == tptr && eqtype(rcvr->type, tt)) {
                                 checklvalue(n->left, "call pointer method on");
-                                if (!debug['s']) addrescapes(n->left);
+                                if(!debug['s'])
+                                        addrescapes(n->left);
                                 n->left = nod(OADDR, n->left, N);
                                 n->left->implicit = 1;
                                 typecheck(&n->left, Etype|Erv);
                         } else if(tt->etype == tptr && eqtype(tt->type, rcvr)) {
                                 n->left = nod(OIND, n->left, N);
                                 n->left->implicit = 1;
                                 typecheck(&n->left, Etype|Erv);
                         } else {
                                 // method is attached to wrong type?
                                 fatal("method mismatch: %T for %T", rcvr, tt);
@@ skipping 353 matching lines @@
         lno = lineno;
 
         if(n->right == N) {
                 if(n->list != nil)
                         setlineno(n->list->n);
                 yyerror("missing type in composite literal");
                 goto error;
         }
 
         setlineno(n->right);
-        l = typecheck(&n->right /* sic */, Etype);
+        l = typecheck(&n->right /* sic */, Etype|Ecomplit);
         if((t = l->type) == T)
                 goto error;
         nerr = nerrors;
 
         // can omit type on composite literal values if the outer
         // composite literal is array, slice, or map, and the·
         // element type is itself a struct, array, slice, or map.
         pushtype = T;
         if(t->etype == TARRAY || t->etype == TMAP) {
                 pushtype = t->type;
@@ skipping 47 matching lines @@
                                         setlineno(l);
                                         yyerror("array index %d out of bounds [0:%d]", len, t->bound);
                                         t->bound = -1;  // no more errors
                                 }
                         }
 
                         if(l->right->op == OCOMPLIT && l->right->right == N && pushtype != T)
                                 l->right->right = typenod(pushtype);
                         typecheck(&l->right, Erv);
                         defaultlit(&l->right, t->type);
-                        l->right = assignconv(l->right, t->type, "array index");
+                        l->right = assignconv(l->right, t->type, "array element");
                 }
                 if(t->bound == -100)
                         t->bound = len;
                 if(t->bound < 0)
                         n->right = nodintconst(len);
                 n->op = OARRAYLIT;
                 break;
 
         case TMAP:
                 nhash = inithash(n, &hash, autohash, nelem(autohash));
@@ skipping 321 matching lines @@
 }
 
 /*
  * type check function definition
  */
 static void
 typecheckfunc(Node *n)
 {
         Type *t, *rcvr;
 
-//dump("nname", n->nname);
         typecheck(&n->nname, Erv | Easgn);
         if((t = n->nname->type) == T)
                 return;
         n->type = t;
 
         rcvr = getthisx(t)->type;
         if(rcvr != nil && n->shortname != N && !isblank(n->shortname))
                 addmethod(n->shortname->sym, t, 1);
 }
 
@@ skipping 289 matching lines @@
                         convlit(&e, t);
                 }
                 n->val = e->val;
                 n->type = e->type;
                 break;
 
         case ONAME:
                 if(n->ntype != N) {
                         typecheck(&n->ntype, Etype);
                         n->type = n->ntype->type;
+
                         if(n->type == T) {
                                 n->diag = 1;
                                 goto ret;
                         }
                 }
                 if(n->type != T)
                         break;
                 if(n->defn == N) {
                         if(n->etype != 0)       // like OPRINTN
                                 break;
@@ skipping 33 matching lines @@
 ret:
         if(typecheckdefstack->n != n)
                 fatal("typecheckdefstack mismatch");
         l = typecheckdefstack;
         typecheckdefstack = l->next;
 
         lineno = lno;
         n->walkdef = 1;
         return n;
 }