gc: changes in export format in preparation of inlining.

Includes minimal change to gcimporter to keep it working,

R=rsc, gri
CC=golang-dev
https://golang.org/cl/5431046

src/cmd/gc/dcl.c

@@ -8,6 +8,7 @@
 #include	"y.tab.h"
 
 static	void	funcargs(Node*);
+static	void	funcargs2(Type*);
 
 static int
 dflag(void)
@@ -547,13 +548,6 @@ ifacedcl(Node *n)
 void
 funchdr(Node *n)
 {
-
-	if(n->nname != N) {
-		n->nname->op = ONAME;
-		declare(n->nname, PFUNC);
-		n->nname->defn = n;
-	}
-
 	// change the declaration context from extern to auto
 	if(funcdepth == 0 && dclcontext != PEXTERN)
 		fatal("funchdr: dclcontext");
@@ -564,10 +558,13 @@ funchdr(Node *n)
 
 	n->outer = curfn;
 	curfn = n;
+
 	if(n->nname)
 		funcargs(n->nname->ntype);
-	else
+	else if (n->ntype)
 		funcargs(n->ntype);
+	else
+		funcargs2(n->type);
 }
 
 static void
@@ -582,11 +579,11 @@ funcargs(Node *nt)
 
 	// declare the receiver and in arguments.
 	// no n->defn because type checking of func header
-	// will fill in the types before we can demand them.
+	// will not fill in the types until later
 	if(nt->left != N) {
 		n = nt->left;
 		if(n->op != ODCLFIELD)
-			fatal("funcargs1 %O", n->op);
+			fatal("funcargs receiver %O", n->op);
 		if(n->left != N) {
 			n->left->op = ONAME;
 			n->left->ntype = n->right;
@@ -596,7 +593,7 @@ funcargs(Node *nt)
 	for(l=nt->list; l; l=l->next) {
 		n = l->n;
 		if(n->op != ODCLFIELD)
-			fatal("funcargs2 %O", n->op);
+			fatal("funcargs in %O", n->op);
 		if(n->left != N) {
 			n->left->op = ONAME;
 			n->left->ntype = n->right;
@@ -609,7 +606,7 @@ funcargs(Node *nt)
 	for(l=nt->rlist; l; l=l->next) {
 		n = l->n;
 		if(n->op != ODCLFIELD)
-			fatal("funcargs3 %O", n->op);
+			fatal("funcargs out %O", n->op);
 		if(n->left != N) {
 			n->left->op = ONAME;
 			n->left->ntype = n->right;
@@ -627,6 +624,48 @@ funcargs(Node *nt)
 	}
 }
 
+/*
+ * Same as funcargs, except run over an already constructed TFUNC.
+ * This happens during import, where the hidden_fndcl rule has
+ * used functype directly to parse the function's type.
+ */
+static void
+funcargs2(Type *t)
+{
+	Type *ft;
+	Node *n;
+
+	if(t->etype != TFUNC)
+		fatal("funcargs2 %T", t);
+	
+	if(t->thistuple)
+		for(ft=getthisx(t)->type; ft; ft=ft->down) {
+			if(!ft->nname || !ft->nname->sym)
+				continue;
+			n = newname(ft->nname->sym);
+			n->type = ft->type;
+			declare(n, PPARAM);
+		}
+
+	if(t->intuple)
+		for(ft=getinargx(t)->type; ft; ft=ft->down) {
+			if(!ft->nname || !ft->nname->sym)
+				continue;
+			n = newname(ft->nname->sym);
+			n->type = ft->type;
+			declare(n, PPARAM);
+		}
+
+	if(t->outtuple)
+		for(ft=getoutargx(t)->type; ft; ft=ft->down) {
+			if(!ft->nname || !ft->nname->sym)
+				continue;
+			n = newname(ft->nname->sym);
+			n->type = ft->type;
+			declare(n, PPARAMOUT);
+		}
+}
+
 /*
  * finish the body.
  * called in auto-declaration context.
@@ -654,7 +693,7 @@ typedcl0(Sym *s)
 {
 	Node *n;
 
-	n = dclname(s);
+	n = newname(s);
 	n->op = OTYPE;
 	declare(n, dclcontext);
 	return n;
@@ -740,8 +779,6 @@ structfield(Node *n)
 		f->nname = n->left;
 		f->embedded = n->embedded;
 		f->sym = f->nname->sym;
-		if(importpkg && !exportname(f->sym->name))
-			f->sym = pkglookup(f->sym->name, structpkg);
 	}
 
 	lineno = lno;
@@ -778,8 +815,12 @@ tostruct(NodeList *l)
 	Type *t, *f, **tp;
 	t = typ(TSTRUCT);
 
-	for(tp = &t->type; l; l=l->next,tp = &(*tp)->down)
-		*tp = structfield(l->n);
+	for(tp = &t->type; l; l=l->next) {
+		f = structfield(l->n);
+
+		*tp = f;
+		tp = &f->down;
+	}
 
 	for(f=t->type; f && !t->broke; f=f->down)
 		if(f->broke)
@@ -803,7 +844,7 @@ tofunargs(NodeList *l)
 
 	for(tp = &t->type; l; l=l->next) {
 		f = structfield(l->n);
-
+		f->funarg = 1;
 		// esc.c needs to find f given a PPARAM to add the tag.
 		if(l->n->left && l->n->left->class == PPARAM)
 			l->n->left->paramfld = f;
@@ -944,7 +985,10 @@ embedded(Sym *s)
 		*utfrune(name, CenterDot) = 0;
 	}
 
+	if(exportname(name) || s->pkg == builtinpkg)  // old behaviour, tests pass, but is it correct?
 		n = newname(lookup(name));
+	else
+		n = newname(pkglookup(name, s->pkg));
 	n = nod(ODCLFIELD, n, oldname(s));
 	n->embedded = 1;
 	return n;
@@ -1009,6 +1053,17 @@ checkarglist(NodeList *all, int input)
 			t = n;
 			n = N;
 		}
+
+		// during import l->n->op is OKEY, but l->n->left->sym == S
+		// means it was a '?', not that it was
+		// a lone type This doesn't matter for the exported
+		// declarations, which are parsed by rules that don't
+		// use checkargs, but can happen for func literals in
+		// the inline bodies.
+		// TODO(rsc) this can go when typefmt case TFIELD in exportmode fmt.c prints _ instead of ?
+		if(importpkg && n->sym == S)
+			n = N;
+
 		if(n != N && n->sym == S) {
 			t = n;
 			n = N;
@@ -1137,7 +1192,6 @@ methodsym(Sym *nsym, Type *t0, int iface)
 	else
 		p = smprint("%-hT.%s%s", t0, nsym->name, suffix);
 	s = pkglookup(p, s->pkg);
-	//print("methodsym:%s -> %+S\n", p, s);
 	free(p);
 	return s;
 
@@ -1174,6 +1228,10 @@ methodname1(Node *n, Node *t)
 		p = smprint("(%s%S).%S", star, t->sym, n->sym);
 	else
 		p = smprint("%S.%S", t->sym, n->sym);
+
+	if(exportname(t->sym->name))
+		n = newname(lookup(p));
+	else
 		n = newname(pkglookup(p, t->sym->pkg));
 	free(p);
 	return n;
@@ -1234,8 +1292,6 @@ addmethod(Sym *sf, Type *t, int local)
 	}
 
 	pa = f;
-	if(importpkg && !exportname(sf->name))
-		sf = pkglookup(sf->name, importpkg);
 
 	n = nod(ODCLFIELD, newname(sf), N);
 	n->type = t;
@@ -1258,10 +1314,16 @@ addmethod(Sym *sf, Type *t, int local)
 		return;
 	}
 
+	f = structfield(n);
+
+	// during import unexported method names should be in the type's package
+	if(importpkg && f->sym && !exportname(f->sym->name) && f->sym->pkg != structpkg)
+		fatal("imported method name %+S in wrong package %s\n", f->sym, structpkg->name);
+
 	if(d == T)
-		pa->method = structfield(n);
+		pa->method = f;
 	else
-		d->down = structfield(n);
+		d->down = f;
 	return;
 }
 

src/cmd/gc/export.c

@@ -7,11 +7,9 @@
 #include	"go.h"
 #include	"y.tab.h"
 
-static	void	dumpsym(Sym*);
 static void	dumpexporttype(Type*);
-static	void	dumpexportvar(Sym*);
-static	void	dumpexportconst(Sym*);
 
+// Mark n's symbol as exported
 void
 exportsym(Node *n)
 {
@@ -27,6 +25,7 @@ exportsym(Node *n)
 	exportlist = list(exportlist, n);
 }
 
+// Mark n's symbol as package-local
 static void
 packagesym(Node *n)
 {
@@ -178,7 +177,7 @@ dumpexporttype(Type *t)
 	Bprint(bout, "\ttype %#S %#lT\n", t->sym, t);
 	for(i=0; i<n; i++) {
 		f = m[i];
-		Bprint(bout, "\tfunc (%#T) %#hS%#hT\n", getthisx(f->type)->type, f->sym, f->type);
+		Bprint(bout, "\tfunc (%#T) %#hhS%#hT\n", getthisx(f->type)->type, f->sym, f->type);
 	}
 }
 
@@ -200,15 +199,18 @@ dumpsym(Sym *s)
 	default:
 		yyerror("unexpected export symbol: %O %S", s->def->op, s);
 		break;
+
 	case OLITERAL:
 		dumpexportconst(s);
 		break;
+
 	case OTYPE:
 		if(s->def->type->etype == TFORW)
 			yyerror("export of incomplete type %S", s);
 		else
 			dumpexporttype(s->def->type);
 		break;
+
 	case ONAME:
 		dumpexportvar(s);
 		break;
@@ -286,12 +288,25 @@ pkgtype(Sym *s)
 	return s->def->type;
 }
 
-static int
-mypackage(Sym *s)
+void
+importimport(Sym *s, Strlit *z)
 {
-	// we import all definitions for runtime.
-	// lowercase ones can only be used by the compiler.
-	return s->pkg == localpkg || s->pkg == runtimepkg;
+	// Informational: record package name
+	// associated with import path, for use in
+	// human-readable messages.
+	Pkg *p;
+
+	p = mkpkg(z);
+	if(p->name == nil) {
+		p->name = s->name;
+		pkglookup(s->name, nil)->npkg++;
+	} else if(strcmp(p->name, s->name) != 0)
+		yyerror("conflicting names %s and %s for package \"%Z\"", p->name, s->name, p->path);
+	
+	if(!incannedimport && myimportpath != nil && strcmp(z->s, myimportpath) == 0) {
+		yyerror("import \"%Z\": package depends on \"%Z\" (import cycle)", importpkg->path, z);
+		errorexit();
+	}
 }
 
 void
@@ -299,19 +314,17 @@ importconst(Sym *s, Type *t, Node *n)
 {
 	Node *n1;
 
-	if(!exportname(s->name) && !mypackage(s))
-		return;
 	importsym(s, OLITERAL);
 	convlit(&n, t);
-	if(s->def != N) {
-		// TODO: check if already the same.
+
+	if(s->def != N)	 // TODO: check if already the same.
 		return;
-	}
 
 	if(n->op != OLITERAL) {
 		yyerror("expression must be a constant");
 		return;
 	}
+
 	if(n->sym != S) {
 		n1 = nod(OXXX, N, N);
 		*n1 = *n;
@@ -325,13 +338,10 @@ importconst(Sym *s, Type *t, Node *n)
 }
 
 void
-importvar(Sym *s, Type *t, int ctxt)
+importvar(Sym *s, Type *t)
 {
 	Node *n;
 
-	if(!exportname(s->name) && !initname(s->name) && !mypackage(s))
-		return;
-
 	importsym(s, ONAME);
 	if(s->def != N && s->def->op == ONAME) {
 		if(eqtype(t, s->def->type))
@@ -340,7 +350,7 @@ importvar(Sym *s, Type *t, int ctxt)
 	}
 	n = newname(s);
 	n->type = t;
-	declare(n, ctxt);
+	declare(n, PEXTERN);
 
 	if(debug['E'])
 		print("import var %S %lT\n", s, t);
@@ -351,7 +361,6 @@ importtype(Type *pt, Type *t)
 {
 	Node *n;
 
-	if(pt != T && t != T) {
 	// override declaration in unsafe.go for Pointer.
 	// there is no way in Go code to define unsafe.Pointer
 	// so we have to supply it.
@@ -364,25 +373,13 @@ importtype(Type *pt, Type *t)
 	if(pt->etype == TFORW) {
 		n = pt->nod;
 		copytype(pt->nod, t);
-			// unzero nod
-			pt->nod = n;
-			
+		pt->nod = n;		// unzero nod
 		pt->sym->lastlineno = parserline();
 		declare(n, PEXTERN);
-			
 		checkwidth(pt);
 	} else if(!eqtype(pt->orig, t))
 		yyerror("inconsistent definition for type %S during import\n\t%lT\n\t%lT", pt->sym, pt->orig, t);
-	}
 
 	if(debug['E'])
 		print("import type %T %lT\n", pt, t);
 }
-
-void
-importmethod(Sym *s, Type *t)
-{
-	checkwidth(t);
-	addmethod(s, t, 0);
-}
-

src/cmd/gc/fmt.c

@@ -24,7 +24,7 @@
 //	%S Sym*		Symbols
 //		Flags: +,- #: mode (see below)
 //			"%hS"	unqualified identifier in any mode
-//			"%hhS"  strip type qualifier off of method name
+//			"%hhS"  in export mode: unqualified identifier if exported, qualified if not
 //
 //	%T Type*	Types
 //		Flags: +,- #: mode (see below)
@@ -341,6 +341,9 @@ Jconv(Fmt *fp)
 	if(n->implicit != 0)
 		fmtprint(fp, " implicit(%d)", n->implicit);
 
+	if(n->embedded != 0)
+		fmtprint(fp, " embedded(%d)", n->embedded);
+
 	if(!c && n->used != 0)
 		fmtprint(fp, " used(%d)", n->used);
 	return 0;
@@ -488,7 +491,7 @@ symfmt(Fmt *fp, Sym *s)
 			if(s->pkg == localpkg)
 				return fmtstrcpy(fp, s->name);
 			// If the name was used by multiple packages, display the full path,
-			if(pkglookup(s->pkg->name, nil)->npkg > 1)
+			if(s->pkg->name && pkglookup(s->pkg->name, nil)->npkg > 1)
 				return fmtprint(fp, "\"%Z\".%s", s->pkg->path, s->name);
 			return fmtprint(fp, "%s.%s", s->pkg->name, s->name);
 		case FDbg:
@@ -502,11 +505,19 @@ symfmt(Fmt *fp, Sym *s)
 		}
 	}
 
-	if(fp->flags&FmtByte) {
+	if(fp->flags&FmtByte) {  // FmtByte (hh) implies FmtShort (h)
 		// skip leading "type." in method name
 		p = utfrrune(s->name, '.');
 		if(p)
-			return fmtstrcpy(fp, p+1);
+			p++;
+		else
+			p = s->name;
+
+		// exportname needs to see the name without the prefix too.
+		if((fmtmode == FExp && !exportname(p)) || fmtmode == FDbg)
+			return fmtprint(fp, "@\"%Z\".%s", s->pkg->path, p);
+
+		return fmtstrcpy(fp, p);
 	}
 
 	return fmtstrcpy(fp, s->name);
@@ -672,9 +683,9 @@ typefmt(Fmt *fp, Type *t)
 			fmtstrcpy(fp, "struct {");
 			for(t1=t->type; t1!=T; t1=t1->down)
 				if(t1->down)
-					fmtprint(fp, " %T;", t1);
+					fmtprint(fp, " %lT;", t1);
 				else
-					fmtprint(fp, " %T ", t1);
+					fmtprint(fp, " %lT ", t1);
 			fmtstrcpy(fp, "}");
 		}
 		return 0;
@@ -682,21 +693,22 @@ typefmt(Fmt *fp, Type *t)
 	case TFIELD:
 		if(!(fp->flags&FmtShort)) {
 			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)
+			if (t->nname && (fmtmode == FErr || fmtmode == FExp))
 				s = t->nname->orig->sym;
 			
-				if((s == S || t->embedded)) {
+			if(s != S && !t->embedded) {
+				if(fp->flags&FmtLong)
+					fmtprint(fp, "%hhS ", s);  // qualify non-exported names (used on structs, not on funarg)
+				else 
+					fmtprint(fp, "%S ", s);
+			} else if(fmtmode == FExp) {
+				// TODO(rsc) this breaks on the eliding of unused arguments in the backend
+				// when this is fixed, the special case in dcl.c checkarglist can go.
+				//if(t->funarg)
+				//	fmtstrcpy(fp, "_ ");
+				//else
 					fmtstrcpy(fp, "? ");
-					break;
-				}
-				// fallthrough
-			default:
-				if(!(s == S || t->embedded))
-					fmtprint(fp, "%hS ", s);
 			}
 		}
 
@@ -764,16 +776,8 @@ stmtfmt(Fmt *f, Node *n)
 
 	switch(n->op){
 	case ODCL:
-		switch(n->left->class) {
-		case PFUNC:
-		case PEXTERN:
 		fmtprint(f, "var %S %T", n->left->sym, n->left->type);
 		break;
-		default:
-			fmtprint(f, "var %hS %T", n->left->sym, n->left->type);
-			break;
-		}
-		break;
 
 	case ODCLFIELD:
 		if(n->left)
@@ -931,9 +935,15 @@ static int opprec[] = {
 	[ORECV] = 8,
 	[ORUNESTR] = 8,
 	[OTPAREN] = 8,
+	[OSTRUCTLIT] = 8,
+	[OMAPLIT] = 8,
+	[OARRAYLIT] = 8,
 
 	[OINDEXMAP] = 8,
 	[OINDEX] = 8,
+	[OSLICE] = 8,
+	[OSLICESTR] = 8,
+	[OSLICEARR] = 8,
 	[ODOTINTER] = 8,
 	[ODOTMETH] = 8,
 	[ODOTPTR] = 8,
@@ -1006,6 +1016,7 @@ static int
 exprfmt(Fmt *f, Node *n, int prec)
 {
 	int nprec;
+	NodeList *l;
 
 	while(n && n->implicit)
 		n = n->left;
@@ -1044,15 +1055,6 @@ exprfmt(Fmt *f, Node *n, int prec)
 	case ONAME:
 	case OPACK:
 	case ONONAME:
-		if(fmtmode == FExp) {
-			switch(n->class&~PHEAP) {
-			case PEXTERN:
-			case PFUNC:
-				break;
-			default:
-				return fmtprint(f, "%hS", n->sym);
-			}
-		}
 		return fmtprint(f, "%S", n->sym);
 
 	case OTYPE:
@@ -1091,39 +1093,31 @@ exprfmt(Fmt *f, Node *n, int prec)
 	case OTFUNC:
 		return fmtprint(f, "<func>");
 
-	case OPLUS:
-	case OMINUS:
-		if(n->left->op == n->op)
-			return fmtprint(f, "%#O %N", n->op, n->left);
-		// fallthrough
-	case OADDR:
-	case OCOM:
-	case OIND:
-	case ONOT:
-	case ORECV:
-		return fmtprint(f, "%#O%N", n->op, n->left);
-
 	case OCLOSURE:
 		if(fmtmode == FErr)
 			return fmtstrcpy(f, "func literal");
-		// return fmtprint(f, "%T { %H }", n->type, n->nbody); this prints the list/rlist turned to types, not what we want
-		if(!n->rlist)
-			return fmtprint(f, "func(%,H) { %H } ", n->list, n->nbody);
-		if(!n->rlist->next && !n->rlist->n->left)
-			return fmtprint(f, "func(%,H) %N { %H } ", n->list, n->rlist->n->right, n->nbody);
-		return fmtprint(f, "func(%,H) (%,H) { %H } ", n->list, n->rlist, n->nbody);
+		return fmtprint(f, "%T { %H }", n->type, n->nbody);
 
 	case OCOMPLIT:
 		return fmtstrcpy(f, "composite literal");
 
 	case OPTRLIT:
-		if(fmtmode == FErr)
-			return fmtprint(f, "&%T literal", n->type->type);
-		return fmtprint(f, "&%T{ %,H }", n->type->type, n->list);
+		return fmtprint(f, "&%N", n->left);
+
+	case OSTRUCTLIT:
+		if (fmtmode == FExp) {   // requires special handling of field names
+			fmtprint(f, "%T{", n->type);
+			for(l=n->list; l; l=l->next)
+				if(l->next)
+					fmtprint(f, " %hhS:%N,", l->n->left->sym, l->n->right);
+				else
+					fmtprint(f, " %hhS:%N ", l->n->left->sym, l->n->right);
+			return fmtstrcpy(f, "}");
+		}
+		// fallthrough
 
 	case OARRAYLIT:
 	case OMAPLIT:
-	case OSTRUCTLIT:
 		if(fmtmode == FErr)
 			return fmtprint(f, "%T literal", n->type);
 		return fmtprint(f, "%T{ %,H }", n->type, n->list);
@@ -1211,6 +1205,21 @@ exprfmt(Fmt *f, Node *n, int prec)
 			return fmtprint(f, "make(%T, %,H)", n->type, n->list->next);
 		return fmtprint(f, "make(%T)", n->type);
 
+	// Unary
+	case OPLUS:
+	case OMINUS:
+	case OADDR:
+	case OCOM:
+	case OIND:
+	case ONOT:
+	case ORECV:
+		if(n->left->op == n->op)
+			fmtprint(f, "%#O ", n->op);
+		else
+			fmtprint(f, "%#O", n->op);
+		return exprfmt(f, n->left, nprec+1);
+
+	// Binary
 	case OADD:
 	case OADDSTR:
 	case OAND:
@@ -1274,7 +1283,6 @@ indent(Fmt *fp)
 {
 	int i;
 
-	if(dumpdepth > 1)
 	fmtstrcpy(fp, "\n");
 	for(i = 0; i < dumpdepth; ++i)
 		fmtstrcpy(fp, ".   ");
@@ -1324,7 +1332,6 @@ nodedump(Fmt *fp, Node *n)
 	case OTYPE:
 		fmtprint(fp, "%O %S type=%T", n->op, n->sym, n->type);
 		if(recur && n->type == T && n->ntype) {
-			fmtstrcpy(fp, "\n");
 			indent(fp);
 			fmtprint(fp, "%O-ntype%N", n->op, n->ntype);
 		}
@@ -1384,6 +1391,9 @@ Sconv(Fmt *fp)
 	if(s == S)
 		return fmtstrcpy(fp, "<S>");
 
+	if(s->name[0] == '_' && s->name[1] == '\0')
+		return fmtstrcpy(fp, "_");
+
 	sf = fp->flags;
 	sm = setfmode(&fp->flags);
 	r = symfmt(fp, s);

src/cmd/gc/go.h

@@ -135,7 +135,7 @@ struct	Type
 	uchar	printed;
 	uchar	embedded;	// TFIELD embedded type
 	uchar	siggen;
-	uchar	funarg;
+	uchar	funarg;		// on TSTRUCT and TFIELD
 	uchar	copyany;
 	uchar	local;		// created in this file
 	uchar	deferwidth;
@@ -325,9 +325,9 @@ struct	NodeList
 
 enum
 {
-	SymExport	= 1<<0,
+	SymExport	= 1<<0,	// to be exported
 	SymPackage	= 1<<1,
-	SymExported	= 1<<2,
+	SymExported	= 1<<2,	// already written out by export
 	SymUniq		= 1<<3,
 	SymSiggen	= 1<<4,
 };
@@ -794,7 +794,7 @@ EXTERN	NodeList*	xtop;
 EXTERN	NodeList*	externdcl;
 EXTERN	NodeList*	closures;
 EXTERN	NodeList*	exportlist;
-EXTERN	NodeList*	typelist;
+EXTERN	NodeList*	importlist;	// imported functions and methods with inlinable bodies
 EXTERN	int	dclcontext;		// PEXTERN/PAUTO
 EXTERN	int	incannedimport;
 EXTERN	int	statuniqgen;		// name generator for static temps
@@ -951,10 +951,10 @@ void	dumpexport(void);
 int	exportname(char *s);
 void	exportsym(Node *n);
 void    importconst(Sym *s, Type *t, Node *n);
-void	importmethod(Sym *s, Type *t);
+void	importimport(Sym *s, Strlit *z);
 Sym*    importsym(Sym *s, int op);
 void    importtype(Type *pt, Type *t);
-void	importvar(Sym *s, Type *t, int ctxt);
+void    importvar(Sym *s, Type *t);
 Type*	pkgtype(Sym *s);
 
 /*
@@ -983,7 +983,7 @@ Node*	temp(Type*);
  *	init.c
  */
 void	fninit(NodeList *n);
-Node*	renameinit(Node *n);
+Sym*	renameinit(void);
 
 /*
  *	lex.c

src/cmd/gc/go.y

@@ -56,7 +56,7 @@ static void fixlbrace(int);
 %type	<node>	case caseblock
 %type	<node>	compound_stmt dotname embed expr complitexpr
 %type	<node>	expr_or_type
-%type	<node>	fndcl fnliteral
+%type	<node>	fndcl hidden_fndcl fnliteral
 %type	<node>	for_body for_header for_stmt if_header if_stmt else non_dcl_stmt
 %type	<node>	interfacedcl keyval labelname name
 %type	<node>	name_or_type non_expr_type
@@ -80,8 +80,8 @@ static void fixlbrace(int);
 
 %type	<sym>	hidden_importsym hidden_pkg_importsym
 
-%type	<node>	hidden_constant hidden_literal hidden_dcl
-%type	<node>	hidden_interfacedcl hidden_structdcl hidden_opt_sym
+%type	<node>	hidden_constant hidden_literal hidden_funarg
+%type	<node>	hidden_interfacedcl hidden_structdcl
 
 %type	<list>	hidden_funres
 %type	<list>	ohidden_funres
@@ -235,7 +235,7 @@ import_here:
 	}
 
 import_package:
-	LPACKAGE sym import_safety ';'
+	LPACKAGE LNAME import_safety ';'
 	{
 		if(importpkg->name == nil) {
 			importpkg->name = $2->name;
@@ -1004,7 +1004,17 @@ onew_name:
 
 sym:
 	LNAME
+	{
+		$$ = $1;
+		// during imports, unqualified non-exported identifiers are from builtinpkg
+		if(importpkg != nil && !exportname($1->name))
+			$$ = pkglookup($1->name, builtinpkg);
+	}
 |	hidden_importsym
+|	'?'
+	{
+		$$ = S;
+	}
 
 hidden_importsym:
 	'@' LLITERAL '.' LNAME
@@ -1186,38 +1196,43 @@ xfndcl:
 	}
 
 fndcl:
-	dcl_name '(' oarg_type_list_ocomma ')' fnres
+	sym '(' oarg_type_list_ocomma ')' fnres
 	{
-		Node *n;
+		Node *t;
 
+		$$ = N;
 		$3 = checkarglist($3, 1);
-		$$ = nod(ODCLFUNC, N, N);
-		$$->nname = $1;
-		n = nod(OTFUNC, N, N);
-		n->list = $3;
-		n->rlist = $5;
-		if(strcmp($1->sym->name, "init") == 0) {
-			$$->nname = renameinit($1);
+
+		if(strcmp($1->name, "init") == 0) {
+			$1 = renameinit();
 			if($3 != nil || $5 != nil)
 				yyerror("func init must have no arguments and no return values");
 		}
-		if(strcmp(localpkg->name, "main") == 0 && strcmp($1->sym->name, "main") == 0) {
+		if(strcmp(localpkg->name, "main") == 0 && strcmp($1->name, "main") == 0) {
 			if($3 != nil || $5 != nil)
 				yyerror("func main must have no arguments and no return values");
 		}
-		// TODO: check if nname already has an ntype
-		$$->nname->ntype = n;
+
+		t = nod(OTFUNC, N, N);
+		t->list = $3;
+		t->rlist = $5;
+
+		$$ = nod(ODCLFUNC, N, N);
+		$$->nname = newname($1);
+		$$->nname->defn = $$;
+		$$->nname->ntype = t;		// TODO: check if nname already has an ntype
+		declare($$->nname, PFUNC);
+
 		funchdr($$);
 	}
 |	'(' oarg_type_list_ocomma ')' sym '(' oarg_type_list_ocomma ')' fnres
 	{
 		Node *rcvr, *t;
-		Node *name;
 
-		name = newname($4);
+		$$ = N;
 		$2 = checkarglist($2, 0);
 		$6 = checkarglist($6, 1);
-		$$ = N;
+
 		if($2 == nil) {
 			yyerror("method has no receiver");
 			break;
@@ -1234,13 +1249,51 @@ fndcl:
 		if(rcvr->right->op == OTPAREN || (rcvr->right->op == OIND && rcvr->right->left->op == OTPAREN))
 			yyerror("cannot parenthesize receiver type");
 
-		$$ = nod(ODCLFUNC, N, N);
-		$$->nname = methodname1(name, rcvr->right);
 		t = nod(OTFUNC, rcvr, N);
 		t->list = $6;
 		t->rlist = $8;
+
+		$$ = nod(ODCLFUNC, N, N);
+		$$->shortname = newname($4);
+		$$->nname = methodname1($$->shortname, rcvr->right);
+		$$->nname->defn = $$;
 		$$->nname->ntype = t;
-		$$->shortname = name;
+		declare($$->nname, PFUNC);
+
+		funchdr($$);
+	}
+
+hidden_fndcl:
+	hidden_pkg_importsym '(' ohidden_funarg_list ')' ohidden_funres
+	{
+		Sym *s;
+		Type *t;
+
+		$$ = N;
+
+		s = $1;
+		t = functype(N, $3, $5);
+
+		importsym(s, ONAME);
+		if(s->def != N && s->def->op == ONAME) {
+			if(eqtype(t, s->def->type))
+				break;
+			yyerror("inconsistent definition for func %S during import\n\t%T\n\t%T", s, s->def->type, t);
+		}
+
+		$$ = newname(s);
+		$$->type = t;
+		declare($$, PFUNC);
+
+		funchdr($$);
+	}
+|	'(' hidden_funarg_list ')' sym '(' ohidden_funarg_list ')' ohidden_funres
+	{
+		$$ = methodname1(newname($4), $2->n->right); 
+		$$->type = functype($2->n, $6, $8);
+
+		checkwidth($$->type);
+		addmethod($4, $$->type, 0);
 		funchdr($$);
 	}
 
@@ -1709,31 +1762,16 @@ oliteral:
 |	LLITERAL
 
 /*
- * import syntax from header of
- * an output package
+ * import syntax from package header
  */
 hidden_import:
-	LIMPORT sym LLITERAL ';'
+	LIMPORT LNAME LLITERAL ';'
 	{
-		// Informational: record package name
-		// associated with import path, for use in
-		// human-readable messages.
-		Pkg *p;
-
-		p = mkpkg($3.u.sval);
-		if(p->name == nil) {
-			p->name = $2->name;
-			pkglookup($2->name, nil)->npkg++;
-		} else if(strcmp(p->name, $2->name) != 0)
-			yyerror("conflicting names %s and %s for package \"%Z\"", p->name, $2->name, p->path);
-		if(!incannedimport && myimportpath != nil && strcmp($3.u.sval->s, myimportpath) == 0) {
-			yyerror("import \"%Z\": package depends on \"%Z\" (import cycle)", importpkg->path, $3.u.sval);
-			errorexit();
-		}
+		importimport($2, $3.u.sval);
 	}
 |	LVAR hidden_pkg_importsym hidden_type ';'
 	{
-		importvar($2, $3, PEXTERN);
+		importvar($2, $3);
 	}
 |	LCONST hidden_pkg_importsym '=' hidden_constant ';'
 	{
@@ -1747,17 +1785,24 @@ hidden_import:
 	{
 		importtype($2, $3);
 	}
-|	LFUNC hidden_pkg_importsym '(' ohidden_funarg_list ')' ohidden_funres ';'
+|	LFUNC hidden_fndcl fnbody ';'
 	{
-		importvar($2, functype(N, $4, $6), PFUNC);
+		if($2 == N)
+			break;
+
+		funcbody($2);
+		importlist = list(importlist, $2);
+
+		if(debug['E']) {
+			print("import [%Z] func %lN \n", $2->sym->pkg->path, $2);
 		}
-|	LFUNC '(' hidden_funarg_list ')' sym '(' ohidden_funarg_list ')' ohidden_funres ';'
-	{
-		if($3->next != nil || $3->n->op != ODCLFIELD) {
-			yyerror("bad receiver in method");
-			YYERROR;
 	}
-		importmethod($5, functype($3->n, $7, $9));
+
+hidden_pkg_importsym:
+	hidden_importsym
+	{
+		$$ = $1;
+		structpkg = $$->pkg;
 	}
 
 hidden_pkgtype:
@@ -1767,6 +1812,10 @@ hidden_pkgtype:
 		importsym($1, OTYPE);
 	}
 
+/*
+ *  importing types
+ */
+
 hidden_type:
 	hidden_type_misc
 |	hidden_type_recv_chan
@@ -1848,53 +1897,46 @@ hidden_type_func:
 		$$ = functype(nil, $3, $5);
 	}
 
-hidden_opt_sym:
-	sym
-	{
-		$$ = newname($1);
-	}
-|	'?'
-	{
-		$$ = N;
-	}
-
-hidden_dcl:
-	hidden_opt_sym hidden_type oliteral
+hidden_funarg:
+	sym hidden_type oliteral
 	{
-		$$ = nod(ODCLFIELD, $1, typenod($2));
+		$$ = nod(ODCLFIELD, N, typenod($2));
+		if($1)
+			$$->left = newname($1);
 		$$->val = $3;
 	}
-|	hidden_opt_sym LDDD hidden_type oliteral
+|	sym LDDD hidden_type oliteral
 	{
 		Type *t;
 	
 		t = typ(TARRAY);
 		t->bound = -1;
 		t->type = $3;
-		$$ = nod(ODCLFIELD, $1, typenod(t));
+
+		$$ = nod(ODCLFIELD, N, typenod(t));
+		if($1)
+			$$->left = newname($1);
 		$$->isddd = 1;
 		$$->val = $4;
 	}
 
 hidden_structdcl:
 	sym hidden_type oliteral
-	{
-		$$ = nod(ODCLFIELD, newname($1), typenod($2));
-		$$->val = $3;
-	}
-|	'?' hidden_type oliteral
 	{
 		Sym *s;
 
+		if($1 != S) {
+			$$ = nod(ODCLFIELD, newname($1), typenod($2));
+			$$->val = $3;
+		} else {
 			s = $2->sym;
 			if(s == S && isptr[$2->etype])
 				s = $2->type->sym;
-		if(s && s->pkg == builtinpkg)
-			s = lookup(s->name);
 			$$ = embedded(s);
 			$$->right = typenod($2);
 			$$->val = $3;
 		}
+	}
 
 hidden_interfacedcl:
 	sym '(' ohidden_funarg_list ')' ohidden_funres
@@ -1918,6 +1960,10 @@ hidden_funres:
 		$$ = list1(nod(ODCLFIELD, N, typenod($1)));
 	}
 
+/*
+ *  importing constants
+ */
+
 hidden_literal:
 	LLITERAL
 	{
@@ -1951,22 +1997,15 @@ hidden_constant:
 		$$ = nodcplxlit($2->val, $4->val);
 	}
 
-hidden_pkg_importsym:
-	hidden_importsym
-	{
-		$$ = $1;
-		structpkg = $$->pkg;
-	}
-
 hidden_import_list:
 |	hidden_import_list hidden_import
 
 hidden_funarg_list:
-	hidden_dcl
+	hidden_funarg
 	{
 		$$ = list1($1);
 	}
-|	hidden_funarg_list ',' hidden_dcl
+|	hidden_funarg_list ',' hidden_funarg
 	{
 		$$ = list($1, $3);
 	}

src/cmd/gc/init.c

@@ -13,21 +13,13 @@
  * package and also uncallable, the name,
  * normally "pkg.init", is altered to "pkg.init·1".
  */
-Node*
-renameinit(Node *n)
+Sym*
+renameinit(void)
 {
-	Sym *s;
 	static int initgen;
 
-	s = n->sym;
-	if(s == S)
-		return n;
-	if(strcmp(s->name, "init") != 0)
-		return n;
-
 	snprint(namebuf, sizeof(namebuf), "init·%d", ++initgen);
-	s = lookup(namebuf);
-	return newname(s);
+	return lookup(namebuf);
 }
 
 /*
@@ -125,7 +117,9 @@ fninit(NodeList *n)
 	fn = nod(ODCLFUNC, N, N);
 	initsym = lookup(namebuf);
 	fn->nname = newname(initsym);
+	fn->nname->defn = fn;
 	fn->nname->ntype = nod(OTFUNC, N, N);
+	declare(fn->nname, PFUNC);
 	funchdr(fn);
 
 	// (3)

src/cmd/gc/lex.c

@@ -334,11 +334,11 @@ main(int argc, char *argv[])
 	if(nsavederrors+nerrors)
 		errorexit();
 
-	// Phase 3b: escape analysis.
+	// Phase 4: escape analysis.
 	if(!debug['N'])
 		escapes();
 
-	// Phase 4: Compile function bodies.
+	// Phase 5: Compile top level functions.
 	for(l=xtop; l; l=l->next)
 		if(l->n->op == ODCLFUNC)
 			funccompile(l->n, 0);
@@ -346,16 +346,15 @@ main(int argc, char *argv[])
 	if(nsavederrors+nerrors == 0)
 		fninit(xtop);
 
-	// Phase 4b: Compile all closures.
+	// Phase 5b: Compile all closures.
 	while(closures) {
 		l = closures;
 		closures = nil;
-		for(; l; l=l->next) {
+		for(; l; l=l->next)
 			funccompile(l->n, 1);
 	}
-	}
 
-	// Phase 5: check external declarations.
+	// Phase 6: check external declarations.
 	for(l=externdcl; l; l=l->next)
 		if(l->n->op == ONAME)
 			typecheck(&l->n, Erv);
@@ -1710,6 +1709,7 @@ lexinit(void)
 	Sym *s, *s1;
 	Type *t;
 	int etype;
+	Val v;
 
 	/*
 	 * initialize basic types array
@@ -1738,6 +1738,16 @@ lexinit(void)
 			s1->def = typenod(t);
 			continue;
 		}
+
+		etype = syms[i].op;
+		if(etype != OXXX) {
+			s1 = pkglookup(syms[i].name, builtinpkg);
+			s1->lexical = LNAME;
+			s1->def = nod(ONAME, N, N);
+			s1->def->sym = s;
+			s1->def->etype = etype;
+			s1->def->builtin = 1;
+		}
 	}
 
 	// logically, the type of a string literal.
@@ -1765,6 +1775,19 @@ lexinit(void)
 	types[TBLANK] = typ(TBLANK);
 	s->def->type = types[TBLANK];
 	nblank = s->def;
+
+	s = pkglookup("_", builtinpkg);
+	s->block = -100;
+	s->def = nod(ONAME, N, N);
+	s->def->sym = s;
+	types[TBLANK] = typ(TBLANK);
+	s->def->type = types[TBLANK];
+
+	types[TNIL] = typ(TNIL);
+	s = pkglookup("nil", builtinpkg);
+	v.ctype = CTNIL;
+	s->def = nodlit(v);
+	s->def->sym = s;
 }
 
 static void
@@ -1875,7 +1898,6 @@ lexfini(void)
 	if(s->def == N)
 		s->def = typenod(runetype);
 
-	types[TNIL] = typ(TNIL);
 	s = lookup("nil");
 	if(s->def == N) {
 		v.ctype = CTNIL;

src/cmd/gc/subr.c

@@ -2287,8 +2287,6 @@ genwrapper(Type *rcvr, Type *method, Sym *newnam, int iface)
 	in = structargs(getinarg(method->type), 1);
 	out = structargs(getoutarg(method->type), 0);
 
-	fn = nod(ODCLFUNC, N, N);
-	fn->nname = newname(newnam);
 	t = nod(OTFUNC, N, N);
 	l = list1(this);
 	if(iface && rcvr->width < types[tptr]->width) {
@@ -2305,7 +2303,12 @@ genwrapper(Type *rcvr, Type *method, Sym *newnam, int iface)
 	}
 	t->list = concat(l, in);
 	t->rlist = out;
+
+	fn = nod(ODCLFUNC, N, N);
+	fn->nname = newname(newnam);
+	fn->nname->defn = fn;
 	fn->nname->ntype = t;
+	declare(fn->nname, PFUNC);
 	funchdr(fn);
 
 	// arg list

src/cmd/gc/typecheck.c

@@ -43,7 +43,7 @@ resolve(Node *n)
 {
 	Node *r;
 
-	if(n != N && n->op == ONONAME && (r = n->sym->def) != N) {
+	if(n != N && n->op == ONONAME && n->sym != S && (r = n->sym->def) != N) {
 		if(r->op != OIOTA)
 			n = r;
 		else if(n->iota >= 0)
@@ -114,7 +114,6 @@ typecheck(Node **np, int top)
 	NodeList *args;
 	int lno, ok, ntop;
 	Type *t, *tp, *ft, *missing, *have;
-	Sym *sym;
 	Val v;
 	char *why;
 
@@ -567,15 +566,14 @@ reswitch:
 	case ODOT:
 		typecheck(&n->left, Erv|Etype);
 		defaultlit(&n->left, T);
-		l = n->left;
-		if((t = l->type) == T)
+		if((t = n->left->type) == T)
 			goto error;
 		if(n->right->op != ONAME) {
 			yyerror("rhs of . must be a name");	// impossible
 			goto error;
 		}
-		sym = n->right->sym;
-		if(l->op == OTYPE) {
+
+		if(n->left->op == OTYPE) {
 			if(!looktypedot(n, t, 0)) {
 				if(looktypedot(n, t, 1))
 					yyerror("%N undefined (cannot refer to unexported method %S)", n, n->right->sym);
@@ -584,19 +582,18 @@ reswitch:
 				goto error;
 			}
 			if(n->type->etype != TFUNC || n->type->thistuple != 1) {
-				yyerror("type %T has no method %hS", n->left->type, sym);
+				yyerror("type %T has no method %hS", n->left->type, n->right->sym);
 				n->type = T;
 				goto error;
 			}
 			n->op = ONAME;
-			n->sym = methodsym(sym, l->type, 0);
-			n->type = methodfunc(n->type, l->type);
+			n->sym = n->right->sym;
+			n->type = methodfunc(n->type, n->left->type);
 			n->xoffset = 0;
 			n->class = PFUNC;
 			ok = Erv;
 			goto ret;
 		}
-		tp = t;
 		if(isptr[t->etype] && t->type->etype != TINTER) {
 			t = t->type;
 			if(t == T)
@@ -608,7 +605,7 @@ reswitch:
 			if(lookdot(n, t, 1))
 				yyerror("%N undefined (cannot refer to unexported field or method %S)", n, n->right->sym);
 			else
-				yyerror("%N undefined (type %T has no field or method %S)", n, tp, n->right->sym);
+				yyerror("%N undefined (type %T has no field or method %S)", n, n->left->type, n->right->sym);
 			goto error;
 		}
 		switch(n->op) {
@@ -2167,14 +2164,16 @@ typecheckcomplit(Node **np)
 					typecheck(&l->right, Erv);
 					continue;
 				}
+
 				// Sym might have resolved to name in other top-level
 				// package, because of import dot.  Redirect to correct sym
 				// before we do the lookup.
-				if(s->pkg != localpkg)
+				if(s->pkg != localpkg && exportname(s->name))
 					s = lookup(s->name);
+
 				f = lookdot1(s, t, t->type, 0);
 				if(f == nil) {
-					yyerror("unknown %T field '%s' in struct literal", t, s->name);
+					yyerror("unknown %T field '%S' in struct literal", t, s);
 					continue;
 				}
 				l->left = newname(s);

src/pkg/exp/types/gcimporter.go

@@ -323,7 +323,7 @@ func (p *gcParser) parseMapType() Type {
 	return &Map{Key: key, Elt: elt}
 }
 
-// Name = identifier | "?" .
+// Name = identifier | "?" | ExportedName  .
 //
 func (p *gcParser) parseName() (name string) {
 	switch p.tok {
@@ -333,6 +333,9 @@ func (p *gcParser) parseName() (name string) {
 	case '?':
 		// anonymous
 		p.next()
+	case '@':
+		// exported name prefixed with package path
+		_, name = p.parseExportedName()
 	default:
 		p.error("name expected")
 	}
@@ -747,7 +750,7 @@ func (p *gcParser) parseFuncDecl() {
 	}
 }
 
-// MethodDecl = "func" Receiver identifier Signature .
+// MethodDecl = "func" Receiver Name Signature .
 // Receiver   = "(" ( identifier | "?" ) [ "*" ] ExportedName ")" [ FuncBody ].
 //
 func (p *gcParser) parseMethodDecl() {
@@ -755,7 +758,7 @@ func (p *gcParser) parseMethodDecl() {
 	p.expect('(')
 	p.parseParameter() // receiver
 	p.expect(')')
-	p.expect(scanner.Ident)
+	p.parseName() // unexported method names in imports are qualified with their package.
 	p.parseSignature()
 	if p.tok == '{' {
 		p.parseFuncBody()