Imported Upstream version 1.4upstream/1.4

58 files changed, 0 insertions, 6354 deletions

diff --git a/src/pkg/go/doc/Makefile b/src/pkg/go/doc/Makefile
deleted file mode 100644
index ca4948f91..000000000
--- a/src/pkg/go/doc/Makefile
+++ /dev/null
@@ -1,7 +0,0 @@
-# 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.
-
-# Script to test heading detection heuristic
-headscan: headscan.go
-	go build headscan.go
diff --git a/src/pkg/go/doc/comment.go b/src/pkg/go/doc/comment.go
deleted file mode 100644
index f414ca409..000000000
--- a/src/pkg/go/doc/comment.go
+++ /dev/null
@@ -1,480 +0,0 @@
-// 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.
-
-// Godoc comment extraction and comment -> HTML formatting.
-
-package doc
-
-import (
-	"io"
-	"regexp"
-	"strings"
-	"text/template" // for HTMLEscape
-	"unicode"
-	"unicode/utf8"
-)
-
-var (
-	ldquo = []byte("“")
-	rdquo = []byte("”")
-)
-
-// Escape comment text for HTML. If nice is set,
-// also turn `` into “ and '' into ”.
-func commentEscape(w io.Writer, text string, nice bool) {
-	last := 0
-	if nice {
-		for i := 0; i < len(text)-1; i++ {
-			ch := text[i]
-			if ch == text[i+1] && (ch == '`' || ch == '\'') {
-				template.HTMLEscape(w, []byte(text[last:i]))
-				last = i + 2
-				switch ch {
-				case '`':
-					w.Write(ldquo)
-				case '\'':
-					w.Write(rdquo)
-				}
-				i++ // loop will add one more
-			}
-		}
-	}
-	template.HTMLEscape(w, []byte(text[last:]))
-}
-
-const (
-	// Regexp for Go identifiers
-	identRx = `[\pL_][\pL_0-9]*`
-
-	// Regexp for URLs
-	protocol = `https?|ftp|file|gopher|mailto|news|nntp|telnet|wais|prospero`
-	hostPart = `[a-zA-Z0-9_@\-]+`
-	filePart = `[a-zA-Z0-9_?%#~&/\-+=()]+` // parentheses may not be matching; see pairedParensPrefixLen
-	urlRx    = `(` + protocol + `)://` +   // http://
-		hostPart + `([.:]` + hostPart + `)*/?` + // //www.google.com:8080/
-		filePart + `([:.,]` + filePart + `)*`
-)
-
-var matchRx = regexp.MustCompile(`(` + urlRx + `)|(` + identRx + `)`)
-
-var (
-	html_a      = []byte(`<a href="`)
-	html_aq     = []byte(`">`)
-	html_enda   = []byte("</a>")
-	html_i      = []byte("<i>")
-	html_endi   = []byte("</i>")
-	html_p      = []byte("<p>\n")
-	html_endp   = []byte("</p>\n")
-	html_pre    = []byte("<pre>")
-	html_endpre = []byte("</pre>\n")
-	html_h      = []byte(`<h3 id="`)
-	html_hq     = []byte(`">`)
-	html_endh   = []byte("</h3>\n")
-)
-
-// pairedParensPrefixLen returns the length of the longest prefix of s containing paired parentheses.
-func pairedParensPrefixLen(s string) int {
-	parens := 0
-	l := len(s)
-	for i, ch := range s {
-		switch ch {
-		case '(':
-			if parens == 0 {
-				l = i
-			}
-			parens++
-		case ')':
-			parens--
-			if parens == 0 {
-				l = len(s)
-			} else if parens < 0 {
-				return i
-			}
-		}
-	}
-	return l
-}
-
-// Emphasize and escape a line of text for HTML. URLs are converted into links;
-// if the URL also appears in the words map, the link is taken from the map (if
-// the corresponding map value is the empty string, the URL is not converted
-// into a link). Go identifiers that appear in the words map are italicized; if
-// the corresponding map value is not the empty string, it is considered a URL
-// and the word is converted into a link. If nice is set, the remaining text's
-// appearance is improved where it makes sense (e.g., `` is turned into &ldquo;
-// and '' into &rdquo;).
-func emphasize(w io.Writer, line string, words map[string]string, nice bool) {
-	for {
-		m := matchRx.FindStringSubmatchIndex(line)
-		if m == nil {
-			break
-		}
-		// m >= 6 (two parenthesized sub-regexps in matchRx, 1st one is urlRx)
-
-		// write text before match
-		commentEscape(w, line[0:m[0]], nice)
-
-		// adjust match if necessary
-		match := line[m[0]:m[1]]
-		if n := pairedParensPrefixLen(match); n < len(match) {
-			// match contains unpaired parentheses (rare);
-			// redo matching with shortened line for correct indices
-			m = matchRx.FindStringSubmatchIndex(line[:m[0]+n])
-			match = match[:n]
-		}
-
-		// analyze match
-		url := ""
-		italics := false
-		if words != nil {
-			url, italics = words[match]
-		}
-		if m[2] >= 0 {
-			// match against first parenthesized sub-regexp; must be match against urlRx
-			if !italics {
-				// no alternative URL in words list, use match instead
-				url = match
-			}
-			italics = false // don't italicize URLs
-		}
-
-		// write match
-		if len(url) > 0 {
-			w.Write(html_a)
-			template.HTMLEscape(w, []byte(url))
-			w.Write(html_aq)
-		}
-		if italics {
-			w.Write(html_i)
-		}
-		commentEscape(w, match, nice)
-		if italics {
-			w.Write(html_endi)
-		}
-		if len(url) > 0 {
-			w.Write(html_enda)
-		}
-
-		// advance
-		line = line[m[1]:]
-	}
-	commentEscape(w, line, nice)
-}
-
-func indentLen(s string) int {
-	i := 0
-	for i < len(s) && (s[i] == ' ' || s[i] == '\t') {
-		i++
-	}
-	return i
-}
-
-func isBlank(s string) bool {
-	return len(s) == 0 || (len(s) == 1 && s[0] == '\n')
-}
-
-func commonPrefix(a, b string) string {
-	i := 0
-	for i < len(a) && i < len(b) && a[i] == b[i] {
-		i++
-	}
-	return a[0:i]
-}
-
-func unindent(block []string) {
-	if len(block) == 0 {
-		return
-	}
-
-	// compute maximum common white prefix
-	prefix := block[0][0:indentLen(block[0])]
-	for _, line := range block {
-		if !isBlank(line) {
-			prefix = commonPrefix(prefix, line[0:indentLen(line)])
-		}
-	}
-	n := len(prefix)
-
-	// remove
-	for i, line := range block {
-		if !isBlank(line) {
-			block[i] = line[n:]
-		}
-	}
-}
-
-// heading returns the trimmed line if it passes as a section heading;
-// otherwise it returns the empty string.
-func heading(line string) string {
-	line = strings.TrimSpace(line)
-	if len(line) == 0 {
-		return ""
-	}
-
-	// a heading must start with an uppercase letter
-	r, _ := utf8.DecodeRuneInString(line)
-	if !unicode.IsLetter(r) || !unicode.IsUpper(r) {
-		return ""
-	}
-
-	// it must end in a letter or digit:
-	r, _ = utf8.DecodeLastRuneInString(line)
-	if !unicode.IsLetter(r) && !unicode.IsDigit(r) {
-		return ""
-	}
-
-	// exclude lines with illegal characters
-	if strings.IndexAny(line, ",.;:!?+*/=()[]{}_^°&§~%#@<\">\\") >= 0 {
-		return ""
-	}
-
-	// allow "'" for possessive "'s" only
-	for b := line; ; {
-		i := strings.IndexRune(b, '\'')
-		if i < 0 {
-			break
-		}
-		if i+1 >= len(b) || b[i+1] != 's' || (i+2 < len(b) && b[i+2] != ' ') {
-			return "" // not followed by "s "
-		}
-		b = b[i+2:]
-	}
-
-	return line
-}
-
-type op int
-
-const (
-	opPara op = iota
-	opHead
-	opPre
-)
-
-type block struct {
-	op    op
-	lines []string
-}
-
-var nonAlphaNumRx = regexp.MustCompile(`[^a-zA-Z0-9]`)
-
-func anchorID(line string) string {
-	// Add a "hdr-" prefix to avoid conflicting with IDs used for package symbols.
-	return "hdr-" + nonAlphaNumRx.ReplaceAllString(line, "_")
-}
-
-// ToHTML converts comment text to formatted HTML.
-// The comment was prepared by DocReader,
-// so it is known not to have leading, trailing blank lines
-// nor to have trailing spaces at the end of lines.
-// The comment markers have already been removed.
-//
-// Each span of unindented non-blank lines is converted into
-// a single paragraph. There is one exception to the rule: a span that
-// consists of a single line, is followed by another paragraph span,
-// begins with a capital letter, and contains no punctuation
-// is formatted as a heading.
-//
-// A span of indented lines is converted into a <pre> block,
-// with the common indent prefix removed.
-//
-// URLs in the comment text are converted into links; if the URL also appears
-// in the words map, the link is taken from the map (if the corresponding map
-// value is the empty string, the URL is not converted into a link).
-//
-// Go identifiers that appear in the words map are italicized; if the corresponding
-// map value is not the empty string, it is considered a URL and the word is converted
-// into a link.
-func ToHTML(w io.Writer, text string, words map[string]string) {
-	for _, b := range blocks(text) {
-		switch b.op {
-		case opPara:
-			w.Write(html_p)
-			for _, line := range b.lines {
-				emphasize(w, line, words, true)
-			}
-			w.Write(html_endp)
-		case opHead:
-			w.Write(html_h)
-			id := ""
-			for _, line := range b.lines {
-				if id == "" {
-					id = anchorID(line)
-					w.Write([]byte(id))
-					w.Write(html_hq)
-				}
-				commentEscape(w, line, true)
-			}
-			if id == "" {
-				w.Write(html_hq)
-			}
-			w.Write(html_endh)
-		case opPre:
-			w.Write(html_pre)
-			for _, line := range b.lines {
-				emphasize(w, line, nil, false)
-			}
-			w.Write(html_endpre)
-		}
-	}
-}
-
-func blocks(text string) []block {
-	var (
-		out  []block
-		para []string
-
-		lastWasBlank   = false
-		lastWasHeading = false
-	)
-
-	close := func() {
-		if para != nil {
-			out = append(out, block{opPara, para})
-			para = nil
-		}
-	}
-
-	lines := strings.SplitAfter(text, "\n")
-	unindent(lines)
-	for i := 0; i < len(lines); {
-		line := lines[i]
-		if isBlank(line) {
-			// close paragraph
-			close()
-			i++
-			lastWasBlank = true
-			continue
-		}
-		if indentLen(line) > 0 {
-			// close paragraph
-			close()
-
-			// count indented or blank lines
-			j := i + 1
-			for j < len(lines) && (isBlank(lines[j]) || indentLen(lines[j]) > 0) {
-				j++
-			}
-			// but not trailing blank lines
-			for j > i && isBlank(lines[j-1]) {
-				j--
-			}
-			pre := lines[i:j]
-			i = j
-
-			unindent(pre)
-
-			// put those lines in a pre block
-			out = append(out, block{opPre, pre})
-			lastWasHeading = false
-			continue
-		}
-
-		if lastWasBlank && !lastWasHeading && i+2 < len(lines) &&
-			isBlank(lines[i+1]) && !isBlank(lines[i+2]) && indentLen(lines[i+2]) == 0 {
-			// current line is non-blank, surrounded by blank lines
-			// and the next non-blank line is not indented: this
-			// might be a heading.
-			if head := heading(line); head != "" {
-				close()
-				out = append(out, block{opHead, []string{head}})
-				i += 2
-				lastWasHeading = true
-				continue
-			}
-		}
-
-		// open paragraph
-		lastWasBlank = false
-		lastWasHeading = false
-		para = append(para, lines[i])
-		i++
-	}
-	close()
-
-	return out
-}
-
-// ToText prepares comment text for presentation in textual output.
-// It wraps paragraphs of text to width or fewer Unicode code points
-// and then prefixes each line with the indent.  In preformatted sections
-// (such as program text), it prefixes each non-blank line with preIndent.
-func ToText(w io.Writer, text string, indent, preIndent string, width int) {
-	l := lineWrapper{
-		out:    w,
-		width:  width,
-		indent: indent,
-	}
-	for _, b := range blocks(text) {
-		switch b.op {
-		case opPara:
-			// l.write will add leading newline if required
-			for _, line := range b.lines {
-				l.write(line)
-			}
-			l.flush()
-		case opHead:
-			w.Write(nl)
-			for _, line := range b.lines {
-				l.write(line + "\n")
-			}
-			l.flush()
-		case opPre:
-			w.Write(nl)
-			for _, line := range b.lines {
-				if isBlank(line) {
-					w.Write([]byte("\n"))
-				} else {
-					w.Write([]byte(preIndent))
-					w.Write([]byte(line))
-				}
-			}
-		}
-	}
-}
-
-type lineWrapper struct {
-	out       io.Writer
-	printed   bool
-	width     int
-	indent    string
-	n         int
-	pendSpace int
-}
-
-var nl = []byte("\n")
-var space = []byte(" ")
-
-func (l *lineWrapper) write(text string) {
-	if l.n == 0 && l.printed {
-		l.out.Write(nl) // blank line before new paragraph
-	}
-	l.printed = true
-
-	for _, f := range strings.Fields(text) {
-		w := utf8.RuneCountInString(f)
-		// wrap if line is too long
-		if l.n > 0 && l.n+l.pendSpace+w > l.width {
-			l.out.Write(nl)
-			l.n = 0
-			l.pendSpace = 0
-		}
-		if l.n == 0 {
-			l.out.Write([]byte(l.indent))
-		}
-		l.out.Write(space[:l.pendSpace])
-		l.out.Write([]byte(f))
-		l.n += l.pendSpace + w
-		l.pendSpace = 1
-	}
-}
-
-func (l *lineWrapper) flush() {
-	if l.n == 0 {
-		return
-	}
-	l.out.Write(nl)
-	l.pendSpace = 0
-	l.n = 0
-}
diff --git a/src/pkg/go/doc/comment_test.go b/src/pkg/go/doc/comment_test.go
deleted file mode 100644
index ad65c2a27..000000000
--- a/src/pkg/go/doc/comment_test.go
+++ /dev/null
@@ -1,207 +0,0 @@
-// 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.
-
-package doc
-
-import (
-	"bytes"
-	"reflect"
-	"testing"
-)
-
-var headingTests = []struct {
-	line string
-	ok   bool
-}{
-	{"Section", true},
-	{"A typical usage", true},
-	{"ΔΛΞ is Greek", true},
-	{"Foo 42", true},
-	{"", false},
-	{"section", false},
-	{"A typical usage:", false},
-	{"This code:", false},
-	{"δ is Greek", false},
-	{"Foo §", false},
-	{"Fermat's Last Sentence", true},
-	{"Fermat's", true},
-	{"'sX", false},
-	{"Ted 'Too' Bar", false},
-	{"Use n+m", false},
-	{"Scanning:", false},
-	{"N:M", false},
-}
-
-func TestIsHeading(t *testing.T) {
-	for _, tt := range headingTests {
-		if h := heading(tt.line); (len(h) > 0) != tt.ok {
-			t.Errorf("isHeading(%q) = %v, want %v", tt.line, h, tt.ok)
-		}
-	}
-}
-
-var blocksTests = []struct {
-	in   string
-	out  []block
-	text string
-}{
-	{
-		in: `Para 1.
-Para 1 line 2.
-
-Para 2.
-
-Section
-
-Para 3.
-
-	pre
-	pre1
-
-Para 4.
-
-	pre
-	pre1
-
-	pre2
-
-Para 5.
-
-
-	pre
-
-
-	pre1
-	pre2
-
-Para 6.
-	pre
-	pre2
-`,
-		out: []block{
-			{opPara, []string{"Para 1.\n", "Para 1 line 2.\n"}},
-			{opPara, []string{"Para 2.\n"}},
-			{opHead, []string{"Section"}},
-			{opPara, []string{"Para 3.\n"}},
-			{opPre, []string{"pre\n", "pre1\n"}},
-			{opPara, []string{"Para 4.\n"}},
-			{opPre, []string{"pre\n", "pre1\n", "\n", "pre2\n"}},
-			{opPara, []string{"Para 5.\n"}},
-			{opPre, []string{"pre\n", "\n", "\n", "pre1\n", "pre2\n"}},
-			{opPara, []string{"Para 6.\n"}},
-			{opPre, []string{"pre\n", "pre2\n"}},
-		},
-		text: `.   Para 1. Para 1 line 2.
-
-.   Para 2.
-
-
-.   Section
-
-.   Para 3.
-
-$	pre
-$	pre1
-
-.   Para 4.
-
-$	pre
-$	pre1
-
-$	pre2
-
-.   Para 5.
-
-$	pre
-
-
-$	pre1
-$	pre2
-
-.   Para 6.
-
-$	pre
-$	pre2
-`,
-	},
-}
-
-func TestBlocks(t *testing.T) {
-	for i, tt := range blocksTests {
-		b := blocks(tt.in)
-		if !reflect.DeepEqual(b, tt.out) {
-			t.Errorf("#%d: mismatch\nhave: %v\nwant: %v", i, b, tt.out)
-		}
-	}
-}
-
-func TestToText(t *testing.T) {
-	var buf bytes.Buffer
-	for i, tt := range blocksTests {
-		ToText(&buf, tt.in, ".   ", "$\t", 40)
-		if have := buf.String(); have != tt.text {
-			t.Errorf("#%d: mismatch\nhave: %s\nwant: %s\nhave vs want:\n%q\n%q", i, have, tt.text, have, tt.text)
-		}
-		buf.Reset()
-	}
-}
-
-var emphasizeTests = []struct {
-	in, out string
-}{
-	{"http://www.google.com/", `<a href="http://www.google.com/">http://www.google.com/</a>`},
-	{"https://www.google.com/", `<a href="https://www.google.com/">https://www.google.com/</a>`},
-	{"http://www.google.com/path.", `<a href="http://www.google.com/path">http://www.google.com/path</a>.`},
-	{"http://en.wikipedia.org/wiki/Camellia_(cipher)", `<a href="http://en.wikipedia.org/wiki/Camellia_(cipher)">http://en.wikipedia.org/wiki/Camellia_(cipher)</a>`},
-	{"(http://www.google.com/)", `(<a href="http://www.google.com/">http://www.google.com/</a>)`},
-	{"http://gmail.com)", `<a href="http://gmail.com">http://gmail.com</a>)`},
-	{"((http://gmail.com))", `((<a href="http://gmail.com">http://gmail.com</a>))`},
-	{"http://gmail.com ((http://gmail.com)) ()", `<a href="http://gmail.com">http://gmail.com</a> ((<a href="http://gmail.com">http://gmail.com</a>)) ()`},
-	{"Foo bar http://example.com/ quux!", `Foo bar <a href="http://example.com/">http://example.com/</a> quux!`},
-	{"Hello http://example.com/%2f/ /world.", `Hello <a href="http://example.com/%2f/">http://example.com/%2f/</a> /world.`},
-	{"Lorem http: ipsum //host/path", "Lorem http: ipsum //host/path"},
-	{"javascript://is/not/linked", "javascript://is/not/linked"},
-}
-
-func TestEmphasize(t *testing.T) {
-	for i, tt := range emphasizeTests {
-		var buf bytes.Buffer
-		emphasize(&buf, tt.in, nil, true)
-		out := buf.String()
-		if out != tt.out {
-			t.Errorf("#%d: mismatch\nhave: %v\nwant: %v", i, out, tt.out)
-		}
-	}
-}
-
-var pairedParensPrefixLenTests = []struct {
-	in, out string
-}{
-	{"", ""},
-	{"foo", "foo"},
-	{"()", "()"},
-	{"foo()", "foo()"},
-	{"foo()()()", "foo()()()"},
-	{"foo()((()()))", "foo()((()()))"},
-	{"foo()((()()))bar", "foo()((()()))bar"},
-	{"foo)", "foo"},
-	{"foo))", "foo"},
-	{"foo)))))", "foo"},
-	{"(foo", ""},
-	{"((foo", ""},
-	{"(((((foo", ""},
-	{"(foo)", "(foo)"},
-	{"((((foo))))", "((((foo))))"},
-	{"foo()())", "foo()()"},
-	{"foo((()())", "foo"},
-	{"foo((()())) (() foo ", "foo((()())) "},
-}
-
-func TestPairedParensPrefixLen(t *testing.T) {
-	for i, tt := range pairedParensPrefixLenTests {
-		if out := tt.in[:pairedParensPrefixLen(tt.in)]; out != tt.out {
-			t.Errorf("#%d: mismatch\nhave: %q\nwant: %q", i, out, tt.out)
-		}
-	}
-}
diff --git a/src/pkg/go/doc/doc.go b/src/pkg/go/doc/doc.go
deleted file mode 100644
index 4264940a0..000000000
--- a/src/pkg/go/doc/doc.go
+++ /dev/null
@@ -1,111 +0,0 @@
-// 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.
-
-// Package doc extracts source code documentation from a Go AST.
-package doc
-
-import (
-	"go/ast"
-	"go/token"
-)
-
-// Package is the documentation for an entire package.
-type Package struct {
-	Doc        string
-	Name       string
-	ImportPath string
-	Imports    []string
-	Filenames  []string
-	Notes      map[string][]*Note
-	// DEPRECATED. For backward compatibility Bugs is still populated,
-	// but all new code should use Notes instead.
-	Bugs []string
-
-	// declarations
-	Consts []*Value
-	Types  []*Type
-	Vars   []*Value
-	Funcs  []*Func
-}
-
-// Value is the documentation for a (possibly grouped) var or const declaration.
-type Value struct {
-	Doc   string
-	Names []string // var or const names in declaration order
-	Decl  *ast.GenDecl
-
-	order int
-}
-
-// Type is the documentation for a type declaration.
-type Type struct {
-	Doc  string
-	Name string
-	Decl *ast.GenDecl
-
-	// associated declarations
-	Consts  []*Value // sorted list of constants of (mostly) this type
-	Vars    []*Value // sorted list of variables of (mostly) this type
-	Funcs   []*Func  // sorted list of functions returning this type
-	Methods []*Func  // sorted list of methods (including embedded ones) of this type
-}
-
-// Func is the documentation for a func declaration.
-type Func struct {
-	Doc  string
-	Name string
-	Decl *ast.FuncDecl
-
-	// methods
-	// (for functions, these fields have the respective zero value)
-	Recv  string // actual   receiver "T" or "*T"
-	Orig  string // original receiver "T" or "*T"
-	Level int    // embedding level; 0 means not embedded
-}
-
-// A Note represents a marked comment starting with "MARKER(uid): note body".
-// Any note with a marker of 2 or more upper case [A-Z] letters and a uid of
-// at least one character is recognized. The ":" following the uid is optional.
-// Notes are collected in the Package.Notes map indexed by the notes marker.
-type Note struct {
-	Pos, End token.Pos // position range of the comment containing the marker
-	UID      string    // uid found with the marker
-	Body     string    // note body text
-}
-
-// Mode values control the operation of New.
-type Mode int
-
-const (
-	// extract documentation for all package-level declarations,
-	// not just exported ones
-	AllDecls Mode = 1 << iota
-
-	// show all embedded methods, not just the ones of
-	// invisible (unexported) anonymous fields
-	AllMethods
-)
-
-// New computes the package documentation for the given package AST.
-// New takes ownership of the AST pkg and may edit or overwrite it.
-//
-func New(pkg *ast.Package, importPath string, mode Mode) *Package {
-	var r reader
-	r.readPackage(pkg, mode)
-	r.computeMethodSets()
-	r.cleanupTypes()
-	return &Package{
-		Doc:        r.doc,
-		Name:       pkg.Name,
-		ImportPath: importPath,
-		Imports:    sortedKeys(r.imports),
-		Filenames:  r.filenames,
-		Notes:      r.notes,
-		Bugs:       noteBodies(r.notes["BUG"]),
-		Consts:     sortedValues(r.values, token.CONST),
-		Types:      sortedTypes(r.types, mode&AllMethods != 0),
-		Vars:       sortedValues(r.values, token.VAR),
-		Funcs:      sortedFuncs(r.funcs, true),
-	}
-}
diff --git a/src/pkg/go/doc/doc_test.go b/src/pkg/go/doc/doc_test.go
deleted file mode 100644
index ad8ba5378..000000000
--- a/src/pkg/go/doc/doc_test.go
+++ /dev/null
@@ -1,146 +0,0 @@
-// Copyright 2012 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.
-
-package doc
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"go/parser"
-	"go/printer"
-	"go/token"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"testing"
-	"text/template"
-)
-
-var update = flag.Bool("update", false, "update golden (.out) files")
-var files = flag.String("files", "", "consider only Go test files matching this regular expression")
-
-const dataDir = "testdata"
-
-var templateTxt = readTemplate("template.txt")
-
-func readTemplate(filename string) *template.Template {
-	t := template.New(filename)
-	t.Funcs(template.FuncMap{
-		"node":     nodeFmt,
-		"synopsis": synopsisFmt,
-		"indent":   indentFmt,
-	})
-	return template.Must(t.ParseFiles(filepath.Join(dataDir, filename)))
-}
-
-func nodeFmt(node interface{}, fset *token.FileSet) string {
-	var buf bytes.Buffer
-	printer.Fprint(&buf, fset, node)
-	return strings.Replace(strings.TrimSpace(buf.String()), "\n", "\n\t", -1)
-}
-
-func synopsisFmt(s string) string {
-	const n = 64
-	if len(s) > n {
-		// cut off excess text and go back to a word boundary
-		s = s[0:n]
-		if i := strings.LastIndexAny(s, "\t\n "); i >= 0 {
-			s = s[0:i]
-		}
-		s = strings.TrimSpace(s) + " ..."
-	}
-	return "// " + strings.Replace(s, "\n", " ", -1)
-}
-
-func indentFmt(indent, s string) string {
-	end := ""
-	if strings.HasSuffix(s, "\n") {
-		end = "\n"
-		s = s[:len(s)-1]
-	}
-	return indent + strings.Replace(s, "\n", "\n"+indent, -1) + end
-}
-
-func isGoFile(fi os.FileInfo) bool {
-	name := fi.Name()
-	return !fi.IsDir() &&
-		len(name) > 0 && name[0] != '.' && // ignore .files
-		filepath.Ext(name) == ".go"
-}
-
-type bundle struct {
-	*Package
-	FSet *token.FileSet
-}
-
-func test(t *testing.T, mode Mode) {
-	// determine file filter
-	filter := isGoFile
-	if *files != "" {
-		rx, err := regexp.Compile(*files)
-		if err != nil {
-			t.Fatal(err)
-		}
-		filter = func(fi os.FileInfo) bool {
-			return isGoFile(fi) && rx.MatchString(fi.Name())
-		}
-	}
-
-	// get packages
-	fset := token.NewFileSet()
-	pkgs, err := parser.ParseDir(fset, dataDir, filter, parser.ParseComments)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// test packages
-	for _, pkg := range pkgs {
-		importpath := dataDir + "/" + pkg.Name
-		doc := New(pkg, importpath, mode)
-
-		// golden files always use / in filenames - canonicalize them
-		for i, filename := range doc.Filenames {
-			doc.Filenames[i] = filepath.ToSlash(filename)
-		}
-
-		// print documentation
-		var buf bytes.Buffer
-		if err := templateTxt.Execute(&buf, bundle{doc, fset}); err != nil {
-			t.Error(err)
-			continue
-		}
-		got := buf.Bytes()
-
-		// update golden file if necessary
-		golden := filepath.Join(dataDir, fmt.Sprintf("%s.%d.golden", pkg.Name, mode))
-		if *update {
-			err := ioutil.WriteFile(golden, got, 0644)
-			if err != nil {
-				t.Error(err)
-			}
-			continue
-		}
-
-		// get golden file
-		want, err := ioutil.ReadFile(golden)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-
-		// compare
-		if !bytes.Equal(got, want) {
-			t.Errorf("package %s\n\tgot:\n%s\n\twant:\n%s", pkg.Name, got, want)
-		}
-	}
-}
-
-func Test(t *testing.T) {
-	test(t, 0)
-	test(t, AllDecls)
-	test(t, AllMethods)
-}
diff --git a/src/pkg/go/doc/example.go b/src/pkg/go/doc/example.go
deleted file mode 100644
index c414e548c..000000000
--- a/src/pkg/go/doc/example.go
+++ /dev/null
@@ -1,355 +0,0 @@
-// 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.
-
-// Extract example functions from file ASTs.
-
-package doc
-
-import (
-	"go/ast"
-	"go/token"
-	"path"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-// An Example represents an example function found in a source files.
-type Example struct {
-	Name        string // name of the item being exemplified
-	Doc         string // example function doc string
-	Code        ast.Node
-	Play        *ast.File // a whole program version of the example
-	Comments    []*ast.CommentGroup
-	Output      string // expected output
-	EmptyOutput bool   // expect empty output
-	Order       int    // original source code order
-}
-
-// Examples returns the examples found in the files, sorted by Name field.
-// The Order fields record the order in which the examples were encountered.
-//
-// Playable Examples must be in a package whose name ends in "_test".
-// An Example is "playable" (the Play field is non-nil) in either of these
-// circumstances:
-//   - The example function is self-contained: the function references only
-//     identifiers from other packages (or predeclared identifiers, such as
-//     "int") and the test file does not include a dot import.
-//   - The entire test file is the example: the file contains exactly one
-//     example function, zero test or benchmark functions, and at least one
-//     top-level function, type, variable, or constant declaration other
-//     than the example function.
-func Examples(files ...*ast.File) []*Example {
-	var list []*Example
-	for _, file := range files {
-		hasTests := false // file contains tests or benchmarks
-		numDecl := 0      // number of non-import declarations in the file
-		var flist []*Example
-		for _, decl := range file.Decls {
-			if g, ok := decl.(*ast.GenDecl); ok && g.Tok != token.IMPORT {
-				numDecl++
-				continue
-			}
-			f, ok := decl.(*ast.FuncDecl)
-			if !ok {
-				continue
-			}
-			numDecl++
-			name := f.Name.Name
-			if isTest(name, "Test") || isTest(name, "Benchmark") {
-				hasTests = true
-				continue
-			}
-			if !isTest(name, "Example") {
-				continue
-			}
-			var doc string
-			if f.Doc != nil {
-				doc = f.Doc.Text()
-			}
-			output, hasOutput := exampleOutput(f.Body, file.Comments)
-			flist = append(flist, &Example{
-				Name:        name[len("Example"):],
-				Doc:         doc,
-				Code:        f.Body,
-				Play:        playExample(file, f.Body),
-				Comments:    file.Comments,
-				Output:      output,
-				EmptyOutput: output == "" && hasOutput,
-				Order:       len(flist),
-			})
-		}
-		if !hasTests && numDecl > 1 && len(flist) == 1 {
-			// If this file only has one example function, some
-			// other top-level declarations, and no tests or
-			// benchmarks, use the whole file as the example.
-			flist[0].Code = file
-			flist[0].Play = playExampleFile(file)
-		}
-		list = append(list, flist...)
-	}
-	sort.Sort(exampleByName(list))
-	return list
-}
-
-var outputPrefix = regexp.MustCompile(`(?i)^[[:space:]]*output:`)
-
-// Extracts the expected output and whether there was a valid output comment
-func exampleOutput(b *ast.BlockStmt, comments []*ast.CommentGroup) (output string, ok bool) {
-	if _, last := lastComment(b, comments); last != nil {
-		// test that it begins with the correct prefix
-		text := last.Text()
-		if loc := outputPrefix.FindStringIndex(text); loc != nil {
-			text = text[loc[1]:]
-			// Strip zero or more spaces followed by \n or a single space.
-			text = strings.TrimLeft(text, " ")
-			if len(text) > 0 && text[0] == '\n' {
-				text = text[1:]
-			}
-			return text, true
-		}
-	}
-	return "", false // no suitable comment found
-}
-
-// isTest tells whether name looks like a test, example, or benchmark.
-// It is a Test (say) if there is a character after Test that is not a
-// lower-case letter. (We don't want Testiness.)
-func isTest(name, prefix string) bool {
-	if !strings.HasPrefix(name, prefix) {
-		return false
-	}
-	if len(name) == len(prefix) { // "Test" is ok
-		return true
-	}
-	rune, _ := utf8.DecodeRuneInString(name[len(prefix):])
-	return !unicode.IsLower(rune)
-}
-
-type exampleByName []*Example
-
-func (s exampleByName) Len() int           { return len(s) }
-func (s exampleByName) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-func (s exampleByName) Less(i, j int) bool { return s[i].Name < s[j].Name }
-
-// playExample synthesizes a new *ast.File based on the provided
-// file with the provided function body as the body of main.
-func playExample(file *ast.File, body *ast.BlockStmt) *ast.File {
-	if !strings.HasSuffix(file.Name.Name, "_test") {
-		// We don't support examples that are part of the
-		// greater package (yet).
-		return nil
-	}
-
-	// Find top-level declarations in the file.
-	topDecls := make(map[*ast.Object]bool)
-	for _, decl := range file.Decls {
-		switch d := decl.(type) {
-		case *ast.FuncDecl:
-			topDecls[d.Name.Obj] = true
-		case *ast.GenDecl:
-			for _, spec := range d.Specs {
-				switch s := spec.(type) {
-				case *ast.TypeSpec:
-					topDecls[s.Name.Obj] = true
-				case *ast.ValueSpec:
-					for _, id := range s.Names {
-						topDecls[id.Obj] = true
-					}
-				}
-			}
-		}
-	}
-
-	// Find unresolved identifiers and uses of top-level declarations.
-	unresolved := make(map[string]bool)
-	usesTopDecl := false
-	var inspectFunc func(ast.Node) bool
-	inspectFunc = func(n ast.Node) bool {
-		// For selector expressions, only inspect the left hand side.
-		// (For an expression like fmt.Println, only add "fmt" to the
-		// set of unresolved names, not "Println".)
-		if e, ok := n.(*ast.SelectorExpr); ok {
-			ast.Inspect(e.X, inspectFunc)
-			return false
-		}
-		// For key value expressions, only inspect the value
-		// as the key should be resolved by the type of the
-		// composite literal.
-		if e, ok := n.(*ast.KeyValueExpr); ok {
-			ast.Inspect(e.Value, inspectFunc)
-			return false
-		}
-		if id, ok := n.(*ast.Ident); ok {
-			if id.Obj == nil {
-				unresolved[id.Name] = true
-			} else if topDecls[id.Obj] {
-				usesTopDecl = true
-			}
-		}
-		return true
-	}
-	ast.Inspect(body, inspectFunc)
-	if usesTopDecl {
-		// We don't support examples that are not self-contained (yet).
-		return nil
-	}
-
-	// Remove predeclared identifiers from unresolved list.
-	for n := range unresolved {
-		if predeclaredTypes[n] || predeclaredConstants[n] || predeclaredFuncs[n] {
-			delete(unresolved, n)
-		}
-	}
-
-	// Use unresolved identifiers to determine the imports used by this
-	// example. The heuristic assumes package names match base import
-	// paths for imports w/o renames (should be good enough most of the time).
-	namedImports := make(map[string]string) // [name]path
-	var blankImports []ast.Spec             // _ imports
-	for _, s := range file.Imports {
-		p, err := strconv.Unquote(s.Path.Value)
-		if err != nil {
-			continue
-		}
-		n := path.Base(p)
-		if s.Name != nil {
-			n = s.Name.Name
-			switch n {
-			case "_":
-				blankImports = append(blankImports, s)
-				continue
-			case ".":
-				// We can't resolve dot imports (yet).
-				return nil
-			}
-		}
-		if unresolved[n] {
-			namedImports[n] = p
-			delete(unresolved, n)
-		}
-	}
-
-	// If there are other unresolved identifiers, give up because this
-	// synthesized file is not going to build.
-	if len(unresolved) > 0 {
-		return nil
-	}
-
-	// Include documentation belonging to blank imports.
-	var comments []*ast.CommentGroup
-	for _, s := range blankImports {
-		if c := s.(*ast.ImportSpec).Doc; c != nil {
-			comments = append(comments, c)
-		}
-	}
-
-	// Include comments that are inside the function body.
-	for _, c := range file.Comments {
-		if body.Pos() <= c.Pos() && c.End() <= body.End() {
-			comments = append(comments, c)
-		}
-	}
-
-	// Strip "Output:" comment and adjust body end position.
-	body, comments = stripOutputComment(body, comments)
-
-	// Synthesize import declaration.
-	importDecl := &ast.GenDecl{
-		Tok:    token.IMPORT,
-		Lparen: 1, // Need non-zero Lparen and Rparen so that printer
-		Rparen: 1, // treats this as a factored import.
-	}
-	for n, p := range namedImports {
-		s := &ast.ImportSpec{Path: &ast.BasicLit{Value: strconv.Quote(p)}}
-		if path.Base(p) != n {
-			s.Name = ast.NewIdent(n)
-		}
-		importDecl.Specs = append(importDecl.Specs, s)
-	}
-	importDecl.Specs = append(importDecl.Specs, blankImports...)
-
-	// Synthesize main function.
-	funcDecl := &ast.FuncDecl{
-		Name: ast.NewIdent("main"),
-		Type: &ast.FuncType{Params: &ast.FieldList{}}, // FuncType.Params must be non-nil
-		Body: body,
-	}
-
-	// Synthesize file.
-	return &ast.File{
-		Name:     ast.NewIdent("main"),
-		Decls:    []ast.Decl{importDecl, funcDecl},
-		Comments: comments,
-	}
-}
-
-// playExampleFile takes a whole file example and synthesizes a new *ast.File
-// such that the example is function main in package main.
-func playExampleFile(file *ast.File) *ast.File {
-	// Strip copyright comment if present.
-	comments := file.Comments
-	if len(comments) > 0 && strings.HasPrefix(comments[0].Text(), "Copyright") {
-		comments = comments[1:]
-	}
-
-	// Copy declaration slice, rewriting the ExampleX function to main.
-	var decls []ast.Decl
-	for _, d := range file.Decls {
-		if f, ok := d.(*ast.FuncDecl); ok && isTest(f.Name.Name, "Example") {
-			// Copy the FuncDecl, as it may be used elsewhere.
-			newF := *f
-			newF.Name = ast.NewIdent("main")
-			newF.Body, comments = stripOutputComment(f.Body, comments)
-			d = &newF
-		}
-		decls = append(decls, d)
-	}
-
-	// Copy the File, as it may be used elsewhere.
-	f := *file
-	f.Name = ast.NewIdent("main")
-	f.Decls = decls
-	f.Comments = comments
-	return &f
-}
-
-// stripOutputComment finds and removes an "Output:" comment from body
-// and comments, and adjusts the body block's end position.
-func stripOutputComment(body *ast.BlockStmt, comments []*ast.CommentGroup) (*ast.BlockStmt, []*ast.CommentGroup) {
-	// Do nothing if no "Output:" comment found.
-	i, last := lastComment(body, comments)
-	if last == nil || !outputPrefix.MatchString(last.Text()) {
-		return body, comments
-	}
-
-	// Copy body and comments, as the originals may be used elsewhere.
-	newBody := &ast.BlockStmt{
-		Lbrace: body.Lbrace,
-		List:   body.List,
-		Rbrace: last.Pos(),
-	}
-	newComments := make([]*ast.CommentGroup, len(comments)-1)
-	copy(newComments, comments[:i])
-	copy(newComments[i:], comments[i+1:])
-	return newBody, newComments
-}
-
-// lastComment returns the last comment inside the provided block.
-func lastComment(b *ast.BlockStmt, c []*ast.CommentGroup) (i int, last *ast.CommentGroup) {
-	pos, end := b.Pos(), b.End()
-	for j, cg := range c {
-		if cg.Pos() < pos {
-			continue
-		}
-		if cg.End() > end {
-			break
-		}
-		i, last = j, cg
-	}
-	return
-}
diff --git a/src/pkg/go/doc/example_test.go b/src/pkg/go/doc/example_test.go
deleted file mode 100644
index e154ea8bf..000000000
--- a/src/pkg/go/doc/example_test.go
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright 2013 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.
-
-package doc_test
-
-import (
-	"bytes"
-	"go/doc"
-	"go/format"
-	"go/parser"
-	"go/token"
-	"strings"
-	"testing"
-)
-
-const exampleTestFile = `
-package foo_test
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"os/exec"
-)
-
-func ExampleHello() {
-	fmt.Println("Hello, world!")
-	// Output: Hello, world!
-}
-
-func ExampleImport() {
-	out, err := exec.Command("date").Output()
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Printf("The date is %s\n", out)
-}
-
-func ExampleKeyValue() {
-	v := struct {
-		a string
-		b int
-	}{
-		a: "A",
-		b: 1,
-	}
-	fmt.Print(v)
-	// Output: a: "A", b: 1
-}
-
-func ExampleKeyValueImport() {
-	f := flag.Flag{
-		Name: "play",
-	}
-	fmt.Print(f)
-	// Output: Name: "play"
-}
-
-var keyValueTopDecl = struct {
-	a string
-	b int
-}{
-	a: "B",
-	b: 2,
-}
-
-func ExampleKeyValueTopDecl() {
-	fmt.Print(keyValueTopDecl)
-}
-`
-
-var exampleTestCases = []struct {
-	Name, Play, Output string
-}{
-	{
-		Name:   "Hello",
-		Play:   exampleHelloPlay,
-		Output: "Hello, world!\n",
-	},
-	{
-		Name: "Import",
-		Play: exampleImportPlay,
-	},
-	{
-		Name:   "KeyValue",
-		Play:   exampleKeyValuePlay,
-		Output: "a: \"A\", b: 1\n",
-	},
-	{
-		Name:   "KeyValueImport",
-		Play:   exampleKeyValueImportPlay,
-		Output: "Name: \"play\"\n",
-	},
-	{
-		Name: "KeyValueTopDecl",
-		Play: "<nil>",
-	},
-}
-
-const exampleHelloPlay = `package main
-
-import (
-	"fmt"
-)
-
-func main() {
-	fmt.Println("Hello, world!")
-}
-`
-const exampleImportPlay = `package main
-
-import (
-	"fmt"
-	"log"
-	"os/exec"
-)
-
-func main() {
-	out, err := exec.Command("date").Output()
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Printf("The date is %s\n", out)
-}
-`
-
-const exampleKeyValuePlay = `package main
-
-import (
-	"fmt"
-)
-
-func main() {
-	v := struct {
-		a string
-		b int
-	}{
-		a: "A",
-		b: 1,
-	}
-	fmt.Print(v)
-}
-`
-
-const exampleKeyValueImportPlay = `package main
-
-import (
-	"flag"
-	"fmt"
-)
-
-func main() {
-	f := flag.Flag{
-		Name: "play",
-	}
-	fmt.Print(f)
-}
-`
-
-func TestExamples(t *testing.T) {
-	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "test.go", strings.NewReader(exampleTestFile), parser.ParseComments)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i, e := range doc.Examples(file) {
-		c := exampleTestCases[i]
-		if e.Name != c.Name {
-			t.Errorf("got Name == %q, want %q", e.Name, c.Name)
-		}
-		if w := c.Play; w != "" {
-			var g string // hah
-			if e.Play == nil {
-				g = "<nil>"
-			} else {
-				var buf bytes.Buffer
-				if err := format.Node(&buf, fset, e.Play); err != nil {
-					t.Fatal(err)
-				}
-				g = buf.String()
-			}
-			if g != w {
-				t.Errorf("%s: got Play == %q, want %q", c.Name, g, w)
-			}
-		}
-		if g, w := e.Output, c.Output; g != w {
-			t.Errorf("%s: got Output == %q, want %q", c.Name, g, w)
-		}
-	}
-}
diff --git a/src/pkg/go/doc/exports.go b/src/pkg/go/doc/exports.go
deleted file mode 100644
index ff01285d4..000000000
--- a/src/pkg/go/doc/exports.go
+++ /dev/null
@@ -1,199 +0,0 @@
-// 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.
-
-// This file implements export filtering of an AST.
-
-package doc
-
-import "go/ast"
-
-// filterIdentList removes unexported names from list in place
-// and returns the resulting list.
-//
-func filterIdentList(list []*ast.Ident) []*ast.Ident {
-	j := 0
-	for _, x := range list {
-		if ast.IsExported(x.Name) {
-			list[j] = x
-			j++
-		}
-	}
-	return list[0:j]
-}
-
-// removeErrorField removes anonymous fields named "error" from an interface.
-// This is called when "error" has been determined to be a local name,
-// not the predeclared type.
-//
-func removeErrorField(ityp *ast.InterfaceType) {
-	list := ityp.Methods.List // we know that ityp.Methods != nil
-	j := 0
-	for _, field := range list {
-		keepField := true
-		if n := len(field.Names); n == 0 {
-			// anonymous field
-			if fname, _ := baseTypeName(field.Type); fname == "error" {
-				keepField = false
-			}
-		}
-		if keepField {
-			list[j] = field
-			j++
-		}
-	}
-	if j < len(list) {
-		ityp.Incomplete = true
-	}
-	ityp.Methods.List = list[0:j]
-}
-
-// filterFieldList removes unexported fields (field names) from the field list
-// in place and returns true if fields were removed. Anonymous fields are
-// recorded with the parent type. filterType is called with the types of
-// all remaining fields.
-//
-func (r *reader) filterFieldList(parent *namedType, fields *ast.FieldList, ityp *ast.InterfaceType) (removedFields bool) {
-	if fields == nil {
-		return
-	}
-	list := fields.List
-	j := 0
-	for _, field := range list {
-		keepField := false
-		if n := len(field.Names); n == 0 {
-			// anonymous field
-			fname := r.recordAnonymousField(parent, field.Type)
-			if ast.IsExported(fname) {
-				keepField = true
-			} else if ityp != nil && fname == "error" {
-				// possibly the predeclared error interface; keep
-				// it for now but remember this interface so that
-				// it can be fixed if error is also defined locally
-				keepField = true
-				r.remember(ityp)
-			}
-		} else {
-			field.Names = filterIdentList(field.Names)
-			if len(field.Names) < n {
-				removedFields = true
-			}
-			if len(field.Names) > 0 {
-				keepField = true
-			}
-		}
-		if keepField {
-			r.filterType(nil, field.Type)
-			list[j] = field
-			j++
-		}
-	}
-	if j < len(list) {
-		removedFields = true
-	}
-	fields.List = list[0:j]
-	return
-}
-
-// filterParamList applies filterType to each parameter type in fields.
-//
-func (r *reader) filterParamList(fields *ast.FieldList) {
-	if fields != nil {
-		for _, f := range fields.List {
-			r.filterType(nil, f.Type)
-		}
-	}
-}
-
-// filterType strips any unexported struct fields or method types from typ
-// in place. If fields (or methods) have been removed, the corresponding
-// struct or interface type has the Incomplete field set to true.
-//
-func (r *reader) filterType(parent *namedType, typ ast.Expr) {
-	switch t := typ.(type) {
-	case *ast.Ident:
-		// nothing to do
-	case *ast.ParenExpr:
-		r.filterType(nil, t.X)
-	case *ast.ArrayType:
-		r.filterType(nil, t.Elt)
-	case *ast.StructType:
-		if r.filterFieldList(parent, t.Fields, nil) {
-			t.Incomplete = true
-		}
-	case *ast.FuncType:
-		r.filterParamList(t.Params)
-		r.filterParamList(t.Results)
-	case *ast.InterfaceType:
-		if r.filterFieldList(parent, t.Methods, t) {
-			t.Incomplete = true
-		}
-	case *ast.MapType:
-		r.filterType(nil, t.Key)
-		r.filterType(nil, t.Value)
-	case *ast.ChanType:
-		r.filterType(nil, t.Value)
-	}
-}
-
-func (r *reader) filterSpec(spec ast.Spec) bool {
-	switch s := spec.(type) {
-	case *ast.ImportSpec:
-		// always keep imports so we can collect them
-		return true
-	case *ast.ValueSpec:
-		s.Names = filterIdentList(s.Names)
-		if len(s.Names) > 0 {
-			r.filterType(nil, s.Type)
-			return true
-		}
-	case *ast.TypeSpec:
-		if name := s.Name.Name; ast.IsExported(name) {
-			r.filterType(r.lookupType(s.Name.Name), s.Type)
-			return true
-		} else if name == "error" {
-			// special case: remember that error is declared locally
-			r.errorDecl = true
-		}
-	}
-	return false
-}
-
-func (r *reader) filterSpecList(list []ast.Spec) []ast.Spec {
-	j := 0
-	for _, s := range list {
-		if r.filterSpec(s) {
-			list[j] = s
-			j++
-		}
-	}
-	return list[0:j]
-}
-
-func (r *reader) filterDecl(decl ast.Decl) bool {
-	switch d := decl.(type) {
-	case *ast.GenDecl:
-		d.Specs = r.filterSpecList(d.Specs)
-		return len(d.Specs) > 0
-	case *ast.FuncDecl:
-		// ok to filter these methods early because any
-		// conflicting method will be filtered here, too -
-		// thus, removing these methods early will not lead
-		// to the false removal of possible conflicts
-		return ast.IsExported(d.Name.Name)
-	}
-	return false
-}
-
-// fileExports removes unexported declarations from src in place.
-//
-func (r *reader) fileExports(src *ast.File) {
-	j := 0
-	for _, d := range src.Decls {
-		if r.filterDecl(d) {
-			src.Decls[j] = d
-			j++
-		}
-	}
-	src.Decls = src.Decls[0:j]
-}
diff --git a/src/pkg/go/doc/filter.go b/src/pkg/go/doc/filter.go
deleted file mode 100644
index a6f243f33..000000000
--- a/src/pkg/go/doc/filter.go
+++ /dev/null
@@ -1,105 +0,0 @@
-// 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.
-
-package doc
-
-import "go/ast"
-
-type Filter func(string) bool
-
-func matchFields(fields *ast.FieldList, f Filter) bool {
-	if fields != nil {
-		for _, field := range fields.List {
-			for _, name := range field.Names {
-				if f(name.Name) {
-					return true
-				}
-			}
-		}
-	}
-	return false
-}
-
-func matchDecl(d *ast.GenDecl, f Filter) bool {
-	for _, d := range d.Specs {
-		switch v := d.(type) {
-		case *ast.ValueSpec:
-			for _, name := range v.Names {
-				if f(name.Name) {
-					return true
-				}
-			}
-		case *ast.TypeSpec:
-			if f(v.Name.Name) {
-				return true
-			}
-			switch t := v.Type.(type) {
-			case *ast.StructType:
-				if matchFields(t.Fields, f) {
-					return true
-				}
-			case *ast.InterfaceType:
-				if matchFields(t.Methods, f) {
-					return true
-				}
-			}
-		}
-	}
-	return false
-}
-
-func filterValues(a []*Value, f Filter) []*Value {
-	w := 0
-	for _, vd := range a {
-		if matchDecl(vd.Decl, f) {
-			a[w] = vd
-			w++
-		}
-	}
-	return a[0:w]
-}
-
-func filterFuncs(a []*Func, f Filter) []*Func {
-	w := 0
-	for _, fd := range a {
-		if f(fd.Name) {
-			a[w] = fd
-			w++
-		}
-	}
-	return a[0:w]
-}
-
-func filterTypes(a []*Type, f Filter) []*Type {
-	w := 0
-	for _, td := range a {
-		n := 0 // number of matches
-		if matchDecl(td.Decl, f) {
-			n = 1
-		} else {
-			// type name doesn't match, but we may have matching consts, vars, factories or methods
-			td.Consts = filterValues(td.Consts, f)
-			td.Vars = filterValues(td.Vars, f)
-			td.Funcs = filterFuncs(td.Funcs, f)
-			td.Methods = filterFuncs(td.Methods, f)
-			n += len(td.Consts) + len(td.Vars) + len(td.Funcs) + len(td.Methods)
-		}
-		if n > 0 {
-			a[w] = td
-			w++
-		}
-	}
-	return a[0:w]
-}
-
-// Filter eliminates documentation for names that don't pass through the filter f.
-// TODO(gri): Recognize "Type.Method" as a name.
-//
-func (p *Package) Filter(f Filter) {
-	p.Consts = filterValues(p.Consts, f)
-	p.Vars = filterValues(p.Vars, f)
-	p.Types = filterTypes(p.Types, f)
-	p.Funcs = filterFuncs(p.Funcs, f)
-	p.Doc = "" // don't show top-level package doc
-}
diff --git a/src/pkg/go/doc/headscan.go b/src/pkg/go/doc/headscan.go
deleted file mode 100644
index f55934763..000000000
--- a/src/pkg/go/doc/headscan.go
+++ /dev/null
@@ -1,113 +0,0 @@
-// 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.
-
-// +build ignore
-
-/*
-	The headscan command extracts comment headings from package files;
-	it is used to detect false positives which may require an adjustment
-	to the comment formatting heuristics in comment.go.
-
-	Usage: headscan [-root root_directory]
-
-	By default, the $GOROOT/src directory is scanned.
-*/
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"go/doc"
-	"go/parser"
-	"go/token"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-)
-
-var (
-	root    = flag.String("root", filepath.Join(runtime.GOROOT(), "src"), "root of filesystem tree to scan")
-	verbose = flag.Bool("v", false, "verbose mode")
-)
-
-const (
-	html_h    = "<h3>"
-	html_endh = "</h3>\n"
-)
-
-func isGoFile(fi os.FileInfo) bool {
-	return strings.HasSuffix(fi.Name(), ".go") &&
-		!strings.HasSuffix(fi.Name(), "_test.go")
-}
-
-func appendHeadings(list []string, comment string) []string {
-	var buf bytes.Buffer
-	doc.ToHTML(&buf, comment, nil)
-	for s := buf.String(); ; {
-		i := strings.Index(s, html_h)
-		if i < 0 {
-			break
-		}
-		i += len(html_h)
-		j := strings.Index(s, html_endh)
-		if j < 0 {
-			list = append(list, s[i:]) // incorrect HTML
-			break
-		}
-		list = append(list, s[i:j])
-		s = s[j+len(html_endh):]
-	}
-	return list
-}
-
-func main() {
-	flag.Parse()
-	fset := token.NewFileSet()
-	nheadings := 0
-	err := filepath.Walk(*root, func(path string, fi os.FileInfo, err error) error {
-		if !fi.IsDir() {
-			return nil
-		}
-		pkgs, err := parser.ParseDir(fset, path, isGoFile, parser.ParseComments)
-		if err != nil {
-			if *verbose {
-				fmt.Fprintln(os.Stderr, err)
-			}
-			return nil
-		}
-		for _, pkg := range pkgs {
-			d := doc.New(pkg, path, doc.Mode(0))
-			list := appendHeadings(nil, d.Doc)
-			for _, d := range d.Consts {
-				list = appendHeadings(list, d.Doc)
-			}
-			for _, d := range d.Types {
-				list = appendHeadings(list, d.Doc)
-			}
-			for _, d := range d.Vars {
-				list = appendHeadings(list, d.Doc)
-			}
-			for _, d := range d.Funcs {
-				list = appendHeadings(list, d.Doc)
-			}
-			if len(list) > 0 {
-				// directories may contain multiple packages;
-				// print path and package name
-				fmt.Printf("%s (package %s)\n", path, pkg.Name)
-				for _, h := range list {
-					fmt.Printf("\t%s\n", h)
-				}
-				nheadings += len(list)
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-	fmt.Println(nheadings, "headings found")
-}
diff --git a/src/pkg/go/doc/reader.go b/src/pkg/go/doc/reader.go
deleted file mode 100644
index ed82c47cd..000000000
--- a/src/pkg/go/doc/reader.go
+++ /dev/null
@@ -1,853 +0,0 @@
-// 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.
-
-package doc
-
-import (
-	"go/ast"
-	"go/token"
-	"regexp"
-	"sort"
-	"strconv"
-)
-
-// ----------------------------------------------------------------------------
-// function/method sets
-//
-// Internally, we treat functions like methods and collect them in method sets.
-
-// A methodSet describes a set of methods. Entries where Decl == nil are conflict
-// entries (more then one method with the same name at the same embedding level).
-//
-type methodSet map[string]*Func
-
-// recvString returns a string representation of recv of the
-// form "T", "*T", or "BADRECV" (if not a proper receiver type).
-//
-func recvString(recv ast.Expr) string {
-	switch t := recv.(type) {
-	case *ast.Ident:
-		return t.Name
-	case *ast.StarExpr:
-		return "*" + recvString(t.X)
-	}
-	return "BADRECV"
-}
-
-// set creates the corresponding Func for f and adds it to mset.
-// If there are multiple f's with the same name, set keeps the first
-// one with documentation; conflicts are ignored.
-//
-func (mset methodSet) set(f *ast.FuncDecl) {
-	name := f.Name.Name
-	if g := mset[name]; g != nil && g.Doc != "" {
-		// A function with the same name has already been registered;
-		// since it has documentation, assume f is simply another
-		// implementation and ignore it. This does not happen if the
-		// caller is using go/build.ScanDir to determine the list of
-		// files implementing a package.
-		return
-	}
-	// function doesn't exist or has no documentation; use f
-	recv := ""
-	if f.Recv != nil {
-		var typ ast.Expr
-		// be careful in case of incorrect ASTs
-		if list := f.Recv.List; len(list) == 1 {
-			typ = list[0].Type
-		}
-		recv = recvString(typ)
-	}
-	mset[name] = &Func{
-		Doc:  f.Doc.Text(),
-		Name: name,
-		Decl: f,
-		Recv: recv,
-		Orig: recv,
-	}
-	f.Doc = nil // doc consumed - remove from AST
-}
-
-// add adds method m to the method set; m is ignored if the method set
-// already contains a method with the same name at the same or a higher
-// level then m.
-//
-func (mset methodSet) add(m *Func) {
-	old := mset[m.Name]
-	if old == nil || m.Level < old.Level {
-		mset[m.Name] = m
-		return
-	}
-	if old != nil && m.Level == old.Level {
-		// conflict - mark it using a method with nil Decl
-		mset[m.Name] = &Func{
-			Name:  m.Name,
-			Level: m.Level,
-		}
-	}
-}
-
-// ----------------------------------------------------------------------------
-// Named types
-
-// baseTypeName returns the name of the base type of x (or "")
-// and whether the type is imported or not.
-//
-func baseTypeName(x ast.Expr) (name string, imported bool) {
-	switch t := x.(type) {
-	case *ast.Ident:
-		return t.Name, false
-	case *ast.SelectorExpr:
-		if _, ok := t.X.(*ast.Ident); ok {
-			// only possible for qualified type names;
-			// assume type is imported
-			return t.Sel.Name, true
-		}
-	case *ast.StarExpr:
-		return baseTypeName(t.X)
-	}
-	return
-}
-
-// An embeddedSet describes a set of embedded types.
-type embeddedSet map[*namedType]bool
-
-// A namedType represents a named unqualified (package local, or possibly
-// predeclared) type. The namedType for a type name is always found via
-// reader.lookupType.
-//
-type namedType struct {
-	doc  string       // doc comment for type
-	name string       // type name
-	decl *ast.GenDecl // nil if declaration hasn't been seen yet
-
-	isEmbedded bool        // true if this type is embedded
-	isStruct   bool        // true if this type is a struct
-	embedded   embeddedSet // true if the embedded type is a pointer
-
-	// associated declarations
-	values  []*Value // consts and vars
-	funcs   methodSet
-	methods methodSet
-}
-
-// ----------------------------------------------------------------------------
-// AST reader
-
-// reader accumulates documentation for a single package.
-// It modifies the AST: Comments (declaration documentation)
-// that have been collected by the reader are set to nil
-// in the respective AST nodes so that they are not printed
-// twice (once when printing the documentation and once when
-// printing the corresponding AST node).
-//
-type reader struct {
-	mode Mode
-
-	// package properties
-	doc       string // package documentation, if any
-	filenames []string
-	notes     map[string][]*Note
-
-	// declarations
-	imports map[string]int
-	values  []*Value // consts and vars
-	types   map[string]*namedType
-	funcs   methodSet
-
-	// support for package-local error type declarations
-	errorDecl bool                 // if set, type "error" was declared locally
-	fixlist   []*ast.InterfaceType // list of interfaces containing anonymous field "error"
-}
-
-func (r *reader) isVisible(name string) bool {
-	return r.mode&AllDecls != 0 || ast.IsExported(name)
-}
-
-// lookupType returns the base type with the given name.
-// If the base type has not been encountered yet, a new
-// type with the given name but no associated declaration
-// is added to the type map.
-//
-func (r *reader) lookupType(name string) *namedType {
-	if name == "" || name == "_" {
-		return nil // no type docs for anonymous types
-	}
-	if typ, found := r.types[name]; found {
-		return typ
-	}
-	// type not found - add one without declaration
-	typ := &namedType{
-		name:     name,
-		embedded: make(embeddedSet),
-		funcs:    make(methodSet),
-		methods:  make(methodSet),
-	}
-	r.types[name] = typ
-	return typ
-}
-
-// recordAnonymousField registers fieldType as the type of an
-// anonymous field in the parent type. If the field is imported
-// (qualified name) or the parent is nil, the field is ignored.
-// The function returns the field name.
-//
-func (r *reader) recordAnonymousField(parent *namedType, fieldType ast.Expr) (fname string) {
-	fname, imp := baseTypeName(fieldType)
-	if parent == nil || imp {
-		return
-	}
-	if ftype := r.lookupType(fname); ftype != nil {
-		ftype.isEmbedded = true
-		_, ptr := fieldType.(*ast.StarExpr)
-		parent.embedded[ftype] = ptr
-	}
-	return
-}
-
-func (r *reader) readDoc(comment *ast.CommentGroup) {
-	// By convention there should be only one package comment
-	// but collect all of them if there are more then one.
-	text := comment.Text()
-	if r.doc == "" {
-		r.doc = text
-		return
-	}
-	r.doc += "\n" + text
-}
-
-func (r *reader) remember(typ *ast.InterfaceType) {
-	r.fixlist = append(r.fixlist, typ)
-}
-
-func specNames(specs []ast.Spec) []string {
-	names := make([]string, 0, len(specs)) // reasonable estimate
-	for _, s := range specs {
-		// s guaranteed to be an *ast.ValueSpec by readValue
-		for _, ident := range s.(*ast.ValueSpec).Names {
-			names = append(names, ident.Name)
-		}
-	}
-	return names
-}
-
-// readValue processes a const or var declaration.
-//
-func (r *reader) readValue(decl *ast.GenDecl) {
-	// determine if decl should be associated with a type
-	// Heuristic: For each typed entry, determine the type name, if any.
-	//            If there is exactly one type name that is sufficiently
-	//            frequent, associate the decl with the respective type.
-	domName := ""
-	domFreq := 0
-	prev := ""
-	n := 0
-	for _, spec := range decl.Specs {
-		s, ok := spec.(*ast.ValueSpec)
-		if !ok {
-			continue // should not happen, but be conservative
-		}
-		name := ""
-		switch {
-		case s.Type != nil:
-			// a type is present; determine its name
-			if n, imp := baseTypeName(s.Type); !imp {
-				name = n
-			}
-		case decl.Tok == token.CONST:
-			// no type is present but we have a constant declaration;
-			// use the previous type name (w/o more type information
-			// we cannot handle the case of unnamed variables with
-			// initializer expressions except for some trivial cases)
-			name = prev
-		}
-		if name != "" {
-			// entry has a named type
-			if domName != "" && domName != name {
-				// more than one type name - do not associate
-				// with any type
-				domName = ""
-				break
-			}
-			domName = name
-			domFreq++
-		}
-		prev = name
-		n++
-	}
-
-	// nothing to do w/o a legal declaration
-	if n == 0 {
-		return
-	}
-
-	// determine values list with which to associate the Value for this decl
-	values := &r.values
-	const threshold = 0.75
-	if domName != "" && r.isVisible(domName) && domFreq >= int(float64(len(decl.Specs))*threshold) {
-		// typed entries are sufficiently frequent
-		if typ := r.lookupType(domName); typ != nil {
-			values = &typ.values // associate with that type
-		}
-	}
-
-	*values = append(*values, &Value{
-		Doc:   decl.Doc.Text(),
-		Names: specNames(decl.Specs),
-		Decl:  decl,
-		order: len(*values),
-	})
-	decl.Doc = nil // doc consumed - remove from AST
-}
-
-// fields returns a struct's fields or an interface's methods.
-//
-func fields(typ ast.Expr) (list []*ast.Field, isStruct bool) {
-	var fields *ast.FieldList
-	switch t := typ.(type) {
-	case *ast.StructType:
-		fields = t.Fields
-		isStruct = true
-	case *ast.InterfaceType:
-		fields = t.Methods
-	}
-	if fields != nil {
-		list = fields.List
-	}
-	return
-}
-
-// readType processes a type declaration.
-//
-func (r *reader) readType(decl *ast.GenDecl, spec *ast.TypeSpec) {
-	typ := r.lookupType(spec.Name.Name)
-	if typ == nil {
-		return // no name or blank name - ignore the type
-	}
-
-	// A type should be added at most once, so typ.decl
-	// should be nil - if it is not, simply overwrite it.
-	typ.decl = decl
-
-	// compute documentation
-	doc := spec.Doc
-	spec.Doc = nil // doc consumed - remove from AST
-	if doc == nil {
-		// no doc associated with the spec, use the declaration doc, if any
-		doc = decl.Doc
-	}
-	decl.Doc = nil // doc consumed - remove from AST
-	typ.doc = doc.Text()
-
-	// record anonymous fields (they may contribute methods)
-	// (some fields may have been recorded already when filtering
-	// exports, but that's ok)
-	var list []*ast.Field
-	list, typ.isStruct = fields(spec.Type)
-	for _, field := range list {
-		if len(field.Names) == 0 {
-			r.recordAnonymousField(typ, field.Type)
-		}
-	}
-}
-
-// readFunc processes a func or method declaration.
-//
-func (r *reader) readFunc(fun *ast.FuncDecl) {
-	// strip function body
-	fun.Body = nil
-
-	// associate methods with the receiver type, if any
-	if fun.Recv != nil {
-		// method
-		recvTypeName, imp := baseTypeName(fun.Recv.List[0].Type)
-		if imp {
-			// should not happen (incorrect AST);
-			// don't show this method
-			return
-		}
-		if typ := r.lookupType(recvTypeName); typ != nil {
-			typ.methods.set(fun)
-		}
-		// otherwise ignore the method
-		// TODO(gri): There may be exported methods of non-exported types
-		// that can be called because of exported values (consts, vars, or
-		// function results) of that type. Could determine if that is the
-		// case and then show those methods in an appropriate section.
-		return
-	}
-
-	// associate factory functions with the first visible result type, if any
-	if fun.Type.Results.NumFields() >= 1 {
-		res := fun.Type.Results.List[0]
-		if len(res.Names) <= 1 {
-			// exactly one (named or anonymous) result associated
-			// with the first type in result signature (there may
-			// be more than one result)
-			if n, imp := baseTypeName(res.Type); !imp && r.isVisible(n) {
-				if typ := r.lookupType(n); typ != nil {
-					// associate function with typ
-					typ.funcs.set(fun)
-					return
-				}
-			}
-		}
-	}
-
-	// just an ordinary function
-	r.funcs.set(fun)
-}
-
-var (
-	noteMarker    = `([A-Z][A-Z]+)\(([^)]+)\):?`                    // MARKER(uid), MARKER at least 2 chars, uid at least 1 char
-	noteMarkerRx  = regexp.MustCompile(`^[ \t]*` + noteMarker)      // MARKER(uid) at text start
-	noteCommentRx = regexp.MustCompile(`^/[/*][ \t]*` + noteMarker) // MARKER(uid) at comment start
-)
-
-// readNote collects a single note from a sequence of comments.
-//
-func (r *reader) readNote(list []*ast.Comment) {
-	text := (&ast.CommentGroup{List: list}).Text()
-	if m := noteMarkerRx.FindStringSubmatchIndex(text); m != nil {
-		// The note body starts after the marker.
-		// We remove any formatting so that we don't
-		// get spurious line breaks/indentation when
-		// showing the TODO body.
-		body := clean(text[m[1]:], keepNL)
-		if body != "" {
-			marker := text[m[2]:m[3]]
-			r.notes[marker] = append(r.notes[marker], &Note{
-				Pos:  list[0].Pos(),
-				End:  list[len(list)-1].End(),
-				UID:  text[m[4]:m[5]],
-				Body: body,
-			})
-		}
-	}
-}
-
-// readNotes extracts notes from comments.
-// A note must start at the beginning of a comment with "MARKER(uid):"
-// and is followed by the note body (e.g., "// BUG(gri): fix this").
-// The note ends at the end of the comment group or at the start of
-// another note in the same comment group, whichever comes first.
-//
-func (r *reader) readNotes(comments []*ast.CommentGroup) {
-	for _, group := range comments {
-		i := -1 // comment index of most recent note start, valid if >= 0
-		list := group.List
-		for j, c := range list {
-			if noteCommentRx.MatchString(c.Text) {
-				if i >= 0 {
-					r.readNote(list[i:j])
-				}
-				i = j
-			}
-		}
-		if i >= 0 {
-			r.readNote(list[i:])
-		}
-	}
-}
-
-// readFile adds the AST for a source file to the reader.
-//
-func (r *reader) readFile(src *ast.File) {
-	// add package documentation
-	if src.Doc != nil {
-		r.readDoc(src.Doc)
-		src.Doc = nil // doc consumed - remove from AST
-	}
-
-	// add all declarations
-	for _, decl := range src.Decls {
-		switch d := decl.(type) {
-		case *ast.GenDecl:
-			switch d.Tok {
-			case token.IMPORT:
-				// imports are handled individually
-				for _, spec := range d.Specs {
-					if s, ok := spec.(*ast.ImportSpec); ok {
-						if import_, err := strconv.Unquote(s.Path.Value); err == nil {
-							r.imports[import_] = 1
-						}
-					}
-				}
-			case token.CONST, token.VAR:
-				// constants and variables are always handled as a group
-				r.readValue(d)
-			case token.TYPE:
-				// types are handled individually
-				if len(d.Specs) == 1 && !d.Lparen.IsValid() {
-					// common case: single declaration w/o parentheses
-					// (if a single declaration is parenthesized,
-					// create a new fake declaration below, so that
-					// go/doc type declarations always appear w/o
-					// parentheses)
-					if s, ok := d.Specs[0].(*ast.TypeSpec); ok {
-						r.readType(d, s)
-					}
-					break
-				}
-				for _, spec := range d.Specs {
-					if s, ok := spec.(*ast.TypeSpec); ok {
-						// use an individual (possibly fake) declaration
-						// for each type; this also ensures that each type
-						// gets to (re-)use the declaration documentation
-						// if there's none associated with the spec itself
-						fake := &ast.GenDecl{
-							Doc: d.Doc,
-							// don't use the existing TokPos because it
-							// will lead to the wrong selection range for
-							// the fake declaration if there are more
-							// than one type in the group (this affects
-							// src/cmd/godoc/godoc.go's posLink_urlFunc)
-							TokPos: s.Pos(),
-							Tok:    token.TYPE,
-							Specs:  []ast.Spec{s},
-						}
-						r.readType(fake, s)
-					}
-				}
-			}
-		case *ast.FuncDecl:
-			r.readFunc(d)
-		}
-	}
-
-	// collect MARKER(...): annotations
-	r.readNotes(src.Comments)
-	src.Comments = nil // consumed unassociated comments - remove from AST
-}
-
-func (r *reader) readPackage(pkg *ast.Package, mode Mode) {
-	// initialize reader
-	r.filenames = make([]string, len(pkg.Files))
-	r.imports = make(map[string]int)
-	r.mode = mode
-	r.types = make(map[string]*namedType)
-	r.funcs = make(methodSet)
-	r.notes = make(map[string][]*Note)
-
-	// sort package files before reading them so that the
-	// result does not depend on map iteration order
-	i := 0
-	for filename := range pkg.Files {
-		r.filenames[i] = filename
-		i++
-	}
-	sort.Strings(r.filenames)
-
-	// process files in sorted order
-	for _, filename := range r.filenames {
-		f := pkg.Files[filename]
-		if mode&AllDecls == 0 {
-			r.fileExports(f)
-		}
-		r.readFile(f)
-	}
-}
-
-// ----------------------------------------------------------------------------
-// Types
-
-func customizeRecv(f *Func, recvTypeName string, embeddedIsPtr bool, level int) *Func {
-	if f == nil || f.Decl == nil || f.Decl.Recv == nil || len(f.Decl.Recv.List) != 1 {
-		return f // shouldn't happen, but be safe
-	}
-
-	// copy existing receiver field and set new type
-	newField := *f.Decl.Recv.List[0]
-	origPos := newField.Type.Pos()
-	_, origRecvIsPtr := newField.Type.(*ast.StarExpr)
-	newIdent := &ast.Ident{NamePos: origPos, Name: recvTypeName}
-	var typ ast.Expr = newIdent
-	if !embeddedIsPtr && origRecvIsPtr {
-		newIdent.NamePos++ // '*' is one character
-		typ = &ast.StarExpr{Star: origPos, X: newIdent}
-	}
-	newField.Type = typ
-
-	// copy existing receiver field list and set new receiver field
-	newFieldList := *f.Decl.Recv
-	newFieldList.List = []*ast.Field{&newField}
-
-	// copy existing function declaration and set new receiver field list
-	newFuncDecl := *f.Decl
-	newFuncDecl.Recv = &newFieldList
-
-	// copy existing function documentation and set new declaration
-	newF := *f
-	newF.Decl = &newFuncDecl
-	newF.Recv = recvString(typ)
-	// the Orig field never changes
-	newF.Level = level
-
-	return &newF
-}
-
-// collectEmbeddedMethods collects the embedded methods of typ in mset.
-//
-func (r *reader) collectEmbeddedMethods(mset methodSet, typ *namedType, recvTypeName string, embeddedIsPtr bool, level int, visited embeddedSet) {
-	visited[typ] = true
-	for embedded, isPtr := range typ.embedded {
-		// Once an embedded type is embedded as a pointer type
-		// all embedded types in those types are treated like
-		// pointer types for the purpose of the receiver type
-		// computation; i.e., embeddedIsPtr is sticky for this
-		// embedding hierarchy.
-		thisEmbeddedIsPtr := embeddedIsPtr || isPtr
-		for _, m := range embedded.methods {
-			// only top-level methods are embedded
-			if m.Level == 0 {
-				mset.add(customizeRecv(m, recvTypeName, thisEmbeddedIsPtr, level))
-			}
-		}
-		if !visited[embedded] {
-			r.collectEmbeddedMethods(mset, embedded, recvTypeName, thisEmbeddedIsPtr, level+1, visited)
-		}
-	}
-	delete(visited, typ)
-}
-
-// computeMethodSets determines the actual method sets for each type encountered.
-//
-func (r *reader) computeMethodSets() {
-	for _, t := range r.types {
-		// collect embedded methods for t
-		if t.isStruct {
-			// struct
-			r.collectEmbeddedMethods(t.methods, t, t.name, false, 1, make(embeddedSet))
-		} else {
-			// interface
-			// TODO(gri) fix this
-		}
-	}
-
-	// if error was declared locally, don't treat it as exported field anymore
-	if r.errorDecl {
-		for _, ityp := range r.fixlist {
-			removeErrorField(ityp)
-		}
-	}
-}
-
-// cleanupTypes removes the association of functions and methods with
-// types that have no declaration. Instead, these functions and methods
-// are shown at the package level. It also removes types with missing
-// declarations or which are not visible.
-//
-func (r *reader) cleanupTypes() {
-	for _, t := range r.types {
-		visible := r.isVisible(t.name)
-		if t.decl == nil && (predeclaredTypes[t.name] || t.isEmbedded && visible) {
-			// t.name is a predeclared type (and was not redeclared in this package),
-			// or it was embedded somewhere but its declaration is missing (because
-			// the AST is incomplete): move any associated values, funcs, and methods
-			// back to the top-level so that they are not lost.
-			// 1) move values
-			r.values = append(r.values, t.values...)
-			// 2) move factory functions
-			for name, f := range t.funcs {
-				// in a correct AST, package-level function names
-				// are all different - no need to check for conflicts
-				r.funcs[name] = f
-			}
-			// 3) move methods
-			for name, m := range t.methods {
-				// don't overwrite functions with the same name - drop them
-				if _, found := r.funcs[name]; !found {
-					r.funcs[name] = m
-				}
-			}
-		}
-		// remove types w/o declaration or which are not visible
-		if t.decl == nil || !visible {
-			delete(r.types, t.name)
-		}
-	}
-}
-
-// ----------------------------------------------------------------------------
-// Sorting
-
-type data struct {
-	n    int
-	swap func(i, j int)
-	less func(i, j int) bool
-}
-
-func (d *data) Len() int           { return d.n }
-func (d *data) Swap(i, j int)      { d.swap(i, j) }
-func (d *data) Less(i, j int) bool { return d.less(i, j) }
-
-// sortBy is a helper function for sorting
-func sortBy(less func(i, j int) bool, swap func(i, j int), n int) {
-	sort.Sort(&data{n, swap, less})
-}
-
-func sortedKeys(m map[string]int) []string {
-	list := make([]string, len(m))
-	i := 0
-	for key := range m {
-		list[i] = key
-		i++
-	}
-	sort.Strings(list)
-	return list
-}
-
-// sortingName returns the name to use when sorting d into place.
-//
-func sortingName(d *ast.GenDecl) string {
-	if len(d.Specs) == 1 {
-		if s, ok := d.Specs[0].(*ast.ValueSpec); ok {
-			return s.Names[0].Name
-		}
-	}
-	return ""
-}
-
-func sortedValues(m []*Value, tok token.Token) []*Value {
-	list := make([]*Value, len(m)) // big enough in any case
-	i := 0
-	for _, val := range m {
-		if val.Decl.Tok == tok {
-			list[i] = val
-			i++
-		}
-	}
-	list = list[0:i]
-
-	sortBy(
-		func(i, j int) bool {
-			if ni, nj := sortingName(list[i].Decl), sortingName(list[j].Decl); ni != nj {
-				return ni < nj
-			}
-			return list[i].order < list[j].order
-		},
-		func(i, j int) { list[i], list[j] = list[j], list[i] },
-		len(list),
-	)
-
-	return list
-}
-
-func sortedTypes(m map[string]*namedType, allMethods bool) []*Type {
-	list := make([]*Type, len(m))
-	i := 0
-	for _, t := range m {
-		list[i] = &Type{
-			Doc:     t.doc,
-			Name:    t.name,
-			Decl:    t.decl,
-			Consts:  sortedValues(t.values, token.CONST),
-			Vars:    sortedValues(t.values, token.VAR),
-			Funcs:   sortedFuncs(t.funcs, true),
-			Methods: sortedFuncs(t.methods, allMethods),
-		}
-		i++
-	}
-
-	sortBy(
-		func(i, j int) bool { return list[i].Name < list[j].Name },
-		func(i, j int) { list[i], list[j] = list[j], list[i] },
-		len(list),
-	)
-
-	return list
-}
-
-func removeStar(s string) string {
-	if len(s) > 0 && s[0] == '*' {
-		return s[1:]
-	}
-	return s
-}
-
-func sortedFuncs(m methodSet, allMethods bool) []*Func {
-	list := make([]*Func, len(m))
-	i := 0
-	for _, m := range m {
-		// determine which methods to include
-		switch {
-		case m.Decl == nil:
-			// exclude conflict entry
-		case allMethods, m.Level == 0, !ast.IsExported(removeStar(m.Orig)):
-			// forced inclusion, method not embedded, or method
-			// embedded but original receiver type not exported
-			list[i] = m
-			i++
-		}
-	}
-	list = list[0:i]
-	sortBy(
-		func(i, j int) bool { return list[i].Name < list[j].Name },
-		func(i, j int) { list[i], list[j] = list[j], list[i] },
-		len(list),
-	)
-	return list
-}
-
-// noteBodies returns a list of note body strings given a list of notes.
-// This is only used to populate the deprecated Package.Bugs field.
-//
-func noteBodies(notes []*Note) []string {
-	var list []string
-	for _, n := range notes {
-		list = append(list, n.Body)
-	}
-	return list
-}
-
-// ----------------------------------------------------------------------------
-// Predeclared identifiers
-
-var predeclaredTypes = map[string]bool{
-	"bool":       true,
-	"byte":       true,
-	"complex64":  true,
-	"complex128": true,
-	"error":      true,
-	"float32":    true,
-	"float64":    true,
-	"int":        true,
-	"int8":       true,
-	"int16":      true,
-	"int32":      true,
-	"int64":      true,
-	"rune":       true,
-	"string":     true,
-	"uint":       true,
-	"uint8":      true,
-	"uint16":     true,
-	"uint32":     true,
-	"uint64":     true,
-	"uintptr":    true,
-}
-
-var predeclaredFuncs = map[string]bool{
-	"append":  true,
-	"cap":     true,
-	"close":   true,
-	"complex": true,
-	"copy":    true,
-	"delete":  true,
-	"imag":    true,
-	"len":     true,
-	"make":    true,
-	"new":     true,
-	"panic":   true,
-	"print":   true,
-	"println": true,
-	"real":    true,
-	"recover": true,
-}
-
-var predeclaredConstants = map[string]bool{
-	"false": true,
-	"iota":  true,
-	"nil":   true,
-	"true":  true,
-}
diff --git a/src/pkg/go/doc/synopsis.go b/src/pkg/go/doc/synopsis.go
deleted file mode 100644
index c90080b7c..000000000
--- a/src/pkg/go/doc/synopsis.go
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2012 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.
-
-package doc
-
-import (
-	"strings"
-	"unicode"
-)
-
-// firstSentenceLen returns the length of the first sentence in s.
-// The sentence ends after the first period followed by space and
-// not preceded by exactly one uppercase letter.
-//
-func firstSentenceLen(s string) int {
-	var ppp, pp, p rune
-	for i, q := range s {
-		if q == '\n' || q == '\r' || q == '\t' {
-			q = ' '
-		}
-		if q == ' ' && p == '.' && (!unicode.IsUpper(pp) || unicode.IsUpper(ppp)) {
-			return i
-		}
-		if p == '。' || p == '．' {
-			return i
-		}
-		ppp, pp, p = pp, p, q
-	}
-	return len(s)
-}
-
-const (
-	keepNL = 1 << iota
-)
-
-// clean replaces each sequence of space, \n, \r, or \t characters
-// with a single space and removes any trailing and leading spaces.
-// If the keepNL flag is set, newline characters are passed through
-// instead of being change to spaces.
-func clean(s string, flags int) string {
-	var b []byte
-	p := byte(' ')
-	for i := 0; i < len(s); i++ {
-		q := s[i]
-		if (flags&keepNL) == 0 && q == '\n' || q == '\r' || q == '\t' {
-			q = ' '
-		}
-		if q != ' ' || p != ' ' {
-			b = append(b, q)
-			p = q
-		}
-	}
-	// remove trailing blank, if any
-	if n := len(b); n > 0 && p == ' ' {
-		b = b[0 : n-1]
-	}
-	return string(b)
-}
-
-// Synopsis returns a cleaned version of the first sentence in s.
-// That sentence ends after the first period followed by space and
-// not preceded by exactly one uppercase letter. The result string
-// has no \n, \r, or \t characters and uses only single spaces between
-// words. If s starts with any of the IllegalPrefixes, the result
-// is the empty string.
-//
-func Synopsis(s string) string {
-	s = clean(s[0:firstSentenceLen(s)], 0)
-	for _, prefix := range IllegalPrefixes {
-		if strings.HasPrefix(strings.ToLower(s), prefix) {
-			return ""
-		}
-	}
-	return s
-}
-
-var IllegalPrefixes = []string{
-	"copyright",
-	"all rights",
-	"author",
-}
diff --git a/src/pkg/go/doc/synopsis_test.go b/src/pkg/go/doc/synopsis_test.go
deleted file mode 100644
index 59b253cb8..000000000
--- a/src/pkg/go/doc/synopsis_test.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2012 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.
-
-package doc
-
-import "testing"
-
-var tests = []struct {
-	txt string
-	fsl int
-	syn string
-}{
-	{"", 0, ""},
-	{"foo", 3, "foo"},
-	{"foo.", 4, "foo."},
-	{"foo.bar", 7, "foo.bar"},
-	{"  foo.  ", 6, "foo."},
-	{"  foo\t  bar.\n", 12, "foo bar."},
-	{"  foo\t  bar.\n", 12, "foo bar."},
-	{"a  b\n\nc\r\rd\t\t", 12, "a b c d"},
-	{"a  b\n\nc\r\rd\t\t  . BLA", 15, "a b c d ."},
-	{"Package poems by T.S.Eliot. To rhyme...", 27, "Package poems by T.S.Eliot."},
-	{"Package poems by T. S. Eliot. To rhyme...", 29, "Package poems by T. S. Eliot."},
-	{"foo implements the foo ABI. The foo ABI is...", 27, "foo implements the foo ABI."},
-	{"Package\nfoo. ..", 12, "Package foo."},
-	{"P . Q.", 3, "P ."},
-	{"P. Q.   ", 8, "P. Q."},
-	{"Package Καλημέρα κόσμε.", 36, "Package Καλημέρα κόσμε."},
-	{"Package こんにちは 世界\n", 31, "Package こんにちは 世界"},
-	{"Package こんにちは。世界", 26, "Package こんにちは。"},
-	{"Package 안녕．世界", 17, "Package 안녕．"},
-	{"Package foo does bar.", 21, "Package foo does bar."},
-	{"Copyright 2012 Google, Inc. Package foo does bar.", 27, ""},
-	{"All Rights reserved. Package foo does bar.", 20, ""},
-	{"All rights reserved. Package foo does bar.", 20, ""},
-	{"Authors: foo@bar.com. Package foo does bar.", 21, ""},
-}
-
-func TestSynopsis(t *testing.T) {
-	for _, e := range tests {
-		fsl := firstSentenceLen(e.txt)
-		if fsl != e.fsl {
-			t.Errorf("got fsl = %d; want %d for %q\n", fsl, e.fsl, e.txt)
-		}
-		syn := Synopsis(e.txt)
-		if syn != e.syn {
-			t.Errorf("got syn = %q; want %q for %q\n", syn, e.syn, e.txt)
-		}
-	}
-}
diff --git a/src/pkg/go/doc/testdata/a.0.golden b/src/pkg/go/doc/testdata/a.0.golden
deleted file mode 100644
index 7e680b80b..000000000
--- a/src/pkg/go/doc/testdata/a.0.golden
+++ /dev/null
@@ -1,52 +0,0 @@
-// comment 0  comment 1 
-PACKAGE a
-
-IMPORTPATH
-	testdata/a
-
-FILENAMES
-	testdata/a0.go
-	testdata/a1.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	bug0
-
-	bug1
-
-
-BUGS
-BUG(uid)	bug0
-
-BUG(uid)	bug1
-
-
-NOTES
-NOTE(uid)	
-
-NOTE(foo)	1 of 4 - this is the first line of note 1
-	- note 1 continues on this 2nd line
-	- note 1 continues on this 3rd line
-
-NOTE(foo)	2 of 4
-
-NOTE(bar)	3 of 4
-
-NOTE(bar)	4 of 4
-	- this is the last line of note 4
-
-NOTE(bam)	This note which contains a (parenthesized) subphrase
-	 must appear in its entirety.
-
-NOTE(xxx)	The ':' after the marker and uid is optional.
-
-
-SECBUGS
-SECBUG(uid)	sec hole 0
-	need to fix asap
-
-
-TODOS
-TODO(uid)	todo0
-
-TODO(uid)	todo1
-
diff --git a/src/pkg/go/doc/testdata/a.1.golden b/src/pkg/go/doc/testdata/a.1.golden
deleted file mode 100644
index 7e680b80b..000000000
--- a/src/pkg/go/doc/testdata/a.1.golden
+++ /dev/null
@@ -1,52 +0,0 @@
-// comment 0  comment 1 
-PACKAGE a
-
-IMPORTPATH
-	testdata/a
-
-FILENAMES
-	testdata/a0.go
-	testdata/a1.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	bug0
-
-	bug1
-
-
-BUGS
-BUG(uid)	bug0
-
-BUG(uid)	bug1
-
-
-NOTES
-NOTE(uid)	
-
-NOTE(foo)	1 of 4 - this is the first line of note 1
-	- note 1 continues on this 2nd line
-	- note 1 continues on this 3rd line
-
-NOTE(foo)	2 of 4
-
-NOTE(bar)	3 of 4
-
-NOTE(bar)	4 of 4
-	- this is the last line of note 4
-
-NOTE(bam)	This note which contains a (parenthesized) subphrase
-	 must appear in its entirety.
-
-NOTE(xxx)	The ':' after the marker and uid is optional.
-
-
-SECBUGS
-SECBUG(uid)	sec hole 0
-	need to fix asap
-
-
-TODOS
-TODO(uid)	todo0
-
-TODO(uid)	todo1
-
diff --git a/src/pkg/go/doc/testdata/a.2.golden b/src/pkg/go/doc/testdata/a.2.golden
deleted file mode 100644
index 7e680b80b..000000000
--- a/src/pkg/go/doc/testdata/a.2.golden
+++ /dev/null
@@ -1,52 +0,0 @@
-// comment 0  comment 1 
-PACKAGE a
-
-IMPORTPATH
-	testdata/a
-
-FILENAMES
-	testdata/a0.go
-	testdata/a1.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	bug0
-
-	bug1
-
-
-BUGS
-BUG(uid)	bug0
-
-BUG(uid)	bug1
-
-
-NOTES
-NOTE(uid)	
-
-NOTE(foo)	1 of 4 - this is the first line of note 1
-	- note 1 continues on this 2nd line
-	- note 1 continues on this 3rd line
-
-NOTE(foo)	2 of 4
-
-NOTE(bar)	3 of 4
-
-NOTE(bar)	4 of 4
-	- this is the last line of note 4
-
-NOTE(bam)	This note which contains a (parenthesized) subphrase
-	 must appear in its entirety.
-
-NOTE(xxx)	The ':' after the marker and uid is optional.
-
-
-SECBUGS
-SECBUG(uid)	sec hole 0
-	need to fix asap
-
-
-TODOS
-TODO(uid)	todo0
-
-TODO(uid)	todo1
-
diff --git a/src/pkg/go/doc/testdata/a0.go b/src/pkg/go/doc/testdata/a0.go
deleted file mode 100644
index 2420c8a48..000000000
--- a/src/pkg/go/doc/testdata/a0.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2012 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.
-
-// comment 0
-package a
-
-//BUG(uid): bug0
-
-//TODO(uid): todo0
-
-// A note with some spaces after it, should be ignored (watch out for
-// emacs modes that remove trailing whitespace).
-//NOTE(uid):
-
-// SECBUG(uid): sec hole 0
-// need to fix asap
-
-// Multiple notes may be in the same comment group and should be
-// recognized individually. Notes may start in the middle of a
-// comment group as long as they start at the beginning of an
-// individual comment.
-//
-// NOTE(foo): 1 of 4 - this is the first line of note 1
-// - note 1 continues on this 2nd line
-// - note 1 continues on this 3rd line
-// NOTE(foo): 2 of 4
-// NOTE(bar): 3 of 4
-/* NOTE(bar): 4 of 4 */
-// - this is the last line of note 4
-//
-//
-
-// NOTE(bam): This note which contains a (parenthesized) subphrase
-//            must appear in its entirety.
-
-// NOTE(xxx) The ':' after the marker and uid is optional.
-
-// NOTE(): NO uid - should not show up.
-// NOTE()  NO uid - should not show up.
diff --git a/src/pkg/go/doc/testdata/a1.go b/src/pkg/go/doc/testdata/a1.go
deleted file mode 100644
index 9fad1e09b..000000000
--- a/src/pkg/go/doc/testdata/a1.go
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2012 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.
-
-// comment 1
-package a
-
-//BUG(uid): bug1
-
-//TODO(uid): todo1
-
-//TODO(): ignored
diff --git a/src/pkg/go/doc/testdata/b.0.golden b/src/pkg/go/doc/testdata/b.0.golden
deleted file mode 100644
index 9d93392ea..000000000
--- a/src/pkg/go/doc/testdata/b.0.golden
+++ /dev/null
@@ -1,71 +0,0 @@
-// 
-PACKAGE b
-
-IMPORTPATH
-	testdata/b
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/b.go
-
-CONSTANTS
-	// 
-	const (
-		C1	notExported	= iota
-		C2
-	
-		C4
-		C5
-	)
-
-	// 
-	const C notExported = 0
-
-	// 
-	const Pi = 3.14	// Pi
-
-
-VARIABLES
-	// 
-	var (
-		U1, U2, U4, U5	notExported
-	
-		U7	notExported	= 7
-	)
-
-	// 
-	var MaxInt int	// MaxInt
-
-	// 
-	var V notExported
-
-	// 
-	var V1, V2, V4, V5 notExported
-
-
-FUNCTIONS
-	// 
-	func F(x int) int
-
-	// 
-	func F1() notExported
-
-	// Always under the package functions list. 
-	func NotAFactory() int
-
-	// Associated with uint type if AllDecls is set. 
-	func UintFactory() uint
-
-
-TYPES
-	// 
-	type T struct{}	// T
-
-	// 
-	var V T	// v
-
-	// 
-	func (x *T) M()
-
diff --git a/src/pkg/go/doc/testdata/b.1.golden b/src/pkg/go/doc/testdata/b.1.golden
deleted file mode 100644
index 66c47b5c2..000000000
--- a/src/pkg/go/doc/testdata/b.1.golden
+++ /dev/null
@@ -1,83 +0,0 @@
-// 
-PACKAGE b
-
-IMPORTPATH
-	testdata/b
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/b.go
-
-CONSTANTS
-	// 
-	const Pi = 3.14	// Pi
-
-
-VARIABLES
-	// 
-	var MaxInt int	// MaxInt
-
-
-FUNCTIONS
-	// 
-	func F(x int) int
-
-	// Always under the package functions list. 
-	func NotAFactory() int
-
-
-TYPES
-	// 
-	type T struct{}	// T
-
-	// 
-	var V T	// v
-
-	// 
-	func (x *T) M()
-
-	// 
-	type notExported int
-
-	// 
-	const (
-		C1	notExported	= iota
-		C2
-		c3
-		C4
-		C5
-	)
-
-	// 
-	const C notExported = 0
-
-	// 
-	var (
-		U1, U2, u3, U4, U5	notExported
-		u6			notExported
-		U7			notExported	= 7
-	)
-
-	// 
-	var V notExported
-
-	// 
-	var V1, V2, v3, V4, V5 notExported
-
-	// 
-	func F1() notExported
-
-	// 
-	func f2() notExported
-
-	// Should only appear if AllDecls is set. 
-	type uint struct{}	// overrides a predeclared type uint
-
-	// Associated with uint type if AllDecls is set. 
-	func UintFactory() uint
-
-	// Associated with uint type if AllDecls is set. 
-	func uintFactory() uint
-
diff --git a/src/pkg/go/doc/testdata/b.2.golden b/src/pkg/go/doc/testdata/b.2.golden
deleted file mode 100644
index 9d93392ea..000000000
--- a/src/pkg/go/doc/testdata/b.2.golden
+++ /dev/null
@@ -1,71 +0,0 @@
-// 
-PACKAGE b
-
-IMPORTPATH
-	testdata/b
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/b.go
-
-CONSTANTS
-	// 
-	const (
-		C1	notExported	= iota
-		C2
-	
-		C4
-		C5
-	)
-
-	// 
-	const C notExported = 0
-
-	// 
-	const Pi = 3.14	// Pi
-
-
-VARIABLES
-	// 
-	var (
-		U1, U2, U4, U5	notExported
-	
-		U7	notExported	= 7
-	)
-
-	// 
-	var MaxInt int	// MaxInt
-
-	// 
-	var V notExported
-
-	// 
-	var V1, V2, V4, V5 notExported
-
-
-FUNCTIONS
-	// 
-	func F(x int) int
-
-	// 
-	func F1() notExported
-
-	// Always under the package functions list. 
-	func NotAFactory() int
-
-	// Associated with uint type if AllDecls is set. 
-	func UintFactory() uint
-
-
-TYPES
-	// 
-	type T struct{}	// T
-
-	// 
-	var V T	// v
-
-	// 
-	func (x *T) M()
-
diff --git a/src/pkg/go/doc/testdata/b.go b/src/pkg/go/doc/testdata/b.go
deleted file mode 100644
index e50663b3d..000000000
--- a/src/pkg/go/doc/testdata/b.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2012 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.
-
-package b
-
-import "a"
-
-// ----------------------------------------------------------------------------
-// Basic declarations
-
-const Pi = 3.14   // Pi
-var MaxInt int    // MaxInt
-type T struct{}   // T
-var V T           // v
-func F(x int) int {} // F
-func (x *T) M()   {} // M
-
-// Corner cases: association with (presumed) predeclared types
-
-// Always under the package functions list.
-func NotAFactory() int {}
-
-// Associated with uint type if AllDecls is set.
-func UintFactory() uint {}
-
-// Associated with uint type if AllDecls is set.
-func uintFactory() uint {}
-
-// Should only appear if AllDecls is set.
-type uint struct{} // overrides a predeclared type uint
-
-// ----------------------------------------------------------------------------
-// Exported declarations associated with non-exported types must always be shown.
-
-type notExported int
-
-const C notExported = 0
-
-const (
-	C1 notExported = iota
-	C2
-	c3
-	C4
-	C5
-)
-
-var V notExported
-var V1, V2, v3, V4, V5 notExported
-
-var (
-	U1, U2, u3, U4, U5 notExported
-	u6                 notExported
-	U7                 notExported = 7
-)
-
-func F1() notExported {}
-func f2() notExported {}
diff --git a/src/pkg/go/doc/testdata/benchmark.go b/src/pkg/go/doc/testdata/benchmark.go
deleted file mode 100644
index 905e49644..000000000
--- a/src/pkg/go/doc/testdata/benchmark.go
+++ /dev/null
@@ -1,293 +0,0 @@
-// 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.
-
-package testing
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"runtime"
-	"time"
-)
-
-var matchBenchmarks = flag.String("test.bench", "", "regular expression to select benchmarks to run")
-var benchTime = flag.Duration("test.benchtime", 1*time.Second, "approximate run time for each benchmark")
-
-// An internal type but exported because it is cross-package; part of the implementation
-// of go test.
-type InternalBenchmark struct {
-	Name string
-	F    func(b *B)
-}
-
-// B is a type passed to Benchmark functions to manage benchmark
-// timing and to specify the number of iterations to run.
-type B struct {
-	common
-	N         int
-	benchmark InternalBenchmark
-	bytes     int64
-	timerOn   bool
-	result    BenchmarkResult
-}
-
-// StartTimer starts timing a test.  This function is called automatically
-// before a benchmark starts, but it can also used to resume timing after
-// a call to StopTimer.
-func (b *B) StartTimer() {
-	if !b.timerOn {
-		b.start = time.Now()
-		b.timerOn = true
-	}
-}
-
-// StopTimer stops timing a test.  This can be used to pause the timer
-// while performing complex initialization that you don't
-// want to measure.
-func (b *B) StopTimer() {
-	if b.timerOn {
-		b.duration += time.Now().Sub(b.start)
-		b.timerOn = false
-	}
-}
-
-// ResetTimer sets the elapsed benchmark time to zero.
-// It does not affect whether the timer is running.
-func (b *B) ResetTimer() {
-	if b.timerOn {
-		b.start = time.Now()
-	}
-	b.duration = 0
-}
-
-// SetBytes records the number of bytes processed in a single operation.
-// If this is called, the benchmark will report ns/op and MB/s.
-func (b *B) SetBytes(n int64) { b.bytes = n }
-
-func (b *B) nsPerOp() int64 {
-	if b.N <= 0 {
-		return 0
-	}
-	return b.duration.Nanoseconds() / int64(b.N)
-}
-
-// runN runs a single benchmark for the specified number of iterations.
-func (b *B) runN(n int) {
-	// Try to get a comparable environment for each run
-	// by clearing garbage from previous runs.
-	runtime.GC()
-	b.N = n
-	b.ResetTimer()
-	b.StartTimer()
-	b.benchmark.F(b)
-	b.StopTimer()
-}
-
-func min(x, y int) int {
-	if x > y {
-		return y
-	}
-	return x
-}
-
-func max(x, y int) int {
-	if x < y {
-		return y
-	}
-	return x
-}
-
-// roundDown10 rounds a number down to the nearest power of 10.
-func roundDown10(n int) int {
-	var tens = 0
-	// tens = floor(log_10(n))
-	for n > 10 {
-		n = n / 10
-		tens++
-	}
-	// result = 10^tens
-	result := 1
-	for i := 0; i < tens; i++ {
-		result *= 10
-	}
-	return result
-}
-
-// roundUp rounds x up to a number of the form [1eX, 2eX, 5eX].
-func roundUp(n int) int {
-	base := roundDown10(n)
-	if n < (2 * base) {
-		return 2 * base
-	}
-	if n < (5 * base) {
-		return 5 * base
-	}
-	return 10 * base
-}
-
-// run times the benchmark function in a separate goroutine.
-func (b *B) run() BenchmarkResult {
-	go b.launch()
-	<-b.signal
-	return b.result
-}
-
-// launch launches the benchmark function.  It gradually increases the number
-// of benchmark iterations until the benchmark runs for a second in order
-// to get a reasonable measurement.  It prints timing information in this form
-//		testing.BenchmarkHello	100000		19 ns/op
-// launch is run by the fun function as a separate goroutine.
-func (b *B) launch() {
-	// Run the benchmark for a single iteration in case it's expensive.
-	n := 1
-
-	// Signal that we're done whether we return normally
-	// or by FailNow's runtime.Goexit.
-	defer func() {
-		b.signal <- b
-	}()
-
-	b.runN(n)
-	// Run the benchmark for at least the specified amount of time.
-	d := *benchTime
-	for !b.failed && b.duration < d && n < 1e9 {
-		last := n
-		// Predict iterations/sec.
-		if b.nsPerOp() == 0 {
-			n = 1e9
-		} else {
-			n = int(d.Nanoseconds() / b.nsPerOp())
-		}
-		// Run more iterations than we think we'll need for a second (1.5x).
-		// Don't grow too fast in case we had timing errors previously.
-		// Be sure to run at least one more than last time.
-		n = max(min(n+n/2, 100*last), last+1)
-		// Round up to something easy to read.
-		n = roundUp(n)
-		b.runN(n)
-	}
-	b.result = BenchmarkResult{b.N, b.duration, b.bytes}
-}
-
-// The results of a benchmark run.
-type BenchmarkResult struct {
-	N     int           // The number of iterations.
-	T     time.Duration // The total time taken.
-	Bytes int64         // Bytes processed in one iteration.
-}
-
-func (r BenchmarkResult) NsPerOp() int64 {
-	if r.N <= 0 {
-		return 0
-	}
-	return r.T.Nanoseconds() / int64(r.N)
-}
-
-func (r BenchmarkResult) mbPerSec() float64 {
-	if r.Bytes <= 0 || r.T <= 0 || r.N <= 0 {
-		return 0
-	}
-	return (float64(r.Bytes) * float64(r.N) / 1e6) / r.T.Seconds()
-}
-
-func (r BenchmarkResult) String() string {
-	mbs := r.mbPerSec()
-	mb := ""
-	if mbs != 0 {
-		mb = fmt.Sprintf("\t%7.2f MB/s", mbs)
-	}
-	nsop := r.NsPerOp()
-	ns := fmt.Sprintf("%10d ns/op", nsop)
-	if r.N > 0 && nsop < 100 {
-		// The format specifiers here make sure that
-		// the ones digits line up for all three possible formats.
-		if nsop < 10 {
-			ns = fmt.Sprintf("%13.2f ns/op", float64(r.T.Nanoseconds())/float64(r.N))
-		} else {
-			ns = fmt.Sprintf("%12.1f ns/op", float64(r.T.Nanoseconds())/float64(r.N))
-		}
-	}
-	return fmt.Sprintf("%8d\t%s%s", r.N, ns, mb)
-}
-
-// An internal function but exported because it is cross-package; part of the implementation
-// of go test.
-func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark) {
-	// If no flag was specified, don't run benchmarks.
-	if len(*matchBenchmarks) == 0 {
-		return
-	}
-	for _, Benchmark := range benchmarks {
-		matched, err := matchString(*matchBenchmarks, Benchmark.Name)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.bench: %s\n", err)
-			os.Exit(1)
-		}
-		if !matched {
-			continue
-		}
-		for _, procs := range cpuList {
-			runtime.GOMAXPROCS(procs)
-			b := &B{
-				common: common{
-					signal: make(chan interface{}),
-				},
-				benchmark: Benchmark,
-			}
-			benchName := Benchmark.Name
-			if procs != 1 {
-				benchName = fmt.Sprintf("%s-%d", Benchmark.Name, procs)
-			}
-			fmt.Printf("%s\t", benchName)
-			r := b.run()
-			if b.failed {
-				// The output could be very long here, but probably isn't.
-				// We print it all, regardless, because we don't want to trim the reason
-				// the benchmark failed.
-				fmt.Printf("--- FAIL: %s\n%s", benchName, b.output)
-				continue
-			}
-			fmt.Printf("%v\n", r)
-			// Unlike with tests, we ignore the -chatty flag and always print output for
-			// benchmarks since the output generation time will skew the results.
-			if len(b.output) > 0 {
-				b.trimOutput()
-				fmt.Printf("--- BENCH: %s\n%s", benchName, b.output)
-			}
-			if p := runtime.GOMAXPROCS(-1); p != procs {
-				fmt.Fprintf(os.Stderr, "testing: %s left GOMAXPROCS set to %d\n", benchName, p)
-			}
-		}
-	}
-}
-
-// trimOutput shortens the output from a benchmark, which can be very long.
-func (b *B) trimOutput() {
-	// The output is likely to appear multiple times because the benchmark
-	// is run multiple times, but at least it will be seen. This is not a big deal
-	// because benchmarks rarely print, but just in case, we trim it if it's too long.
-	const maxNewlines = 10
-	for nlCount, j := 0, 0; j < len(b.output); j++ {
-		if b.output[j] == '\n' {
-			nlCount++
-			if nlCount >= maxNewlines {
-				b.output = append(b.output[:j], "\n\t... [output truncated]\n"...)
-				break
-			}
-		}
-	}
-}
-
-// Benchmark benchmarks a single function. Useful for creating
-// custom benchmarks that do not use go test.
-func Benchmark(f func(b *B)) BenchmarkResult {
-	b := &B{
-		common: common{
-			signal: make(chan interface{}),
-		},
-		benchmark: InternalBenchmark{"", f},
-	}
-	return b.run()
-}
diff --git a/src/pkg/go/doc/testdata/bugpara.0.golden b/src/pkg/go/doc/testdata/bugpara.0.golden
deleted file mode 100644
index 580485950..000000000
--- a/src/pkg/go/doc/testdata/bugpara.0.golden
+++ /dev/null
@@ -1,20 +0,0 @@
-// 
-PACKAGE bugpara
-
-IMPORTPATH
-	testdata/bugpara
-
-FILENAMES
-	testdata/bugpara.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
-
-BUGS
-BUG(rsc)	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
diff --git a/src/pkg/go/doc/testdata/bugpara.1.golden b/src/pkg/go/doc/testdata/bugpara.1.golden
deleted file mode 100644
index 580485950..000000000
--- a/src/pkg/go/doc/testdata/bugpara.1.golden
+++ /dev/null
@@ -1,20 +0,0 @@
-// 
-PACKAGE bugpara
-
-IMPORTPATH
-	testdata/bugpara
-
-FILENAMES
-	testdata/bugpara.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
-
-BUGS
-BUG(rsc)	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
diff --git a/src/pkg/go/doc/testdata/bugpara.2.golden b/src/pkg/go/doc/testdata/bugpara.2.golden
deleted file mode 100644
index 580485950..000000000
--- a/src/pkg/go/doc/testdata/bugpara.2.golden
+++ /dev/null
@@ -1,20 +0,0 @@
-// 
-PACKAGE bugpara
-
-IMPORTPATH
-	testdata/bugpara
-
-FILENAMES
-	testdata/bugpara.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
-
-BUGS
-BUG(rsc)	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
diff --git a/src/pkg/go/doc/testdata/bugpara.go b/src/pkg/go/doc/testdata/bugpara.go
deleted file mode 100644
index f5345a797..000000000
--- a/src/pkg/go/doc/testdata/bugpara.go
+++ /dev/null
@@ -1,5 +0,0 @@
-package bugpara
-
-// BUG(rsc): Sometimes bugs have multiple paragraphs.
-//
-// Like this one.
diff --git a/src/pkg/go/doc/testdata/c.0.golden b/src/pkg/go/doc/testdata/c.0.golden
deleted file mode 100644
index e21959b19..000000000
--- a/src/pkg/go/doc/testdata/c.0.golden
+++ /dev/null
@@ -1,48 +0,0 @@
-// 
-PACKAGE c
-
-IMPORTPATH
-	testdata/c
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/c.go
-
-TYPES
-	// A (should see this) 
-	type A struct{}
-
-	// B (should see this) 
-	type B struct{}
-
-	// C (should see this) 
-	type C struct{}
-
-	// D (should see this) 
-	type D struct{}
-
-	// E1 (should see this) 
-	type E1 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E2 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E3 struct{}
-
-	// E4 (should see this) 
-	type E4 struct{}
-
-	// 
-	type T1 struct{}
-
-	// 
-	func (t1 *T1) M()
-
-	// T2 must not show methods of local T1 
-	type T2 struct {
-		a.T1	// not the same as locally declared T1
-	}
-
diff --git a/src/pkg/go/doc/testdata/c.1.golden b/src/pkg/go/doc/testdata/c.1.golden
deleted file mode 100644
index e21959b19..000000000
--- a/src/pkg/go/doc/testdata/c.1.golden
+++ /dev/null
@@ -1,48 +0,0 @@
-// 
-PACKAGE c
-
-IMPORTPATH
-	testdata/c
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/c.go
-
-TYPES
-	// A (should see this) 
-	type A struct{}
-
-	// B (should see this) 
-	type B struct{}
-
-	// C (should see this) 
-	type C struct{}
-
-	// D (should see this) 
-	type D struct{}
-
-	// E1 (should see this) 
-	type E1 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E2 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E3 struct{}
-
-	// E4 (should see this) 
-	type E4 struct{}
-
-	// 
-	type T1 struct{}
-
-	// 
-	func (t1 *T1) M()
-
-	// T2 must not show methods of local T1 
-	type T2 struct {
-		a.T1	// not the same as locally declared T1
-	}
-
diff --git a/src/pkg/go/doc/testdata/c.2.golden b/src/pkg/go/doc/testdata/c.2.golden
deleted file mode 100644
index e21959b19..000000000
--- a/src/pkg/go/doc/testdata/c.2.golden
+++ /dev/null
@@ -1,48 +0,0 @@
-// 
-PACKAGE c
-
-IMPORTPATH
-	testdata/c
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/c.go
-
-TYPES
-	// A (should see this) 
-	type A struct{}
-
-	// B (should see this) 
-	type B struct{}
-
-	// C (should see this) 
-	type C struct{}
-
-	// D (should see this) 
-	type D struct{}
-
-	// E1 (should see this) 
-	type E1 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E2 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E3 struct{}
-
-	// E4 (should see this) 
-	type E4 struct{}
-
-	// 
-	type T1 struct{}
-
-	// 
-	func (t1 *T1) M()
-
-	// T2 must not show methods of local T1 
-	type T2 struct {
-		a.T1	// not the same as locally declared T1
-	}
-
diff --git a/src/pkg/go/doc/testdata/c.go b/src/pkg/go/doc/testdata/c.go
deleted file mode 100644
index e0f39196d..000000000
--- a/src/pkg/go/doc/testdata/c.go
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2012 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.
-
-package c
-
-import "a"
-
-// ----------------------------------------------------------------------------
-// Test that empty declarations don't cause problems
-
-const ()
-
-type ()
-
-var ()
-
-// ----------------------------------------------------------------------------
-// Test that types with documentation on both, the Decl and the Spec node
-// are handled correctly.
-
-// A (should see this)
-type A struct{}
-
-// B (should see this)
-type (
-	B struct{}
-)
-
-type (
-	// C (should see this)
-	C struct{}
-)
-
-// D (should not see this)
-type (
-	// D (should see this)
-	D struct{}
-)
-
-// E (should see this for E2 and E3)
-type (
-	// E1 (should see this)
-	E1 struct{}
-	E2 struct{}
-	E3 struct{}
-	// E4 (should see this)
-	E4 struct{}
-)
-
-// ----------------------------------------------------------------------------
-// Test that local and imported types are different when
-// handling anonymous fields.
-
-type T1 struct{}
-
-func (t1 *T1) M() {}
-
-// T2 must not show methods of local T1
-type T2 struct {
-	a.T1 // not the same as locally declared T1
-}
diff --git a/src/pkg/go/doc/testdata/d.0.golden b/src/pkg/go/doc/testdata/d.0.golden
deleted file mode 100644
index c00519953..000000000
--- a/src/pkg/go/doc/testdata/d.0.golden
+++ /dev/null
@@ -1,104 +0,0 @@
-// 
-PACKAGE d
-
-IMPORTPATH
-	testdata/d
-
-FILENAMES
-	testdata/d1.go
-	testdata/d2.go
-
-CONSTANTS
-	// CBx constants should appear before CAx constants. 
-	const (
-		CB2	= iota	// before CB1
-		CB1		// before CB0
-		CB0		// at end
-	)
-
-	// CAx constants should appear after CBx constants. 
-	const (
-		CA2	= iota	// before CA1
-		CA1		// before CA0
-		CA0		// at end
-	)
-
-	// C0 should be first. 
-	const C0 = 0
-
-	// C1 should be second. 
-	const C1 = 1
-
-	// C2 should be third. 
-	const C2 = 2
-
-	// 
-	const (
-		// Single const declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Cungrouped = 0
-	)
-
-
-VARIABLES
-	// VBx variables should appear before VAx variables. 
-	var (
-		VB2	int	// before VB1
-		VB1	int	// before VB0
-		VB0	int	// at end
-	)
-
-	// VAx variables should appear after VBx variables. 
-	var (
-		VA2	int	// before VA1
-		VA1	int	// before VA0
-		VA0	int	// at end
-	)
-
-	// V0 should be first. 
-	var V0 uintptr
-
-	// V1 should be second. 
-	var V1 uint
-
-	// V2 should be third. 
-	var V2 int
-
-	// 
-	var (
-		// Single var declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Vungrouped = 0
-	)
-
-
-FUNCTIONS
-	// F0 should be first. 
-	func F0()
-
-	// F1 should be second. 
-	func F1()
-
-	// F2 should be third. 
-	func F2()
-
-
-TYPES
-	// T0 should be first. 
-	type T0 struct{}
-
-	// T1 should be second. 
-	type T1 struct{}
-
-	// T2 should be third. 
-	type T2 struct{}
-
-	// TG0 should be first. 
-	type TG0 struct{}
-
-	// TG1 should be second. 
-	type TG1 struct{}
-
-	// TG2 should be third. 
-	type TG2 struct{}
-
diff --git a/src/pkg/go/doc/testdata/d.1.golden b/src/pkg/go/doc/testdata/d.1.golden
deleted file mode 100644
index c00519953..000000000
--- a/src/pkg/go/doc/testdata/d.1.golden
+++ /dev/null
@@ -1,104 +0,0 @@
-// 
-PACKAGE d
-
-IMPORTPATH
-	testdata/d
-
-FILENAMES
-	testdata/d1.go
-	testdata/d2.go
-
-CONSTANTS
-	// CBx constants should appear before CAx constants. 
-	const (
-		CB2	= iota	// before CB1
-		CB1		// before CB0
-		CB0		// at end
-	)
-
-	// CAx constants should appear after CBx constants. 
-	const (
-		CA2	= iota	// before CA1
-		CA1		// before CA0
-		CA0		// at end
-	)
-
-	// C0 should be first. 
-	const C0 = 0
-
-	// C1 should be second. 
-	const C1 = 1
-
-	// C2 should be third. 
-	const C2 = 2
-
-	// 
-	const (
-		// Single const declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Cungrouped = 0
-	)
-
-
-VARIABLES
-	// VBx variables should appear before VAx variables. 
-	var (
-		VB2	int	// before VB1
-		VB1	int	// before VB0
-		VB0	int	// at end
-	)
-
-	// VAx variables should appear after VBx variables. 
-	var (
-		VA2	int	// before VA1
-		VA1	int	// before VA0
-		VA0	int	// at end
-	)
-
-	// V0 should be first. 
-	var V0 uintptr
-
-	// V1 should be second. 
-	var V1 uint
-
-	// V2 should be third. 
-	var V2 int
-
-	// 
-	var (
-		// Single var declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Vungrouped = 0
-	)
-
-
-FUNCTIONS
-	// F0 should be first. 
-	func F0()
-
-	// F1 should be second. 
-	func F1()
-
-	// F2 should be third. 
-	func F2()
-
-
-TYPES
-	// T0 should be first. 
-	type T0 struct{}
-
-	// T1 should be second. 
-	type T1 struct{}
-
-	// T2 should be third. 
-	type T2 struct{}
-
-	// TG0 should be first. 
-	type TG0 struct{}
-
-	// TG1 should be second. 
-	type TG1 struct{}
-
-	// TG2 should be third. 
-	type TG2 struct{}
-
diff --git a/src/pkg/go/doc/testdata/d.2.golden b/src/pkg/go/doc/testdata/d.2.golden
deleted file mode 100644
index c00519953..000000000
--- a/src/pkg/go/doc/testdata/d.2.golden
+++ /dev/null
@@ -1,104 +0,0 @@
-// 
-PACKAGE d
-
-IMPORTPATH
-	testdata/d
-
-FILENAMES
-	testdata/d1.go
-	testdata/d2.go
-
-CONSTANTS
-	// CBx constants should appear before CAx constants. 
-	const (
-		CB2	= iota	// before CB1
-		CB1		// before CB0
-		CB0		// at end
-	)
-
-	// CAx constants should appear after CBx constants. 
-	const (
-		CA2	= iota	// before CA1
-		CA1		// before CA0
-		CA0		// at end
-	)
-
-	// C0 should be first. 
-	const C0 = 0
-
-	// C1 should be second. 
-	const C1 = 1
-
-	// C2 should be third. 
-	const C2 = 2
-
-	// 
-	const (
-		// Single const declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Cungrouped = 0
-	)
-
-
-VARIABLES
-	// VBx variables should appear before VAx variables. 
-	var (
-		VB2	int	// before VB1
-		VB1	int	// before VB0
-		VB0	int	// at end
-	)
-
-	// VAx variables should appear after VBx variables. 
-	var (
-		VA2	int	// before VA1
-		VA1	int	// before VA0
-		VA0	int	// at end
-	)
-
-	// V0 should be first. 
-	var V0 uintptr
-
-	// V1 should be second. 
-	var V1 uint
-
-	// V2 should be third. 
-	var V2 int
-
-	// 
-	var (
-		// Single var declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Vungrouped = 0
-	)
-
-
-FUNCTIONS
-	// F0 should be first. 
-	func F0()
-
-	// F1 should be second. 
-	func F1()
-
-	// F2 should be third. 
-	func F2()
-
-
-TYPES
-	// T0 should be first. 
-	type T0 struct{}
-
-	// T1 should be second. 
-	type T1 struct{}
-
-	// T2 should be third. 
-	type T2 struct{}
-
-	// TG0 should be first. 
-	type TG0 struct{}
-
-	// TG1 should be second. 
-	type TG1 struct{}
-
-	// TG2 should be third. 
-	type TG2 struct{}
-
diff --git a/src/pkg/go/doc/testdata/d1.go b/src/pkg/go/doc/testdata/d1.go
deleted file mode 100644
index ebd694195..000000000
--- a/src/pkg/go/doc/testdata/d1.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2012 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.
-
-// Test cases for sort order of declarations.
-
-package d
-
-// C2 should be third.
-const C2 = 2
-
-// V2 should be third.
-var V2 int
-
-// CBx constants should appear before CAx constants.
-const (
-	CB2 = iota // before CB1
-	CB1        // before CB0
-	CB0        // at end
-)
-
-// VBx variables should appear before VAx variables.
-var (
-	VB2 int // before VB1
-	VB1 int // before VB0
-	VB0 int // at end
-)
-
-const (
-	// Single const declarations inside ()'s are considered ungrouped
-	// and show up in sorted order.
-	Cungrouped = 0
-)
-
-var (
-	// Single var declarations inside ()'s are considered ungrouped
-	// and show up in sorted order.
-	Vungrouped = 0
-)
-
-// T2 should be third.
-type T2 struct{}
-
-// Grouped types are sorted nevertheless.
-type (
-	// TG2 should be third.
-	TG2 struct{}
-
-	// TG1 should be second.
-	TG1 struct{}
-
-	// TG0 should be first.
-	TG0 struct{}
-)
-
-// F2 should be third.
-func F2() {}
diff --git a/src/pkg/go/doc/testdata/d2.go b/src/pkg/go/doc/testdata/d2.go
deleted file mode 100644
index 2f56f4fa4..000000000
--- a/src/pkg/go/doc/testdata/d2.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2012 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.
-
-// Test cases for sort order of declarations.
-
-package d
-
-// C1 should be second.
-const C1 = 1
-
-// C0 should be first.
-const C0 = 0
-
-// V1 should be second.
-var V1 uint
-
-// V0 should be first.
-var V0 uintptr
-
-// CAx constants should appear after CBx constants.
-const (
-	CA2 = iota // before CA1
-	CA1        // before CA0
-	CA0        // at end
-)
-
-// VAx variables should appear after VBx variables.
-var (
-	VA2 int // before VA1
-	VA1 int // before VA0
-	VA0 int // at end
-)
-
-// T1 should be second.
-type T1 struct{}
-
-// T0 should be first.
-type T0 struct{}
-
-// F1 should be second.
-func F1() {}
-
-// F0 should be first.
-func F0() {}
diff --git a/src/pkg/go/doc/testdata/e.0.golden b/src/pkg/go/doc/testdata/e.0.golden
deleted file mode 100644
index 6987e5867..000000000
--- a/src/pkg/go/doc/testdata/e.0.golden
+++ /dev/null
@@ -1,109 +0,0 @@
-// The package e is a go/doc test for embedded methods. 
-PACKAGE e
-
-IMPORTPATH
-	testdata/e
-
-FILENAMES
-	testdata/e.go
-
-TYPES
-	// T1 has no embedded (level 1) M method due to conflict. 
-	type T1 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T2 has only M as top-level method. 
-	type T2 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T2.M should appear as method of T2. 
-	func (T2) M()
-
-	// T3 has only M as top-level method. 
-	type T3 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T3.M should appear as method of T3. 
-	func (T3) M()
-
-	// 
-	type T4 struct{}
-
-	// T4.M should appear as method of T5 only if AllMethods is set. 
-	func (*T4) M()
-
-	// 
-	type T5 struct {
-		T4
-	}
-
-	// 
-	type U1 struct {
-		*U1
-	}
-
-	// U1.M should appear as method of U1. 
-	func (*U1) M()
-
-	// 
-	type U2 struct {
-		*U3
-	}
-
-	// U2.M should appear as method of U2 and as method of U3 only if ...
-	func (*U2) M()
-
-	// 
-	type U3 struct {
-		*U2
-	}
-
-	// U3.N should appear as method of U3 and as method of U2 only if ...
-	func (*U3) N()
-
-	// 
-	type U4 struct {
-		// contains filtered or unexported fields
-	}
-
-	// U4.M should appear as method of U4. 
-	func (*U4) M()
-
-	// 
-	type V1 struct {
-		*V2
-		*V5
-	}
-
-	// 
-	type V2 struct {
-		*V3
-	}
-
-	// 
-	type V3 struct {
-		*V4
-	}
-
-	// 
-	type V4 struct {
-		*V5
-	}
-
-	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
-	func (*V4) M()
-
-	// 
-	type V5 struct {
-		*V6
-	}
-
-	// 
-	type V6 struct{}
-
-	// V6.M should appear as method of V1 and V5 if AllMethods is set. 
-	func (*V6) M()
-
diff --git a/src/pkg/go/doc/testdata/e.1.golden b/src/pkg/go/doc/testdata/e.1.golden
deleted file mode 100644
index cbe22e0bf..000000000
--- a/src/pkg/go/doc/testdata/e.1.golden
+++ /dev/null
@@ -1,144 +0,0 @@
-// The package e is a go/doc test for embedded methods. 
-PACKAGE e
-
-IMPORTPATH
-	testdata/e
-
-FILENAMES
-	testdata/e.go
-
-TYPES
-	// T1 has no embedded (level 1) M method due to conflict. 
-	type T1 struct {
-		t1
-		t2
-	}
-
-	// T2 has only M as top-level method. 
-	type T2 struct {
-		t1
-	}
-
-	// T2.M should appear as method of T2. 
-	func (T2) M()
-
-	// T3 has only M as top-level method. 
-	type T3 struct {
-		t1e
-		t2e
-	}
-
-	// T3.M should appear as method of T3. 
-	func (T3) M()
-
-	// 
-	type T4 struct{}
-
-	// T4.M should appear as method of T5 only if AllMethods is set. 
-	func (*T4) M()
-
-	// 
-	type T5 struct {
-		T4
-	}
-
-	// 
-	type U1 struct {
-		*U1
-	}
-
-	// U1.M should appear as method of U1. 
-	func (*U1) M()
-
-	// 
-	type U2 struct {
-		*U3
-	}
-
-	// U2.M should appear as method of U2 and as method of U3 only if ...
-	func (*U2) M()
-
-	// 
-	type U3 struct {
-		*U2
-	}
-
-	// U3.N should appear as method of U3 and as method of U2 only if ...
-	func (*U3) N()
-
-	// 
-	type U4 struct {
-		*u5
-	}
-
-	// U4.M should appear as method of U4. 
-	func (*U4) M()
-
-	// 
-	type V1 struct {
-		*V2
-		*V5
-	}
-
-	// 
-	type V2 struct {
-		*V3
-	}
-
-	// 
-	type V3 struct {
-		*V4
-	}
-
-	// 
-	type V4 struct {
-		*V5
-	}
-
-	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
-	func (*V4) M()
-
-	// 
-	type V5 struct {
-		*V6
-	}
-
-	// 
-	type V6 struct{}
-
-	// V6.M should appear as method of V1 and V5 if AllMethods is set. 
-	func (*V6) M()
-
-	// 
-	type t1 struct{}
-
-	// t1.M should not appear as method in a Tx type. 
-	func (t1) M()
-
-	// 
-	type t1e struct {
-		t1
-	}
-
-	// t1.M should not appear as method in a Tx type. 
-	func (t1e) M()
-
-	// 
-	type t2 struct{}
-
-	// t2.M should not appear as method in a Tx type. 
-	func (t2) M()
-
-	// 
-	type t2e struct {
-		t2
-	}
-
-	// t2.M should not appear as method in a Tx type. 
-	func (t2e) M()
-
-	// 
-	type u5 struct {
-		*U4
-	}
-
diff --git a/src/pkg/go/doc/testdata/e.2.golden b/src/pkg/go/doc/testdata/e.2.golden
deleted file mode 100644
index e7b05e80f..000000000
--- a/src/pkg/go/doc/testdata/e.2.golden
+++ /dev/null
@@ -1,130 +0,0 @@
-// The package e is a go/doc test for embedded methods. 
-PACKAGE e
-
-IMPORTPATH
-	testdata/e
-
-FILENAMES
-	testdata/e.go
-
-TYPES
-	// T1 has no embedded (level 1) M method due to conflict. 
-	type T1 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T2 has only M as top-level method. 
-	type T2 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T2.M should appear as method of T2. 
-	func (T2) M()
-
-	// T3 has only M as top-level method. 
-	type T3 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T3.M should appear as method of T3. 
-	func (T3) M()
-
-	// 
-	type T4 struct{}
-
-	// T4.M should appear as method of T5 only if AllMethods is set. 
-	func (*T4) M()
-
-	// 
-	type T5 struct {
-		T4
-	}
-
-	// T4.M should appear as method of T5 only if AllMethods is set. 
-	func (*T5) M()
-
-	// 
-	type U1 struct {
-		*U1
-	}
-
-	// U1.M should appear as method of U1. 
-	func (*U1) M()
-
-	// 
-	type U2 struct {
-		*U3
-	}
-
-	// U2.M should appear as method of U2 and as method of U3 only if ...
-	func (*U2) M()
-
-	// U3.N should appear as method of U3 and as method of U2 only if ...
-	func (U2) N()
-
-	// 
-	type U3 struct {
-		*U2
-	}
-
-	// U2.M should appear as method of U2 and as method of U3 only if ...
-	func (U3) M()
-
-	// U3.N should appear as method of U3 and as method of U2 only if ...
-	func (*U3) N()
-
-	// 
-	type U4 struct {
-		// contains filtered or unexported fields
-	}
-
-	// U4.M should appear as method of U4. 
-	func (*U4) M()
-
-	// 
-	type V1 struct {
-		*V2
-		*V5
-	}
-
-	// V6.M should appear as method of V1 and V5 if AllMethods is set. 
-	func (V1) M()
-
-	// 
-	type V2 struct {
-		*V3
-	}
-
-	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
-	func (V2) M()
-
-	// 
-	type V3 struct {
-		*V4
-	}
-
-	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
-	func (V3) M()
-
-	// 
-	type V4 struct {
-		*V5
-	}
-
-	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
-	func (*V4) M()
-
-	// 
-	type V5 struct {
-		*V6
-	}
-
-	// V6.M should appear as method of V1 and V5 if AllMethods is set. 
-	func (V5) M()
-
-	// 
-	type V6 struct{}
-
-	// V6.M should appear as method of V1 and V5 if AllMethods is set. 
-	func (*V6) M()
-
diff --git a/src/pkg/go/doc/testdata/e.go b/src/pkg/go/doc/testdata/e.go
deleted file mode 100644
index ec432e3e5..000000000
--- a/src/pkg/go/doc/testdata/e.go
+++ /dev/null
@@ -1,147 +0,0 @@
-// Copyright 2012 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.
-
-// The package e is a go/doc test for embedded methods.
-package e
-
-// ----------------------------------------------------------------------------
-// Conflicting methods M must not show up.
-
-type t1 struct{}
-
-// t1.M should not appear as method in a Tx type.
-func (t1) M() {}
-
-type t2 struct{}
-
-// t2.M should not appear as method in a Tx type.
-func (t2) M() {}
-
-// T1 has no embedded (level 1) M method due to conflict.
-type T1 struct {
-	t1
-	t2
-}
-
-// ----------------------------------------------------------------------------
-// Higher-level method M wins over lower-level method M.
-
-// T2 has only M as top-level method.
-type T2 struct {
-	t1
-}
-
-// T2.M should appear as method of T2.
-func (T2) M() {}
-
-// ----------------------------------------------------------------------------
-// Higher-level method M wins over lower-level conflicting methods M.
-
-type t1e struct {
-	t1
-}
-
-type t2e struct {
-	t2
-}
-
-// T3 has only M as top-level method.
-type T3 struct {
-	t1e
-	t2e
-}
-
-// T3.M should appear as method of T3.
-func (T3) M() {}
-
-// ----------------------------------------------------------------------------
-// Don't show conflicting methods M embedded via an exported and non-exported
-// type.
-
-// T1 has no embedded (level 1) M method due to conflict.
-type T4 struct {
-	t2
-	T2
-}
-
-// ----------------------------------------------------------------------------
-// Don't show embedded methods of exported anonymous fields unless AllMethods
-// is set.
-
-type T4 struct{}
-
-// T4.M should appear as method of T5 only if AllMethods is set.
-func (*T4) M() {}
-
-type T5 struct {
-	T4
-}
-
-// ----------------------------------------------------------------------------
-// Recursive type declarations must not lead to endless recursion.
-
-type U1 struct {
-	*U1
-}
-
-// U1.M should appear as method of U1.
-func (*U1) M() {}
-
-type U2 struct {
-	*U3
-}
-
-// U2.M should appear as method of U2 and as method of U3 only if AllMethods is set.
-func (*U2) M() {}
-
-type U3 struct {
-	*U2
-}
-
-// U3.N should appear as method of U3 and as method of U2 only if AllMethods is set.
-func (*U3) N() {}
-
-type U4 struct {
-	*u5
-}
-
-// U4.M should appear as method of U4.
-func (*U4) M() {}
-
-type u5 struct {
-	*U4
-}
-
-// ----------------------------------------------------------------------------
-// A higher-level embedded type (and its methods) wins over the same type (and
-// its methods) embedded at a lower level.
-
-type V1 struct {
-	*V2
-	*V5
-}
-
-type V2 struct {
-	*V3
-}
-
-type V3 struct {
-	*V4
-}
-
-type V4 struct {
-	*V5
-}
-
-type V5 struct {
-	*V6
-}
-
-type V6 struct{}
-
-// V4.M should appear as method of V2 and V3 if AllMethods is set.
-func (*V4) M() {}
-
-// V6.M should appear as method of V1 and V5 if AllMethods is set.
-func (*V6) M() {}
diff --git a/src/pkg/go/doc/testdata/error1.0.golden b/src/pkg/go/doc/testdata/error1.0.golden
deleted file mode 100644
index 6c6fe5d49..000000000
--- a/src/pkg/go/doc/testdata/error1.0.golden
+++ /dev/null
@@ -1,30 +0,0 @@
-// 
-PACKAGE error1
-
-IMPORTPATH
-	testdata/error1
-
-FILENAMES
-	testdata/error1.go
-
-TYPES
-	// 
-	type I0 interface {
-		// When embedded, the predeclared error interface
-		// must remain visible in interface types.
-		error
-	}
-
-	// 
-	type S0 struct {
-		// contains filtered or unexported fields
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// error should be visible
-			error
-		}
-	}
-
diff --git a/src/pkg/go/doc/testdata/error1.1.golden b/src/pkg/go/doc/testdata/error1.1.golden
deleted file mode 100644
index a8dc2e71d..000000000
--- a/src/pkg/go/doc/testdata/error1.1.golden
+++ /dev/null
@@ -1,32 +0,0 @@
-// 
-PACKAGE error1
-
-IMPORTPATH
-	testdata/error1
-
-FILENAMES
-	testdata/error1.go
-
-TYPES
-	// 
-	type I0 interface {
-		// When embedded, the predeclared error interface
-		// must remain visible in interface types.
-		error
-	}
-
-	// 
-	type S0 struct {
-		// In struct types, an embedded error must only be visible
-		// if AllDecls is set.
-		error
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// error should be visible
-			error
-		}
-	}
-
diff --git a/src/pkg/go/doc/testdata/error1.2.golden b/src/pkg/go/doc/testdata/error1.2.golden
deleted file mode 100644
index 6c6fe5d49..000000000
--- a/src/pkg/go/doc/testdata/error1.2.golden
+++ /dev/null
@@ -1,30 +0,0 @@
-// 
-PACKAGE error1
-
-IMPORTPATH
-	testdata/error1
-
-FILENAMES
-	testdata/error1.go
-
-TYPES
-	// 
-	type I0 interface {
-		// When embedded, the predeclared error interface
-		// must remain visible in interface types.
-		error
-	}
-
-	// 
-	type S0 struct {
-		// contains filtered or unexported fields
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// error should be visible
-			error
-		}
-	}
-
diff --git a/src/pkg/go/doc/testdata/error1.go b/src/pkg/go/doc/testdata/error1.go
deleted file mode 100644
index 3c777a780..000000000
--- a/src/pkg/go/doc/testdata/error1.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2012 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.
-
-package error1
-
-type I0 interface {
-	// When embedded, the predeclared error interface
-	// must remain visible in interface types.
-	error
-}
-
-type T0 struct {
-	ExportedField interface {
-		// error should be visible
-		error
-	}
-}
-
-type S0 struct {
-	// In struct types, an embedded error must only be visible
-	// if AllDecls is set.
-	error
-}
diff --git a/src/pkg/go/doc/testdata/error2.0.golden b/src/pkg/go/doc/testdata/error2.0.golden
deleted file mode 100644
index dedfe412a..000000000
--- a/src/pkg/go/doc/testdata/error2.0.golden
+++ /dev/null
@@ -1,27 +0,0 @@
-// 
-PACKAGE error2
-
-IMPORTPATH
-	testdata/error2
-
-FILENAMES
-	testdata/error2.go
-
-TYPES
-	// 
-	type I0 interface {
-		// contains filtered or unexported methods
-	}
-
-	// 
-	type S0 struct {
-		// contains filtered or unexported fields
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// contains filtered or unexported methods
-		}
-	}
-
diff --git a/src/pkg/go/doc/testdata/error2.1.golden b/src/pkg/go/doc/testdata/error2.1.golden
deleted file mode 100644
index dbcc1b03e..000000000
--- a/src/pkg/go/doc/testdata/error2.1.golden
+++ /dev/null
@@ -1,37 +0,0 @@
-// 
-PACKAGE error2
-
-IMPORTPATH
-	testdata/error2
-
-FILENAMES
-	testdata/error2.go
-
-TYPES
-	// 
-	type I0 interface {
-		// When embedded, the locally-declared error interface
-		// is only visible if all declarations are shown.
-		error
-	}
-
-	// 
-	type S0 struct {
-		// In struct types, an embedded error must only be visible
-		// if AllDecls is set.
-		error
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// error should not be visible
-			error
-		}
-	}
-
-	// This error declaration shadows the predeclared error type. 
-	type error interface {
-		Error() string
-	}
-
diff --git a/src/pkg/go/doc/testdata/error2.2.golden b/src/pkg/go/doc/testdata/error2.2.golden
deleted file mode 100644
index dedfe412a..000000000
--- a/src/pkg/go/doc/testdata/error2.2.golden
+++ /dev/null
@@ -1,27 +0,0 @@
-// 
-PACKAGE error2
-
-IMPORTPATH
-	testdata/error2
-
-FILENAMES
-	testdata/error2.go
-
-TYPES
-	// 
-	type I0 interface {
-		// contains filtered or unexported methods
-	}
-
-	// 
-	type S0 struct {
-		// contains filtered or unexported fields
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// contains filtered or unexported methods
-		}
-	}
-
diff --git a/src/pkg/go/doc/testdata/error2.go b/src/pkg/go/doc/testdata/error2.go
deleted file mode 100644
index 6ee96c245..000000000
--- a/src/pkg/go/doc/testdata/error2.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2012 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.
-
-package error2
-
-type I0 interface {
-	// When embedded, the locally-declared error interface
-	// is only visible if all declarations are shown.
-	error
-}
-
-type T0 struct {
-	ExportedField interface {
-		// error should not be visible
-		error
-	}
-}
-
-type S0 struct {
-	// In struct types, an embedded error must only be visible
-	// if AllDecls is set.
-	error
-}
-
-// This error declaration shadows the predeclared error type.
-type error interface {
-	Error() string
-}
diff --git a/src/pkg/go/doc/testdata/example.go b/src/pkg/go/doc/testdata/example.go
deleted file mode 100644
index fdeda137e..000000000
--- a/src/pkg/go/doc/testdata/example.go
+++ /dev/null
@@ -1,81 +0,0 @@
-// 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.
-
-package testing
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-	"time"
-)
-
-type InternalExample struct {
-	Name   string
-	F      func()
-	Output string
-}
-
-func RunExamples(examples []InternalExample) (ok bool) {
-	ok = true
-
-	var eg InternalExample
-
-	stdout, stderr := os.Stdout, os.Stderr
-	defer func() {
-		os.Stdout, os.Stderr = stdout, stderr
-		if e := recover(); e != nil {
-			fmt.Printf("--- FAIL: %s\npanic: %v\n", eg.Name, e)
-			os.Exit(1)
-		}
-	}()
-
-	for _, eg = range examples {
-		if *chatty {
-			fmt.Printf("=== RUN: %s\n", eg.Name)
-		}
-
-		// capture stdout and stderr
-		r, w, err := os.Pipe()
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-		os.Stdout, os.Stderr = w, w
-		outC := make(chan string)
-		go func() {
-			buf := new(bytes.Buffer)
-			_, err := io.Copy(buf, r)
-			if err != nil {
-				fmt.Fprintf(stderr, "testing: copying pipe: %v\n", err)
-				os.Exit(1)
-			}
-			outC <- buf.String()
-		}()
-
-		// run example
-		t0 := time.Now()
-		eg.F()
-		dt := time.Now().Sub(t0)
-
-		// close pipe, restore stdout/stderr, get output
-		w.Close()
-		os.Stdout, os.Stderr = stdout, stderr
-		out := <-outC
-
-		// report any errors
-		tstr := fmt.Sprintf("(%.2f seconds)", dt.Seconds())
-		if g, e := strings.TrimSpace(out), strings.TrimSpace(eg.Output); g != e {
-			fmt.Printf("--- FAIL: %s %s\ngot:\n%s\nwant:\n%s\n",
-				eg.Name, tstr, g, e)
-			ok = false
-		} else if *chatty {
-			fmt.Printf("--- PASS: %s %s\n", eg.Name, tstr)
-		}
-	}
-
-	return
-}
diff --git a/src/pkg/go/doc/testdata/f.0.golden b/src/pkg/go/doc/testdata/f.0.golden
deleted file mode 100644
index 817590186..000000000
--- a/src/pkg/go/doc/testdata/f.0.golden
+++ /dev/null
@@ -1,13 +0,0 @@
-// The package f is a go/doc test for functions and factory ...
-PACKAGE f
-
-IMPORTPATH
-	testdata/f
-
-FILENAMES
-	testdata/f.go
-
-FUNCTIONS
-	// Exported must always be visible. Was issue 2824. 
-	func Exported() private
-
diff --git a/src/pkg/go/doc/testdata/f.1.golden b/src/pkg/go/doc/testdata/f.1.golden
deleted file mode 100644
index ba68e884c..000000000
--- a/src/pkg/go/doc/testdata/f.1.golden
+++ /dev/null
@@ -1,16 +0,0 @@
-// The package f is a go/doc test for functions and factory ...
-PACKAGE f
-
-IMPORTPATH
-	testdata/f
-
-FILENAMES
-	testdata/f.go
-
-TYPES
-	// 
-	type private struct{}
-
-	// Exported must always be visible. Was issue 2824. 
-	func Exported() private
-
diff --git a/src/pkg/go/doc/testdata/f.2.golden b/src/pkg/go/doc/testdata/f.2.golden
deleted file mode 100644
index 817590186..000000000
--- a/src/pkg/go/doc/testdata/f.2.golden
+++ /dev/null
@@ -1,13 +0,0 @@
-// The package f is a go/doc test for functions and factory ...
-PACKAGE f
-
-IMPORTPATH
-	testdata/f
-
-FILENAMES
-	testdata/f.go
-
-FUNCTIONS
-	// Exported must always be visible. Was issue 2824. 
-	func Exported() private
-
diff --git a/src/pkg/go/doc/testdata/f.go b/src/pkg/go/doc/testdata/f.go
deleted file mode 100644
index 7e9add907..000000000
--- a/src/pkg/go/doc/testdata/f.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2012 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.
-
-// The package f is a go/doc test for functions and factory methods.
-package f
-
-// ----------------------------------------------------------------------------
-// Factory functions for non-exported types must not get lost.
-
-type private struct{}
-
-// Exported must always be visible. Was issue 2824.
-func Exported() private {}
diff --git a/src/pkg/go/doc/testdata/template.txt b/src/pkg/go/doc/testdata/template.txt
deleted file mode 100644
index 1b0738261..000000000
--- a/src/pkg/go/doc/testdata/template.txt
+++ /dev/null
@@ -1,68 +0,0 @@
-{{synopsis .Doc}}
-PACKAGE {{.Name}}
-
-IMPORTPATH
-	{{.ImportPath}}
-
-{{with .Imports}}IMPORTS
-{{range .}}	{{.}}
-{{end}}
-{{end}}{{/*
-
-*/}}FILENAMES
-{{range .Filenames}}	{{.}}
-{{end}}{{/*
-
-*/}}{{with .Consts}}
-CONSTANTS
-{{range .}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{end}}{{/*
-
-*/}}{{with .Vars}}
-VARIABLES
-{{range .}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{end}}{{/*
-
-*/}}{{with .Funcs}}
-FUNCTIONS
-{{range .}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{end}}{{/*
-
-*/}}{{with .Types}}
-TYPES
-{{range .}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{range .Consts}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{/*
-
-*/}}{{range .Vars}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{/*
-
-*/}}{{range .Funcs}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{/*
-
-*/}}{{range .Methods}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{end}}{{end}}{{/*
-
-*/}}{{with .Bugs}}
-BUGS .Bugs is now deprecated, please use .Notes instead
-{{range .}}{{indent "\t" .}}
-{{end}}{{end}}{{with .Notes}}{{range $marker, $content := .}}
-{{$marker}}S
-{{range $content}}{{$marker}}({{.UID}}){{indent "\t" .Body}}
-{{end}}{{end}}{{end}}
\ No newline at end of file
diff --git a/src/pkg/go/doc/testdata/testing.0.golden b/src/pkg/go/doc/testdata/testing.0.golden
deleted file mode 100644
index f8348f1ac..000000000
--- a/src/pkg/go/doc/testdata/testing.0.golden
+++ /dev/null
@@ -1,156 +0,0 @@
-// Package testing provides support for automated testing of Go ...
-PACKAGE testing
-
-IMPORTPATH
-	testdata/testing
-
-IMPORTS
-	bytes
-	flag
-	fmt
-	io
-	os
-	runtime
-	runtime/pprof
-	strconv
-	strings
-	time
-
-FILENAMES
-	testdata/benchmark.go
-	testdata/example.go
-	testdata/testing.go
-
-FUNCTIONS
-	// An internal function but exported because it is cross-package; ...
-	func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)
-
-	// An internal function but exported because it is cross-package; ...
-	func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark)
-
-	// 
-	func RunExamples(examples []InternalExample) (ok bool)
-
-	// 
-	func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)
-
-	// Short reports whether the -test.short flag is set. 
-	func Short() bool
-
-
-TYPES
-	// B is a type passed to Benchmark functions to manage benchmark ...
-	type B struct {
-		N int
-		// contains filtered or unexported fields
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *B) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *B) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *B) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *B) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *B) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *B) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *B) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *B) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *B) Logf(format string, args ...interface{})
-
-	// ResetTimer sets the elapsed benchmark time to zero. It does not ...
-	func (b *B) ResetTimer()
-
-	// SetBytes records the number of bytes processed in a single ...
-	func (b *B) SetBytes(n int64)
-
-	// StartTimer starts timing a test.  This function is called ...
-	func (b *B) StartTimer()
-
-	// StopTimer stops timing a test.  This can be used to pause the ...
-	func (b *B) StopTimer()
-
-	// The results of a benchmark run. 
-	type BenchmarkResult struct {
-		N	int		// The number of iterations.
-		T	time.Duration	// The total time taken.
-		Bytes	int64		// Bytes processed in one iteration.
-	}
-
-	// Benchmark benchmarks a single function. Useful for creating ...
-	func Benchmark(f func(b *B)) BenchmarkResult
-
-	// 
-	func (r BenchmarkResult) NsPerOp() int64
-
-	// 
-	func (r BenchmarkResult) String() string
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalBenchmark struct {
-		Name	string
-		F	func(b *B)
-	}
-
-	// 
-	type InternalExample struct {
-		Name	string
-		F	func()
-		Output	string
-	}
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalTest struct {
-		Name	string
-		F	func(*T)
-	}
-
-	// T is a type passed to Test functions to manage test state and ...
-	type T struct {
-		// contains filtered or unexported fields
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *T) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *T) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *T) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *T) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *T) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *T) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *T) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *T) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *T) Logf(format string, args ...interface{})
-
-	// Parallel signals that this test is to be run in parallel with ...
-	func (t *T) Parallel()
-
diff --git a/src/pkg/go/doc/testdata/testing.1.golden b/src/pkg/go/doc/testdata/testing.1.golden
deleted file mode 100644
index 282bb1015..000000000
--- a/src/pkg/go/doc/testdata/testing.1.golden
+++ /dev/null
@@ -1,298 +0,0 @@
-// Package testing provides support for automated testing of Go ...
-PACKAGE testing
-
-IMPORTPATH
-	testdata/testing
-
-IMPORTS
-	bytes
-	flag
-	fmt
-	io
-	os
-	runtime
-	runtime/pprof
-	strconv
-	strings
-	time
-
-FILENAMES
-	testdata/benchmark.go
-	testdata/example.go
-	testdata/testing.go
-
-VARIABLES
-	// 
-	var (
-		// The short flag requests that tests run more quickly, but its functionality
-		// is provided by test writers themselves.  The testing package is just its
-		// home.  The all.bash installation script sets it to make installation more
-		// efficient, but by default the flag is off so a plain "go test" will do a
-		// full test of the package.
-		short	= flag.Bool("test.short", false, "run smaller test suite to save time")
-	
-		// Report as tests are run; default is silent for success.
-		chatty		= flag.Bool("test.v", false, "verbose: print additional output")
-		match		= flag.String("test.run", "", "regular expression to select tests to run")
-		memProfile	= flag.String("test.memprofile", "", "write a memory profile to the named file after execution")
-		memProfileRate	= flag.Int("test.memprofilerate", 0, "if >=0, sets runtime.MemProfileRate")
-		cpuProfile	= flag.String("test.cpuprofile", "", "write a cpu profile to the named file during execution")
-		timeout		= flag.Duration("test.timeout", 0, "if positive, sets an aggregate time limit for all tests")
-		cpuListStr	= flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test")
-		parallel	= flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism")
-	
-		cpuList	[]int
-	)
-
-	// 
-	var benchTime = flag.Duration("test.benchtime", 1*time.Second, "approximate run time for each benchmark")
-
-	// 
-	var matchBenchmarks = flag.String("test.bench", "", "regular expression to select benchmarks to run")
-
-	// 
-	var timer *time.Timer
-
-
-FUNCTIONS
-	// An internal function but exported because it is cross-package; ...
-	func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)
-
-	// An internal function but exported because it is cross-package; ...
-	func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark)
-
-	// 
-	func RunExamples(examples []InternalExample) (ok bool)
-
-	// 
-	func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)
-
-	// Short reports whether the -test.short flag is set. 
-	func Short() bool
-
-	// after runs after all testing. 
-	func after()
-
-	// alarm is called if the timeout expires. 
-	func alarm()
-
-	// before runs before all testing. 
-	func before()
-
-	// decorate inserts the final newline if needed and indentation ...
-	func decorate(s string, addFileLine bool) string
-
-	// 
-	func max(x, y int) int
-
-	// 
-	func min(x, y int) int
-
-	// 
-	func parseCpuList()
-
-	// roundDown10 rounds a number down to the nearest power of 10. 
-	func roundDown10(n int) int
-
-	// roundUp rounds x up to a number of the form [1eX, 2eX, 5eX]. 
-	func roundUp(n int) int
-
-	// startAlarm starts an alarm if requested. 
-	func startAlarm()
-
-	// stopAlarm turns off the alarm. 
-	func stopAlarm()
-
-	// 
-	func tRunner(t *T, test *InternalTest)
-
-
-TYPES
-	// B is a type passed to Benchmark functions to manage benchmark ...
-	type B struct {
-		common
-		N		int
-		benchmark	InternalBenchmark
-		bytes		int64
-		timerOn		bool
-		result		BenchmarkResult
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *B) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *B) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *B) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *B) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *B) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *B) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *B) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *B) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *B) Logf(format string, args ...interface{})
-
-	// ResetTimer sets the elapsed benchmark time to zero. It does not ...
-	func (b *B) ResetTimer()
-
-	// SetBytes records the number of bytes processed in a single ...
-	func (b *B) SetBytes(n int64)
-
-	// StartTimer starts timing a test.  This function is called ...
-	func (b *B) StartTimer()
-
-	// StopTimer stops timing a test.  This can be used to pause the ...
-	func (b *B) StopTimer()
-
-	// launch launches the benchmark function.  It gradually increases ...
-	func (b *B) launch()
-
-	// log generates the output. It's always at the same stack depth. 
-	func (c *B) log(s string)
-
-	// 
-	func (b *B) nsPerOp() int64
-
-	// run times the benchmark function in a separate goroutine. 
-	func (b *B) run() BenchmarkResult
-
-	// runN runs a single benchmark for the specified number of ...
-	func (b *B) runN(n int)
-
-	// trimOutput shortens the output from a benchmark, which can be ...
-	func (b *B) trimOutput()
-
-	// The results of a benchmark run. 
-	type BenchmarkResult struct {
-		N	int		// The number of iterations.
-		T	time.Duration	// The total time taken.
-		Bytes	int64		// Bytes processed in one iteration.
-	}
-
-	// Benchmark benchmarks a single function. Useful for creating ...
-	func Benchmark(f func(b *B)) BenchmarkResult
-
-	// 
-	func (r BenchmarkResult) NsPerOp() int64
-
-	// 
-	func (r BenchmarkResult) String() string
-
-	// 
-	func (r BenchmarkResult) mbPerSec() float64
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalBenchmark struct {
-		Name	string
-		F	func(b *B)
-	}
-
-	// 
-	type InternalExample struct {
-		Name	string
-		F	func()
-		Output	string
-	}
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalTest struct {
-		Name	string
-		F	func(*T)
-	}
-
-	// T is a type passed to Test functions to manage test state and ...
-	type T struct {
-		common
-		name		string		// Name of test.
-		startParallel	chan bool	// Parallel tests will wait on this.
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *T) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *T) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *T) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *T) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *T) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *T) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *T) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *T) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *T) Logf(format string, args ...interface{})
-
-	// Parallel signals that this test is to be run in parallel with ...
-	func (t *T) Parallel()
-
-	// log generates the output. It's always at the same stack depth. 
-	func (c *T) log(s string)
-
-	// 
-	func (t *T) report()
-
-	// common holds the elements common between T and B and captures ...
-	type common struct {
-		output		[]byte		// Output generated by test or benchmark.
-		failed		bool		// Test or benchmark has failed.
-		start		time.Time	// Time test or benchmark started
-		duration	time.Duration
-		self		interface{}		// To be sent on signal channel when done.
-		signal		chan interface{}	// Output for serial tests.
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *common) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *common) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *common) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *common) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *common) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *common) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *common) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *common) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *common) Logf(format string, args ...interface{})
-
-	// log generates the output. It's always at the same stack depth. 
-	func (c *common) log(s string)
-
diff --git a/src/pkg/go/doc/testdata/testing.2.golden b/src/pkg/go/doc/testdata/testing.2.golden
deleted file mode 100644
index f8348f1ac..000000000
--- a/src/pkg/go/doc/testdata/testing.2.golden
+++ /dev/null
@@ -1,156 +0,0 @@
-// Package testing provides support for automated testing of Go ...
-PACKAGE testing
-
-IMPORTPATH
-	testdata/testing
-
-IMPORTS
-	bytes
-	flag
-	fmt
-	io
-	os
-	runtime
-	runtime/pprof
-	strconv
-	strings
-	time
-
-FILENAMES
-	testdata/benchmark.go
-	testdata/example.go
-	testdata/testing.go
-
-FUNCTIONS
-	// An internal function but exported because it is cross-package; ...
-	func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)
-
-	// An internal function but exported because it is cross-package; ...
-	func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark)
-
-	// 
-	func RunExamples(examples []InternalExample) (ok bool)
-
-	// 
-	func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)
-
-	// Short reports whether the -test.short flag is set. 
-	func Short() bool
-
-
-TYPES
-	// B is a type passed to Benchmark functions to manage benchmark ...
-	type B struct {
-		N int
-		// contains filtered or unexported fields
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *B) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *B) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *B) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *B) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *B) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *B) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *B) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *B) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *B) Logf(format string, args ...interface{})
-
-	// ResetTimer sets the elapsed benchmark time to zero. It does not ...
-	func (b *B) ResetTimer()
-
-	// SetBytes records the number of bytes processed in a single ...
-	func (b *B) SetBytes(n int64)
-
-	// StartTimer starts timing a test.  This function is called ...
-	func (b *B) StartTimer()
-
-	// StopTimer stops timing a test.  This can be used to pause the ...
-	func (b *B) StopTimer()
-
-	// The results of a benchmark run. 
-	type BenchmarkResult struct {
-		N	int		// The number of iterations.
-		T	time.Duration	// The total time taken.
-		Bytes	int64		// Bytes processed in one iteration.
-	}
-
-	// Benchmark benchmarks a single function. Useful for creating ...
-	func Benchmark(f func(b *B)) BenchmarkResult
-
-	// 
-	func (r BenchmarkResult) NsPerOp() int64
-
-	// 
-	func (r BenchmarkResult) String() string
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalBenchmark struct {
-		Name	string
-		F	func(b *B)
-	}
-
-	// 
-	type InternalExample struct {
-		Name	string
-		F	func()
-		Output	string
-	}
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalTest struct {
-		Name	string
-		F	func(*T)
-	}
-
-	// T is a type passed to Test functions to manage test state and ...
-	type T struct {
-		// contains filtered or unexported fields
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *T) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *T) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *T) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *T) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *T) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *T) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *T) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *T) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *T) Logf(format string, args ...interface{})
-
-	// Parallel signals that this test is to be run in parallel with ...
-	func (t *T) Parallel()
-
diff --git a/src/pkg/go/doc/testdata/testing.go b/src/pkg/go/doc/testdata/testing.go
deleted file mode 100644
index 93ed494c3..000000000
--- a/src/pkg/go/doc/testdata/testing.go
+++ /dev/null
@@ -1,404 +0,0 @@
-// 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.
-
-// Package testing provides support for automated testing of Go packages.
-// It is intended to be used in concert with the ``go test'' utility, which automates
-// execution of any function of the form
-//     func TestXxx(*testing.T)
-// where Xxx can be any alphanumeric string (but the first letter must not be in
-// [a-z]) and serves to identify the test routine.
-// These TestXxx routines should be declared within the package they are testing.
-//
-// Functions of the form
-//     func BenchmarkXxx(*testing.B)
-// are considered benchmarks, and are executed by go test when the -test.bench
-// flag is provided.
-//
-// A sample benchmark function looks like this:
-//     func BenchmarkHello(b *testing.B) {
-//         for i := 0; i < b.N; i++ {
-//             fmt.Sprintf("hello")
-//         }
-//     }
-// The benchmark package will vary b.N until the benchmark function lasts
-// long enough to be timed reliably.  The output
-//     testing.BenchmarkHello    10000000    282 ns/op
-// means that the loop ran 10000000 times at a speed of 282 ns per loop.
-//
-// If a benchmark needs some expensive setup before running, the timer
-// may be stopped:
-//     func BenchmarkBigLen(b *testing.B) {
-//         b.StopTimer()
-//         big := NewBig()
-//         b.StartTimer()
-//         for i := 0; i < b.N; i++ {
-//             big.Len()
-//         }
-//     }
-package testing
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"runtime"
-	"runtime/pprof"
-	"strconv"
-	"strings"
-	"time"
-)
-
-var (
-	// The short flag requests that tests run more quickly, but its functionality
-	// is provided by test writers themselves.  The testing package is just its
-	// home.  The all.bash installation script sets it to make installation more
-	// efficient, but by default the flag is off so a plain "go test" will do a
-	// full test of the package.
-	short = flag.Bool("test.short", false, "run smaller test suite to save time")
-
-	// Report as tests are run; default is silent for success.
-	chatty         = flag.Bool("test.v", false, "verbose: print additional output")
-	match          = flag.String("test.run", "", "regular expression to select tests to run")
-	memProfile     = flag.String("test.memprofile", "", "write a memory profile to the named file after execution")
-	memProfileRate = flag.Int("test.memprofilerate", 0, "if >=0, sets runtime.MemProfileRate")
-	cpuProfile     = flag.String("test.cpuprofile", "", "write a cpu profile to the named file during execution")
-	timeout        = flag.Duration("test.timeout", 0, "if positive, sets an aggregate time limit for all tests")
-	cpuListStr     = flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test")
-	parallel       = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism")
-
-	cpuList []int
-)
-
-// common holds the elements common between T and B and
-// captures common methods such as Errorf.
-type common struct {
-	output   []byte    // Output generated by test or benchmark.
-	failed   bool      // Test or benchmark has failed.
-	start    time.Time // Time test or benchmark started
-	duration time.Duration
-	self     interface{}      // To be sent on signal channel when done.
-	signal   chan interface{} // Output for serial tests.
-}
-
-// Short reports whether the -test.short flag is set.
-func Short() bool {
-	return *short
-}
-
-// decorate inserts the final newline if needed and indentation tabs for formatting.
-// If addFileLine is true, it also prefixes the string with the file and line of the call site.
-func decorate(s string, addFileLine bool) string {
-	if addFileLine {
-		_, file, line, ok := runtime.Caller(3) // decorate + log + public function.
-		if ok {
-			// Truncate file name at last file name separator.
-			if index := strings.LastIndex(file, "/"); index >= 0 {
-				file = file[index+1:]
-			} else if index = strings.LastIndex(file, "\\"); index >= 0 {
-				file = file[index+1:]
-			}
-		} else {
-			file = "???"
-			line = 1
-		}
-		s = fmt.Sprintf("%s:%d: %s", file, line, s)
-	}
-	s = "\t" + s // Every line is indented at least one tab.
-	n := len(s)
-	if n > 0 && s[n-1] != '\n' {
-		s += "\n"
-		n++
-	}
-	for i := 0; i < n-1; i++ { // -1 to avoid final newline
-		if s[i] == '\n' {
-			// Second and subsequent lines are indented an extra tab.
-			return s[0:i+1] + "\t" + decorate(s[i+1:n], false)
-		}
-	}
-	return s
-}
-
-// T is a type passed to Test functions to manage test state and support formatted test logs.
-// Logs are accumulated during execution and dumped to standard error when done.
-type T struct {
-	common
-	name          string    // Name of test.
-	startParallel chan bool // Parallel tests will wait on this.
-}
-
-// Fail marks the function as having failed but continues execution.
-func (c *common) Fail() { c.failed = true }
-
-// Failed reports whether the function has failed.
-func (c *common) Failed() bool { return c.failed }
-
-// FailNow marks the function as having failed and stops its execution.
-// Execution will continue at the next Test.
-func (c *common) FailNow() {
-	c.Fail()
-
-	// Calling runtime.Goexit will exit the goroutine, which
-	// will run the deferred functions in this goroutine,
-	// which will eventually run the deferred lines in tRunner,
-	// which will signal to the test loop that this test is done.
-	//
-	// A previous version of this code said:
-	//
-	//	c.duration = ...
-	//	c.signal <- c.self
-	//	runtime.Goexit()
-	//
-	// This previous version duplicated code (those lines are in
-	// tRunner no matter what), but worse the goroutine teardown
-	// implicit in runtime.Goexit was not guaranteed to complete
-	// before the test exited.  If a test deferred an important cleanup
-	// function (like removing temporary files), there was no guarantee
-	// it would run on a test failure.  Because we send on c.signal during
-	// a top-of-stack deferred function now, we know that the send
-	// only happens after any other stacked defers have completed.
-	runtime.Goexit()
-}
-
-// log generates the output. It's always at the same stack depth.
-func (c *common) log(s string) {
-	c.output = append(c.output, decorate(s, true)...)
-}
-
-// Log formats its arguments using default formatting, analogous to Println(),
-// and records the text in the error log.
-func (c *common) Log(args ...interface{}) { c.log(fmt.Sprintln(args...)) }
-
-// Logf formats its arguments according to the format, analogous to Printf(),
-// and records the text in the error log.
-func (c *common) Logf(format string, args ...interface{}) { c.log(fmt.Sprintf(format, args...)) }
-
-// Error is equivalent to Log() followed by Fail().
-func (c *common) Error(args ...interface{}) {
-	c.log(fmt.Sprintln(args...))
-	c.Fail()
-}
-
-// Errorf is equivalent to Logf() followed by Fail().
-func (c *common) Errorf(format string, args ...interface{}) {
-	c.log(fmt.Sprintf(format, args...))
-	c.Fail()
-}
-
-// Fatal is equivalent to Log() followed by FailNow().
-func (c *common) Fatal(args ...interface{}) {
-	c.log(fmt.Sprintln(args...))
-	c.FailNow()
-}
-
-// Fatalf is equivalent to Logf() followed by FailNow().
-func (c *common) Fatalf(format string, args ...interface{}) {
-	c.log(fmt.Sprintf(format, args...))
-	c.FailNow()
-}
-
-// Parallel signals that this test is to be run in parallel with (and only with)
-// other parallel tests in this CPU group.
-func (t *T) Parallel() {
-	t.signal <- (*T)(nil) // Release main testing loop
-	<-t.startParallel     // Wait for serial tests to finish
-}
-
-// An internal type but exported because it is cross-package; part of the implementation
-// of go test.
-type InternalTest struct {
-	Name string
-	F    func(*T)
-}
-
-func tRunner(t *T, test *InternalTest) {
-	t.start = time.Now()
-
-	// When this goroutine is done, either because test.F(t)
-	// returned normally or because a test failure triggered
-	// a call to runtime.Goexit, record the duration and send
-	// a signal saying that the test is done.
-	defer func() {
-		t.duration = time.Now().Sub(t.start)
-		t.signal <- t
-	}()
-
-	test.F(t)
-}
-
-// An internal function but exported because it is cross-package; part of the implementation
-// of go test.
-func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) {
-	flag.Parse()
-	parseCpuList()
-
-	before()
-	startAlarm()
-	testOk := RunTests(matchString, tests)
-	exampleOk := RunExamples(examples)
-	if !testOk || !exampleOk {
-		fmt.Println("FAIL")
-		os.Exit(1)
-	}
-	fmt.Println("PASS")
-	stopAlarm()
-	RunBenchmarks(matchString, benchmarks)
-	after()
-}
-
-func (t *T) report() {
-	tstr := fmt.Sprintf("(%.2f seconds)", t.duration.Seconds())
-	format := "--- %s: %s %s\n%s"
-	if t.failed {
-		fmt.Printf(format, "FAIL", t.name, tstr, t.output)
-	} else if *chatty {
-		fmt.Printf(format, "PASS", t.name, tstr, t.output)
-	}
-}
-
-func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool) {
-	ok = true
-	if len(tests) == 0 {
-		fmt.Fprintln(os.Stderr, "testing: warning: no tests to run")
-		return
-	}
-	for _, procs := range cpuList {
-		runtime.GOMAXPROCS(procs)
-		// We build a new channel tree for each run of the loop.
-		// collector merges in one channel all the upstream signals from parallel tests.
-		// If all tests pump to the same channel, a bug can occur where a test
-		// kicks off a goroutine that Fails, yet the test still delivers a completion signal,
-		// which skews the counting.
-		var collector = make(chan interface{})
-
-		numParallel := 0
-		startParallel := make(chan bool)
-
-		for i := 0; i < len(tests); i++ {
-			matched, err := matchString(*match, tests[i].Name)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.run: %s\n", err)
-				os.Exit(1)
-			}
-			if !matched {
-				continue
-			}
-			testName := tests[i].Name
-			if procs != 1 {
-				testName = fmt.Sprintf("%s-%d", tests[i].Name, procs)
-			}
-			t := &T{
-				common: common{
-					signal: make(chan interface{}),
-				},
-				name:          testName,
-				startParallel: startParallel,
-			}
-			t.self = t
-			if *chatty {
-				fmt.Printf("=== RUN %s\n", t.name)
-			}
-			go tRunner(t, &tests[i])
-			out := (<-t.signal).(*T)
-			if out == nil { // Parallel run.
-				go func() {
-					collector <- <-t.signal
-				}()
-				numParallel++
-				continue
-			}
-			t.report()
-			ok = ok && !out.failed
-		}
-
-		running := 0
-		for numParallel+running > 0 {
-			if running < *parallel && numParallel > 0 {
-				startParallel <- true
-				running++
-				numParallel--
-				continue
-			}
-			t := (<-collector).(*T)
-			t.report()
-			ok = ok && !t.failed
-			running--
-		}
-	}
-	return
-}
-
-// before runs before all testing.
-func before() {
-	if *memProfileRate > 0 {
-		runtime.MemProfileRate = *memProfileRate
-	}
-	if *cpuProfile != "" {
-		f, err := os.Create(*cpuProfile)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "testing: %s", err)
-			return
-		}
-		if err := pprof.StartCPUProfile(f); err != nil {
-			fmt.Fprintf(os.Stderr, "testing: can't start cpu profile: %s", err)
-			f.Close()
-			return
-		}
-		// Could save f so after can call f.Close; not worth the effort.
-	}
-
-}
-
-// after runs after all testing.
-func after() {
-	if *cpuProfile != "" {
-		pprof.StopCPUProfile() // flushes profile to disk
-	}
-	if *memProfile != "" {
-		f, err := os.Create(*memProfile)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "testing: %s", err)
-			return
-		}
-		if err = pprof.WriteHeapProfile(f); err != nil {
-			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s", *memProfile, err)
-		}
-		f.Close()
-	}
-}
-
-var timer *time.Timer
-
-// startAlarm starts an alarm if requested.
-func startAlarm() {
-	if *timeout > 0 {
-		timer = time.AfterFunc(*timeout, alarm)
-	}
-}
-
-// stopAlarm turns off the alarm.
-func stopAlarm() {
-	if *timeout > 0 {
-		timer.Stop()
-	}
-}
-
-// alarm is called if the timeout expires.
-func alarm() {
-	panic("test timed out")
-}
-
-func parseCpuList() {
-	if len(*cpuListStr) == 0 {
-		cpuList = append(cpuList, runtime.GOMAXPROCS(-1))
-	} else {
-		for _, val := range strings.Split(*cpuListStr, ",") {
-			cpu, err := strconv.Atoi(val)
-			if err != nil || cpu <= 0 {
-				fmt.Fprintf(os.Stderr, "testing: invalid value %q for -test.cpu", val)
-				os.Exit(1)
-			}
-			cpuList = append(cpuList, cpu)
-		}
-	}
-}