code review 7437043: cmd/gc: unbreak exporting of composite literals.

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 1073 matching lines @@
         [OXCASE] = -1,
         [OXFALL] = -1,
 
         [OEND] = 0
 };
 
 static int
 exprfmt(Fmt *f, Node *n, int prec)
 {
         int nprec;
+        int ptrlit;
         NodeList *l;
 
         while(n && n->implicit && (n->op == OIND || n->op == OADDR))
                 n = n->left;
 
         if(n == N)
                 return fmtstrcpy(f, "<N>");
 
         nprec = opprec[n->op];
         if(n->op == OTYPE && n->sym != S)
@@ skipping 90 matching lines @@
                 return fmtprint(f, "<func>");
 
         case OCLOSURE:
                 if(fmtmode == FErr)
                         return fmtstrcpy(f, "func literal");
                 if(n->nbody)
                         return fmtprint(f, "%T { %H }", n->type, n->nbody);
                 return fmtprint(f, "%T { %H }", n->type, n->closure->nbody);
 
         case OCOMPLIT:
-                if(fmtmode == FErr)
+                ptrlit = n->right != N && n->right->implicit && n->right->type && isptr[n->right->type->etype];
+                if(fmtmode == FErr) {
+                        if(n->right != N && n->right->type != T && !n->implicit) {
+                                if(ptrlit)
+                                        return fmtprint(f, "&%T literal", n->right->type->type);
+                                else
+                                        return fmtprint(f, "%T literal", n->right->type);
+                        }
                         return fmtstrcpy(f, "composite literal");
+                }
+                if(fmtmode == FExp && ptrlit)
+                        // typecheck has overwritten OIND by OTYPE with pointer type.
+                        return fmtprint(f, "&%T{ %,H }", n->right->type->type, n->list);
                 return fmtprint(f, "(%N{ %,H })", n->right, n->list);
 
         case OPTRLIT:
-                if(fmtmode == FExp)  // handle printing of '&' below.
+                if(fmtmode == FExp && n->left->implicit)
                         return fmtprint(f, "%N", n->left);
                 return fmtprint(f, "&%N", n->left);
 
         case OSTRUCTLIT:
                 if(fmtmode == FExp) {   // requires special handling of field names
                         if(n->implicit)
                                 fmtstrcpy(f, "{");
-                        else if(n->right->implicit)
-                                fmtprint(f, "&%T{", n->type);
                         else
                                 fmtprint(f, "(%T{", n->type);
                         for(l=n->list; l; l=l->next) {
                                 fmtprint(f, " %hhS:%N", l->n->left->sym, l->n->right);
 
                                 if(l->next)
                                         fmtstrcpy(f, ",");
                                 else
                                         fmtstrcpy(f, " ");
                         }
-                        if(!n->implicit && !n->right->implicit)
+                        if(!n->implicit)
                                 return fmtstrcpy(f, "})");
                         return fmtstrcpy(f, "}");
                 }
                 // fallthrough
 
         case OARRAYLIT:
         case OMAPLIT:
                 if(fmtmode == FErr)
                         return fmtprint(f, "%T literal", n->type);
                 if(fmtmode == FExp && n->implicit)
                         return fmtprint(f, "{ %,H }", n->list);
-                if(fmtmode == FExp && n->right->implicit)
-                        return fmtprint(f, "&%T{ %,H }", n->type, n->list);
                 return fmtprint(f, "(%T{ %,H })", n->type, n->list);
 
         case OKEY:
-                if(n->left && n->right)
-                        return fmtprint(f, "%N:%N", n->left, n->right);
+                if(n->left && n->right) {
+                        if(fmtmode == FExp && n->left->type && n->left->type->etype == TFIELD) {
+                                // requires special handling of field names
+                                return fmtprint(f, "%hhS:%N", n->left->sym, n->right);
+                        } else
+                                return fmtprint(f, "%N:%N", n->left, n->right);
+                }
                 if(!n->left && n->right)
                         return fmtprint(f, ":%N", n->right);
                 if(n->left && !n->right)
                         return fmtprint(f, "%N:", n->left);
                 return fmtstrcpy(f, ":");
 
         case OXDOT:
         case ODOT:
         case ODOTPTR:
         case ODOTINTER:
@@ skipping 422 matching lines @@
 dumplist(char *s, NodeList *l)
 {
         print("%s%+H\n", s, l);
 }
 
 void
 dump(char *s, Node *n)
 {
         print("%s [%p]%+N\n", s, n, n);
 }