code review 5370066: gc: fix newlines in %+N

src/cmd/gc/fmt.c

 // Copyright 2011 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        "go.h"
 #include        "opnames.h"
 
 //
@@ skipping 10 matching lines @@
 //
 //      %V Val*         Constant values
 //
 //      %S Sym*         Symbols
 //              Flags: +,- #: mode (see below)
 //                      "%hS"   unqualified identifier in any mode
 //                      "%hhS"  strip type qualifier off of method name
 //
 //      %T Type*        Types
 //              Flags: +,- #: mode (see below)
-//                      'l' definition instead of name. 
+//                      'l' definition instead of name.
 //                      'h' omit "func" and receiver in function types
-//                      'u' (only in -/Sym mode) print type identifiers wit package name instead of prefix. 
+//                      'u' (only in -/Sym mode) print type identifiers wit package name instead of prefix.
 //
 //      %N Node*        Nodes
 //              Flags: +,- #: mode (see below)
 //                      'h' (only in +/debug mode) suppress recursion
 //                      'l' (only in Error mode) print "foo (type Bar)"
 //
 //      %H NodeList*    NodeLists
 //              Flags: those of %N
 //                      ','  separate items with ',' instead of ';'
 //
-//      %Z Strlit*      String literals 
+//      %Z Strlit*      String literals
 //
 //   In mparith1.c:
 //      %B Mpint*       Big integers
 //      %F Mpflt*       Big floats
 //
 //   %S, %T and %N obey use the following flags to set the format mode:
 enum {
         FErr,   //     error mode (default)
         FDbg,   //     "%+N" debug mode
         FExp,   //     "%#N" export mode
@@ skipping 480 matching lines @@
         [TSTRING]       = "string",
         [TNIL]          = "nil",
         [TIDEAL]        = "ideal",
         [TBLANK]        = "blank",
 };
 
 static int
 typefmt(Fmt *fp, Type *t)
 {
         Type *t1;
+        Sym *s;
 
         if(t == T)
                 return fmtstrcpy(fp, "<T>");
 
         if (t == bytetype || t == runetype) {
                 // in %-T mode collapse rune and byte with their originals.
                 if(fmtmode != FTypeId)
                         return fmtprint(fp, "%hS", t->sym);
                 t = types[t->etype];
         }
@@ skipping 118 matching lines @@
                                 if(t1->down)
                                         fmtprint(fp, " %T;", t1);
                                 else
                                         fmtprint(fp, " %T ", t1);
                         fmtstrcpy(fp, "}");
                 }
                 return 0;
 
         case TFIELD:
                 if(!(fp->flags&FmtShort)) {
-                        if(t->sym != S && !t->embedded)
-                                fmtprint(fp, "%hS ", t->sym);
-                        if((!t->sym || t->embedded) && fmtmode == FExp)
-                                fmtstrcpy(fp, "? ");
+                        s = t->sym;
+                        switch(fmtmode) {
+                        case FErr:
+                        case FExp:
+                                // Take the name from the original, lest we substituted it with .anon%d
+                                if (t->nname)
+                                        s = t->nname->orig->sym;
+
+                                if((s == S || t->embedded)) {
+                                        fmtstrcpy(fp, "? ");
+                                        break;
+                                }
+                                // fallthrough
+                        default:
+                                if(!(s == S || t->embedded))
+                                        fmtprint(fp, "%hS ", s);
+                        }
                 }
 
                 if(t->isddd)
                         fmtprint(fp, "...%T", t->type->type);
                 else
                         fmtprint(fp, "%T", t->type);
 
                 if(!(fp->flags&FmtShort) && t->note)
                         fmtprint(fp, " \"%Z\"", t->note);
                 return 0;
@@ skipping 84 matching lines @@
 
         case OAS2:
                 if(n->colas && !complexinit) {
                         fmtprint(f, "%,H := %,H", n->list, n->rlist);
                         break;
                 }
                 // fallthrough
         case OAS2DOTTYPE:
         case OAS2FUNC:
         case OAS2MAPR:
-        case OAS2MAPW:
         case OAS2RECV:
                 fmtprint(f, "%,H = %,H", n->list, n->rlist);
                 break;
 
         case ORETURN:
                 fmtprint(f, "return %,H", n->list);
                 break;
 
         case OPROC:
                 fmtprint(f, "go %N", n->left);
@@ skipping 158 matching lines @@
         [OSEND] = 3,
         [OANDAND] = 2,
         [OOROR] = 1,
 
         // Statements handled by stmtfmt
         [OAS] = -1,
         [OAS2] = -1,
         [OAS2DOTTYPE] = -1,
         [OAS2FUNC] = -1,
         [OAS2MAPR] = -1,
-        [OAS2MAPW] = -1,
         [OAS2RECV] = -1,
         [OASOP] = -1,
         [OBREAK] = -1,
         [OCASE] = -1,
         [OCONTINUE] = -1,
         [ODCL] = -1,
         [ODCLFIELD] = -1,
         [ODEFER] = -1,
         [OFALL] = -1,
         [OFOR] = -1,
@@ skipping 530 matching lines @@
 dumplist(char *s, NodeList *l)
 {
         print("%s\n%+H\n", s, l);
 }
 
 void
 dump(char *s, Node *n)
 {
         print("%s [%p]\n%+N\n", s, n, n);
 }