code review 4634073: gc: Escape analysis.

src/cmd/gc/dcl.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.
 
 #include        "go.h"
 #include        "y.tab.h"
 
 static  void    funcargs(Node*);
 
 static int
@@ skipping 439 matching lines @@
         case OTYPE:
         case OLITERAL:
                 return n->sym != S;
         }
         return 0;
 }
 
 void
 colasdefn(NodeList *left, Node *defn)
 {
-        int nnew;
+        int nnew, nerr;
         NodeList *l;
         Node *n;
 
         nnew = 0;
+        nerr = 0;
         for(l=left; l; l=l->next) {
                 n = l->n;
                 if(isblank(n))
                         continue;
                 if(!colasname(n)) {
                         yyerror("non-name %#N on left side of :=", n);
+                        nerr++;
                         continue;
                 }
                 if(n->sym->block == block)
                         continue;
 
                 nnew++;
                 n = newname(n->sym);
                 declare(n, dclcontext);
                 n->defn = defn;
                 defn->ninit = list(defn->ninit, nod(ODCL, n, N));
                 l->n = n;
         }
-        if(nnew == 0)
+        if(nnew == 0 && nerr == 0)
                 yyerror("no new variables on left side of :=");
 }
 
 Node*
 colas(NodeList *left, NodeList *right)
 {
         Node *as;
 
         as = nod(OAS2, N, N);
         as->list = left;
@@ skipping 243 matching lines @@
                                 // right now all we need is the name list.
                                 // avoids cycles for recursive interface types.
                                 n->type = typ(TINTERMETH);
                                 n->type->nname = n->right;
                                 n->right = N;
                                 left->type = n->type;
                                 queuemethod(n);
                         } else {
                                 typecheck(&n->right, Etype);
                                 n->type = n->right->type;
-                                if(n->type == T) {
-                                        *t0 = T;
-                                        return t0;
-                                }
+                                if(n->type == T)
+                                        continue;
                                 if(left != N)
                                         left->type = n->type;
                                 n->right = N;
                                 if(n->embedded && n->type != T) {
                                         t1 = n->type;
                                         if(t1->sym == S && isptr[t1->etype]) {
                                                 t1 = t1->type;
                                                 if(t1->etype == TINTER)
                                                         yyerror("embedded type cannot be a pointer to interface");
                                         }
@@ skipping 53 matching lines @@
                         continue;
                 }
 
                 f = typ(TFIELD);
                 f->type = n->type;
                 f->note = note;
                 f->width = BADWIDTH;
                 f->isddd = n->isddd;
 
                 // esc.c needs to find f given a PPARAM to add the tag.
-                if (funarg && n->left && n->left->class == PPARAM) {
+                if(funarg && n->left && n->left->class == PPARAM)
                         n->left->paramfld = f;
-                }
 
                 if(left != N && left->op == ONAME) {
                         f->nname = left;
                         f->embedded = n->embedded;
                         f->sym = f->nname->sym;
                         if(importpkg && !exportname(f->sym->name))
                                 f->sym = pkglookup(f->sym->name, structpkg);
                         if(f->sym && !isblank(f->nname)) {
                                 for(t1=*t0; t1!=T; t1=t1->down) {
                                         if(t1->sym == f->sym) {
@@ skipping 238 matching lines @@
         // we want to see *t, not t0, in the method name.
         if(t != t0 && t0->sym)
                 t0 = ptrto(t);
 
         suffix = "";
         if(iface) {
                 dowidth(t0);
                 if(t0->width < types[tptr]->width)
                         suffix = "·i";
         }
-        p = smprint("%#hT·%s%s", t0, nsym->name, suffix);
+        if(t0->sym == S && isptr[t0->etype])
+                p = smprint("(%#hT).%s%s", t0, nsym->name, suffix);
+        else
+                p = smprint("%#hT.%s%s", t0, nsym->name, suffix);
         s = pkglookup(p, s->pkg);
         free(p);
         return s;
 
 bad:
         yyerror("illegal receiver type: %T", t0);
         return S;
 }
 
 Node*
 methodname(Node *n, Type *t)
 {
         Sym *s;
 
         s = methodsym(n->sym, t, 0);
         if(s == S)
                 return n;
         return newname(s);
 }
 
 Node*
 methodname1(Node *n, Node *t)
 {
         char *star;
         char *p;
 
-        star = "";
+        star = nil;
         if(t->op == OIND) {
                 star = "*";
                 t = t->left;
         }
         if(t->sym == S || isblank(n))
                 return newname(n->sym);
-        p = smprint("%s%S·%S", star, t->sym, n->sym);
+        if(star)
+                p = smprint("(%s%S).%S", star, t->sym, n->sym);
+        else
+                p = smprint("%S.%S", t->sym, n->sym);
         n = newname(pkglookup(p, t->sym->pkg));
         free(p);
         return n;
 }
 
 /*
  * add a method, declared as a function,
  * n is fieldname, pa is base type, t is function type
  */
 void
@@ skipping 114 matching lines @@
         dclcontext = PAUTO;
         funcdepth = n->funcdepth + 1;
         compile(n);
         curfn = nil;
         funcdepth = 0;
         dclcontext = PEXTERN;
 }