code review 5316043: gc: clean up printing.

src/cmd/gc/reflect.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 <u.h>
 #include <libc.h>
 #include "go.h"
 
 /*
  * runtime interface and reflection data structures
@@ skipping 574 matching lines @@
         ot = duint32(s, ot, typehash(t));
         ot = duint8(s, ot, algtype(t));
         ot = duint8(s, ot, t->align);   // align
         ot = duint8(s, ot, t->align);   // fieldAlign
         i = kinds[t->etype];
         if(t->etype == TARRAY && t->bound < 0)
                 i = KindSlice;
         if(!haspointers(t))
                 i |= KindNoPointers;
         ot = duint8(s, ot, i);  // kind
-        longsymnames = 1;
-        p = smprint("%-T", t);
-        longsymnames = 0;
+        p = smprint("%-uT", t);
+        //print("dcommontype: %s\n", p);
         ot = dgostringptr(s, ot, p);    // string
         free(p);
 ········
         // skip pointer to extraType,
         // which follows the rest of this type structure.
         // caller will fill in if needed.
         // otherwise linker will assume 0.
         ot += widthptr;
 
         ot = dsymptr(s, ot, sptr, 0);  // ptrto type
         return ot;
 }
 
 Sym*
 typesym(Type *t)
 {
         char *p;
         Sym *s;
 
-        p = smprint("%#-T", t);
+        p = smprint("%-T", t);
         s = pkglookup(p, typepkg);
+        //print("typesym: %s -> %+S\n", p, s);
         free(p);
         return s;
 }
 
 Node*
 typename(Type *t)
 {
         Sym *s;
         Node *n;
 
@@ skipping 26 matching lines @@
         char *p;
         Sym *s;
         static Pkg *weak;
 ········
         if(weak == nil) {
                 weak = mkpkg(strlit("weak.type"));
                 weak->name = "weak.type";
                 weak->prefix = "weak.type";  // not weak%2etype
         }
 ········
-        p = smprint("%#-T", t);
+        if (t == bytetype || t == runetype)

[rsc, 2011/10/31 15:04:45]

This should be unnecessary: the print format should do this.
If this is necessary, it means the print format is broken for
the cases where these types appear inside other types.
Also, this code is not in typesym above, so it seems likely
that this is a dreg and can just be deleted.

[lvd, 2011/10/31 15:39:55]

yes, leftover from earlier iteration.  gone.

+                t = types[t->etype];
+
+        p = smprint("%-T", t);
         s = pkglookup(p, weak);
+        //print("weaktypesym: %s -> %+S\n", p, s);
         free(p);
         return s;
 }
 
 static Sym*
 dtypesym(Type *t)
 {
         int ot, xt, n, isddd, dupok;
         Sym *s, *s1, *s2;
         Sig *a, *m;
@@ skipping 224 matching lines @@
                 for(i=1; i<=TBOOL; i++)
                         dtypesym(ptrto(types[i]));
                 dtypesym(ptrto(types[TSTRING]));
                 dtypesym(ptrto(types[TUNSAFEPTR]));
 ················
                 // add paths for runtime and main, which 6l imports implicitly.
                 dimportpath(runtimepkg);
                 dimportpath(mkpkg(strlit("main")));
         }
 }