code review 186263: eliminate the package global name space assumption in o...

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 "go.h"
 
 /*
  * runtime interface and reflection data structures
  */
 
@@ skipping 156 matching lines @@
                 && f->embedded != 2 && !isifacemethod(f->type))
                         continue;
 
                 b = mal(sizeof(*b));
                 b->link = a;
                 a = b;
 
                 a->name = method->name;
                 a->hash = PRIME8*stringhash(a->name) + PRIME9*typehash(f->type);
                 if(!exportname(a->name)) {
-                        a->package = method->package;
-                        a->hash += PRIME10*stringhash(a->package);
+                        a->pkg = method->pkg;
+                        a->hash += PRIME10*stringhash(a->pkg->name);
                 }
                 a->perm = o++;
                 a->isym = methodsym(method, it);
                 a->tsym = methodsym(method, t);
                 a->type = methodfunc(f->type);
 
                 if(!(a->isym->flags & SymSiggen)) {
                         a->isym->flags |= SymSiggen;
                         if(!eqtype(this, it)) {
                                 if(oldlist == nil)
@@ skipping 54 matching lines @@
                         fatal("imethods: not field");
                 if(f->type->etype != TFUNC || f->sym == nil)
                         continue;
                 b = mal(sizeof(*b));
                 b->link = a;
                 a = b;
 
                 a->name = f->sym->name;
                 a->hash = PRIME8*stringhash(a->name) + PRIME9*typehash(f->type);
                 if(!exportname(a->name)) {
-                        a->package = f->sym->package;
-                        a->hash += PRIME10*stringhash(a->package);
+                        a->pkg = f->sym->pkg;
+                        a->hash += PRIME10*stringhash(a->pkg->name);
                 }
                 a->perm = o++;
                 a->offset = 0;
                 a->type = methodfunc(f->type);
         }
 
         return lsort(a, sigcmp);
 }
 
+static int
+dgopkgpath(Sym *s, int ot, Pkg *pkg)
+{
+        if(pkg == nil)
+                return dgostringptr(s, ot, nil);
+
+        // PGNS: This needs to be import path instead of pkg->name,
+        // but we need to figure out how to fill it in during 6l when
+        // trying to refer to localpkg.
+        return dgostringptr(s, ot, pkg->name);
+}
+
+
 /*
  * uncommonType
  * ../../pkg/runtime/type.go:/uncommonType
  */
 static Sym*
 dextratype(Type *t)
 {
         int ot, n;
         char *p;
         Sym *s;
         Sig *a, *m;
 
         m = methods(t);
         if(t->sym == nil && m == nil)
                 return nil;
 
         n = 0;
         for(a=m; a; a=a->link) {
                 dtypesym(a->type);
                 n++;
         }
 
-        p = smprint("%#-T", t);
-        s = pkglookup(p, "extratype");
+        p = smprint("_.%#T", t);
+        s = pkglookup(p, typepkg);
         ot = 0;
         if(t->sym) {
                 ot = dgostringptr(s, ot, t->sym->name);
                 if(t != types[t->etype])
-                        ot = dgostringptr(s, ot, t->sym->package);
+                        ot = dgopkgpath(s, ot, t->sym->pkg);
                 else
                         ot = dgostringptr(s, ot, nil);
         } else {
                 ot = dgostringptr(s, ot, nil);
                 ot = dgostringptr(s, ot, nil);
         }
 
         // slice header
         ot = dsymptr(s, ot, s, ot + widthptr + 2*4);
         ot = duint32(s, ot, n);
         ot = duint32(s, ot, n);
 
         // methods
         for(a=m; a; a=a->link) {
                 // method
                 // ../../pkg/runtime/type.go:/method
                 ot = duint32(s, ot, a->hash);
                 ot = rnd(ot, widthptr);
                 ot = dgostringptr(s, ot, a->name);
-                ot = dgostringptr(s, ot, a->package);
+                ot = dgopkgpath(s, ot, a->pkg);
                 ot = dsymptr(s, ot, dtypesym(a->type), 0);
                 if(a->isym)
                         ot = dsymptr(s, ot, a->isym, 0);
                 else
                         ot = duintptr(s, ot, 0);
                 if(a->tsym)
                         ot = dsymptr(s, ot, a->tsym, 0);
                 else
                         ot = duintptr(s, ot, 0);
         }
@@ skipping 105 matching lines @@
                 fatal("typestruct %lT", t);
                 return nil;     // silence gcc
         }
 
         if(isslice(t))
                 name = "*runtime.SliceType";
 
         if(isptr[et] && t->type->etype == TANY)
                 name = "*runtime.UnsafePointerType";
 
-        return pkglookup(name, "type");
+        return pkglookup(name, typepkg);
 }
 
 static int
 haspointers(Type *t)
 {
         Type *t1;
 
         switch(t->etype) {
         case TINT:
         case TUINT:
@@ skipping 94 matching lines @@
         return ot;
 }
 
 Sym*
 typesym(Type *t)
 {
         char *p;
         Sym *s;
 
         p = smprint("%#-T", t);
-        s = pkglookup(p, "type");
+        s = pkglookup(p, typepkg);
         free(p);
         return s;
 }
 
 Node*
 typename(Type *t)
 {
         Sym *s;
         Node *n;
 
@@ skipping 42 matching lines @@
         // emit the type structures for int, float, etc.
         t1 = T;
         if(isptr[t->etype])
                 t1 = t->type;
         tsym = S;
         if(t1)
                 tsym = t1->sym;
         else
                 tsym = t->sym;
 
-        if(strcmp(package, "runtime") == 0) {
+        // PGNS: Fixme
+        if(strcmp(localpkg->name, "runtime") == 0) {
                 if(t == types[t->etype])
                         goto ok;
                 if(t1 && t1 == types[t1->etype])
                         goto ok;
                 if(t1 && t1->etype == tptr && t1->type->etype == TANY)
                         goto ok;
         }
 
         // named types from other files are defined in those files
         if(t->sym && !t->local)
@@ skipping 68 matching lines @@
                 // ../../pkg/runtime/type.go:/InterfaceType
                 ot = dcommontype(s, ot, t);
                 ot = dsymptr(s, ot, s, ot+widthptr+2*4);
                 ot = duint32(s, ot, n);
                 ot = duint32(s, ot, n);
                 for(a=m; a; a=a->link) {
                         // ../../pkg/runtime/type.go:/imethod
                         ot = duint32(s, ot, a->hash);
                         ot = duint32(s, ot, a->perm);
                         ot = dgostringptr(s, ot, a->name);
-                        ot = dgostringptr(s, ot, a->package);
+                        ot = dgopkgpath(s, ot, a->pkg);
                         ot = dsymptr(s, ot, dtypesym(a->type), 0);
                 }
                 break;
 
         case TMAP:
                 // ../../pkg/runtime/type.go:/MapType
                 s1 = dtypesym(t->down);
                 s2 = dtypesym(t->type);
                 ot = dcommontype(s, ot, t);
                 ot = dsymptr(s, ot, s1, 0);
@@ skipping 24 matching lines @@
                 ot = dsymptr(s, ot, s, ot+widthptr+2*4);
                 ot = duint32(s, ot, n);
                 ot = duint32(s, ot, n);
                 for(t1=t->type; t1!=T; t1=t1->down) {
                         // ../../pkg/runtime/type.go:/structField
                         if(t1->sym && !t1->embedded) {
                                 ot = dgostringptr(s, ot, t1->sym->name);
                                 if(exportname(t1->sym->name))
                                         ot = dgostringptr(s, ot, nil);
                                 else
-                                        ot = dgostringptr(s, ot, t1->sym->package);
+                                        ot = dgopkgpath(s, ot, t1->sym->pkg);
                         } else {
                                 ot = dgostringptr(s, ot, nil);
                                 ot = dgostringptr(s, ot, nil);
                         }
                         ot = dsymptr(s, ot, dtypesym(t1->type), 0);
                         ot = dgostrlitptr(s, ot, t1->note);
                         ot = duintptr(s, ot, t1->width);        // field offset
                 }
                 break;
         }
@@ skipping 28 matching lines @@
                 if(t->sym && !isptr[t->etype])
                         dtypesym(ptrto(t));
         }
 
         // do basic types if compiling package runtime.
         // they have to be in at least one package,
         // and reflect is always loaded implicitly,
         // so this is as good as any.
         // another possible choice would be package main,
         // but using runtime means fewer copies in .6 files.
-        if(strcmp(package, "runtime") == 0) {
+        if(strcmp(localpkg->name, "runtime") == 0) {    // PGNS: fixme
                 for(i=1; i<=TBOOL; i++)
                         dtypesym(ptrto(types[i]));
                 dtypesym(ptrto(types[TSTRING]));
                 dtypesym(typ(TDDD));
-                dtypesym(ptrto(pkglookup("Pointer", "unsafe")->def->type));
+                dtypesym(ptrto(pkglookup("Pointer", unsafepkg)->def->type));
         }
 }