[llgo] Roll gotools to d4e70101.

[pcc]

Summary

Most importantly, this gives us https://go-review.googlesource.com/7533 which
fixes a bug in go/ssa that caused test failures in the Go 1.4 standard library.

Also remove the go1.4 tag workaround. We no longer need it now that we
ship llgo-go.

[axw]

LGTM

llgo/trunk/irgen/compiler.go

func (compiler *compiler) compile(fset *token.FileSet, astFiles []*ast.File, importpath string) (m *Module, err error) {
   impcfg := &loader.Config{
     Fset: fset,
     TypeChecker: types.Config{
       Packages: compiler.Packages,
       Import:   compiler.Importer,
       Sizes:    compiler.llvmtypes,
       DisableUnusedImportCheck: compiler.DisableUnusedImportCheck,
     },
-    Build:          &buildctx.Context,
-    PackageCreated: compiler.PackageCreated,
+    ImportFromBinary: true,
+    Build:            &buildctx.Context,
+    PackageCreated:   compiler.PackageCreated,
   }
   // If no import path is specified, then set the import
   // path to be the same as the package's name.
   if importpath == "" {
     importpath = astFiles[0].Name.String()
   }
   impcfg.CreateFromFiles(importpath, astFiles...)
   iprog, err := impcfg.Load()

llgo/trunk/third_party/gofrontend/config.sub

-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
         | -linux-newlib* | -linux-uclibc* \
         | -uxpv* | -beos* | -mpeix* | -udk* \
         | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
         | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
         | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
         | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
         | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
         | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
-        | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*)
+        | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* | -bitrig*)
   # Remember, each alternative MUST END IN *, to match a version number.
     ;;
   -qnx*)
     case $basic_machine in
         x86-* | i*86-*)
       ;;
         *)
       os=-nto$os

llgo/trunk/third_party/gotools/go/ast/astutil/imports.go

for _, spec := range gen.Specs {
     impspec := spec.(*ast.ImportSpec)
     if importPath(impspec) == path {
       return true
     }
   }
   return false
 }
 
-// matchLen returns the length of the longest prefix shared by x and y.
+// matchLen returns the length of the longest path segment prefix shared by x and y.
 func matchLen(x, y string) int {
-  i := 0
-  for i < len(x) && i < len(y) && x[i] == y[i] {
-    i++
+  n := 0
+  for i := 0; i < len(x) && i < len(y) && x[i] == y[i]; i++ {
+    if x[i] == '/' {
+      n++
     }
-  return i
+  }
+  return n
 }
 
 // isTopName returns true if n is a top-level unresolved identifier with the given name.
 func isTopName(n ast.Expr, name string) bool {
   id, ok := n.(*ast.Ident)
   return ok && id.Name == name && id.Obj == nil
 }
 

llgo/trunk/third_party/gotools/go/ast/astutil/imports_test.go

 `,
     out: `// comment before
 package main // comment on
 import "time"
 
 type T time.Time
 `,
   },
+
+  // Issue 9961: Match prefixes using path segments rather than bytes
+  {
+    name: "issue 9961",
+    pkg:  "regexp",
+    in: `package main
+
+import (
+  "flag"
+  "testing"
+
+  "rsc.io/p"
+)
+`,
+    out: `package main
+
+import (
+  "flag"
+  "regexp"
+  "testing"
+
+  "rsc.io/p"
+)
+`,
+  },
 }
 
 func TestAddImport(t *testing.T) {
   for _, test := range addTests {
     file := parse(t, test.name, test.in)
     var before bytes.Buffer
     ast.Fprint(&before, fset, file, nil)
     AddNamedImport(fset, file, test.renamedPkg, test.pkg)

llgo/trunk/third_party/gotools/go/buildutil/allpackages.go

 // The result may include import paths for directories that contain no
 // *.go files, such as "archive" (in $GOROOT/src).
 //
 // All I/O is done via the build.Context file system interface,
 // which must be concurrency-safe.
 //
 func AllPackages(ctxt *build.Context) []string {
   var list []string
-  var mu sync.Mutex
   ForEachPackage(ctxt, func(pkg string, _ error) {
-    mu.Lock()
     list = append(list, pkg)
-    mu.Unlock()
   })
   sort.Strings(list)
   return list
 }
 
 // ForEachPackage calls the found function with the import path of
 // each Go package it finds in any source directory of the specified
 // build context (e.g. $GOROOT or an element of $GOPATH).
 //
 // If the package directory exists but could not be read, the second
 // argument to the found function provides the error.
 //
-// The found function and the build.Context file system interface
-// accessors must be concurrency safe.
+// All I/O is done via the build.Context file system interface,
+// which must be concurrency-safe.
 //
 func ForEachPackage(ctxt *build.Context, found func(importPath string, err error)) {
   // We use a counting semaphore to limit
   // the number of parallel calls to ReadDir.
   sema := make(chan bool, 20)
 
+  ch := make(chan item)
+
   var wg sync.WaitGroup
   for _, root := range ctxt.SrcDirs() {
     root := root
     wg.Add(1)
     go func() {
-      allPackages(ctxt, sema, root, found)
+      allPackages(ctxt, sema, root, ch)
       wg.Done()
     }()
   }
+  go func() {
     wg.Wait()
+    close(ch)
+  }()
+
+  // All calls to found occur in the caller's goroutine.
+  for i := range ch {
+    found(i.importPath, i.err)
+  }
+}
+
+type item struct {
+  importPath string
+  err        error // (optional)
 }
 
-func allPackages(ctxt *build.Context, sema chan bool, root string, found func(string, error)) {
+func allPackages(ctxt *build.Context, sema chan bool, root string, ch chan<- item) {
   root = filepath.Clean(root) + string(os.PathSeparator)
 
   var wg sync.WaitGroup
 
   var walkDir func(dir string)
   walkDir = func(dir string) {
     // Avoid .foo, _foo, and testdata directory trees.
     base := filepath.Base(dir)
     if base == "" || base[0] == '.' || base[0] == '_' || base == "testdata" {
       return
     }
 
     pkg := filepath.ToSlash(strings.TrimPrefix(dir, root))
 
     // Prune search if we encounter any of these import paths.
     switch pkg {
     case "builtin":
       return
     }
 
     sema <- true
     files, err := ReadDir(ctxt, dir)
     <-sema
     if pkg != "" || err != nil {
-      found(pkg, err)
+      ch <- item{pkg, err}
     }
     for _, fi := range files {
       fi := fi
       if fi.IsDir() {
         wg.Add(1)
         go func() {
           walkDir(filepath.Join(dir, fi.Name()))
           wg.Done()
         }()
       }
     }
   }
 
   walkDir(root)
   wg.Wait()
 }

llgo/trunk/third_party/gotools/go/buildutil/fakecontext.go

+package buildutil
+
+import (
+  "fmt"
+  "go/build"
+  "io"
+  "io/ioutil"
+  "os"
+  "path"
+  "path/filepath"
+  "sort"
+  "strings"
+  "time"
+)
+
+// FakeContext returns a build.Context for the fake file tree specified
+// by pkgs, which maps package import paths to a mapping from file base
+// names to contents.
+//
+// The fake Context has a GOROOT of "/go" and no GOPATH, and overrides
+// the necessary file access methods to read from memory instead of the
+// real file system.
+//
+// Unlike a real file tree, the fake one has only two levels---packages
+// and files---so ReadDir("/go/src/") returns all packages under
+// /go/src/ including, for instance, "math" and "math/big".
+// ReadDir("/go/src/math/big") would return all the files in the
+// "math/big" package.
+//
+func FakeContext(pkgs map[string]map[string]string) *build.Context {
+  clean := func(filename string) string {
+    f := path.Clean(filepath.ToSlash(filename))
+    // Removing "/go/src" while respecting segment
+    // boundaries has this unfortunate corner case:
+    if f == "/go/src" {
+      return ""
+    }
+    return strings.TrimPrefix(f, "/go/src/")
+  }
+
+  ctxt := build.Default // copy
+  ctxt.GOROOT = "/go"
+  ctxt.GOPATH = ""
+  ctxt.IsDir = func(dir string) bool {
+    dir = clean(dir)
+    if dir == "" {
+      return true // needed by (*build.Context).SrcDirs
+    }
+    return pkgs[dir] != nil
+  }
+  ctxt.ReadDir = func(dir string) ([]os.FileInfo, error) {
+    dir = clean(dir)
+    var fis []os.FileInfo
+    if dir == "" {
+      // enumerate packages
+      for importPath := range pkgs {
+        fis = append(fis, fakeDirInfo(importPath))
+      }
+    } else {
+      // enumerate files of package
+      for basename := range pkgs[dir] {
+        fis = append(fis, fakeFileInfo(basename))
+      }
+    }
+    sort.Sort(byName(fis))
+    return fis, nil
+  }
+  ctxt.OpenFile = func(filename string) (io.ReadCloser, error) {
+    filename = clean(filename)
+    dir, base := path.Split(filename)
+    content, ok := pkgs[path.Clean(dir)][base]
+    if !ok {
+      return nil, fmt.Errorf("file not found: %s", filename)
+    }
+    return ioutil.NopCloser(strings.NewReader(content)), nil
+  }
+  ctxt.IsAbsPath = func(path string) bool {
+    path = filepath.ToSlash(path)
+    // Don't rely on the default (filepath.Path) since on
+    // Windows, it reports virtual paths as non-absolute.
+    return strings.HasPrefix(path, "/")
+  }
+  return &ctxt
+}
+
+type byName []os.FileInfo
+
+func (s byName) Len() int           { return len(s) }
+func (s byName) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s byName) Less(i, j int) bool { return s[i].Name() < s[j].Name() }
+
+type fakeFileInfo string
+
+func (fi fakeFileInfo) Name() string    { return string(fi) }
+func (fakeFileInfo) Sys() interface{}   { return nil }
+func (fakeFileInfo) ModTime() time.Time { return time.Time{} }
+func (fakeFileInfo) IsDir() bool        { return false }
+func (fakeFileInfo) Size() int64        { return 0 }
+func (fakeFileInfo) Mode() os.FileMode  { return 0644 }
+
+type fakeDirInfo string
+
+func (fd fakeDirInfo) Name() string    { return string(fd) }
+func (fakeDirInfo) Sys() interface{}   { return nil }
+func (fakeDirInfo) ModTime() time.Time { return time.Time{} }
+func (fakeDirInfo) IsDir() bool        { return true }
+func (fakeDirInfo) Size() int64        { return 0 }
+func (fakeDirInfo) Mode() os.FileMode  { return 0755 }

llgo/trunk/third_party/gotools/go/callgraph/cha/cha_test.go

func TestCHA(t *testing.T) {
   for _, filename := range inputs {
     content, err := ioutil.ReadFile(filename)
     if err != nil {
       t.Errorf("couldn't read file '%s': %s", filename, err)
       continue
     }
 
     conf := loader.Config{
-      SourceImports: true,
-      ParserMode:    parser.ParseComments,
+      ParserMode: parser.ParseComments,
     }
     f, err := conf.ParseFile(filename, content)
     if err != nil {
       t.Error(err)
       continue
     }
 
     want, pos := expectation(f)

llgo/trunk/third_party/gotools/go/callgraph/rta/rta_test.go

func TestRTA(t *testing.T) {
   for _, filename := range inputs {
     content, err := ioutil.ReadFile(filename)
     if err != nil {
       t.Errorf("couldn't read file '%s': %s", filename, err)
       continue
     }
 
     conf := loader.Config{
-      SourceImports: true,
-      ParserMode:    parser.ParseComments,
+      ParserMode: parser.ParseComments,
     }
     f, err := conf.ParseFile(filename, content)
     if err != nil {
       t.Error(err)
       continue
     }
 
     want, pos := expectation(f)

llgo/trunk/third_party/gotools/go/exact/go13.go

 // Copyright 2014 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 !go1.4
 
 package exact
 
 import (
   "math"
   "math/big"
 )
 

llgo/trunk/third_party/gotools/go/exact/go14.go

+// Copyright 2014 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 go1.4
+
+package exact
+
+import "math/big"
+
+func ratToFloat32(x *big.Rat) (float32, bool) {
+  return x.Float32()
+}

llgo/trunk/third_party/gotools/go/gccgoimporter/importer_test.go

 }
 
 var importerTests = [...]importerTest{
   {pkgpath: "pointer", name: "Int8Ptr", want: "type Int8Ptr *int8"},
   {pkgpath: "complexnums", name: "NN", want: "const NN untyped complex", wantval: "(-1/1 + -1/1i)"},
   {pkgpath: "complexnums", name: "NP", want: "const NP untyped complex", wantval: "(-1/1 + 1/1i)"},
   {pkgpath: "complexnums", name: "PN", want: "const PN untyped complex", wantval: "(1/1 + -1/1i)"},
   {pkgpath: "complexnums", name: "PP", want: "const PP untyped complex", wantval: "(1/1 + 1/1i)"},
-  {pkgpath: "imports", wantinits: []string{"imports..import", "fmt..import", "math..import"}},
+  // TODO: enable this entry once bug has been tracked down
+  //{pkgpath: "imports", wantinits: []string{"imports..import", "fmt..import", "math..import"}},
 }
 
 func TestGoxImporter(t *testing.T) {
   initmap := make(map[*types.Package]InitData)
   imp := GetImporter([]string{"testdata"}, initmap)
 
   for _, test := range importerTests {
     runImporterTest(t, imp, initmap, &test)

llgo/trunk/third_party/gotools/go/loader/loader.go

 //
 //      // Use the command-line arguments to specify
 //      // a set of initial packages to load from source.
 //      // See FromArgsUsage for help.
 //      rest, err := conf.FromArgs(os.Args[1:], wantTests)
 //
 //      // Parse the specified files and create an ad-hoc package with path "foo".
 //      // All files must have the same 'package' declaration.
-//      err := conf.CreateFromFilenames("foo", "foo.go", "bar.go")
+//      conf.CreateFromFilenames("foo", "foo.go", "bar.go")
 //
 //      // Create an ad-hoc package with path "foo" from
 //      // the specified already-parsed files.
 //      // All ASTs must have the same 'package' declaration.
-//      err := conf.CreateFromFiles("foo", parsedFiles)
+//      conf.CreateFromFiles("foo", parsedFiles)
 //
 //      // Add "runtime" to the set of packages to be loaded.
 //      conf.Import("runtime")
 //
 //      // Adds "fmt" and "fmt_test" to the set of packages
 //      // to be loaded.  "fmt" will include *_test.go files.
-//      err := conf.ImportWithTests("fmt")
+//      conf.ImportWithTests("fmt")
 //
 //      // Finally, load all the packages specified by the configuration.
 //      prog, err := conf.Load()
 //
 //
 // CONCEPTS AND TERMINOLOGY
 //
 // An AD-HOC package is one specified as a set of source files on the

 // An AUGMENTED package is an importable package P plus all the
 // *_test.go files with same 'package foo' declaration as P.
 // (go/build.Package calls these files TestFiles.)
 //
 // The INITIAL packages are those specified in the configuration.  A
 // DEPENDENCY is a package loaded to satisfy an import in an initial
 // package or another dependency.
 //
-package loader // import "llvm.org/llgo/third_party/gotools/go/loader"
+package loader
 
 // 'go test', in-package test files, and import cycles
 // ---------------------------------------------------
 //
 // An external test package may depend upon members of the augmented
 // package that are not in the unaugmented package, such as functions
 // that expose internals.  (See bufio/export_test.go for an example.)
 // So, the loader must ensure that for each external test package

 //    B' imports A
 //    A' imports B
 // This last edge would be expected to create an error were it not
 // for the special type-checking discipline above.
 // Cycles of size greater than two are possible.  For example:
 //   compress/bzip2/bzip2_test.go (package bzip2)  imports "io/ioutil"
 //   io/ioutil/tempfile_test.go   (package ioutil) imports "regexp"
 //   regexp/exec_test.go          (package regexp) imports "compress/bzip2"
+//
+//
+// Concurrency
+// -----------
+//
+// Let us define the import dependency graph as follows.  Each node is a
+// list of files passed to (Checker).Files at once.  Many of these lists
+// are the production code of an importable Go package, so those nodes
+// are labelled by the package's import path.  The remaining nodes are
+// ad-hoc packages and lists of in-package *_test.go files that augment
+// an importable package; those nodes have no label.
+//
+// The edges of the graph represent import statements appearing within a
+// file.  An edge connects a node (a list of files) to the node it
+// imports, which is importable and thus always labelled.
+//
+// Loading is controlled by this dependency graph.
+//
+// To reduce I/O latency, we start loading a package's dependencies
+// asynchronously as soon as we've parsed its files and enumerated its
+// imports (scanImports).  This performs a preorder traversal of the
+// import dependency graph.
+//
+// To exploit hardware parallelism, we type-check unrelated packages in
+// parallel, where "unrelated" means not ordered by the partial order of
+// the import dependency graph.
+//
+// We use a concurrency-safe blocking cache (importer.imported) to
+// record the results of type-checking, whether success or failure.  An
+// entry is created in this cache by startLoad the first time the
+// package is imported.  The first goroutine to request an entry becomes
+// responsible for completing the task and broadcasting completion to
+// subsequent requestors, which block until then.
+//
+// Type checking occurs in (parallel) postorder: we cannot type-check a
+// set of files until we have loaded and type-checked all of their
+// immediate dependencies (and thus all of their transitive
+// dependencies). If the input were guaranteed free of import cycles,
+// this would be trivial: we could simply wait for completion of the
+// dependencies and then invoke the typechecker.
+//
+// But as we saw in the 'go test' section above, some cycles in the
+// import graph over packages are actually legal, so long as the
+// cycle-forming edge originates in the in-package test files that
+// augment the package.  This explains why the nodes of the import
+// dependency graph are not packages, but lists of files: the unlabelled
+// nodes avoid the cycles.  Consider packages A and B where B imports A
+// and A's in-package tests AT import B.  The naively constructed import
+// graph over packages would contain a cycle (A+AT) --> B --> (A+AT) but
+// the graph over lists of files is AT --> B --> A, where AT is an
+// unlabelled node.
+//
+// Awaiting completion of the dependencies in a cyclic graph would
+// deadlock, so we must materialize the import dependency graph (as
+// importer.graph) and check whether each import edge forms a cycle.  If
+// x imports y, and the graph already contains a path from y to x, then
+// there is an import cycle, in which case the processing of x must not
+// wait for the completion of processing of y.
+//
+// When the type-checker makes a callback (doImport) to the loader for a
+// given import edge, there are two possible cases.  In the normal case,
+// the dependency has already been completely type-checked; doImport
+// does a cache lookup and returns it.  In the cyclic case, the entry in
+// the cache is still necessarily incomplete, indicating a cycle.  We
+// perform the cycle check again to obtain the error message, and return
+// the error.
+//
+// The result of using concurrency is about a 2.5x speedup for stdlib_test.
 
 // TODO(adonovan):
-// - (*Config).ParseFile is very handy, but feels like feature creep.
-//   (*Config).CreateFromFiles has a nasty precondition.
-// - s/path/importPath/g to avoid ambiguity with other meanings of
-//   "path": a file name, a colon-separated directory list.
 // - cache the calls to build.Import so we don't do it three times per
 //   test package.
 // - Thorough overhaul of package documentation.
-// - Certain errors (e.g. parse error in x_test.go files, or failure to
-//   import an initial package) still cause Load() to fail hard.
-//   Fix that.  (It's tricky because of the way x_test files are parsed
-//   eagerly.)
 
 import (
   "errors"
   "fmt"
   "go/ast"
   "go/build"
   "go/parser"
   "go/token"
   "os"
+  "sort"
   "strings"
+  "sync"
+  "time"
 
   "llvm.org/llgo/third_party/gotools/go/ast/astutil"
   "llvm.org/llgo/third_party/gotools/go/gcimporter"
   "llvm.org/llgo/third_party/gotools/go/types"
 )
 
+const trace = false // show timing info for type-checking
+
 // Config specifies the configuration for a program to load.
 // The zero value for Config is a ready-to-use default configuration.
 type Config struct {
   // Fset is the file set for the parser to use when loading the
-  // program.  If nil, it will be lazily initialized by any
+  // program.  If nil, it may be lazily initialized by any
   // method of Config.
   Fset *token.FileSet
 
   // ParserMode specifies the mode to be used by the parser when
   // loading source packages.
   ParserMode parser.Mode
 
   // TypeChecker contains options relating to the type checker.
   //
   // The supplied IgnoreFuncBodies is not used; the effective
   // value comes from the TypeCheckFuncBodies func below.
   //
   // TypeChecker.Packages is lazily initialized during Load.
   TypeChecker types.Config
 
   // TypeCheckFuncBodies is a predicate over package import
   // paths.  A package for which the predicate is false will
   // have its package-level declarations type checked, but not
   // its function bodies; this can be used to quickly load
   // dependencies from source.  If nil, all func bodies are type
   // checked.
   TypeCheckFuncBodies func(string) bool
 
-  // SourceImports determines whether to satisfy dependencies by
-  // loading Go source code.
+  // ImportFromBinary determines whether to satisfy dependencies by
+  // loading gc export data instead of Go source code.
   //
-  // If true, the entire program---the initial packages and
-  // their transitive closure of dependencies---will be loaded,
-  // parsed and type-checked.  This is required for
+  // If false, the entire program---the initial packages and their
+  // transitive closure of dependencies---will be loaded from
+  // source, parsed, and type-checked.  This is required for
   // whole-program analyses such as pointer analysis.
   //
-  // If false, the TypeChecker.Import mechanism will be used
-  // instead.  Since that typically supplies only the types of
-  // package-level declarations and values of constants, but no
-  // code, it will not yield a whole program.  It is intended
-  // for analyses that perform modular analysis of a
-  // single package, e.g. traditional compilation.
+  // If true, the go/gcimporter mechanism is used instead to read
+  // the binary export-data files written by the gc toolchain.
+  // They supply only the types of package-level declarations and
+  // values of constants, but no code, this option will not yield
+  // a whole program.  It is intended for analyses that perform
+  // modular analysis of a single package, e.g. traditional
+  // compilation.
+  //
+  // No check is made that the export data files are up-to-date.
   //
   // The initial packages (CreatePkgs and ImportPkgs) are always
   // loaded from Go source, regardless of this flag's setting.
-  SourceImports bool
+  //
+  // NB: there is a bug when loading multiple initial packages with
+  // this flag enabled: https://github.com/golang/go/issues/9955.
+  ImportFromBinary bool
 
   // If Build is non-nil, it is used to locate source packages.
   // Otherwise &build.Default is used.
   //
   // By default, cgo is invoked to preprocess Go files that
   // import the fake package "C".  This behaviour can be
   // disabled by setting CGO_ENABLED=0 in the environment prior
   // to startup, or by setting Build.CgoEnabled=false.
   Build *build.Context
 
+  // The current directory, used for resolving relative package
+  // references such as "./go/loader".  If empty, os.Getwd will be
+  // used instead.
+  Cwd string
+
   // If DisplayPath is non-nil, it is used to transform each
   // file name obtained from Build.Import().  This can be used
   // to prevent a virtualized build.Config's file names from
   // leaking into the user interface.
   DisplayPath func(path string) string
 
   // If AllowErrors is true, Load will return a Program even
   // if some of the its packages contained I/O, parser or type
   // errors; such errors are accessible via PackageInfo.Errors.  If
   // false, Load will fail if any package had an error.
   AllowErrors bool
 
   // CreatePkgs specifies a list of non-importable initial
-  // packages to create.  Each element specifies a list of
-  // parsed files to be type-checked into a new package, and a
-  // path for that package.  If the path is "", the package's
-  // name will be used instead.  The path needn't be globally
-  // unique.
-  //
-  // The resulting packages will appear in the corresponding
-  // elements of the Program.Created slice.
-  CreatePkgs []CreatePkg
+  // packages to create.  The resulting packages will appear in
+  // the corresponding elements of the Program.Created slice.
+  CreatePkgs []PkgSpec
 
   // ImportPkgs specifies a set of initial packages to load from
   // source.  The map keys are package import paths, used to
-  // locate the package relative to $GOROOT.  The corresponding
-  // values indicate whether to augment the package by *_test.go
-  // files in a second pass.
+  // locate the package relative to $GOROOT.
+  //
+  // The map value indicates whether to load tests.  If true, Load
+  // will add and type-check two lists of files to the package:
+  // non-test files followed by in-package *_test.go files.  In
+  // addition, it will append the external test package (if any)
+  // to Program.Created.
   ImportPkgs map[string]bool
 
+  // FindPackage is called during Load to create the build.Package
+  // for a given import path.  If nil, a default implementation
+  // based on ctxt.Import is used.  A client may use this hook to
+  // adapt to a proprietary build system that does not follow the
+  // "go build" layout conventions, for example.
+  //
+  // It must be safe to call concurrently from multiple goroutines.
+  FindPackage func(ctxt *build.Context, importPath string) (*build.Package, error)
+
   // PackageCreated is a hook called when a types.Package
   // is created but before it has been populated.
   //
   // The package's import Path() and Scope() are defined,
   // but not its Name() since no package declaration has
   // been seen yet.
   //
   // Clients may use this to insert synthetic items into
   // the package scope, for example.
   //
   // It must be safe to call concurrently from multiple goroutines.
   PackageCreated func(*types.Package)
 }
 
-type CreatePkg struct {
-  Path  string
-  Files []*ast.File
+// A PkgSpec specifies a non-importable package to be created by Load.
+// Files are processed first, but typically only one of Files and
+// Filenames is provided.  The path needn't be globally unique.
+//
+type PkgSpec struct {
+  Path      string      // import path ("" => use package declaration)
+  Files     []*ast.File // ASTs of already-parsed files
+  Filenames []string    // names of files to be parsed
 }
 
 // A Program is a Go program loaded from source or binary
 // as specified by a Config.
 type Program struct {
   Fset *token.FileSet // the file set for this program
 
-  // Created[i] contains the initial package whose ASTs were
-  // supplied by Config.CreatePkgs[i].
+  // Created[i] contains the initial package whose ASTs or
+  // filenames were supplied by Config.CreatePkgs[i], followed by
+  // the external test package, if any, of each package in
+  // Config.ImportPkgs ordered by ImportPath.
   Created []*PackageInfo
 
   // Imported contains the initially imported packages,
   // as specified by Config.ImportPkgs.
   Imported map[string]*PackageInfo
 
   // ImportMap is the canonical mapping of import paths to
   // packages used by the type-checker (Config.TypeChecker.Packages).

 
 func (conf *Config) fset() *token.FileSet {
   if conf.Fset == nil {
     conf.Fset = token.NewFileSet()
   }
   return conf.Fset
 }
 
-// ParseFile is a convenience function that invokes the parser using
-// the Config's FileSet, which is initialized if nil.
+// ParseFile is a convenience function (intended for testing) that invokes
+// the parser using the Config's FileSet, which is initialized if nil.
+//
+// src specifies the parser input as a string, []byte, or io.Reader, and
+// filename is its apparent name.  If src is nil, the contents of
+// filename are read from the file system.
 //
 func (conf *Config) ParseFile(filename string, src interface{}) (*ast.File, error) {
   // TODO(adonovan): use conf.build() etc like parseFiles does.
   return parser.ParseFile(conf.fset(), filename, src, conf.ParserMode)
 }
 
 // FromArgsUsage is a partial usage message that applications calling
 // FromArgs may wish to include in their -help output.
2. A list of import paths, each denoting a package.
    In addition, all *_test.go files in the directory are then loaded
    and parsed.  Those files whose package declaration equals that of
    the non-*_test.go files are included in the primary package.  Test
    files whose package declaration ends with "_test" are type-checked
    as another package, the 'external' test package, so that a single
    import path may denote two packages.  (Whether this behaviour is
    enabled is tool-specific, and may depend on additional flags.)
 
-   Due to current limitations in the type-checker, only the first
-   import path of the command line will contribute any tests.
-
 A '--' argument terminates the list of packages.
 `
 
 // FromArgs interprets args as a set of initial packages to load from
 // source and updates the configuration.  It returns the list of
 // unconsumed arguments.
 //
 // It is intended for use in command-line interfaces that require a
 // set of initial packages to be specified; see FromArgsUsage message
 // for details.
 //
-func (conf *Config) FromArgs(args []string, xtest bool) (rest []string, err error) {
+// Only superficial errors are reported at this stage; errors dependent
+// on I/O are detected during Load.
+//
+func (conf *Config) FromArgs(args []string, xtest bool) ([]string, error) {
+  var rest []string
   for i, arg := range args {
     if arg == "--" {
       rest = args[i+1:]
       args = args[:i]
       break // consume "--" and return the remaining args
     }
   }
 
   if len(args) > 0 && strings.HasSuffix(args[0], ".go") {
     // Assume args is a list of a *.go files
     // denoting a single ad-hoc package.
     for _, arg := range args {
       if !strings.HasSuffix(arg, ".go") {
         return nil, fmt.Errorf("named files must be .go files: %s", arg)
       }
     }
-    err = conf.CreateFromFilenames("", args...)
+    conf.CreateFromFilenames("", args...)
   } else {
     // Assume args are directories each denoting a
     // package and (perhaps) an external test, iff xtest.
     for _, arg := range args {
       if xtest {
-        err = conf.ImportWithTests(arg)
-        if err != nil {
-          break
-        }
+        conf.ImportWithTests(arg)
       } else {
         conf.Import(arg)
       }
     }
   }
 
-  return
+  return rest, nil
 }
 
-// CreateFromFilenames is a convenience function that parses the
-// specified *.go files and adds a package entry for them to
-// conf.CreatePkgs.
+// CreateFromFilenames is a convenience function that adds
+// a conf.CreatePkgs entry to create a package of the specified *.go
+// files.
 //
-// It fails if any file could not be loaded or parsed.
-//
-func (conf *Config) CreateFromFilenames(path string, filenames ...string) error {
-  files, errs := parseFiles(conf.fset(), conf.build(), nil, ".", filenames, conf.ParserMode)
-  if len(errs) > 0 {
-    return errs[0]
-  }
-  conf.CreateFromFiles(path, files...)
-  return nil
+func (conf *Config) CreateFromFilenames(path string, filenames ...string) {
+  conf.CreatePkgs = append(conf.CreatePkgs, PkgSpec{Path: path, Filenames: filenames})
 }
 
-// CreateFromFiles is a convenience function that adds a CreatePkgs
+// CreateFromFiles is a convenience function that adds a conf.CreatePkgs
 // entry to create package of the specified path and parsed files.
 //
-// Precondition: conf.Fset is non-nil and was the fileset used to parse
-// the files.  (e.g. the files came from conf.ParseFile().)
-//
 func (conf *Config) CreateFromFiles(path string, files ...*ast.File) {
-  if conf.Fset == nil {
-    panic("nil Fset")
-  }
-  conf.CreatePkgs = append(conf.CreatePkgs, CreatePkg{path, files})
+  conf.CreatePkgs = append(conf.CreatePkgs, PkgSpec{Path: path, Files: files})
 }
 
 // ImportWithTests is a convenience function that adds path to
 // ImportPkgs, the set of initial source packages located relative to
 // $GOPATH.  The package will be augmented by any *_test.go files in
 // its directory that contain a "package x" (not "package x_test")
 // declaration.
 //
 // In addition, if any *_test.go files contain a "package x_test"
 // declaration, an additional package comprising just those files will
 // be added to CreatePkgs.
 //
-func (conf *Config) ImportWithTests(path string) error {
-  if path == "unsafe" {
-    return nil // ignore; not a real package
-  }
-  conf.Import(path)
-
-  // Load the external test package.
-  bp, err := conf.findSourcePackage(path)
-  if err != nil {
-    return err // package not found
-  }
-  xtestFiles, errs := conf.parsePackageFiles(bp, 'x')
-  if len(errs) > 0 {
-    // TODO(adonovan): fix: parse errors in x_test.go files
-    // cause FromArgs() to fail completely.
-    return errs[0] // I/O or parse error
-  }
-  if len(xtestFiles) > 0 {
-    conf.CreateFromFiles(path+"_test", xtestFiles...)
-  }
-
-  // Mark the non-xtest package for augmentation with
-  // in-package *_test.go files when we import it below.
-  conf.ImportPkgs[path] = true
-  return nil
-}
+func (conf *Config) ImportWithTests(path string) { conf.addImport(path, true) }
 
 // Import is a convenience function that adds path to ImportPkgs, the
 // set of initial packages that will be imported from source.
 //
-func (conf *Config) Import(path string) {
+func (conf *Config) Import(path string) { conf.addImport(path, false) }
+
+func (conf *Config) addImport(path string, tests bool) {
   if path == "unsafe" {
     return // ignore; not a real package
   }
   if conf.ImportPkgs == nil {
     conf.ImportPkgs = make(map[string]bool)
   }
-  // Subtle: adds value 'false' unless value is already true.
-  conf.ImportPkgs[path] = conf.ImportPkgs[path] // unaugmented source package
+  conf.ImportPkgs[path] = conf.ImportPkgs[path] || tests
 }
 
 // PathEnclosingInterval returns the PackageInfo and ast.Node that
 // contain source interval [start, end), and all the node's ancestors
 // up to the AST root.  It searches all ast.Files of all packages in prog.
 // exact is defined as for astutil.PathEnclosingInterval.
 //
 // The zero value is returned if not found.
func (prog *Program) InitialPackages() []*PackageInfo {
   }
   return infos
 }
 
 // ---------- Implementation ----------
 
 // importer holds the working state of the algorithm.
 type importer struct {
-  conf     *Config                // the client configuration
-  prog     *Program               // resulting program
-  imported map[string]*importInfo // all imported packages (incl. failures) by import path
+  conf  *Config   // the client configuration
+  prog  *Program  // resulting program
+  start time.Time // for logging
+
+  // This mutex serializes access to prog.ImportMap (aka
+  // TypeChecker.Packages); we also use it for AllPackages.
+  //
+  // The TypeChecker.Packages map is not really used by this
+  // package, but may be used by the client's Import function,
+  // and by clients of the returned Program.
+  typecheckerMu sync.Mutex
+
+  importedMu sync.Mutex
+  imported   map[string]*importInfo // all imported packages (incl. failures) by import path
+
+  // import dependency graph: graph[x][y] => x imports y
+  //
+  // Since non-importable packages cannot be cyclic, we ignore
+  // their imports, thus we only need the subgraph over importable
+  // packages.  Nodes are identified by their import paths.
+  graphMu sync.Mutex
+  graph   map[string]map[string]bool
 }
 
 // importInfo tracks the success or failure of a single import.
+//
+// Upon completion, exactly one of info and err is non-nil:
+// info on successful creation of a package, err otherwise.
+// A successful package may still contain type errors.
+//
 type importInfo struct {
-  info *PackageInfo // results of typechecking (including errors)
-  err  error        // reason for failure to make a package
+  path     string       // import path
+  mu       sync.Mutex   // guards the following fields prior to completion
+  info     *PackageInfo // results of typechecking (including errors)
+  err      error        // reason for failure to create a package
+  complete sync.Cond    // complete condition is that one of info, err is non-nil.
+}
+
+// awaitCompletion blocks until ii is complete,
+// i.e. the info and err fields are safe to inspect without a lock.
+// It is concurrency-safe and idempotent.
+func (ii *importInfo) awaitCompletion() {
+  ii.mu.Lock()
+  for ii.info == nil && ii.err == nil {
+    ii.complete.Wait()
+  }
+  ii.mu.Unlock()
+}
+
+// Complete marks ii as complete.
+// Its info and err fields will not be subsequently updated.
+func (ii *importInfo) Complete(info *PackageInfo, err error) {
+  ii.mu.Lock()
+  ii.info = info
+  ii.err = err
+  ii.complete.Broadcast()
+  ii.mu.Unlock()
 }
 
 // Load creates the initial packages specified by conf.{Create,Import}Pkgs,
 // loading their dependencies packages as needed.
 //
 // On success, Load returns a Program containing a PackageInfo for
 // each package.  On failure, it returns an error.
 //
if conf.TypeChecker.Packages == nil {
     conf.TypeChecker.Packages = make(map[string]*types.Package)
   }
 
   // Create a simple default error handler for parse/type errors.
   if conf.TypeChecker.Error == nil {
     conf.TypeChecker.Error = func(e error) { fmt.Fprintln(os.Stderr, e) }
   }
 
+  // Set default working directory for relative package references.
+  if conf.Cwd == "" {
+    var err error
+    conf.Cwd, err = os.Getwd()
+    if err != nil {
+      return nil, err
+    }
+  }
+
+  // Install default FindPackage hook using go/build logic.
+  if conf.FindPackage == nil {
+    conf.FindPackage = func(ctxt *build.Context, path string) (*build.Package, error) {
+      bp, err := ctxt.Import(path, conf.Cwd, 0)
+      if _, ok := err.(*build.NoGoError); ok {
+        return bp, nil // empty directory is not an error
+      }
+      return bp, err
+    }
+  }
+
   prog := &Program{
     Fset:        conf.fset(),
     Imported:    make(map[string]*PackageInfo),
     ImportMap:   conf.TypeChecker.Packages,
     AllPackages: make(map[*types.Package]*PackageInfo),
   }
 
   imp := importer{
     conf:     conf,
     prog:     prog,
     imported: make(map[string]*importInfo),
+    start:    time.Now(),
+    graph:    make(map[string]map[string]bool),
   }
 
-  for path := range conf.ImportPkgs {
-    info, err := imp.importPackage(path)
-    if err != nil {
-      return nil, err // failed to create package
+  // -- loading proper (concurrent phase) --------------------------------
+
+  var errpkgs []string // packages that contained errors
+
+  // Load the initially imported packages and their dependencies,
+  // in parallel.
+  for _, ii := range imp.loadAll("", conf.ImportPkgs) {
+    if ii.err != nil {
+      conf.TypeChecker.Error(ii.err) // failed to create package
+      errpkgs = append(errpkgs, ii.path)
+      continue
     }
-    prog.Imported[path] = info
+    prog.Imported[ii.info.Pkg.Path()] = ii.info
   }
 
-  // Now augment those packages that need it.
+  // Augment the designated initial packages by their tests.
+  // Dependencies are loaded in parallel.
+  var xtestPkgs []*build.Package
   for path, augment := range conf.ImportPkgs {
-    if augment {
-      // Find and create the actual package.
-      bp, err := conf.findSourcePackage(path)
-      if err != nil {
-        // "Can't happen" because of previous loop.
-        return nil, err // package not found
-      }
+    if !augment {
+      continue
+    }
+
+    bp, err := conf.FindPackage(conf.build(), path)
+      // Package not found, or can't even parse package declaration.
+      // Already reported by previous loop; ignore it.
+      continue
+    }
+
+    // Needs external test package?
+    if len(bp.XTestGoFiles) > 0 {
+      xtestPkgs = append(xtestPkgs, bp)
 
-      info := imp.imported[path].info // must be non-nil, see above
-      files, errs := imp.conf.parsePackageFiles(bp, 't')
-      for _, err := range errs {
-        info.appendError(err)
-      }
-      typeCheckFiles(info, files...)
-    }
-  }
+    imp.importedMu.Lock()           // (unnecessary, we're sequential here)
+    imp.importedMu.Unlock()
+
+    // Parse the in-package test files.
 
-  for _, create := range conf.CreatePkgs {
-    path := create.Path
-    if create.Path == "" && len(create.Files) > 0 {
-      path = create.Files[0].Name.Name
-    }
+    // The test files augmenting package P cannot be imported,
+    // but may import packages that import P,
+    // so we must disable the cycle check.
+    imp.addFiles(info, files, false)
+
+  createPkg := func(path string, files []*ast.File, errs []error) {
     info := imp.newPackageInfo(path)
-    typeCheckFiles(info, create.Files...)
+    for _, err := range errs {
+      info.appendError(err)
+    }
+
+    // Ad-hoc packages are non-importable,
+    // so no cycle check is needed.
+    // addFiles loads dependencies in parallel.
+    imp.addFiles(info, files, false)
     prog.Created = append(prog.Created, info)
   }
 
+  // Create packages specified by conf.CreatePkgs.
+  for _, cp := range conf.CreatePkgs {
+    files, errs := parseFiles(conf.fset(), conf.build(), nil, ".", cp.Filenames, conf.ParserMode)
+    files = append(files, cp.Files...)
+
+    path := cp.Path
+    if path == "" {
+      if len(files) > 0 {
+        path = files[0].Name.Name
+      } else {
+        path = "(unnamed)"
+      }
+    }
+    createPkg(path, files, errs)
+  }
+
+  // Create external test packages.
+  sort.Sort(byImportPath(xtestPkgs))
+  for _, bp := range xtestPkgs {
+    files, errs := imp.conf.parsePackageFiles(bp, 'x')
+    createPkg(bp.ImportPath+"_test", files, errs)
+  }
+
+  // -- finishing up (sequential) ----------------------------------------
+
   if len(prog.Imported)+len(prog.Created) == 0 {
-    return nil, errors.New("no initial packages were specified")
+    return nil, errors.New("no initial packages were loaded")
   }
 
   // Create infos for indirectly imported packages.
   // e.g. incomplete packages without syntax, loaded from export data.
   for _, obj := range prog.ImportMap {
     info := prog.AllPackages[obj]
     if info == nil {
       prog.AllPackages[obj] = &PackageInfo{Pkg: obj, Importable: true}
     } else {
       // finished
       info.checker = nil
       info.errorFunc = nil
     }
   }
 
   if !conf.AllowErrors {
     // Report errors in indirectly imported packages.
-    var errpkgs []string
     for _, info := range prog.AllPackages {
       if len(info.Errors) > 0 {
         errpkgs = append(errpkgs, info.Pkg.Path())
       }
     }
     if errpkgs != nil {
       var more string
       if len(errpkgs) > 3 {
         more = fmt.Sprintf(" and %d more", len(errpkgs)-3)
         errpkgs = errpkgs[:3]
       }
       return nil, fmt.Errorf("couldn't load packages due to errors: %s%s",
         strings.Join(errpkgs, ", "), more)
     }
   }
 
   markErrorFreePackages(prog.AllPackages)
 
   return prog, nil
 }
 
+type byImportPath []*build.Package
+
+func (b byImportPath) Len() int           { return len(b) }
+func (b byImportPath) Less(i, j int) bool { return b[i].ImportPath < b[j].ImportPath }
+func (b byImportPath) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+
 // markErrorFreePackages sets the TransitivelyErrorFree flag on all
 // applicable packages.
 func markErrorFreePackages(allPackages map[*types.Package]*PackageInfo) {
   // Build the transpose of the import graph.
   importedBy := make(map[*types.Package]map[*types.Package]bool)
   for P := range allPackages {
     for _, Q := range P.Imports() {
       clients, ok := importedBy[Q]

 // build returns the effective build context.
 func (conf *Config) build() *build.Context {
   if conf.Build != nil {
     return conf.Build
   }
   return &build.Default
 }
 
-// findSourcePackage locates the specified (possibly empty) package
-// using go/build logic.  It returns an error if not found.
-//
-func (conf *Config) findSourcePackage(path string) (*build.Package, error) {
-  // Import(srcDir="") disables local imports, e.g. import "./foo".
-  bp, err := conf.build().Import(path, "", 0)
-  if _, ok := err.(*build.NoGoError); ok {
-    return bp, nil // empty directory is not an error
-  }
-  return bp, err
-}
-
 // parsePackageFiles enumerates the files belonging to package path,
 // then loads, parses and returns them, plus a list of I/O or parse
 // errors that were encountered.
 //
 // 'which' indicates which files to include:
 //    'g': include non-test *.go source files (GoFiles + processed CgoFiles)
 //    't': include in-package *_test.go source files (TestGoFiles)
 //    'x': include external *_test.go source files. (XTestGoFiles)

 //
 // It returns an error if a package could not be created
 // (e.g. go/build or parse error), but type errors are reported via
 // the types.Config.Error callback (the first of which is also saved
 // in the package's PackageInfo).
 //
 // Idempotent.
 //
-func (imp *importer) doImport(imports map[string]*types.Package, path string) (*types.Package, error) {
+func (imp *importer) doImport(from *PackageInfo, to string) (*types.Package, error) {
   // Package unsafe is handled specially, and has no PackageInfo.
-  if path == "unsafe" {
+  // TODO(adonovan): move this check into go/types?
+  if to == "unsafe" {
     return types.Unsafe, nil
   }
 
-  info, err := imp.importPackage(path)
-  if err != nil {
-    return nil, err
+  imp.importedMu.Lock()
+  ii := imp.imported[to]
+  imp.importedMu.Unlock()
+  if ii == nil {
+    panic("internal error: unexpected import: " + to)
+  }
+  if ii.err != nil {
+    return nil, ii.err
+  }
+  if ii.info != nil {
+    return ii.info.Pkg, nil
   }
 
-  // Update the type checker's package map on success.
-  imports[path] = info.Pkg
+  // Import of incomplete package: this indicates a cycle.
+  fromPath := from.Pkg.Path()
+  if cycle := imp.findPath(to, fromPath); cycle != nil {
+    cycle = append([]string{fromPath}, cycle...)
+    return nil, fmt.Errorf("import cycle: %s", strings.Join(cycle, " -> "))
+  }
 
-  return info.Pkg, nil
+  panic("internal error: import of incomplete (yet acyclic) package: " + fromPath)
 }
 
-// importPackage imports the package with the given import path, plus
-// its dependencies.
+// loadAll loads, parses, and type-checks the specified packages in
+// parallel and returns their completed importInfos in unspecified order.
 //
-// On success, it returns a PackageInfo, possibly containing errors.
-// importPackage returns an error if it couldn't even create the package.
+// fromPath is the import path of the importing package, if it is
+// importable, "" otherwise.  It is used for cycle detection.
+//
+func (imp *importer) loadAll(fromPath string, paths map[string]bool) []*importInfo {
+  result := make([]*importInfo, 0, len(paths))
+  for path := range paths {
+    result = append(result, imp.startLoad(path))
+  }
+
+  if fromPath != "" {
+    // We're loading a set of imports.
+    //
+    // We must record graph edges from the importing package
+    // to its dependencies, and check for cycles.
+    imp.graphMu.Lock()
+    deps, ok := imp.graph[fromPath]
+    if !ok {
+      deps = make(map[string]bool)
+      imp.graph[fromPath] = deps
+    }
+    for path := range paths {
+      deps[path] = true
+    }
+    imp.graphMu.Unlock()
+  }
+
+  for _, ii := range result {
+    if fromPath != "" {
+      if cycle := imp.findPath(ii.path, fromPath); cycle != nil {
+        // Cycle-forming import: we must not await its
+        // completion since it would deadlock.
+        //
+        // We don't record the error in ii since
+        // the error is really associated with the
+        // cycle-forming edge, not the package itself.
+        // (Also it would complicate the
+        // invariants of importPath completion.)
+        if trace {
+          fmt.Fprintln(os.Stderr, "import cycle: %q", cycle)
+        }
+        continue
+      }
+    }
+    ii.awaitCompletion()
+
+  }
+  return result
+}
+
+// findPath returns an arbitrary path from 'from' to 'to' in the import
+// graph, or nil if there was none.
+func (imp *importer) findPath(from, to string) []string {
+  imp.graphMu.Lock()
+  defer imp.graphMu.Unlock()
+
+  seen := make(map[string]bool)
+  var search func(stack []string, importPath string) []string
+  search = func(stack []string, importPath string) []string {
+    if !seen[importPath] {
+      seen[importPath] = true
+      stack = append(stack, importPath)
+      if importPath == to {
+        return stack
+      }
+      for x := range imp.graph[importPath] {
+        if p := search(stack, x); p != nil {
+          return p
+        }
+      }
+    }
+    return nil
+  }
+  return search(make([]string, 0, 20), from)
+}
+
+// startLoad initiates the loading, parsing and type-checking of the
+// specified package and its dependencies, if it has not already begun.
+//
+// It returns an importInfo, not necessarily in a completed state.  The
+// caller must call awaitCompletion() before accessing its info and err
+// fields.
+//
+// startLoad is concurrency-safe and idempotent.
 //
 // Precondition: path != "unsafe".
 //
-func (imp *importer) importPackage(path string) (*PackageInfo, error) {
+func (imp *importer) startLoad(path string) *importInfo {
+  imp.importedMu.Lock()
   ii, ok := imp.imported[path]
   if !ok {
-    // In preorder, initialize the map entry to a cycle
-    // error in case importPackage(path) is called again
-    // before the import is completed.
-    ii = &importInfo{err: fmt.Errorf("import cycle in package %s", path)}
+    ii = &importInfo{path: path}
+    ii.complete.L = &ii.mu
     imp.imported[path] = ii
 
-    // Find and create the actual package.
-    if _, ok := imp.conf.ImportPkgs[path]; ok || imp.conf.SourceImports {
-      ii.info, ii.err = imp.importFromSource(path)
-    } else {
-      ii.info, ii.err = imp.importFromBinary(path)
-    }
-    if ii.info != nil {
-      ii.info.Importable = true
-    }
-  }
+    go imp.load(path, ii)
+  imp.importedMu.Unlock()
+
+  return ii
 
-  return ii.info, ii.err
+func (imp *importer) load(path string, ii *importInfo) {
+  var info *PackageInfo
+  var err error
+  // Find and create the actual package.
+  if _, ok := imp.conf.ImportPkgs[path]; ok || !imp.conf.ImportFromBinary {
+    info, err = imp.loadFromSource(path)
+  } else {
+    info, err = imp.importFromBinary(path)
+  }
+  ii.Complete(info, err)
 }
 
 // importFromBinary implements package loading from the client-supplied
 // external source, e.g. object files from the gc compiler.
 //
 func (imp *importer) importFromBinary(path string) (*PackageInfo, error) {
   // Determine the caller's effective Import function.
   importfn := imp.conf.TypeChecker.Import
   if importfn == nil {
     importfn = gcimporter.Import
   }
+  imp.typecheckerMu.Lock()
   pkg, err := importfn(imp.conf.TypeChecker.Packages, path)
+  if pkg != nil {
+    imp.conf.TypeChecker.Packages[path] = pkg
+  }
+  imp.typecheckerMu.Unlock()
   if err != nil {
     return nil, err
   }
   info := &PackageInfo{Pkg: pkg}
+  info.Importable = true
+  imp.typecheckerMu.Lock()
   imp.prog.AllPackages[pkg] = info
+  imp.typecheckerMu.Unlock()
   return info, nil
 }
 
-// importFromSource implements package loading by parsing Go source files
+// loadFromSource implements package loading by parsing Go source files
 // located by go/build.
+// The returned PackageInfo's typeCheck function must be called.
 //
-func (imp *importer) importFromSource(path string) (*PackageInfo, error) {
-  bp, err := imp.conf.findSourcePackage(path)
+func (imp *importer) loadFromSource(path string) (*PackageInfo, error) {
+  bp, err := imp.conf.FindPackage(imp.conf.build(), path)
   if err != nil {
     return nil, err // package not found
   }
-  // Type-check the package.
-  info := imp.newPackageInfo(path)
+  info := imp.newPackageInfo(bp.ImportPath)
+  info.Importable = true
   files, errs := imp.conf.parsePackageFiles(bp, 'g')
   for _, err := range errs {
     info.appendError(err)
   }
-  typeCheckFiles(info, files...)
+
+  imp.addFiles(info, files, true)
+
+  imp.typecheckerMu.Lock()
+  imp.conf.TypeChecker.Packages[path] = info.Pkg
+  imp.typecheckerMu.Unlock()
+
   return info, nil
 }
 
-// typeCheckFiles adds the specified files to info and type-checks them.
-// The order of files determines the package initialization order.
-// It may be called multiple times.
+// addFiles adds and type-checks the specified files to info, loading
+// their dependencies if needed.  The order of files determines the
+// package initialization order.  It may be called multiple times on the
+// same package.  Errors are appended to the info.Errors field.
+//
+// cycleCheck determines whether the imports within files create
+// dependency edges that should be checked for potential cycles.
 //
-// Errors are stored in the info.Errors field.
-func typeCheckFiles(info *PackageInfo, files ...*ast.File) {
+func (imp *importer) addFiles(info *PackageInfo, files []*ast.File, cycleCheck bool) {
   info.Files = append(info.Files, files...)
 
-  // Ignore the returned (first) error since we already collect them all.
-  _ = info.checker.Files(files)
+  // Ensure the dependencies are loaded, in parallel.
+  var fromPath string
+  if cycleCheck {
+    fromPath = info.Pkg.Path()
+  }
+  imp.loadAll(fromPath, scanImports(files))
+
+  if trace {
+    fmt.Fprintf(os.Stderr, "%s: start %q (%d)\n",
+      time.Since(imp.start), info.Pkg.Path(), len(files))
+  }
+
+  // Ignore the returned (first) error since we
+  // already collect them all in the PackageInfo.
+  info.checker.Files(files)
+
+  if trace {
+    fmt.Fprintf(os.Stderr, "%s: stop %q\n",
+      time.Since(imp.start), info.Pkg.Path())
+  }
 }
 
 func (imp *importer) newPackageInfo(path string) *PackageInfo {
   pkg := types.NewPackage(path, "")
   if imp.conf.PackageCreated != nil {
     imp.conf.PackageCreated(pkg)
   }
   info := &PackageInfo{
func (imp *importer) newPackageInfo(path string) *PackageInfo {
   }
 
   // Copy the types.Config so we can vary it across PackageInfos.
   tc := imp.conf.TypeChecker
   tc.IgnoreFuncBodies = false
   if f := imp.conf.TypeCheckFuncBodies; f != nil {
     tc.IgnoreFuncBodies = !f(path)
   }
-  tc.Import = imp.doImport    // doImport wraps the user's importfn, effectively
+  tc.Import = func(_ map[string]*types.Package, to string) (*types.Package, error) {
+    return imp.doImport(info, to)
+  }
   tc.Error = info.appendError // appendError wraps the user's Error function
 
   info.checker = types.NewChecker(&tc, imp.conf.fset(), pkg, &info.Info)
+  imp.typecheckerMu.Lock()
   imp.prog.AllPackages[pkg] = info
+  imp.typecheckerMu.Unlock()
   return info
 }

llgo/trunk/third_party/gotools/go/loader/loader_test.go

 // 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 loader_test
 
 import (
-  "bytes"
   "fmt"
   "go/build"
-  "io"
-  "io/ioutil"
-  "os"
+  "reflect"
   "sort"
   "strings"
+  "sync"
   "testing"
-  "time"
 
+  "llvm.org/llgo/third_party/gotools/go/buildutil"
   "llvm.org/llgo/third_party/gotools/go/loader"
 )
 
-func loadFromArgs(args []string) (prog *loader.Program, rest []string, err error) {
-  conf := &loader.Config{}
-  rest, err = conf.FromArgs(args, true)
+// TestFromArgs checks that conf.FromArgs populates conf correctly.
+// It does no I/O.
+func TestFromArgs(t *testing.T) {
+  type result struct {
+    Err        string
+    Rest       []string
+    ImportPkgs map[string]bool
+    CreatePkgs []loader.PkgSpec
+  }
+  for _, test := range []struct {
+    args  []string
+    tests bool
+    want  result
+  }{
+    // Mix of existing and non-existent packages.
+    {
+      args: []string{"nosuchpkg", "errors"},
+      want: result{
+        ImportPkgs: map[string]bool{"errors": false, "nosuchpkg": false},
+      },
+    },
+    // Same, with -test flag.
+    {
+      args:  []string{"nosuchpkg", "errors"},
+      tests: true,
+      want: result{
+        ImportPkgs: map[string]bool{"errors": true, "nosuchpkg": true},
+      },
+    },
+    // Surplus arguments.
+    {
+      args: []string{"fmt", "errors", "--", "surplus"},
+      want: result{
+        Rest:       []string{"surplus"},
+        ImportPkgs: map[string]bool{"errors": false, "fmt": false},
+      },
+    },
+    // Ad hoc package specified as *.go files.
+    {
+      args: []string{"foo.go", "bar.go"},
+      want: result{CreatePkgs: []loader.PkgSpec{{
+        Filenames: []string{"foo.go", "bar.go"},
+      }}},
+    },
+    // Mixture of *.go and import paths.
+    {
+      args: []string{"foo.go", "fmt"},
+      want: result{
+        Err: "named files must be .go files: fmt",
+      },
+    },
+  } {
+    var conf loader.Config
+    rest, err := conf.FromArgs(test.args, test.tests)
+    got := result{
+      Rest:       rest,
+      ImportPkgs: conf.ImportPkgs,
+      CreatePkgs: conf.CreatePkgs,
+    }
+    if err != nil {
+      got.Err = err.Error()
+    }
+    if !reflect.DeepEqual(got, test.want) {
+      t.Errorf("FromArgs(%q) = %+v, want %+v", test.args, got, test.want)
+    }
+  }
+}
+
+func TestLoad_NoInitialPackages(t *testing.T) {
+  var conf loader.Config
+
+  const wantErr = "no initial packages were loaded"
+
+  prog, err := conf.Load()
   if err == nil {
-    prog, err = conf.Load()
+    t.Errorf("Load succeeded unexpectedly, want %q", wantErr)
+  } else if err.Error() != wantErr {
+    t.Errorf("Load failed with wrong error %q, want %q", err, wantErr)
+  }
+  if prog != nil {
+    t.Errorf("Load unexpectedly returned a Program")
   }
-  return
 }
 
-func TestLoadFromArgs(t *testing.T) {
-  // Failed load: bad first import path causes parsePackageFiles to fail.
-  args := []string{"nosuchpkg", "errors"}
-  if _, _, err := loadFromArgs(args); err == nil {
-    t.Errorf("loadFromArgs(%q) succeeded, want failure", args)
-  } else {
-    // cannot find package: ok.
-  }
+func TestLoad_MissingInitialPackage(t *testing.T) {
+  var conf loader.Config
+  conf.Import("nosuchpkg")
+  conf.Import("errors")
+
+  const wantErr = "couldn't load packages due to errors: nosuchpkg"
+
+  prog, err := conf.Load()
+  if err == nil {
+    t.Errorf("Load succeeded unexpectedly, want %q", wantErr)
+  } else if err.Error() != wantErr {
+    t.Errorf("Load failed with wrong error %q, want %q", err, wantErr)
+  }
+  if prog != nil {
+    t.Errorf("Load unexpectedly returned a Program")
+  }
 
-  // Failed load: bad second import path proceeds to doImport0, which fails.
-  args = []string{"errors", "nosuchpkg"}
-  if _, _, err := loadFromArgs(args); err == nil {
-    t.Errorf("loadFromArgs(%q) succeeded, want failure", args)
-  } else {
-    // cannot find package: ok
-  }
+func TestLoad_MissingInitialPackage_AllowErrors(t *testing.T) {
+  var conf loader.Config
+  conf.AllowErrors = true
+  conf.Import("nosuchpkg")
+  conf.ImportWithTests("errors")
+
+  prog, err := conf.Load()
+  if err != nil {
+    t.Errorf("Load failed unexpectedly: %v", err)
+  }
+  if prog == nil {
+    t.Fatalf("Load returned a nil Program")
+  }
+  if got, want := created(prog), "errors_test"; got != want {
+    t.Errorf("Created = %s, want %s", got, want)
+  }
+  if got, want := imported(prog), "errors"; got != want {
+    t.Errorf("Imported = %s, want %s", got, want)
+  }
 
-  // Successful load.
-  args = []string{"fmt", "errors", "--", "surplus"}
-  prog, rest, err := loadFromArgs(args)
+func TestCreateUnnamedPackage(t *testing.T) {
+  var conf loader.Config
+  conf.CreateFromFilenames("")
+  prog, err := conf.Load()
   if err != nil {
-    t.Fatalf("loadFromArgs(%q) failed: %s", args, err)
+    t.Fatalf("Load failed: %v", err)
   }
-  if got, want := fmt.Sprint(rest), "[surplus]"; got != want {
-    t.Errorf("loadFromArgs(%q) rest: got %s, want %s", args, got, want)
+  if got, want := fmt.Sprint(prog.InitialPackages()), "[(unnamed)]"; got != want {
+    t.Errorf("InitialPackages = %s, want %s", got, want)
   }
-  // Check list of Created packages.
-  var pkgnames []string
-  for _, info := range prog.Created {
-    pkgnames = append(pkgnames, info.Pkg.Path())
-  }
-  // All import paths may contribute tests.
-  if got, want := fmt.Sprint(pkgnames), "[fmt_test errors_test]"; got != want {
-    t.Errorf("Created: got %s, want %s", got, want)
-  }
-
-  // Check set of Imported packages.
-  pkgnames = nil
-  for path := range prog.Imported {
-    pkgnames = append(pkgnames, path)
-  }
-  sort.Strings(pkgnames)
-  // All import paths may contribute tests.
-  if got, want := fmt.Sprint(pkgnames), "[errors fmt]"; got != want {
-    t.Errorf("Loaded: got %s, want %s", got, want)
-  }
+
+func TestLoad_MissingFileInCreatedPackage(t *testing.T) {
+  var conf loader.Config
+  conf.CreateFromFilenames("", "missing.go")
+
+  const wantErr = "couldn't load packages due to errors: (unnamed)"
+
+  prog, err := conf.Load()
+  if prog != nil {
+    t.Errorf("Load unexpectedly returned a Program")
+  }
+  if err == nil {
+    t.Fatalf("Load succeeded unexpectedly, want %q", wantErr)
+  }
+  if err.Error() != wantErr {
+    t.Fatalf("Load failed with wrong error %q, want %q", err, wantErr)
+  }
 
+func TestLoad_MissingFileInCreatedPackage_AllowErrors(t *testing.T) {
+  conf := loader.Config{AllowErrors: true}
+  conf.CreateFromFilenames("", "missing.go")
+
+  prog, err := conf.Load()
+  if err != nil {
+    t.Errorf("Load failed: %v", err)
+  }
+  if got, want := fmt.Sprint(prog.InitialPackages()), "[(unnamed)]"; got != want {
+    t.Fatalf("InitialPackages = %s, want %s", got, want)
+  }
+}
+
+func TestLoad_ParseError(t *testing.T) {
+  var conf loader.Config
+  conf.CreateFromFilenames("badpkg", "testdata/badpkgdecl.go")
+
+  const wantErr = "couldn't load packages due to errors: badpkg"
+
+  prog, err := conf.Load()
+  if prog != nil {
+    t.Errorf("Load unexpectedly returned a Program")
+  }
+  if err == nil {
+    t.Fatalf("Load succeeded unexpectedly, want %q", wantErr)
+  }
+  if err.Error() != wantErr {
+    t.Fatalf("Load failed with wrong error %q, want %q", err, wantErr)
+  }
+}
+
+func TestLoad_ParseError_AllowErrors(t *testing.T) {
+  var conf loader.Config
+  conf.AllowErrors = true
+  conf.CreateFromFilenames("badpkg", "testdata/badpkgdecl.go")
+
+  prog, err := conf.Load()
+  if err != nil {
+    t.Errorf("Load failed unexpectedly: %v", err)
+  }
+  if prog == nil {
+    t.Fatalf("Load returned a nil Program")
+  }
+  if got, want := created(prog), "badpkg"; got != want {
+    t.Errorf("Created = %s, want %s", got, want)
+  }
+
+  badpkg := prog.Created[0]
+  if len(badpkg.Files) != 1 {
+    t.Errorf("badpkg has %d files, want 1", len(badpkg.Files))
+  }
+  wantErr := "testdata/badpkgdecl.go:1:34: expected 'package', found 'EOF'"
+  if !hasError(badpkg.Errors, wantErr) {
+    t.Errorf("badpkg.Errors = %v, want %s", badpkg.Errors, wantErr)
+  }
+}
+
+func TestLoad_FromSource_Success(t *testing.T) {
+  var conf loader.Config
+  conf.CreateFromFilenames("P", "testdata/a.go", "testdata/b.go")
+
+  prog, err := conf.Load()
+  if err != nil {
+    t.Errorf("Load failed unexpectedly: %v", err)
+  }
+  if prog == nil {
+    t.Fatalf("Load returned a nil Program")
+  }
+  if got, want := created(prog), "P"; got != want {
+    t.Errorf("Created = %s, want %s", got, want)
+  }
+}
+
+func TestLoad_FromImports_Success(t *testing.T) {
+  var conf loader.Config
+  conf.ImportWithTests("fmt")
+  conf.ImportWithTests("errors")
+
+  prog, err := conf.Load()
+  if err != nil {
+    t.Errorf("Load failed unexpectedly: %v", err)
+  }
+  if prog == nil {
+    t.Fatalf("Load returned a nil Program")
+  }
+  if got, want := created(prog), "errors_test fmt_test"; got != want {
+    t.Errorf("Created = %q, want %s", got, want)
+  }
+  if got, want := imported(prog), "errors fmt"; got != want {
+    t.Errorf("Imported = %s, want %s", got, want)
+  }
   // Check set of transitive packages.
   // There are >30 and the set may grow over time, so only check a few.
-  all := map[string]struct{}{}
-  for _, info := range prog.AllPackages {
-    all[info.Pkg.Path()] = struct{}{}
+  want := map[string]bool{
+    "strings": true,
+    "time":    true,
+    "runtime": true,
+    "testing": true,
+    "unicode": true,
+  }
+  for _, path := range all(prog) {
+    delete(want, path)
   }
-  want := []string{"strings", "time", "runtime", "testing", "unicode"}
-  for _, w := range want {
-    if _, ok := all[w]; !ok {
-      t.Errorf("AllPackages: want element %s, got set %v", w, all)
-    }
-  }
+  if len(want) > 0 {
+    t.Errorf("AllPackages is missing these keys: %q", keys(want))
+
+func TestLoad_MissingIndirectImport(t *testing.T) {
+  pkgs := map[string]string{
+    "a": `package a; import _ "b"`,
+    "b": `package b; import _ "c"`,
   }
+  conf := loader.Config{Build: fakeContext(pkgs)}
+  conf.Import("a")
+
+  const wantErr = "couldn't load packages due to errors: b"
 
-func TestLoadFromArgsSource(t *testing.T) {
-  // mixture of *.go/non-go.
-  args := []string{"testdata/a.go", "fmt"}
-  prog, _, err := loadFromArgs(args)
+  prog, err := conf.Load()
   if err == nil {
-    t.Errorf("loadFromArgs(%q) succeeded, want failure", args)
-  } else {
-    // "named files must be .go files: fmt": ok
+    t.Errorf("Load succeeded unexpectedly, want %q", wantErr)
+  } else if err.Error() != wantErr {
+    t.Errorf("Load failed with wrong error %q, want %q", err, wantErr)
+  }
+  if prog != nil {
+    t.Errorf("Load unexpectedly returned a Program")
+  }
+}
+
+func TestLoad_BadDependency_AllowErrors(t *testing.T) {
+  for _, test := range []struct {
+    descr    string
+    pkgs     map[string]string
+    wantPkgs string
+  }{
+
+    {
+      descr: "missing dependency",
+      pkgs: map[string]string{
+        "a": `package a; import _ "b"`,
+        "b": `package b; import _ "c"`,
+      },
+      wantPkgs: "a b",
+    },
+    {
+      descr: "bad package decl in dependency",
+      pkgs: map[string]string{
+        "a": `package a; import _ "b"`,
+        "b": `package b; import _ "c"`,
+        "c": `package`,
+      },
+      wantPkgs: "a b",
+    },
+    {
+      descr: "parse error in dependency",
+      pkgs: map[string]string{
+        "a": `package a; import _ "b"`,
+        "b": `package b; import _ "c"`,
+        "c": `package c; var x = `,
+      },
+      wantPkgs: "a b c",
+    },
+  } {
+    conf := loader.Config{
+      AllowErrors: true,
+      Build:       fakeContext(test.pkgs),
     }
+    conf.Import("a")
 
-  // successful load
-  args = []string{"testdata/a.go", "testdata/b.go"}
-  prog, _, err = loadFromArgs(args)
+    prog, err := conf.Load()
     if err != nil {
-    t.Fatalf("loadFromArgs(%q) failed: %s", args, err)
+      t.Errorf("%s: Load failed unexpectedly: %v", test.descr, err)
     }
-  if len(prog.Created) != 1 {
-    t.Errorf("loadFromArgs(%q): got %d items, want 1", args, len(prog.Created))
+    if prog == nil {
+      t.Fatalf("%s: Load returned a nil Program", test.descr)
     }
-  if len(prog.Created) > 0 {
-    path := prog.Created[0].Pkg.Path()
-    if path != "P" {
-      t.Errorf("loadFromArgs(%q): got %v, want [P]", prog.Created, path)
+
+    if got, want := imported(prog), "a"; got != want {
+      t.Errorf("%s: Imported = %s, want %s", test.descr, got, want)
+    }
+    if got := all(prog); strings.Join(got, " ") != test.wantPkgs {
+      t.Errorf("%s: AllPackages = %s, want %s", test.descr, got, test.wantPkgs)
     }
   }
 }
 
-type fakeFileInfo struct{}
-
-func (fakeFileInfo) Name() string       { return "x.go" }
-func (fakeFileInfo) Sys() interface{}   { return nil }
-func (fakeFileInfo) ModTime() time.Time { return time.Time{} }
-func (fakeFileInfo) IsDir() bool        { return false }
-func (fakeFileInfo) Size() int64        { return 0 }
-func (fakeFileInfo) Mode() os.FileMode  { return 0644 }
-
-var justXgo = [1]os.FileInfo{fakeFileInfo{}} // ["x.go"]
+func TestCwd(t *testing.T) {
+  ctxt := fakeContext(map[string]string{"one/two/three": `package three`})
+  for _, test := range []struct {
+    cwd, arg, want string
+  }{
+    {cwd: "/go/src/one", arg: "./two/three", want: "one/two/three"},
+    {cwd: "/go/src/one", arg: "../one/two/three", want: "one/two/three"},
+    {cwd: "/go/src/one", arg: "one/two/three", want: "one/two/three"},
+    {cwd: "/go/src/one/two/three", arg: ".", want: "one/two/three"},
+    {cwd: "/go/src/one", arg: "two/three", want: ""},
+  } {
+    conf := loader.Config{
+      Cwd:   test.cwd,
+      Build: ctxt,
+    }
+    conf.Import(test.arg)
 
-func fakeContext(pkgs map[string]string) *build.Context {
-  ctxt := build.Default // copy
-  ctxt.GOROOT = "/go"
-  ctxt.GOPATH = ""
-  ctxt.IsDir = func(path string) bool { return true }
-  ctxt.ReadDir = func(dir string) ([]os.FileInfo, error) { return justXgo[:], nil }
-  ctxt.OpenFile = func(path string) (io.ReadCloser, error) {
-    path = path[len("/go/src/"):]
-    return ioutil.NopCloser(bytes.NewBufferString(pkgs[path[0:1]])), nil
+    var got string
+    prog, err := conf.Load()
+    if prog != nil {
+      got = imported(prog)
+    }
+    if got != test.want {
+      t.Errorf("Load(%s) from %s: Imported = %s, want %s",
+        test.arg, test.cwd, got, test.want)
+      if err != nil {
+        t.Errorf("Load failed: %v", err)
+      }
+    }
   }
-  return &ctxt
 }
 
+// TODO(adonovan): more Load tests:
+//
+// failures:
+// - to parse package decl of *_test.go files
+// - to parse package decl of external *_test.go files
+// - to parse whole of *_test.go files
+// - to parse whole of external *_test.go files
+// - to open a *.go file during import scanning
+// - to import from binary
+
+// features:
+// - InitialPackages
+// - PackageCreated hook
+// - TypeCheckFuncBodies hook
+
 func TestTransitivelyErrorFreeFlag(t *testing.T) {
   // Create an minimal custom build.Context
   // that fakes the following packages:
   //
   // a --> b --> c!   c has an error
   //   \              d and e are transitively error-free.
   //    e --> d
   //
   // Each package [a-e] consists of one file, x.go.
   pkgs := map[string]string{
     "a": `package a; import (_ "b"; _ "e")`,
     "b": `package b; import _ "c"`,
     "c": `package c; func f() { _ = int(false) }`, // type error within function body
     "d": `package d;`,
     "e": `package e; import _ "d"`,
   }
   conf := loader.Config{
-    AllowErrors:   true,
-    SourceImports: true,
-    Build:         fakeContext(pkgs),
+    AllowErrors: true,
+    Build:       fakeContext(pkgs),
   }
   conf.Import("a")
 
   prog, err := conf.Load()
   if err != nil {
     t.Errorf("Load failed: %s", err)
   }
   if prog == nil {
for pkg, info := range prog.AllPackages {
 
     if info.TransitivelyErrorFree != wantTEF {
       t.Errorf("Package %q.TransitivelyErrorFree=%t, want %t",
         pkg.Path(), info.TransitivelyErrorFree, wantTEF)
     }
   }
 }
 
-// Test that both syntax (scan/parse) and type errors are both recorded
+// Test that syntax (scan/parse), type, and loader errors are recorded
 // (in PackageInfo.Errors) and reported (via Config.TypeChecker.Error).
 func TestErrorReporting(t *testing.T) {
   pkgs := map[string]string{
-    "a": `package a; import _ "b"; var x int = false`,
+    "a": `package a; import (_ "b"; _ "c"); var x int = false`,
     "b": `package b; 'syntax error!`,
   }
   conf := loader.Config{
-    AllowErrors:   true,
-    SourceImports: true,
-    Build:         fakeContext(pkgs),
+    AllowErrors: true,
+    Build:       fakeContext(pkgs),
   }
+  var mu sync.Mutex
   var allErrors []error
   conf.TypeChecker.Error = func(err error) {
+    mu.Lock()
     allErrors = append(allErrors, err)
+    mu.Unlock()
   }
   conf.Import("a")
 
   prog, err := conf.Load()
   if err != nil {
     t.Errorf("Load failed: %s", err)
   }
   if prog == nil {
     t.Fatalf("Load returned nil *Program")
   }
 
-  hasError := func(errors []error, substr string) bool {
-    for _, err := range errors {
-      if strings.Contains(err.Error(), substr) {
-        return true
-      }
-    }
-    return false
-  }
-
   // TODO(adonovan): test keys of ImportMap.
 
   // Check errors recorded in each PackageInfo.
   for pkg, info := range prog.AllPackages {
     switch pkg.Path() {
     case "a":
       if !hasError(info.Errors, "cannot convert false") {
         t.Errorf("a.Errors = %v, want bool conversion (type) error", info.Errors)
       }
+      if !hasError(info.Errors, "could not import c") {
+        t.Errorf("a.Errors = %v, want import (loader) error", info.Errors)
+      }
     case "b":
       if !hasError(info.Errors, "rune literal not terminated") {
         t.Errorf("b.Errors = %v, want unterminated literal (syntax) error", info.Errors)
       }
     }
   }
 
   // Check errors reported via error handler.
   if !hasError(allErrors, "cannot convert false") ||
-    !hasError(allErrors, "rune literal not terminated") {
-    t.Errorf("allErrors = %v, want both syntax and type errors", allErrors)
+    !hasError(allErrors, "rune literal not terminated") ||
+    !hasError(allErrors, "could not import c") {
+    t.Errorf("allErrors = %v, want syntax, type and loader errors", allErrors)
+  }
+}
+
+func TestCycles(t *testing.T) {
+  for _, test := range []struct {
+    descr   string
+    ctxt    *build.Context
+    wantErr string
+  }{
+    {
+      "self-cycle",
+      fakeContext(map[string]string{
+        "main":      `package main; import _ "selfcycle"`,
+        "selfcycle": `package selfcycle; import _ "selfcycle"`,
+      }),
+      `import cycle: selfcycle -> selfcycle`,
+    },
+    {
+      "three-package cycle",
+      fakeContext(map[string]string{
+        "main": `package main; import _ "a"`,
+        "a":    `package a; import _ "b"`,
+        "b":    `package b; import _ "c"`,
+        "c":    `package c; import _ "a"`,
+      }),
+      `import cycle: c -> a -> b -> c`,
+    },
+    {
+      "self-cycle in dependency of test file",
+      buildutil.FakeContext(map[string]map[string]string{
+        "main": {
+          "main.go":      `package main`,
+          "main_test.go": `package main; import _ "a"`,
+        },
+        "a": {
+          "a.go": `package a; import _ "a"`,
+        },
+      }),
+      `import cycle: a -> a`,
+    },
+    // TODO(adonovan): fix: these fail
+    // {
+    //  "two-package cycle in dependency of test file",
+    //  buildutil.FakeContext(map[string]map[string]string{
+    //    "main": {
+    //      "main.go":      `package main`,
+    //      "main_test.go": `package main; import _ "a"`,
+    //    },
+    //    "a": {
+    //      "a.go": `package a; import _ "main"`,
+    //    },
+    //  }),
+    //  `import cycle: main -> a -> main`,
+    // },
+    // {
+    //  "self-cycle in augmented package",
+    //  buildutil.FakeContext(map[string]map[string]string{
+    //    "main": {
+    //      "main.go":      `package main`,
+    //      "main_test.go": `package main; import _ "main"`,
+    //    },
+    //  }),
+    //  `import cycle: main -> main`,
+    // },
+  } {
+    conf := loader.Config{
+      AllowErrors: true,
+      Build:       test.ctxt,
+    }
+    var mu sync.Mutex
+    var allErrors []error
+    conf.TypeChecker.Error = func(err error) {
+      mu.Lock()
+      allErrors = append(allErrors, err)
+      mu.Unlock()
+    }
+    conf.ImportWithTests("main")
+
+    prog, err := conf.Load()
+    if err != nil {
+      t.Errorf("%s: Load failed: %s", test.descr, err)
+    }
+    if prog == nil {
+      t.Fatalf("%s: Load returned nil *Program", test.descr)
+    }
+
+    if !hasError(allErrors, test.wantErr) {
+      t.Errorf("%s: Load() errors = %q, want %q",
+        test.descr, allErrors, test.wantErr)
+    }
+  }
+
+  // TODO(adonovan):
+  // - Test that in a legal test cycle, none of the symbols
+  //   defined by augmentation are visible via import.
+}
+
+// ---- utilities ----
+
+// Simplifying wrapper around buildutil.FakeContext for single-file packages.
+func fakeContext(pkgs map[string]string) *build.Context {
+  pkgs2 := make(map[string]map[string]string)
+  for path, content := range pkgs {
+    pkgs2[path] = map[string]string{"x.go": content}
+  }
+  return buildutil.FakeContext(pkgs2)
+}
+
+func hasError(errors []error, substr string) bool {
+  for _, err := range errors {
+    if strings.Contains(err.Error(), substr) {
+      return true
+    }
+  }
+  return false
+}
+
+func keys(m map[string]bool) (keys []string) {
+  for key := range m {
+    keys = append(keys, key)
+  }
+  sort.Strings(keys)
+  return
+}
+
+// Returns all loaded packages.
+func all(prog *loader.Program) []string {
+  var pkgs []string
+  for _, info := range prog.AllPackages {
+    pkgs = append(pkgs, info.Pkg.Path())
+  }
+  sort.Strings(pkgs)
+  return pkgs
+}
+
+// Returns initially imported packages, as a string.
+func imported(prog *loader.Program) string {
+  var pkgs []string
+  for _, info := range prog.Imported {
+    pkgs = append(pkgs, info.Pkg.Path())
+  }
+  sort.Strings(pkgs)
+  return strings.Join(pkgs, " ")
+}
+
+// Returns initially created packages, as a string.
+func created(prog *loader.Program) string {
+  var pkgs []string
+  for _, info := range prog.Created {
+    pkgs = append(pkgs, info.Pkg.Path())
   }
+  return strings.Join(pkgs, " ")
 }

llgo/trunk/third_party/gotools/go/loader/stdlib_test.go

func TestStdlib(t *testing.T) {
   runtime.ReadMemStats(&memstats)
   alloc := memstats.Alloc
 
   // Load, parse and type-check the program.
   ctxt := build.Default // copy
   ctxt.GOPATH = ""      // disable GOPATH
   conf := loader.Config{Build: &ctxt}
   for _, path := range buildutil.AllPackages(conf.Build) {
-    if err := conf.ImportWithTests(path); err != nil {
-      t.Error(err)
-    }
+    conf.ImportWithTests(path)
   }
 
   prog, err := conf.Load()
   if err != nil {
     t.Fatalf("Load failed: %v", err)
   }
 
   t1 := time.Now()

llgo/trunk/third_party/gotools/go/loader/testdata/badpkgdecl.go

+// this file has no package decl

llgo/trunk/third_party/gotools/go/loader/util.go

 // 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 loader
 
 import (
   "go/ast"
   "go/build"
   "go/parser"
   "go/token"
   "io"
   "os"
-  "path/filepath"
+  "strconv"
   "sync"
+
+  "llvm.org/llgo/third_party/gotools/go/buildutil"
 )
 
 // parseFiles parses the Go source files within directory dir and
 // returns the ASTs of the ones that could be at least partially parsed,
 // along with a list of I/O and parse errors encountered.
 //
 // I/O is done via ctxt, which may specify a virtual file system.
 // displayPath is used to transform the filenames attached to the ASTs.
 //
 func parseFiles(fset *token.FileSet, ctxt *build.Context, displayPath func(string) string, dir string, files []string, mode parser.Mode) ([]*ast.File, []error) {
   if displayPath == nil {
     displayPath = func(path string) string { return path }
   }
-  isAbs := filepath.IsAbs
-  if ctxt.IsAbsPath != nil {
-    isAbs = ctxt.IsAbsPath
-  }
-  joinPath := filepath.Join
-  if ctxt.JoinPath != nil {
-    joinPath = ctxt.JoinPath
-  }
   var wg sync.WaitGroup
   n := len(files)
   parsed := make([]*ast.File, n)
   errors := make([]error, n)
   for i, file := range files {
-    if !isAbs(file) {
-      file = joinPath(dir, file)
+    if !buildutil.IsAbsPath(ctxt, file) {
+      file = buildutil.JoinPath(ctxt, dir, file)
     }
     wg.Add(1)
     go func(i int, file string) {
       defer wg.Done()
       var rd io.ReadCloser
       var err error
       if ctxt.OpenFile != nil {
         rd, err = ctxt.OpenFile(file)
if err != nil {
       o++
     }
   }
   errors = errors[:o]
 
   return parsed, errors
 }
 
+// scanImports returns the set of all package import paths from all
+// import specs in the specified files.
+func scanImports(files []*ast.File) map[string]bool {
+  imports := make(map[string]bool)
+  for _, f := range files {
+    for _, decl := range f.Decls {
+      if decl, ok := decl.(*ast.GenDecl); ok && decl.Tok == token.IMPORT {
+        for _, spec := range decl.Specs {
+          spec := spec.(*ast.ImportSpec)
+
+          // NB: do not assume the program is well-formed!
+          path, err := strconv.Unquote(spec.Path.Value)
+          if err != nil {
+            continue // quietly ignore the error
+          }
+          if path == "C" || path == "unsafe" {
+            continue // skip pseudo packages
+          }
+          imports[path] = true
+        }
+      }
+    }
+  }
+  return imports
+}
+
 // ---------- Internal helpers ----------
 
 // TODO(adonovan): make this a method: func (*token.File) Contains(token.Pos)
 func tokenFileContainsPos(f *token.File, pos token.Pos) bool {
   p := int(pos)
   base := f.Base()
   return base <= p && p < base+f.Size()
 }

llgo/trunk/third_party/gotools/go/pointer/analysis.go

func Analyze(config *Config) (result *Result, err error) {
   }
 
   // Pointer analysis requires a complete program for soundness.
   // Check to prevent accidental misconfiguration.
   for _, pkg := range a.prog.AllPackages() {
     // (This only checks that the package scope is complete,
     // not that func bodies exist, but it's a good signal.)
     if !pkg.Object.Complete() {
-      return nil, fmt.Errorf(`pointer analysis requires a complete program yet package %q was incomplete (set loader.Config.SourceImports during loading)`, pkg.Object.Path())
+      return nil, fmt.Errorf(`pointer analysis requires a complete program yet package %q was incomplete (don't set loader.Config.ImportFromBinary during loading)`, pkg.Object.Path())
     }
   }
 
   if reflect := a.prog.ImportedPackage("reflect"); reflect != nil {
     rV := reflect.Object.Scope().Lookup("Value")
     a.reflectValueObj = rV
     a.reflectValueCall = a.prog.LookupMethod(rV.Type(), nil, "Call")
     a.reflectType = reflect.Object.Scope().Lookup("Type").Type().(*types.Named)

llgo/trunk/third_party/gotools/go/pointer/api.go

import (
   "llvm.org/llgo/third_party/gotools/go/types/typeutil"
 )
 
 // A Config formulates a pointer analysis problem for Analyze().
 type Config struct {
   // Mains contains the set of 'main' packages to analyze
   // Clients must provide the analysis with at least one
   // package defining a main() function.
+  //
+  // Non-main packages in the ssa.Program that are not
+  // dependencies of any main package may still affect the
+  // analysis result, because they contribute runtime types and
+  // thus methods.
+  // TODO(adonovan): investigate whether this is desirable.
   Mains []*ssa.Package
 
   // Reflection determines whether to handle reflection
   // operators soundly, which is currently rather slow since it
   // causes constraint to be generated during solving
   // proportional to the number of constraint variables, which
   // has not yet been reduced by presolver optimisation.
   Reflection bool

llgo/trunk/third_party/gotools/go/pointer/example_test.go

 }
 
 func main() {
   var i I = C{}
   x := map[string]int{"one":1}
   i.f(x) // dynamic method call
 }
 `
-  // Construct a loader.
-  conf := loader.Config{SourceImports: true}
+  var conf loader.Config
 
-  // Parse the input file.
+  // Parse the input file, a string.
+  // (Command-line tools should use conf.FromArgs.)
   file, err := conf.ParseFile("myprog.go", myprog)
   if err != nil {
     fmt.Print(err) // parse error
     return
   }
 
   // Create single-file main package and import its dependencies.
   conf.CreateFromFiles("main", file)

llgo/trunk/third_party/gotools/go/pointer/gen.go

func (a *analysis) generate() {
   root := a.genRootCalls()
 
   if a.config.BuildCallGraph {
     a.result.CallGraph = callgraph.New(root.fn)
   }
 
   // Create nodes and constraints for all methods of all types
   // that are dynamically accessible via reflection or interfaces.
-  for _, T := range a.prog.TypesWithMethodSets() {
+  for _, T := range a.prog.RuntimeTypes() {
     a.genMethodsOf(T)
   }
 
   // Generate constraints for entire program.
   for len(a.genq) > 0 {
     cgn := a.genq[0]
     a.genq = a.genq[1:]
     a.genFunc(cgn)

llgo/trunk/third_party/gotools/go/pointer/pointer_test.go

if pos.Line == e.linenum && pos.Filename == e.filename {
       //  e.filename, e.linenum, e, p.arg0) // debugging
       return call, queries[call.Args[0]].PointsTo()
     }
   }
   return // e.g. analysis didn't reach this call
 }
 
 func doOneInput(input, filename string) bool {
-  conf := loader.Config{SourceImports: true}
+  var conf loader.Config
 
   // Parsing.
   f, err := conf.ParseFile(filename, input)
   if err != nil {
     fmt.Println(err)
     return false
   }
 

llgo/trunk/third_party/gotools/go/pointer/stdlib_test.go

 func TestStdlib(t *testing.T) {
   if !*runStdlibTest {
     t.Skip("skipping (slow) stdlib test (use --stdlib)")
   }
 
   // Load, parse and type-check the program.
   ctxt := build.Default // copy
   ctxt.GOPATH = ""      // disable GOPATH
-  conf := loader.Config{
-    SourceImports: true,
-    Build:         &ctxt,
-  }
+  conf := loader.Config{Build: &ctxt}
   if _, err := conf.FromArgs(buildutil.AllPackages(conf.Build), true); err != nil {
     t.Errorf("FromArgs failed: %v", err)
     return
   }
 
   iprog, err := conf.Load()
   if err != nil {
     t.Fatalf("Load failed: %v", err)

llgo/trunk/third_party/gotools/go/pointer/util.go

case *types.Named:
     }
     return CanHaveDynamicTypes(T.Underlying())
   case *types.Interface:
     return true
   }
   return false
 }
 
-// isInterface reports whether T is an interface type.
-func isInterface(T types.Type) bool {
-  _, ok := T.Underlying().(*types.Interface)
-  return ok
-}
+func isInterface(T types.Type) bool { return types.IsInterface(T) }
 
 // mustDeref returns the element type of its argument, which must be a
 // pointer; panic ensues otherwise.
 func mustDeref(typ types.Type) types.Type {
   return typ.Underlying().(*types.Pointer).Elem()
 }
 
 // deref returns a pointer's element type; otherwise it returns typ.

llgo/trunk/third_party/gotools/go/ssa/builder.go

case *ast.CompositeLit:
     t := deref(fn.Pkg.typeOf(e))
     var v *Alloc
     if escaping {
       v = emitNew(fn, t, e.Lbrace)
     } else {
       v = fn.addLocal(t, e.Lbrace)
     }
     v.Comment = "complit"
-    b.compLit(fn, v, e, true) // initialize in place
+    var sb storebuf
+    b.compLit(fn, v, e, true, &sb)
+    sb.emit(fn)
     return &address{addr: v, pos: e.Lbrace, expr: e}
 
   case *ast.ParenExpr:
     return b.addr(fn, e.X, escaping)
 
   case *ast.SelectorExpr:
     sel, ok := fn.Pkg.info.Selections[e]
     if !ok {
func (b *builder) addr(fn *Function, e ast.Expr, escaping bool) lvalue {
 
   case *ast.StarExpr:
     return &address{addr: b.expr(fn, e.X), pos: e.Star, expr: e}
   }
 
   panic(fmt.Sprintf("unexpected address expression: %T", e))
 }
 
-// exprInPlace emits to fn code to initialize the lvalue loc with the
-// value of expression e. If isZero is true, exprInPlace assumes that loc
-// holds the zero value for its type.
-//
-// This is equivalent to loc.store(fn, b.expr(fn, e)) but may
-// generate better code in some cases, e.g. for composite literals
-// in an addressable location.
+type store struct {
+  lhs lvalue
+  rhs Value
+}
+
+type storebuf struct{ stores []store }
+
+func (sb *storebuf) store(lhs lvalue, rhs Value) {
+  sb.stores = append(sb.stores, store{lhs, rhs})
+}
+
+func (sb *storebuf) emit(fn *Function) {
+  for _, s := range sb.stores {
+    s.lhs.store(fn, s.rhs)
+  }
+}
+
+// assign emits to fn code to initialize the lvalue loc with the value
+// of expression e.  If isZero is true, assign assumes that loc holds
+// the zero value for its type.
+//
+// This is equivalent to loc.store(fn, b.expr(fn, e)), but may generate
+// better code in some cases, e.g., for composite literals in an
+// addressable location.
+//
+// If sb is not nil, assign generates code to evaluate expression e, but
+// not to update loc.  Instead, the necessary stores are appended to the
+// storebuf sb so that they can be executed later.  This allows correct
+// in-place update of existing variables when the RHS is a composite
+// literal that may reference parts of the LHS.
 //
-func (b *builder) exprInPlace(fn *Function, loc lvalue, e ast.Expr, isZero bool) {
+func (b *builder) assign(fn *Function, loc lvalue, e ast.Expr, isZero bool, sb *storebuf) {
+  // Can we initialize it in place?
   if e, ok := unparen(e).(*ast.CompositeLit); ok {
     // A CompositeLit never evaluates to a pointer,
     // so if the type of the location is a pointer,
     // an &-operation is implied.
     if _, ok := loc.(blank); !ok { // avoid calling blank.typ()
       if isPointer(loc.typ()) {
         ptr := b.addr(fn, e, true).address(fn)
-        loc.store(fn, ptr) // copy address
+        // copy address
+        if sb != nil {
+          sb.store(loc, ptr)
+        } else {
+          loc.store(fn, ptr)
+        }
         return
       }
     }
 
     if _, ok := loc.(*address); ok {
       if isInterface(loc.typ()) {
         // e.g. var x interface{} = T{...}
         // Can't in-place initialize an interface value.
         // Fall back to copying.
       } else {
+        // x = T{...} or x := T{...}
         addr := loc.address(fn)
-        b.compLit(fn, addr, e, isZero) // in place
+        if sb != nil {
+          b.compLit(fn, addr, e, isZero, sb)
+        } else {
+          var sb storebuf
+          b.compLit(fn, addr, e, isZero, &sb)
+          sb.emit(fn)
+        }
+
+        // Subtle: emit debug ref for aggregate types only;
+        // slice and map are handled by store ops in compLit.
+        switch loc.typ().Underlying().(type) {
+        case *types.Struct, *types.Array:
           emitDebugRef(fn, e, addr, true)
+        }
+
         return
       }
     }
   }
-  loc.store(fn, b.expr(fn, e)) // copy value
+
+  // simple case: just copy
+  rhs := b.expr(fn, e)
+  if sb != nil {
+    sb.store(loc, rhs)
+  } else {
+    loc.store(fn, rhs)
+  }
 }
 
 // expr lowers a single-result expression e to SSA form, emitting code
 // to fn and returning the Value defined by the expression.
 //
 func (b *builder) expr(fn *Function, e ast.Expr) Value {
   e = unparen(e)
 
case *ast.SliceExpr:
     var x Value
     switch fn.Pkg.typeOf(e.X).Underlying().(type) {
     case *types.Array:
       // Potentially escaping.
       x = b.addr(fn, e.X, true).address(fn)
     case *types.Basic, *types.Slice, *types.Pointer: // *array
       x = b.expr(fn, e.X)
     default:
-      unreachable()
+      panic("unreachable")
     }
     if e.High != nil {
       high = b.expr(fn, e.High)
     }
     if e.Low != nil {
       low = b.expr(fn, e.Low)
     }
     if e.Slice3 {
func (b *builder) localValueSpec(fn *Function, spec *ast.ValueSpec) {
   case len(spec.Values) == len(spec.Names):
     // e.g. var x, y = 0, 1
     // 1:1 assignment
     for i, id := range spec.Names {
       if !isBlankIdent(id) {
         fn.addLocalForIdent(id)
       }
       lval := b.addr(fn, id, false) // non-escaping
-      b.exprInPlace(fn, lval, spec.Values[i], true)
+      b.assign(fn, lval, spec.Values[i], true, nil)
     }
 
   case len(spec.Values) == 0:
     // e.g. var x, y int
     // Locals are implicitly zero-initialized.
     for _, id := range spec.Names {
       if !isBlankIdent(id) {
         lhs := fn.addLocalForIdent(id)

 
 // assignStmt emits code to fn for a parallel assignment of rhss to lhss.
 // isDef is true if this is a short variable declaration (:=).
 //
 // Note the similarity with localValueSpec.
 //
 func (b *builder) assignStmt(fn *Function, lhss, rhss []ast.Expr, isDef bool) {
   // Side effects of all LHSs and RHSs must occur in left-to-right order.
-  var lvals []lvalue
-  for _, lhs := range lhss {
+  lvals := make([]lvalue, len(lhss))
+  isZero := make([]bool, len(lhss))
+  for i, lhs := range lhss {
     var lval lvalue = blank{}
     if !isBlankIdent(lhs) {
       if isDef {
         if obj := fn.Pkg.info.Defs[lhs.(*ast.Ident)]; obj != nil {
           fn.addNamedLocal(obj)
+          isZero[i] = true
         }
       }
       lval = b.addr(fn, lhs, false) // non-escaping
     }
-    lvals = append(lvals, lval)
+    lvals[i] = lval
   }
   if len(lhss) == len(rhss) {
-    // e.g. x, y = f(), g()
-    if len(lhss) == 1 {
-      // x = type{...}
-      // Optimization: in-place construction
-      // of composite literals.
-      b.exprInPlace(fn, lvals[0], rhss[0], false)
-    } else {
-      // Parallel assignment.  All reads must occur
-      // before all updates, precluding exprInPlace.
-      var rvals []Value
-      for _, rval := range rhss {
-        rvals = append(rvals, b.expr(fn, rval))
-      }
-      for i, lval := range lvals {
-        lval.store(fn, rvals[i])
-      }
+    // Simple assignment:   x     = f()        (!isDef)
+    // Parallel assignment: x, y  = f(), g()   (!isDef)
+    // or short var decl:   x, y := f(), g()   (isDef)
+    //
+    // In all cases, the RHSs may refer to the LHSs,
+    // so we need a storebuf.
+    var sb storebuf
+    for i := range rhss {
+      b.assign(fn, lvals[i], rhss[i], isZero[i], &sb)
     }
+    sb.emit(fn)
   } else {
     // e.g. x, y = pos()
     tuple := b.exprN(fn, rhss[0])
     for i, lval := range lvals {
       lval.store(fn, emitExtract(fn, tuple, i))
     }
   }
 }
for _, e := range elts {
     if i > max {
       max = i
     }
   }
   return max + 1
 }
 
 // compLit emits to fn code to initialize a composite literal e at
-// address addr with type typ, typically allocated by Alloc.
+// address addr with type typ.
+//
 // Nested composite literals are recursively initialized in place
 // where possible. If isZero is true, compLit assumes that addr
 // holds the zero value for typ.
 //
+// Because the elements of a composite literal may refer to the
+// variables being updated, as in the second line below,
+//  x := T{a: 1}
+//  x = T{a: x.a}
+// all the reads must occur before all the writes.  Thus all stores to
+// loc are emitted to the storebuf sb for later execution.
+//
 // A CompositeLit may have pointer type only in the recursive (nested)
 // case when the type name is implicit.  e.g. in []*T{{}}, the inner
 // literal has type *T behaves like &T{}.
 // In that case, addr must hold a T, not a *T.
 //
-func (b *builder) compLit(fn *Function, addr Value, e *ast.CompositeLit, isZero bool) {
+func (b *builder) compLit(fn *Function, addr Value, e *ast.CompositeLit, isZero bool, sb *storebuf) {
   typ := deref(fn.Pkg.typeOf(e))
   switch t := typ.Underlying().(type) {
   case *types.Struct:
     if !isZero && len(e.Elts) != t.NumFields() {
-      emitMemClear(fn, addr, e.Lbrace)
+      // memclear
+      sb.store(&address{addr, e.Lbrace, nil},
+        zeroValue(fn, deref(addr.Type())))
       isZero = true
     }
     for i, e := range e.Elts {
       fieldIndex := i
       pos := e.Pos()
       if kv, ok := e.(*ast.KeyValueExpr); ok {
         fname := kv.Key.(*ast.Ident).Name
         for i, n := 0, t.NumFields(); i < n; i++ {
           sf := t.Field(i)
           if sf.Name() == fname {
             fieldIndex = i
             pos = kv.Colon
             e = kv.Value
             break
           }
         }
       }
       sf := t.Field(fieldIndex)
       faddr := &FieldAddr{
         X:     addr,
         Field: fieldIndex,
       }
       faddr.setType(types.NewPointer(sf.Type()))
       fn.emit(faddr)
-      b.exprInPlace(fn, &address{addr: faddr, pos: pos, expr: e}, e, isZero)
+      b.assign(fn, &address{addr: faddr, pos: pos, expr: e}, e, isZero, sb)
     }
 
   case *types.Array, *types.Slice:
     var at *types.Array
     var array Value
     switch t := t.(type) {
     case *types.Slice:
       at = types.NewArray(t.Elem(), b.arrayLen(fn, e.Elts))
       alloc := emitNew(fn, at, e.Lbrace)
       alloc.Comment = "slicelit"
       array = alloc
-      isZero = true
     case *types.Array:
       at = t
       array = addr
-    }
 
       if !isZero && int64(len(e.Elts)) != at.Len() {
-      emitMemClear(fn, array, e.Lbrace)
-      isZero = true
+        // memclear
+        sb.store(&address{array, e.Lbrace, nil},
+          zeroValue(fn, deref(array.Type())))
+      }
     }
 
     var idx *Const
     for _, e := range e.Elts {
+      pos := e.Pos()
       if kv, ok := e.(*ast.KeyValueExpr); ok {
         idx = b.expr(fn, kv.Key).(*Const)
+        pos = kv.Colon
         e = kv.Value
       } else {
         var idxval int64
         if idx != nil {
           idxval = idx.Int64() + 1
         }
         idx = intConst(idxval)
       }
       iaddr := &IndexAddr{
         X:     array,
         Index: idx,
       }
       iaddr.setType(types.NewPointer(at.Elem()))
       fn.emit(iaddr)
-      b.exprInPlace(fn, &address{addr: iaddr, pos: e.Pos(), expr: e}, e, isZero)
+      if t != at { // slice
+        // backing array is unaliased => storebuf not needed.
+        b.assign(fn, &address{addr: iaddr, pos: pos, expr: e}, e, true, nil)
+      } else {
+        b.assign(fn, &address{addr: iaddr, pos: pos, expr: e}, e, true, sb)
       }
+    }
+
     if t != at { // slice
       s := &Slice{X: array}
       s.setPos(e.Lbrace)
       s.setType(typ)
-      emitStore(fn, addr, fn.emit(s), e.Lbrace)
+      sb.store(&address{addr: addr, pos: e.Lbrace, expr: e}, fn.emit(s))
     }
 
   case *types.Map:
     m := &MakeMap{Reserve: intConst(int64(len(e.Elts)))}
     m.setPos(e.Lbrace)
     m.setType(typ)
-    emitStore(fn, addr, fn.emit(m), e.Lbrace)
+    fn.emit(m)
     for _, e := range e.Elts {
       e := e.(*ast.KeyValueExpr)
-      loc := &element{
+      loc := element{
         m:   m,
         k:   emitConv(fn, b.expr(fn, e.Key), t.Key()),
         t:   t.Elem(),
         pos: e.Colon,
       }
-      b.exprInPlace(fn, loc, e.Value, true)
+
+      // We call assign() only because it takes care
+      // of any &-operation required in the recursive
+      // case, e.g.,
+      // map[int]*struct{}{0: {}} implies &struct{}{}.
+      // In-place update is of course impossible,
+      // and no storebuf is needed.
+      b.assign(fn, &loc, e.Value, true, nil)
     }
+    sb.store(&address{addr: addr, pos: e.Lbrace, expr: e}, m)
 
   default:
     panic("unexpected CompositeLit type: " + t.String())
   }
 }
 
 // switchStmt emits to fn code for the switch statement s, optionally
 // labelled by label.

 // buildFuncDecl builds SSA code for the function or method declared
 // by decl in package pkg.
 //
 func (b *builder) buildFuncDecl(pkg *Package, decl *ast.FuncDecl) {
   id := decl.Name
   if isBlankIdent(id) {
     return // discard
   }
-  var fn *Function
+  fn := pkg.values[pkg.info.Defs[id]].(*Function)
   if decl.Recv == nil && id.Name == "init" {
-    pkg.ninit++
-    fn = &Function{
-      name:      fmt.Sprintf("init#%d", pkg.ninit),
-      Signature: new(types.Signature),
-      pos:       decl.Name.NamePos,
-      Pkg:       pkg,
-      Prog:      pkg.Prog,
-      syntax:    decl,
-    }
-
     var v Call
     v.Call.Value = fn
     v.setType(types.NewTuple())
     pkg.init.emit(&v)
-  } else {
-    fn = pkg.values[pkg.info.Defs[id]].(*Function)
   }
   b.buildFunction(fn)
 }
 
 // BuildAll calls Package.Build() for each package in prog.
 // Building occurs in parallel unless the BuildSerially mode flag was set.
 //
 // BuildAll is idempotent and thread-safe.
if len(p.info.Files) == 0 {
     return // package loaded from export data
   }
 
   // Ensure we have runtime type info for all exported members.
   // TODO(adonovan): ideally belongs in memberFromObject, but
   // that would require package creation in topological order.
   for name, mem := range p.Members {
     if ast.IsExported(name) {
-      p.needMethodsOf(mem.Type())
+      p.Prog.needMethodsOf(mem.Type())
     }
   }
   if p.Prog.mode&LogSource != 0 {
     defer logStack("build %s", p)()
   }
   init := p.init
   init.startBody()
 
for _, varinit := range p.info.InitOrder {
     if len(varinit.Lhs) == 1 {
       // 1:1 initialization: var x, y = a(), b()
       var lval lvalue
       if v := varinit.Lhs[0]; v.Name() != "_" {
         lval = &address{addr: p.values[v].(*Global), pos: v.Pos()}
       } else {
         lval = blank{}
       }
-      b.exprInPlace(init, lval, varinit.Rhs, true)
+      b.assign(init, lval, varinit.Rhs, true, nil)
     } else {
       // n:1 initialization: var x, y :=  f()
       tuple := b.exprN(init, varinit.Rhs)
       for i, v := range varinit.Lhs {
         if v.Name() == "_" {
           continue
         }
         emitStore(init, p.values[v].(*Global), emitExtract(init, tuple, i), v.Pos())

 // Only valid during p's create and build phases.
 func (p *Package) typeOf(e ast.Expr) types.Type {
   if T := p.info.TypeOf(e); T != nil {
     return T
   }
   panic(fmt.Sprintf("no type for %T @ %s",
     e, p.Prog.Fset.Position(e.Pos())))
 }
-
-// needMethodsOf ensures that runtime type information (including the
-// complete method set) is available for the specified type T and all
-// its subcomponents.
-//
-// needMethodsOf must be called for at least every type that is an
-// operand of some MakeInterface instruction, and for the type of
-// every exported package member.
-//
-// Precondition: T is not a method signature (*Signature with Recv()!=nil).
-//
-// Thread-safe.  (Called via emitConv from multiple builder goroutines.)
-//
-// TODO(adonovan): make this faster.  It accounts for 20% of SSA build
-// time.  Do we need to maintain a distinct needRTTI and methodSets per
-// package?  Using just one in the program might be much faster.
-//
-func (p *Package) needMethodsOf(T types.Type) {
-  p.methodsMu.Lock()
-  p.needMethods(T, false)
-  p.methodsMu.Unlock()
-}
-
-// Precondition: T is not a method signature (*Signature with Recv()!=nil).
-// Precondition: the p.methodsMu lock is held.
-// Recursive case: skip => don't call makeMethods(T).
-func (p *Package) needMethods(T types.Type, skip bool) {
-  // Each package maintains its own set of types it has visited.
-  if prevSkip, ok := p.needRTTI.At(T).(bool); ok {
-    // needMethods(T) was previously called
-    if !prevSkip || skip {
-      return // already seen, with same or false 'skip' value
-    }
-  }
-  p.needRTTI.Set(T, skip)
-
-  // Prune the recursion if we find a named or *named type
-  // belonging to another package.
-  var n *types.Named
-  switch T := T.(type) {
-  case *types.Named:
-    n = T
-  case *types.Pointer:
-    n, _ = T.Elem().(*types.Named)
-  }
-  if n != nil {
-    owner := n.Obj().Pkg()
-    if owner == nil {
-      return // built-in error type
-    }
-    if owner != p.Object {
-      return // belongs to another package
-    }
-  }
-
-  // All the actual method sets live in the Program so that
-  // multiple packages can share a single copy in memory of the
-  // symbols that would be compiled into multiple packages (as
-  // weak symbols).
-  if !skip && p.Prog.makeMethods(T) {
-    p.methodSets = append(p.methodSets, T)
-  }
-
-  // Recursion over signatures of each method.
-  tmset := p.Prog.MethodSets.MethodSet(T)
-  for i := 0; i < tmset.Len(); i++ {
-    sig := tmset.At(i).Type().(*types.Signature)
-    p.needMethods(sig.Params(), false)
-    p.needMethods(sig.Results(), false)
-  }
-
-  switch t := T.(type) {
-  case *types.Basic:
-    // nop
-
-  case *types.Interface:
-    // nop---handled by recursion over method set.
-
-  case *types.Pointer:
-    p.needMethods(t.Elem(), false)
-
-  case *types.Slice:
-    p.needMethods(t.Elem(), false)
-
-  case *types.Chan:
-    p.needMethods(t.Elem(), false)
-
-  case *types.Map:
-    p.needMethods(t.Key(), false)
-    p.needMethods(t.Elem(), false)
-
-  case *types.Signature:
-    if t.Recv() != nil {
-      panic(fmt.Sprintf("Signature %s has Recv %s", t, t.Recv()))
-    }
-    p.needMethods(t.Params(), false)
-    p.needMethods(t.Results(), false)
-
-  case *types.Named:
-    // A pointer-to-named type can be derived from a named
-    // type via reflection.  It may have methods too.
-    p.needMethods(types.NewPointer(T), false)
-
-    // Consider 'type T struct{S}' where S has methods.
-    // Reflection provides no way to get from T to struct{S},
-    // only to S, so the method set of struct{S} is unwanted,
-    // so set 'skip' flag during recursion.
-    p.needMethods(t.Underlying(), true)
-
-  case *types.Array:
-    p.needMethods(t.Elem(), false)
-
-  case *types.Struct:
-    for i, n := 0, t.NumFields(); i < n; i++ {
-      p.needMethods(t.Field(i).Type(), false)
-    }
-
-  case *types.Tuple:
-    for i, n := 0, t.Len(); i < n; i++ {
-      p.needMethods(t.At(i).Type(), false)
-    }
-
-  default:
-    panic(T)
-  }
-}

llgo/trunk/third_party/gotools/go/ssa/builder_test.go

import (
   "llvm.org/llgo/third_party/gotools/go/ssa/ssautil"
   "llvm.org/llgo/third_party/gotools/go/types"
 )
 
 func isEmpty(f *ssa.Function) bool { return f.Blocks == nil }
 
 // Tests that programs partially loaded from gc object files contain
 // functions with no code for the external portions, but are otherwise ok.
-func TestExternalPackages(t *testing.T) {
+func TestImportFromBinary(t *testing.T) {
   test := `
 package main
 
 import (
   "bytes"
   "io"
   "testing"
 )
 
 func main() {
         var t testing.T
   t.Parallel()    // static call to external declared method
         t.Fail()        // static call to promoted external declared method
         testing.Short() // static call to external package-level function
 
         var w io.Writer = new(bytes.Buffer)
         w.Write(nil)    // interface invoke of external declared method
 }
 `
 
   // Create a single-file main package.
-  var conf loader.Config
+  conf := loader.Config{ImportFromBinary: true}
   f, err := conf.ParseFile("<input>", test)
   if err != nil {
     t.Error(err)
     return
   }
   conf.CreateFromFiles("main", f)
 
   iprog, err := conf.Load()
for _, instr := range b.Instrs {
       }
     }
   }
   if callNum != 4 {
     t.Errorf("in main.main: got %d calls, want %d", callNum, 4)
   }
 }
 
-// TestTypesWithMethodSets tests that Package.TypesWithMethodSets includes all necessary types.
-func TestTypesWithMethodSets(t *testing.T) {
+// TestRuntimeTypes tests that (*Program).RuntimeTypes() includes all necessary types.
+func TestRuntimeTypes(t *testing.T) {
   tests := []struct {
     input string
     want  []string
   }{
     // An exported package-level type is needed.
     {`package A; type T struct{}; func (T) f() {}`,
       []string{"*p.T", "p.T"},
     },
     // An unexported package-level type is not needed.
     {`package B; type t struct{}; func (t) f() {}`,
       nil,
     },
     // Subcomponents of type of exported package-level var are needed.
     {`package C; import "bytes"; var V struct {*bytes.Buffer}`,
-      []string{"*struct{*bytes.Buffer}", "struct{*bytes.Buffer}"},
+      []string{"*bytes.Buffer", "*struct{*bytes.Buffer}", "struct{*bytes.Buffer}"},
     },
     // Subcomponents of type of unexported package-level var are not needed.
     {`package D; import "bytes"; var v struct {*bytes.Buffer}`,
       nil,
     },
     // Subcomponents of type of exported package-level function are needed.
     {`package E; import "bytes"; func F(struct {*bytes.Buffer}) {}`,
-      []string{"struct{*bytes.Buffer}"},
+      []string{"*bytes.Buffer", "struct{*bytes.Buffer}"},
     },
     // Subcomponents of type of unexported package-level function are not needed.
     {`package F; import "bytes"; func f(struct {*bytes.Buffer}) {}`,
       nil,
     },
     // Subcomponents of type of exported method of uninstantiated unexported type are not needed.
     {`package G; import "bytes"; type x struct{}; func (x) G(struct {*bytes.Buffer}) {}; var v x`,
       nil,
     },
     // ...unless used by MakeInterface.
     {`package G2; import "bytes"; type x struct{}; func (x) G(struct {*bytes.Buffer}) {}; var v interface{} = x{}`,
-      []string{"*p.x", "p.x", "struct{*bytes.Buffer}"},
+      []string{"*bytes.Buffer", "*p.x", "p.x", "struct{*bytes.Buffer}"},
     },
     // Subcomponents of type of unexported method are not needed.
     {`package I; import "bytes"; type X struct{}; func (X) G(struct {*bytes.Buffer}) {}`,
-      []string{"*p.X", "p.X", "struct{*bytes.Buffer}"},
+      []string{"*bytes.Buffer", "*p.X", "p.X", "struct{*bytes.Buffer}"},
     },
     // Local types aren't needed.
     {`package J; import "bytes"; func f() { type T struct {*bytes.Buffer}; var t T; _ = t }`,
       nil,
     },
     // ...unless used by MakeInterface.
     {`package K; import "bytes"; func f() { type T struct {*bytes.Buffer}; _ = interface{}(T{}) }`,
-      []string{"*p.T", "p.T"},
+      []string{"*bytes.Buffer", "*p.T", "p.T"},
     },
     // Types used as operand of MakeInterface are needed.
     {`package L; import "bytes"; func f() { _ = interface{}(struct{*bytes.Buffer}{}) }`,
-      []string{"struct{*bytes.Buffer}"},
+      []string{"*bytes.Buffer", "struct{*bytes.Buffer}"},
     },
     // MakeInterface is optimized away when storing to a blank.
     {`package M; import "bytes"; var _ interface{} = struct{*bytes.Buffer}{}`,
       nil,
     },
   }
   for _, test := range tests {
     // Create a single-file main package.
-    var conf loader.Config
+    conf := loader.Config{ImportFromBinary: true}
     f, err := conf.ParseFile("<input>", test.input)
     if err != nil {
       t.Errorf("test %q: %s", test.input[:15], err)
       continue
     }
     conf.CreateFromFiles("p", f)
 
     iprog, err := conf.Load()
     if err != nil {
       t.Errorf("test 'package %s': Load: %s", f.Name.Name, err)
       continue
     }
     prog := ssa.Create(iprog, ssa.SanityCheckFunctions)
-    mainPkg := prog.Package(iprog.Created[0].Pkg)
     prog.BuildAll()
 
     var typstrs []string
-    for _, T := range mainPkg.TypesWithMethodSets() {
+    for _, T := range prog.RuntimeTypes() {
       typstrs = append(typstrs, T.String())
     }
     sort.Strings(typstrs)
 
     if !reflect.DeepEqual(typstrs, test.want) {
-      t.Errorf("test 'package %s': got %q, want %q", f.Name.Name, typstrs, test.want)
+      t.Errorf("test 'package %s': got %q, want %q",
+        f.Name.Name, typstrs, test.want)
     }
   }
 }
 
 // Tests that synthesized init functions are correctly formed.
 // Bare init functions omit calls to dependent init functions and the use of
 // an init guard. They are useful in cases where the client uses a different
 // calling convention for init functions, or cases where it is easier for a

llgo/trunk/third_party/gotools/go/ssa/create.go

 // 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 ssa
 
 // This file implements the CREATE phase of SSA construction.
 // See builder.go for explanation.
 
 import (
+  "fmt"
   "go/ast"
   "go/token"
   "os"
   "sync"
 
   "llvm.org/llgo/third_party/gotools/go/loader"
   "llvm.org/llgo/third_party/gotools/go/types"
   "llvm.org/llgo/third_party/gotools/go/types/typeutil"
 )
 
-// BuilderMode is a bitmask of options for diagnostics and checking.
-type BuilderMode uint
-
-const (
-  PrintPackages        BuilderMode = 1 << iota // Print package inventory to stdout
-  PrintFunctions                               // Print function SSA code to stdout
-  LogSource                                    // Log source locations as SSA builder progresses
-  SanityCheckFunctions                         // Perform sanity checking of function bodies
-  NaiveForm                                    // Build naïve SSA form: don't replace local loads/stores with registers
-  BuildSerially                                // Build packages serially, not in parallel.
-  GlobalDebug                                  // Enable debug info for all packages
-  BareInits                                    // Build init functions without guards or calls to dependent inits
-)
-
 // Create returns a new SSA Program.  An SSA Package is created for
 // each transitively error-free package of iprog.
 //
 // Code for bodies of functions is not built until Build() is called
 // on the result.
 //
 // mode controls diagnostics and checking during SSA construction.
 //
g := &Global{
       object: obj,
       typ:    types.NewPointer(obj.Type()), // address
       pos:    obj.Pos(),
     }
     pkg.values[obj] = g
     pkg.Members[name] = g
 
   case *types.Func:
+    sig := obj.Type().(*types.Signature)
+    if sig.Recv() == nil && name == "init" {
+      pkg.ninit++
+      name = fmt.Sprintf("init#%d", pkg.ninit)
+    }
     fn := &Function{
       name:      name,
       object:    obj,
-      Signature: obj.Type().(*types.Signature),
+      Signature: sig,
       syntax:    syntax,
       pos:       obj.Pos(),
       Pkg:       pkg,
       Prog:      pkg.Prog,
     }
     if syntax == nil {
       fn.Synthetic = "loaded from gc object file"
     }
 
     pkg.values[obj] = fn
-    if fn.Signature.Recv() == nil {
+    if sig.Recv() == nil {
       pkg.Members[name] = fn // package-level function
     }
 
   default: // (incl. *types.Package)
     panic("unexpected Object type: " + obj.String())
   }
 }
 
case token.TYPE:
         if !isBlankIdent(id) {
           memberFromObject(pkg, pkg.info.Defs[id], nil)
         }
       }
     }
 
   case *ast.FuncDecl:
     id := decl.Name
-    if decl.Recv == nil && id.Name == "init" {
-      return // no object
-    }
     if !isBlankIdent(id) {
       memberFromObject(pkg, pkg.info.Defs[id], decl)
     }
   }
 }
 
 // CreatePackage constructs and returns an SSA Package from an
 // error-free package described by info, and populates its Members
func (prog *Program) CreatePackage(info *loader.PackageInfo) *Package {
   if info.Importable {
     prog.imported[info.Pkg.Path()] = p
   }
   prog.packages[p.Object] = p
 
   return p
 }
 
-// printMu serializes printing of Packages/Functions to stdout
+// printMu serializes printing of Packages/Functions to stdout.
 var printMu sync.Mutex
 
 // AllPackages returns a new slice containing all packages in the
 // program prog in unspecified order.
 //
 func (prog *Program) AllPackages() []*Package {
   pkgs := make([]*Package, 0, len(prog.packages))
   for _, pkg := range prog.packages {

llgo/trunk/third_party/gotools/go/ssa/emit.go

if ut_src == tUntypedNil {
       return nilConst(typ)
     }
 
     // Convert (non-nil) "untyped" literals to their default type.
     if t, ok := ut_src.(*types.Basic); ok && t.Info()&types.IsUntyped != 0 {
       val = emitConv(f, val, DefaultType(ut_src))
     }
 
-    f.Pkg.needMethodsOf(val.Type())
+    f.Pkg.Prog.needMethodsOf(val.Type())
     mi := &MakeInterface{X: val}
     mi.setType(typ)
     return f.emit(mi)
   }
 
   // Conversion of a compile-time constant value?
   if c, ok := val.(*Const); ok {
     if _, ok := ut_dst.(*types.Basic); ok || c.IsNil() {
func zeroValue(f *Function, t types.Type) Value {
   switch t.Underlying().(type) {
   case *types.Struct, *types.Array:
     return emitLoad(f, f.addLocal(t, token.NoPos))
   default:
     return zeroConst(t)
   }
 }
 
-// emitMemClear emits to f code to zero the value pointed to by ptr.
-func emitMemClear(f *Function, ptr Value, pos token.Pos) {
-  // TODO(adonovan): define and use a 'memclr' intrinsic for aggregate types.
-  emitStore(f, ptr, zeroValue(f, deref(ptr.Type())), pos)
-}
-
 // createRecoverBlock emits to f a block of code to return after a
 // recovered panic, and sets f.Recover to it.
 //
 // If f's result parameters are named, the code loads and returns
 // their current values, otherwise it returns the zero values of their
 // type.
 //
 // Idempotent.

llgo/trunk/third_party/gotools/go/ssa/func.go

if alloc, ok := v.(*Alloc); ok && escaping {
       alloc.Heap = true
     }
     return v // function-local var (address)
   }
 
   // Definition must be in an enclosing function;
   // plumb it through intervening closures.
   if f.parent == nil {
-    panic("no Value for type.Object " + obj.Name())
+    panic("no ssa.Value for " + obj.String())
   }
   outer := f.parent.lookup(obj, true) // escaping
   v := &FreeVar{
     name:   obj.Name(),
     typ:    outer.Type(),
     pos:    outer.Pos(),
     outer:  outer,
     parent: f,

 //      "main.main$1"                 // an anonymous function in main
 //      "main.init#1"                 // a declared init function
 //      "main.init"                   // the synthesized package initializer
 //
 // When these functions are referred to from within the same package
 // (i.e. from == f.Pkg.Object), they are rendered without the package path.
 // For example: "IsNaN", "(*Buffer).Bytes", etc.
 //
-// Invariant: all non-synthetic functions have distinct package-qualified names.
+// All non-synthetic functions have distinct package-qualified names.
+// (But two methods may have the same name "(T).f" if one is a synthetic
+// wrapper promoting a non-exported method "f" from another package; in
+// that case, the strings are equal but the identifiers "f" are distinct.)
 //
 func (f *Function) RelString(from *types.Package) string {
   // Anonymous?
   if f.parent != nil {
     // An anonymous function's Name() looks like "parentName$1",
     // but its String() should include the type/package/etc.
     parent := f.parent.RelString(from)
     for i, anon := range f.parent.AnonFuncs {

llgo/trunk/third_party/gotools/go/ssa/interp/interp.go

func visitInstr(fr *frame, instr ssa.Instruction) continuation {
 
   case *ssa.RunDefers:
     fr.runDefers()
 
   case *ssa.Panic:
     panic(targetPanic{fr.get(instr.X)})
 
   case *ssa.Send:
-    fr.get(instr.Chan).(chan value) <- copyVal(fr.get(instr.X))
+    fr.get(instr.Chan).(chan value) <- fr.get(instr.X)
 
   case *ssa.Store:
-    *fr.get(instr.Addr).(*value) = copyVal(fr.get(instr.Val))
+    store(deref(instr.Addr.Type()), fr.get(instr.Addr).(*value), fr.get(instr.Val))
 
   case *ssa.If:
     succ := 1
     if fr.get(instr.Cond).(bool) {
       succ = 0
     }
     fr.prevBlock, fr.block = fr.block, fr.block.Succs[succ]
     return kJump
func visitInstr(fr *frame, instr ssa.Instruction) continuation {
   case *ssa.Range:
     fr.env[instr] = rangeIter(fr.get(instr.X), instr.X.Type())
 
   case *ssa.Next:
     fr.env[instr] = fr.get(instr.Iter).(iter).next()
 
   case *ssa.FieldAddr:
     x := fr.get(instr.X)
+    // FIXME wrong!  &global.f must not change if we do *global = zero!
     fr.env[instr] = &(*x.(*value)).(structure)[instr.Field]
 
   case *ssa.Field:
-    fr.env[instr] = copyVal(fr.get(instr.X).(structure)[instr.Field])
+    fr.env[instr] = fr.get(instr.X).(structure)[instr.Field]
 
   case *ssa.IndexAddr:
     x := fr.get(instr.X)
     idx := fr.get(instr.Index)
     switch x := x.(type) {
     case []value:
       fr.env[instr] = &x[asInt(idx)]
     case *value: // *array
       fr.env[instr] = &(*x).(array)[asInt(idx)]
     default:
       panic(fmt.Sprintf("unexpected x type in IndexAddr: %T", x))
     }
 
   case *ssa.Index:
-    fr.env[instr] = copyVal(fr.get(instr.X).(array)[asInt(fr.get(instr.Index))])
+    fr.env[instr] = fr.get(instr.X).(array)[asInt(fr.get(instr.Index))]
 
   case *ssa.Lookup:
     fr.env[instr] = lookup(instr, fr.get(instr.X), fr.get(instr.Index))
 
   case *ssa.MapUpdate:
     m := fr.get(instr.Map)
     key := fr.get(instr.Key)
     v := fr.get(instr.Value)
if recv.t == nil {
       panic("method invoked on nil interface")
     }
     if f := lookupMethod(fr.i, recv.t, call.Method); f == nil {
       // Unreachable in well-typed programs.
       panic(fmt.Sprintf("method set for dynamic type %v does not contain %s", recv.t, call.Method))
     } else {
       fn = f
     }
-    args = append(args, copyVal(recv.v))
+    args = append(args, recv.v)
   }
   for _, arg := range call.Args {
     args = append(args, fr.get(arg))
   }
   return
 }
 
 // call interprets a call to a function (function, builtin or closure)

llgo/trunk/third_party/gotools/go/ssa/interp/interp_test.go

func run(t *testing.T, dir, input string, success successPredicate) bool {
   var inputs []string
   for _, i := range strings.Split(input, " ") {
     if strings.HasSuffix(i, ".go") {
       i = dir + i
     }
     inputs = append(inputs, i)
   }
 
-  conf := loader.Config{SourceImports: true}
+  var conf loader.Config
   if _, err := conf.FromArgs(inputs, true); err != nil {
     t.Errorf("FromArgs(%s) failed: %s", inputs, err)
     return false
   }
 
   conf.Import("runtime")
 
   // Print a helpful hint if we don't make it to the end.
success := func(exitcode int, output string) error {
     return nil
   }
   run(t, "testdata"+slash, "a_test.go", success)
 }
 
 // CreateTestMainPackage should return nil if there were no tests.
 func TestNullTestmainPackage(t *testing.T) {
   var conf loader.Config
-  if err := conf.CreateFromFilenames("", "testdata/b_test.go"); err != nil {
-    t.Fatalf("ParseFile failed: %s", err)
-  }
+  conf.CreateFromFilenames("", "testdata/b_test.go")
   iprog, err := conf.Load()
   if err != nil {
     t.Fatalf("CreatePackages failed: %s", err)
   }
   prog := ssa.Create(iprog, ssa.SanityCheckFunctions)
   mainPkg := prog.Package(iprog.Created[0].Pkg)
   if mainPkg.Func("main") != nil {
     t.Fatalf("unexpected main function")
   }
   if prog.CreateTestMainPackage(mainPkg) != nil {
     t.Fatalf("CreateTestMainPackage returned non-nil")
   }
 }

llgo/trunk/third_party/gotools/go/ssa/interp/ops.go

case map[value]value, *hashmap:
     var ok bool
     switch x := x.(type) {
     case map[value]value:
       v, ok = x[idx]
     case *hashmap:
       v = x.lookup(idx.(hashable))
       ok = v != nil
     }
-    if ok {
-      v = copyVal(v)
-    } else {
+    if !ok {
       v = zero(instr.X.Type().Underlying().(*types.Map).Elem())
     }
     if instr.CommaOk {
       v = tuple{v, ok}
     }
     return v
   case string:
     return x[asInt(idx)]
case token.SUB:
     case float64:
       return -x
     case complex64:
       return -x
     case complex128:
       return -x
     }
   case token.MUL:
-    return copyVal(*x.(*value)) // load
+    return load(deref(instr.X.Type()), x.(*value))
   case token.NOT:
     return !x.(bool)
   case token.XOR:
     switch x := x.(type) {
     case int:
       return ^x
     case int8:
       return ^x
func typeAssert(i *interpreter, instr *ssa.TypeAssert, itf iface) value {
   if itf.t == nil {
     err = fmt.Sprintf("interface conversion: interface is nil, not %s", instr.AssertedType)
 
   } else if idst, ok := instr.AssertedType.Underlying().(*types.Interface); ok {
     v = itf
     err = checkInterface(i, idst, itf)
 
   } else if types.Identical(itf.t, instr.AssertedType) {
-    v = copyVal(itf.v) // extract value
+    v = itf.v // extract value
 
   } else {
     err = fmt.Sprintf("interface conversion: interface is %s, not %s", itf.t, instr.AssertedType)
   }
 
   if err != "" {
     if !instr.CommaOk {
       panic(err)

llgo/trunk/third_party/gotools/go/ssa/interp/reflect.go

 }
 
 func (t *opaqueType) String() string { return t.name }
 
 // A bogus "reflect" type-checker package.  Shared across interpreters.
 var reflectTypesPackage = types.NewPackage("reflect", "reflect")
 
 // rtype is the concrete type the interpreter uses to implement the
-// reflect.Type interface.  Since its type is opaque to the target
-// language, we use a types.Basic.
+// reflect.Type interface.
 //
 // type rtype <opaque>
 var rtypeType = makeNamedType("rtype", &opaqueType{nil, "rtype"})
 
 // error is an (interpreted) named type whose underlying type is string.
 // The interpreter uses it for all implementations of the built-in error
 // interface that it creates.
 // We put it in the "reflect" package for expedience.

 
 func initReflect(i *interpreter) {
   i.reflectPackage = &ssa.Package{
     Prog:    i.prog,
     Object:  reflectTypesPackage,
     Members: make(map[string]ssa.Member),
   }
 
+  // Clobber the type-checker's notion of reflect.Value's
+  // underlying type so that it more closely matches the fake one
+  // (at least in the number of fields---we lie about the type of
+  // the rtype field).
+  //
+  // We must ensure that calls to (ssa.Value).Type() return the
+  // fake type so that correct "shape" is used when allocating
+  // variables, making zero values, loading, and storing.
+  //
+  // TODO(adonovan): obviously this is a hack.  We need a cleaner
+  // way to fake the reflect package (almost---DeepEqual is fine).
+  // One approach would be not to even load its source code, but
+  // provide fake source files.  This would guarantee that no bad
+  // information leaks into other packages.
+  if r := i.prog.ImportedPackage("reflect"); r != nil {
+    rV := r.Object.Scope().Lookup("Value").Type().(*types.Named)
+    tEface := types.NewInterface(nil, nil).Complete()
+    rV.SetUnderlying(types.NewStruct([]*types.Var{
+      types.NewField(token.NoPos, r.Object, "t", tEface, false), // a lie
+      types.NewField(token.NoPos, r.Object, "v", tEface, false),
+    }, nil))
+  }
+
   i.rtypeMethods = methodSet{
     "Bits":      newMethod(i.reflectPackage, rtypeType, "Bits"),
     "Elem":      newMethod(i.reflectPackage, rtypeType, "Elem"),
     "Field":     newMethod(i.reflectPackage, rtypeType, "Field"),
     "Kind":      newMethod(i.reflectPackage, rtypeType, "Kind"),
     "NumField":  newMethod(i.reflectPackage, rtypeType, "NumField"),
     "NumMethod": newMethod(i.reflectPackage, rtypeType, "NumMethod"),
     "NumOut":    newMethod(i.reflectPackage, rtypeType, "NumOut"),
     "Out":       newMethod(i.reflectPackage, rtypeType, "Out"),
     "Size":      newMethod(i.reflectPackage, rtypeType, "Size"),
     "String":    newMethod(i.reflectPackage, rtypeType, "String"),
   }
   i.errorMethods = methodSet{
     "Error": newMethod(i.reflectPackage, errorType, "Error"),
   }
 }

llgo/trunk/third_party/gotools/go/ssa/interp/testdata/complit.go

func init() {
   if a[2] != 0 {
     panic("a[2] != 0")
   }
   if a[3] != 0 {
     panic("a[3] != 0")
   }
 }
 
+// Regression test for https://github.com/golang/go/issues/10127:
+// composite literal clobbers destination before reading from it.
+func init() {
+  // map
+  {
+    type M map[string]int
+    m := M{"x": 1, "y": 2}
+    m = M{"x": m["y"], "y": m["x"]}
+    if m["x"] != 2 || m["y"] != 1 {
+      panic(fmt.Sprint(m))
+    }
+
+    n := M{"x": 3}
+    m, n = M{"x": n["x"]}, M{"x": m["x"]} // parallel assignment
+    if got := fmt.Sprint(m["x"], n["x"]); got != "3 2" {
+      panic(got)
+    }
+  }
+
+  // struct
+  {
+    type T struct{ x, y, z int }
+    t := T{x: 1, y: 2, z: 3}
+
+    t = T{x: t.y, y: t.z, z: t.x} // all fields
+    if got := fmt.Sprint(t); got != "{2 3 1}" {
+      panic(got)
+    }
+
+    t = T{x: t.y, y: t.z + 3} // not all fields
+    if got := fmt.Sprint(t); got != "{3 4 0}" {
+      panic(got)
+    }
+
+    u := T{x: 5, y: 6, z: 7}
+    t, u = T{x: u.x}, T{x: t.x} // parallel assignment
+    if got := fmt.Sprint(t, u); got != "{5 0 0} {3 0 0}" {
+      panic(got)
+    }
+  }
+
+  // array
+  {
+    a := [3]int{0: 1, 1: 2, 2: 3}
+
+    a = [3]int{0: a[1], 1: a[2], 2: a[0]} //  all elements
+    if got := fmt.Sprint(a); got != "[2 3 1]" {
+      panic(got)
+    }
+
+    a = [3]int{0: a[1], 1: a[2] + 3} //  not all elements
+    if got := fmt.Sprint(a); got != "[3 4 0]" {
+      panic(got)
+    }
+
+    b := [3]int{0: 5, 1: 6, 2: 7}
+    a, b = [3]int{0: b[0]}, [3]int{0: a[0]} // parallel assignment
+    if got := fmt.Sprint(a, b); got != "[5 0 0] [3 0 0]" {
+      panic(got)
+    }
+  }
+
+  // slice
+  {
+    s := []int{0: 1, 1: 2, 2: 3}
+
+    s = []int{0: s[1], 1: s[2], 2: s[0]} //  all elements
+    if got := fmt.Sprint(s); got != "[2 3 1]" {
+      panic(got)
+    }
+
+    s = []int{0: s[1], 1: s[2] + 3} //  not all elements
+    if got := fmt.Sprint(s); got != "[3 4]" {
+      panic(got)
+    }
+
+    t := []int{0: 5, 1: 6, 2: 7}
+    s, t = []int{0: t[0]}, []int{0: s[0]} // parallel assignment
+    if got := fmt.Sprint(s, t); got != "[5] [3]" {
+      panic(got)
+    }
+  }
+}
+
 func main() {
 }

llgo/trunk/third_party/gotools/go/ssa/interp/testdata/coverage.go

func init() {
   s1 := []string{"foo", "bar"}
   s2 := s1 // creates an alias
   s2[0] = "wiz"
   if x := fmt.Sprint(s1, s2); x != "[wiz bar] [wiz bar]" {
     panic(x)
   }
 
   pa1 := &[2]string{"foo", "bar"}
-  pa2 := pa1        // creates an alias
-  (*pa2)[0] = "wiz" // * required to workaround typechecker bug
+  pa2 := pa1 // creates an alias
+  pa2[0] = "wiz"
   if x := fmt.Sprint(*pa1, *pa2); x != "[wiz bar] [wiz bar]" {
     panic(x)
   }
 
   a1 := [2]string{"foo", "bar"}
   a2 := a1 // creates a copy
   a2[0] = "wiz"
   if x := fmt.Sprint(a1, a2); x != "[foo bar] [wiz bar]" {
defer func() {
     if r != "runtime error: value method (main.T).f called using nil *main.T pointer" &&
       r != "value method main.T.f called using nil *T pointer" {
       panic("want panic from call with nil receiver, got " + r)
     }
   }()
   i.f()
   panic("unreachable")
 }
+
+// Regression test for a subtle bug in which copying values would causes
+// subcomponents of aggregate variables to change address, breaking
+// aliases.
+func init() {
+  type T struct{ f int }
+  var x T
+  p := &x.f
+  x = T{}
+  *p = 1
+  if x.f != 1 {
+    panic("lost store")
+  }
+  if p != &x.f {
+    panic("unstable address")
+  }
+}

llgo/trunk/third_party/gotools/go/ssa/interp/value.go

func hash(t types.Type, x value) int {
   case iface:
     return x.hash(t)
   case rtype:
     return x.hash(t)
   }
   panic(fmt.Sprintf("%T is unhashable", x))
 }
 
-// copyVal returns a copy of value v.
-// TODO(adonovan): add tests of aliasing and mutation.
-func copyVal(v value) value {
-  if v == nil {
-    panic("copyVal(nil)")
-  }
-  switch v := v.(type) {
-  case bool, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64, complex64, complex128, string, unsafe.Pointer:
-    return v
-  case map[value]value:
-    return v
-  case *hashmap:
-    return v
-  case chan value:
-    return v
-  case *value:
-    return v
-  case *ssa.Function, *ssa.Builtin, *closure:
-    return v
-  case iface:
-    return v
-  case []value:
-    return v
-  case structure:
+// reflect.Value struct values don't have a fixed shape, since the
+// payload can be a scalar or an aggregate depending on the instance.
+// So store (and load) can't simply use recursion over the shape of the
+// rhs value, or the lhs, to copy the value; we need the static type
+// information.  (We can't make reflect.Value a new basic data type
+// because its "structness" is exposed to Go programs.)
+
+// load returns the value of type T in *addr.
+func load(T types.Type, addr *value) value {
+  switch T := T.Underlying().(type) {
+  case *types.Struct:
+    v := (*addr).(structure)
     a := make(structure, len(v))
-    copy(a, v)
+    for i := range a {
+      a[i] = load(T.Field(i).Type(), &v[i])
+    }
     return a
-  case array:
+  case *types.Array:
+    v := (*addr).(array)
     a := make(array, len(v))
-    copy(a, v)
+    for i := range a {
+      a[i] = load(T.Elem(), &v[i])
+    }
     return a
-  case tuple:
-    break
-  case rtype:
-    return v
+  default:
+    return *addr
+  }
+}
+
+// store stores value v of type T into *addr.
+func store(T types.Type, addr *value, v value) {
+  switch T := T.Underlying().(type) {
+  case *types.Struct:
+    lhs := (*addr).(structure)
+    rhs := v.(structure)
+    for i := range lhs {
+      store(T.Field(i).Type(), &lhs[i], rhs[i])
+    }
+  case *types.Array:
+    lhs := (*addr).(array)
+    rhs := v.(array)
+    for i := range lhs {
+      store(T.Elem(), &lhs[i], rhs[i])
+    }
+  default:
+    *addr = v
   }
-  panic(fmt.Sprintf("cannot copy %T", v))
 }
 
 // Prints in the style of built-in println.
 // (More or less; in gc println is actually a compiler intrinsic and
 // can distinguish println(1) from println(interface{}(1)).)
 func writeValue(buf *bytes.Buffer, v value) {
   switch v := v.(type) {
   case nil, bool, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64, complex64, complex128, string:

llgo/trunk/third_party/gotools/go/ssa/lvalue.go

type lvalue interface {
   address(fn *Function) Value  // address of the location
   typ() types.Type             // returns the type of the location
 }
 
 // An address is an lvalue represented by a true pointer.
 type address struct {
   addr Value
   pos  token.Pos // source position
-  expr ast.Expr  // source syntax [debug mode]
+  expr ast.Expr  // source syntax of the value (not address) [debug mode]
 }
 
 func (a *address) load(fn *Function) Value {
   load := emitLoad(fn, a.addr)
   load.pos = a.pos
   return load
 }
 

llgo/trunk/third_party/gotools/go/ssa/methods.go

 func (prog *Program) LookupMethod(T types.Type, pkg *types.Package, name string) *Function {
   sel := prog.MethodSets.MethodSet(T).Lookup(pkg, name)
   if sel == nil {
     panic(fmt.Sprintf("%s has no method %s", T, types.Id(pkg, name)))
   }
   return prog.Method(sel)
 }
 
-// makeMethods ensures that all concrete methods of type T are
-// generated.  It is equivalent to calling prog.Method() on all
-// members of T.methodSet(), but acquires fewer locks.
-//
-// It reports whether the type's (concrete) method set is non-empty.
-//
-// Thread-safe.
-//
-// EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu)
-//
-func (prog *Program) makeMethods(T types.Type) bool {
-  if isInterface(T) {
-    return false // abstract method
-  }
-  tmset := prog.MethodSets.MethodSet(T)
-  n := tmset.Len()
-  if n == 0 {
-    return false // empty (common case)
-  }
-
-  if prog.mode&LogSource != 0 {
-    defer logStack("makeMethods %s", T)()
-  }
-
-  prog.methodsMu.Lock()
-  defer prog.methodsMu.Unlock()
-
-  mset := prog.createMethodSet(T)
-  if !mset.complete {
-    mset.complete = true
-    for i := 0; i < n; i++ {
-      prog.addMethod(mset, tmset.At(i))
-    }
-  }
-
-  return true
-}
-
 // methodSet contains the (concrete) methods of a non-interface type.
 type methodSet struct {
   mapping  map[string]*Function // populated lazily
   complete bool                 // mapping contains all methods
 }
 
 // Precondition: !isInterface(T).
 // EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
if fn == nil {
     if fn.Signature.Recv() == nil {
       panic(fn) // missing receiver
     }
     mset.mapping[id] = fn
   }
   return fn
 }
 
-// TypesWithMethodSets returns a new unordered slice containing all
+// RuntimeTypes returns a new unordered slice containing all
 // concrete types in the program for which a complete (non-empty)
 // method set is required at run-time.
 //
-// It is the union of pkg.TypesWithMethodSets() for all pkg in
-// prog.AllPackages().
-//
 // Thread-safe.
 //
 // EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu)
 //
-func (prog *Program) TypesWithMethodSets() []types.Type {
+func (prog *Program) RuntimeTypes() []types.Type {
   prog.methodsMu.Lock()
   defer prog.methodsMu.Unlock()
 
   var res []types.Type
   prog.methodSets.Iterate(func(T types.Type, v interface{}) {
     if v.(*methodSet).complete {
       res = append(res, T)
     }
   })
   return res
 }
 
-// TypesWithMethodSets returns an unordered slice containing the set
-// of all concrete types referenced within package pkg and not
-// belonging to some other package, for which a complete (non-empty)
-// method set is required at run-time.
-//
-// A type belongs to a package if it is a named type or a pointer to a
-// named type, and the name was defined in that package.  All other
-// types belong to no package.
-//
-// A type may appear in the TypesWithMethodSets() set of multiple
-// distinct packages if that type belongs to no package.  Typical
-// compilers emit method sets for such types multiple times (using
-// weak symbols) into each package that references them, with the
-// linker performing duplicate elimination.
-//
-// This set includes the types of all operands of some MakeInterface
-// instruction, the types of all exported members of some package, and
-// all types that are subcomponents, since even types that aren't used
-// directly may be derived via reflection.
-//
-// Callers must not mutate the result.
-//
-func (pkg *Package) TypesWithMethodSets() []types.Type {
-  // pkg.methodsMu not required; concurrent (build) phase is over.
-  return pkg.methodSets
-}
-
 // declaredFunc returns the concrete function/method denoted by obj.
 // Panic ensues if there is none.
 //
 func (prog *Program) declaredFunc(obj *types.Func) *Function {
   if v := prog.packageLevelValue(obj); v != nil {
     return v.(*Function)
   }
   panic("no concrete method: " + obj.String())
 }
+
+// needMethodsOf ensures that runtime type information (including the
+// complete method set) is available for the specified type T and all
+// its subcomponents.
+//
+// needMethodsOf must be called for at least every type that is an
+// operand of some MakeInterface instruction, and for the type of
+// every exported package member.
+//
+// Precondition: T is not a method signature (*Signature with Recv()!=nil).
+//
+// Thread-safe.  (Called via emitConv from multiple builder goroutines.)
+//
+// TODO(adonovan): make this faster.  It accounts for 20% of SSA build time.
+//
+// EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu)
+//
+func (prog *Program) needMethodsOf(T types.Type) {
+  prog.methodsMu.Lock()
+  prog.needMethods(T, false)
+  prog.methodsMu.Unlock()
+}
+
+// Precondition: T is not a method signature (*Signature with Recv()!=nil).
+// Recursive case: skip => don't create methods for T.
+//
+// EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
+//
+func (prog *Program) needMethods(T types.Type, skip bool) {
+  // Each package maintains its own set of types it has visited.
+  if prevSkip, ok := prog.runtimeTypes.At(T).(bool); ok {
+    // needMethods(T) was previously called
+    if !prevSkip || skip {
+      return // already seen, with same or false 'skip' value
+    }
+  }
+  prog.runtimeTypes.Set(T, skip)
+
+  tmset := prog.MethodSets.MethodSet(T)
+
+  if !skip && !isInterface(T) && tmset.Len() > 0 {
+    // Create methods of T.
+    mset := prog.createMethodSet(T)
+    if !mset.complete {
+      mset.complete = true
+      n := tmset.Len()
+      for i := 0; i < n; i++ {
+        prog.addMethod(mset, tmset.At(i))
+      }
+    }
+  }
+
+  // Recursion over signatures of each method.
+  for i := 0; i < tmset.Len(); i++ {
+    sig := tmset.At(i).Type().(*types.Signature)
+    prog.needMethods(sig.Params(), false)
+    prog.needMethods(sig.Results(), false)
+  }
+
+  switch t := T.(type) {
+  case *types.Basic:
+    // nop
+
+  case *types.Interface:
+    // nop---handled by recursion over method set.
+
+  case *types.Pointer:
+    prog.needMethods(t.Elem(), false)
+
+  case *types.Slice:
+    prog.needMethods(t.Elem(), false)
+
+  case *types.Chan:
+    prog.needMethods(t.Elem(), false)
+
+  case *types.Map:
+    prog.needMethods(t.Key(), false)
+    prog.needMethods(t.Elem(), false)
+
+  case *types.Signature:
+    if t.Recv() != nil {
+      panic(fmt.Sprintf("Signature %s has Recv %s", t, t.Recv()))
+    }
+    prog.needMethods(t.Params(), false)
+    prog.needMethods(t.Results(), false)
+
+  case *types.Named:
+    // A pointer-to-named type can be derived from a named
+    // type via reflection.  It may have methods too.
+    prog.needMethods(types.NewPointer(T), false)
+
+    // Consider 'type T struct{S}' where S has methods.
+    // Reflection provides no way to get from T to struct{S},
+    // only to S, so the method set of struct{S} is unwanted,
+    // so set 'skip' flag during recursion.
+    prog.needMethods(t.Underlying(), true)
+
+  case *types.Array:
+    prog.needMethods(t.Elem(), false)
+
+  case *types.Struct:
+    for i, n := 0, t.NumFields(); i < n; i++ {
+      prog.needMethods(t.Field(i).Type(), false)
+    }
+
+  case *types.Tuple:
+    for i, n := 0, t.Len(); i < n; i++ {
+      prog.needMethods(t.At(i).Type(), false)
+    }
+
+  default:
+    panic(T)
+  }
+}

llgo/trunk/third_party/gotools/go/ssa/mode.go

+// Copyright 2015 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 ssa
+
+// This file defines the BuilderMode type and its command-line flag.
+
+import (
+  "bytes"
+  "flag"
+  "fmt"
+)
+
+// BuilderMode is a bitmask of options for diagnostics and checking.
+type BuilderMode uint
+
+const (
+  PrintPackages        BuilderMode = 1 << iota // Print package inventory to stdout
+  PrintFunctions                               // Print function SSA code to stdout
+  LogSource                                    // Log source locations as SSA builder progresses
+  SanityCheckFunctions                         // Perform sanity checking of function bodies
+  NaiveForm                                    // Build naïve SSA form: don't replace local loads/stores with registers
+  BuildSerially                                // Build packages serially, not in parallel.
+  GlobalDebug                                  // Enable debug info for all packages
+  BareInits                                    // Build init functions without guards or calls to dependent inits
+)
+
+const modeFlagUsage = `Options controlling the SSA builder.
+The value is a sequence of zero or more of these letters:
+C perform sanity [C]hecking of the SSA form.
+D include [D]ebug info for every function.
+P print [P]ackage inventory.
+F print [F]unction SSA code.
+S log [S]ource locations as SSA builder progresses.
+L build distinct packages seria[L]ly instead of in parallel.
+N build [N]aive SSA form: don't replace local loads/stores with registers.
+I build bare [I]nit functions: no init guards or calls to dependent inits.
+`
+
+// BuilderModeFlag creates a new command line flag of type BuilderMode,
+// adds it to the specified flag set, and returns it.
+//
+// Example:
+//  var ssabuild = BuilderModeFlag(flag.CommandLine, "ssabuild", 0)
+//
+func BuilderModeFlag(set *flag.FlagSet, name string, value BuilderMode) *BuilderMode {
+  set.Var((*builderModeValue)(&value), name, modeFlagUsage)
+  return &value
+}
+
+type builderModeValue BuilderMode // satisfies flag.Value and flag.Getter.
+
+func (v *builderModeValue) Set(s string) error {
+  var mode BuilderMode
+  for _, c := range s {
+    switch c {
+    case 'D':
+      mode |= GlobalDebug
+    case 'P':
+      mode |= PrintPackages
+    case 'F':
+      mode |= PrintFunctions
+    case 'S':
+      mode |= LogSource | BuildSerially
+    case 'C':
+      mode |= SanityCheckFunctions
+    case 'N':
+      mode |= NaiveForm
+    case 'L':
+      mode |= BuildSerially
+    default:
+      return fmt.Errorf("unknown BuilderMode option: %q", c)
+    }
+  }
+  *v = builderModeValue(mode)
+  return nil
+}
+
+func (v *builderModeValue) Get() interface{} { return BuilderMode(*v) }
+
+func (v *builderModeValue) String() string {
+  mode := BuilderMode(*v)
+  var buf bytes.Buffer
+  if mode&GlobalDebug != 0 {
+    buf.WriteByte('D')
+  }
+  if mode&PrintPackages != 0 {
+    buf.WriteByte('P')
+  }
+  if mode&PrintFunctions != 0 {
+    buf.WriteByte('F')
+  }
+  if mode&LogSource != 0 {
+    buf.WriteByte('S')
+  }
+  if mode&SanityCheckFunctions != 0 {
+    buf.WriteByte('C')
+  }
+  if mode&NaiveForm != 0 {
+    buf.WriteByte('N')
+  }
+  if mode&BuildSerially != 0 {
+    buf.WriteByte('L')
+  }
+  return buf.String()
+}

llgo/trunk/third_party/gotools/go/ssa/sanity.go

if obj == nil {
       // {Global,Function}.object have type
       // types.Object.  (If they were declared as
       // *types.{Var,Func}, we'd have a non-empty
       // interface containing a nil pointer.)
 
       continue // not all members have typechecker objects
     }
     if obj.Name() != name {
+      if obj.Name() == "init" && strings.HasPrefix(mem.Name(), "init#") {
+        // Ok.  The name of a declared init function varies between
+        // its types.Func ("init") and its ssa.Function ("init#%d").
+      } else {
         panic(fmt.Sprintf("%s: %T.Object().Name() = %s, want %s",
           pkg.Object.Path(), mem, obj.Name(), name))
       }
+    }
     if obj.Pos() != mem.Pos() {
       panic(fmt.Sprintf("%s Pos=%d obj.Pos=%d", mem, mem.Pos(), obj.Pos()))
     }
   }
 }

llgo/trunk/third_party/gotools/go/ssa/source.go

 //    - the expression is not lexically contained within f;
 //    - f was not built with debug information; or
 //    - e is a constant expression.  (For efficiency, no debug
 //      information is stored for constants. Use
 //      loader.PackageInfo.ValueOf(e) instead.)
 //    - e is a reference to nil or a built-in function.
 //    - the value was optimised away.
 //
-// If e is an addressable expression used an an lvalue context,
+// If e is an addressable expression used in an lvalue context,
 // value is the address denoted by e, and isAddr is true.
 //
 // The types of e (or &e, if isAddr) and the result are equal
 // (modulo "untyped" bools resulting from comparisons).
 //
 // (Tip: to find the ssa.Value given a source position, use
 // importer.PathEnclosingInterval to locate the ast.Node, then
 // EnclosingFunction to locate the Function, then ValueForExpr to find

llgo/trunk/third_party/gotools/go/ssa/ssa.go

import (
 
   "llvm.org/llgo/third_party/gotools/go/exact"
   "llvm.org/llgo/third_party/gotools/go/loader"
   "llvm.org/llgo/third_party/gotools/go/types"
   "llvm.org/llgo/third_party/gotools/go/types/typeutil"
 )
 
 // A Program is a partial or complete Go program converted to SSA form.
-//
 type Program struct {
   Fset       *token.FileSet              // position information for the files of this Program
   imported   map[string]*Package         // all importable Packages, keyed by import path
   packages   map[*types.Package]*Package // all loaded Packages, keyed by object
   mode       BuilderMode                 // set of mode bits for SSA construction
   MethodSets types.MethodSetCache        // cache of type-checker's method-sets
 
-  methodsMu  sync.Mutex                 // guards the following maps:
-  methodSets typeutil.Map               // maps type to its concrete methodSet
-  canon      typeutil.Map               // type canonicalization map
-  bounds     map[*types.Func]*Function  // bounds for curried x.Method closures
-  thunks     map[selectionKey]*Function // thunks for T.Method expressions
+  methodsMu    sync.Mutex                 // guards the following maps:
+  methodSets   typeutil.Map               // maps type to its concrete methodSet
+  runtimeTypes typeutil.Map               // types for which rtypes are needed
+  canon        typeutil.Map               // type canonicalization map
+  bounds       map[*types.Func]*Function  // bounds for curried x.Method closures
+  thunks       map[selectionKey]*Function // thunks for T.Method expressions
 }
 
 // A Package is a single analyzed Go package containing Members for
 // all package-level functions, variables, constants and types it
 // declares.  These may be accessed directly via Members, or via the
 // type-specific accessor methods Func, Type, Var and Const.
 //
+// Members also contains entries for "init" (the synthetic package
+// initializer) and "init#%d", the nth declared init function,
+// and unspecified other things too.
+//
 type Package struct {
-  Prog       *Program               // the owning program
-  Object     *types.Package         // the type checker's package object for this package
-  Members    map[string]Member      // all package members keyed by name
-  methodsMu  sync.Mutex             // guards needRTTI and methodSets
-  methodSets []types.Type           // types whose method sets are included in this package
-  values     map[types.Object]Value // package members (incl. types and methods), keyed by object
-  init       *Function              // Func("init"); the package's init function
-  debug      bool                   // include full debug info in this package.
+  Prog    *Program               // the owning program
+  Object  *types.Package         // the type checker's package object for this package
+  Members map[string]Member      // all package members keyed by name (incl. init and init#%d)
+  values  map[types.Object]Value // package members (incl. types and methods), keyed by object
+  init    *Function              // Func("init"); the package's init function
+  debug   bool                   // include full debug info in this package
 
   // The following fields are set transiently, then cleared
   // after building.
-  started  int32               // atomically tested and set at start of build phase
-  ninit    int32               // number of init functions
-  info     *loader.PackageInfo // package ASTs and type information
-  needRTTI typeutil.Map        // types for which runtime type info is needed
+  started int32               // atomically tested and set at start of build phase
+  ninit   int32               // number of init functions
+  info    *loader.PackageInfo // package ASTs and type information
 }
 
 // A Member is a member of a Go package, implemented by *NamedConst,
 // *Global, *Function, or *Type; they are created by package-level
 // const, var, func and type declarations respectively.
 //
 type Member interface {
   Name() string                    // declared name of the package member
   String() string                  // package-qualified name of the package member
   RelString(*types.Package) string // like String, but relative refs are unqualified
   Object() types.Object            // typechecker's object for this member, if any
   Pos() token.Pos                  // position of member's declaration, if known
   Type() types.Type                // type of the package member
   Token() token.Token              // token.{VAR,FUNC,CONST,TYPE}
-  Package() *Package               // returns the containing package. (TODO: rename Pkg)
+  Package() *Package               // the containing package
 }
 
 // A Type is a Member of a Package representing a package-level named type.
 //
 // Type() returns a *types.Named.
 //
 type Type struct {
   object *types.TypeName
   pkg    *Package
 }
 
-// A NamedConst is a Member of Package representing a package-level
-// named constant value.
+// A NamedConst is a Member of a Package representing a package-level
+// named constant.
 //
 // Pos() returns the position of the declaring ast.ValueSpec.Names[*]
 // identifier.
 //
 // NB: a NamedConst is not a Value; it contains a constant Value, which
 // it augments with the name and position of its 'const' declaration.
 //
 type NamedConst struct {
type Value interface {
   // for an *ast.CallExpr.  This permits a compact but
   // approximate mapping from Values to source positions for use
   // in diagnostic messages, for example.
   //
   // (Do not use this position to determine which Value
   // corresponds to an ast.Expr; use Function.ValueForExpr
   // instead.  NB: it requires that the function was built with
   // debug information.)
-  //
   Pos() token.Pos
 }
 
 // An Instruction is an SSA instruction that computes a new Value or
 // has some effect.
 //
 // An Instruction that defines a value (e.g. BinOp) also implements
 // the Value interface; an Instruction that only has an effect (e.g. Store)
 // does not.
 //
 type Instruction interface {
-  // String returns the disassembled form of this value.  e.g.
+  // String returns the disassembled form of this value.
   //
-  // Examples of Instructions that define a Value:
-  // e.g.  "x + y"     (BinOp)
+  // Examples of Instructions that are Values:
+  //       "x + y"     (BinOp)
   //       "len([])"   (Call)
   // Note that the name of the Value is not printed.
   //
-  // Examples of Instructions that do define (are) Values:
-  // e.g.  "return x"  (Return)
+  // Examples of Instructions that are not Values:
+  //       "return x"  (Return)
   //       "*y = x"    (Store)
   //
-  // (This separation is useful for some analyses which
-  // distinguish the operation from the value it
-  // defines. e.g. 'y = local int' is both an allocation of
-  // memory 'local int' and a definition of a pointer y.)
+  // (The separation Value.Name() from Value.String() is useful
+  // for some analyses which distinguish the operation from the
+  // value it defines, e.g., 'y = local int' is both an allocation
+  // of memory 'local int' and a definition of a pointer y.)
   String() string
 
   // Parent returns the function to which this instruction
   // belongs.
   Parent() *Function
 
   // Block returns the basic block to which this instruction
   // belongs.
type Instruction interface {
   // mapping from Instructions to source positions for use in
   // diagnostic messages, for example.
   //
   // (Do not use this position to determine which Instruction
   // corresponds to an ast.Expr; see the notes for Value.Pos.
   // This position may be used to determine which non-Value
   // Instruction corresponds to some ast.Stmts, but not all: If
   // and Jump instructions have no Pos(), for example.)
-  //
   Pos() token.Pos
 }
 
 // A Node is a node in the SSA value graph.  Every concrete type that
 // implements Node is also either a Value, an Instruction, or both.
 //
 // Node contains the methods common to Value and Instruction, plus the
 // Operands and Referrers methods generalized to return nil for
type Node interface {
   Pos() token.Pos
   Parent() *Function
 
   // Partial methods:
   Operands(rands []*Value) []*Value // nil for non-Instructions
   Referrers() *[]Instruction        // nil for non-Values
 }
 
-// Function represents the parameters, results and code of a function
+// Function represents the parameters, results, and code of a function
 // or method.
 //
 // If Blocks is nil, this indicates an external function for which no
 // Go source code is available.  In this case, FreeVars and Locals
-// will be nil too.  Clients performing whole-program analysis must
+// are nil too.  Clients performing whole-program analysis must
 // handle external functions specially.
 //
 // Blocks contains the function's control-flow graph (CFG).
 // Blocks[0] is the function entry point; block order is not otherwise
 // semantically significant, though it may affect the readability of
 // the disassembly.
 // To iterate over the blocks in dominance order, use DomPreorder().
 //
 // Recover is an optional second entry point to which control resumes
 // after a recovered panic.  The Recover block may contain only a return
 // statement, preceded by a load of the function's named return
 // parameters, if any.
 //
 // A nested function (Parent()!=nil) that refers to one or more
-// lexically enclosing local variables ("free variables") has FreeVar
-// parameters.  Such functions cannot be called directly but require a
+// lexically enclosing local variables ("free variables") has FreeVars.
+// Such functions cannot be called directly but require a
 // value created by MakeClosure which, via its Bindings, supplies
 // values for these parameters.
 //
 // If the function is a method (Signature.Recv() != nil) then the first
 // element of Params is the receiver parameter.
 //
+// A Go package may declare many functions called "init".
+// For each one, Object().Name() returns "init" but Name() returns
+// "init#1", etc, in declaration order.
+//
 // Pos() returns the declaring ast.FuncLit.Type.Func or the position
 // of the ast.FuncDecl.Name, if the function was explicit in the
 // source.  Synthetic wrappers, for which Synthetic != "", may share
 // the same position as the function they wrap.
 // Syntax.Pos() always returns the position of the declaring "func" token.
 //
 // Type() returns the function's Signature.
 //
type Function struct {
   // then cleared.
   currentBlock *BasicBlock             // where to emit code
   objects      map[types.Object]Value  // addresses of local variables
   namedResults []*Alloc                // tuple of named results
   targets      *targets                // linked stack of branch targets
   lblocks      map[*ast.Object]*lblock // labelled blocks
 }
 
-// An SSA basic block.
+// BasicBlock represents an SSA basic block.
 //
 // The final element of Instrs is always an explicit transfer of
-// control (If, Jump, Return or Panic).
+// control (If, Jump, Return, or Panic).
 //
 // A block may contain no Instructions only if it is unreachable,
-// i.e. Preds is nil.  Empty blocks are typically pruned.
+// i.e., Preds is nil.  Empty blocks are typically pruned.
 //
 // BasicBlocks and their Preds/Succs relation form a (possibly cyclic)
 // graph independent of the SSA Value graph: the control-flow graph or
 // CFG.  It is illegal for multiple edges to exist between the same
 // pair of blocks.
 //
 // Each BasicBlock is also a node in the dominator tree of the CFG.
 // The tree may be navigated using Idom()/Dominees() and queried using
 // Dominates().
 //
 // The order of Preds and Succs is significant (to Phi and If
 // instructions, respectively).
 //
 type BasicBlock struct {
   Index        int            // index of this block within Parent().Blocks
   Comment      string         // optional label; no semantic significance
   parent       *Function      // parent function
   Instrs       []Instruction  // instructions in order
   Preds, Succs []*BasicBlock  // predecessors and successors
-  succs2       [2]*BasicBlock // initial space for Succs.
+  succs2       [2]*BasicBlock // initial space for Succs
   dom          domInfo        // dominator tree info
-  gaps         int            // number of nil Instrs (transient).
+  gaps         int            // number of nil Instrs (transient)
   rundefers    int            // number of rundefers (transient)
 }
 
 // Pure values ----------------------------------------
 
 // A FreeVar represents a free variable of the function to which it
 // belongs.
 //
type Parameter struct {
   parent    *Function
   referrers []Instruction
 }
 
 // A Const represents the value of a constant expression.
 //
 // The underlying type of a constant may be any boolean, numeric, or
 // string type.  In addition, a Const may represent the nil value of
-// any reference type: interface, map, channel, pointer, slice, or
+// any reference type---interface, map, channel, pointer, slice, or
 // function---but not "untyped nil".
 //
 // All source-level constant expressions are represented by a Const
-// of equal type and value.
+// of the same type and value.
 //
 // Value holds the exact value of the constant, independent of its
 // Type(), using the same representation as package go/exact uses for
 // constants, or nil for a typed nil value.
 //
 // Pos() returns token.NoPos.
 //
 // Example printed form:

 //
 type Builtin struct {
   name string
   sig  *types.Signature
 }
 
 // Value-defining instructions  ----------------------------------------
 
-// The Alloc instruction reserves space for a value of the given type,
+// The Alloc instruction reserves space for a variable of the given type,
 // zero-initializes it, and yields its address.
 //
 // Alloc values are always addresses, and have pointer types, so the
-// type of the allocated space is actually indirect(Type()).
+// type of the allocated variable is actually
+// Type().Underlying().(*types.Pointer).Elem().
 //
 // If Heap is false, Alloc allocates space in the function's
 // activation record (frame); we refer to an Alloc(Heap=false) as a
 // "local" alloc.  Each local Alloc returns the same address each time
 // it is executed within the same activation; the space is
 // re-initialized to zero.
 //
-// If Heap is true, Alloc allocates space in the heap, and returns; we
+// If Heap is true, Alloc allocates space in the heap; we
 // refer to an Alloc(Heap=true) as a "new" alloc.  Each new Alloc
 // returns a different address each time it is executed.
 //
 // When Alloc is applied to a channel, map or slice type, it returns
 // the address of an uninitialized (nil) reference of that kind; store
 // the result of MakeSlice, MakeMap or MakeChan in that location to
 // instantiate these types.
 //

 // value.  Within a block, all φ-nodes must appear before all non-φ
 // nodes.
 //
 // Pos() returns the position of the && or || for short-circuit
 // control-flow joins, or that of the *Alloc for φ-nodes inserted
 // during SSA renaming.
 //
 // Example printed form:
-//  t2 = phi [0.start: t0, 1.if.then: t1, ...]
+//  t2 = phi [0: t0, 1: t1]
 //
 type Phi struct {
   register
   Comment string  // a hint as to its purpose
   Edges   []Value // Edges[i] is value for Block().Preds[i]
 }
 
 // The Call instruction represents a function or method call.
 //
-// The Call instruction yields the function result, if there is
-// exactly one, or a tuple (empty or len>1) whose components are
+// The Call instruction yields the function result if there is exactly
+// one.  Otherwise it returns a tuple, the components of which are
 // accessed via Extract.
 //
 // See CallCommon for generic function call documentation.
 //
 // Pos() returns the ast.CallExpr.Lparen, if explicit in the source.
 //
 // Example printed form:
 //  t2 = println(t0, t1)
case *Function:
     return fn
   case *MakeClosure:
     return fn.Fn.(*Function)
   }
   return nil
 }
 
 // Description returns a description of the mode of this call suitable
-// for a user interface, e.g. "static method call".
+// for a user interface, e.g., "static method call".
 func (c *CallCommon) Description() string {
   switch fn := c.Value.(type) {
   case *Builtin:
     return "built-in function call"
   case *MakeClosure:
     return "static function closure call"
   case *Function:
     if fn.Signature.Recv() != nil {

llgo/trunk/third_party/gotools/go/ssa/ssautil/visit.go

 func (visit *visitor) program() {
   for _, pkg := range visit.prog.AllPackages() {
     for _, mem := range pkg.Members {
       if fn, ok := mem.(*ssa.Function); ok {
         visit.function(fn)
       }
     }
   }
-  for _, T := range visit.prog.TypesWithMethodSets() {
+  for _, T := range visit.prog.RuntimeTypes() {
     mset := visit.prog.MethodSets.MethodSet(T)
     for i, n := 0, mset.Len(); i < n; i++ {
       visit.function(visit.prog.Method(mset.At(i)))
     }
   }
 }
 
 func (visit *visitor) function(fn *ssa.Function) {

llgo/trunk/third_party/gotools/go/ssa/stdlib_test.go

 // 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 ssa_test
 
 // This file runs the SSA builder in sanity-checking mode on all
 // packages beneath $GOROOT and prints some summary information.
 //
 // Run with "go test -cpu=8 to" set GOMAXPROCS.
 
 import (
+  "go/ast"
   "go/build"
   "go/token"
   "runtime"
   "testing"
   "time"
 
   "llvm.org/llgo/third_party/gotools/go/buildutil"
   "llvm.org/llgo/third_party/gotools/go/loader"

 func TestStdlib(t *testing.T) {
   // Load, parse and type-check the program.
   t0 := time.Now()
   alloc0 := bytesAllocated()
 
   // Load, parse and type-check the program.
   ctxt := build.Default // copy
   ctxt.GOPATH = ""      // disable GOPATH
-  conf := loader.Config{
-    SourceImports: true,
-    Build:         &ctxt,
-  }
+  conf := loader.Config{Build: &ctxt}
   if _, err := conf.FromArgs(buildutil.AllPackages(conf.Build), true); err != nil {
     t.Errorf("FromArgs failed: %v", err)
     return
   }
 
   iprog, err := conf.Load()
   if err != nil {
     t.Fatalf("Load failed: %v", err)
func TestStdlib(t *testing.T) {
   // Keep iprog reachable until after we've measured memory usage.
   if len(iprog.AllPackages) == 0 {
     print() // unreachable
   }
 
   allFuncs := ssautil.AllFunctions(prog)
 
   // Check that all non-synthetic functions have distinct names.
+  // Synthetic wrappers for exported methods should be distinct too,
+  // except for unexported ones (explained at (*Function).RelString).
   byName := make(map[string]*ssa.Function)
   for fn := range allFuncs {
-    if fn.Synthetic == "" {
+    if fn.Synthetic == "" || ast.IsExported(fn.Name()) {
       str := fn.String()
       prev := byName[str]
       byName[str] = fn
       if prev != nil {
         t.Errorf("%s: duplicate function named %s",
           prog.Fset.Position(fn.Pos()), str)
         t.Errorf("%s:   (previously defined here)",
           prog.Fset.Position(prev.Pos()))

llgo/trunk/third_party/gotools/go/ssa/testdata/valueforexpr.go

func complit() {
   // We get different results for
   // - composite literal as value (e.g. operand to print)
   // - composite literal initializer for addressable value
   // - composite literal value assigned to blank var
 
   // 1. Slices
   print( /*@Slice*/ ([]int{}))
   print( /*@Alloc*/ (&[]int{}))
-  print(& /*@Alloc*/ ([]int{}))
+  print(& /*@Slice*/ ([]int{}))
 
   sl1 := /*@Slice*/ ([]int{})
   sl2 := /*@Alloc*/ (&[]int{})
-  sl3 := & /*@Alloc*/ ([]int{})
+  sl3 := & /*@Slice*/ ([]int{})
   _, _, _ = sl1, sl2, sl3
 
   _ = /*@Slice*/ ([]int{})
   _ = /*@<nil>*/ (& /*@Slice*/ ([]int{})) // & optimized away
   _ = & /*@Slice*/ ([]int{})
 
   // 2. Arrays
   print( /*@UnOp*/ ([1]int{}))
   print( /*@Alloc*/ (&[1]int{}))
   print(& /*@Alloc*/ ([1]int{}))
 
   arr1 := /*@Alloc*/ ([1]int{})
   arr2 := /*@Alloc*/ (&[1]int{})
   arr3 := & /*@Alloc*/ ([1]int{})
   _, _, _ = arr1, arr2, arr3
 
   _ = /*@UnOp*/ ([1]int{})
-  _ = /*@Alloc*/ (& /*@Alloc*/ ([1]int{})) // & optimized away
+  _ = /*@Alloc*/ (& /*@Alloc*/ ([1]int{}))
   _ = & /*@Alloc*/ ([1]int{})
 
   // 3. Maps
   type M map[int]int
   print( /*@MakeMap*/ (M{}))
   print( /*@Alloc*/ (&M{}))
-  print(& /*@Alloc*/ (M{}))
+  print(& /*@MakeMap*/ (M{}))
 
   m1 := /*@MakeMap*/ (M{})
   m2 := /*@Alloc*/ (&M{})
-  m3 := & /*@Alloc*/ (M{})
+  m3 := & /*@MakeMap*/ (M{})
   _, _, _ = m1, m2, m3
 
   _ = /*@MakeMap*/ (M{})
   _ = /*@<nil>*/ (& /*@MakeMap*/ (M{})) // & optimized away
   _ = & /*@MakeMap*/ (M{})
 
   // 4. Structs
   print( /*@UnOp*/ (struct{}{}))

llgo/trunk/third_party/gotools/go/ssa/testmain.go

 // 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 ssa
 
 // CreateTestMainPackage synthesizes a main package that runs all the
 // tests of the supplied packages.
 // It is closely coupled to $GOROOT/src/cmd/go/test.go and $GOROOT/src/testing.
 
 import (
   "go/ast"
   "go/token"
   "os"
+  "sort"
   "strings"
 
+  "llvm.org/llgo/third_party/gotools/go/exact"
   "llvm.org/llgo/third_party/gotools/go/types"
 )
 
 // FindTests returns the list of packages that define at least one Test,
 // Example or Benchmark function (as defined by "go test"), and the
 // lists of all such functions.
 //
 func FindTests(pkgs []*Package) (testpkgs []*Package, tests, benchmarks, examples []*Function) {
func (prog *Program) CreateTestMainPackage(pkgs ...*Package) *Package {
   if len(pkgs) == 0 {
     return nil
   }
 
   testmain := &Package{
     Prog:    prog,
     Members: make(map[string]Member),
     values:  make(map[types.Object]Value),
-    Object:  types.NewPackage("testmain", "testmain"),
+    Object:  types.NewPackage("test$main", "main"),
   }
 
   // Build package's init function.
   init := &Function{
     name:      "init",
     Signature: new(types.Signature),
     Synthetic: "package initializer",
     Pkg:       testmain,
     Prog:      prog,
   }
   init.startBody()
 
   if testMainStartBodyHook != nil {
     testMainStartBodyHook(init)
   }
 
   // Initialize packages to test.
+  var pkgpaths []string
   for _, pkg := range pkgs {
     var v Call
     v.Call.Value = pkg.init
     v.setType(types.NewTuple())
     init.emit(&v)
+
+    pkgpaths = append(pkgpaths, pkg.Object.Path())
   }
+  sort.Strings(pkgpaths)
   init.emit(new(Return))
   init.finishBody()
   testmain.init = init
   testmain.Object.MarkComplete()
   testmain.Members[init.name] = init
 
-  main := &Function{
-    name:      "main",
-    Signature: new(types.Signature),
-    Synthetic: "test main function",
-    Prog:      prog,
-    Pkg:       testmain,
-  }
+  // For debugging convenience, define an unexported const
+  // that enumerates the packages.
+  packagesConst := types.NewConst(token.NoPos, testmain.Object, "packages", tString,
+    exact.MakeString(strings.Join(pkgpaths, " ")))
+  memberFromObject(testmain, packagesConst, nil)
+
+  // Create main *types.Func and *ssa.Function
+  mainFunc := types.NewFunc(token.NoPos, testmain.Object, "main", new(types.Signature))
+  memberFromObject(testmain, mainFunc, nil)
+  main := testmain.Func("main")
+  main.Synthetic = "test main function"
 
   main.startBody()
 
   if testMainStartBodyHook != nil {
     testMainStartBodyHook(main)
   }
 
   if testingPkg := prog.ImportedPackage("testing"); testingPkg != nil {

llgo/trunk/third_party/gotools/go/ssa/util.go

import (
   "go/token"
   "io"
   "os"
 
   "llvm.org/llgo/third_party/gotools/go/ast/astutil"
   "llvm.org/llgo/third_party/gotools/go/types"
 )
 
-func unreachable() {
-  panic("unreachable")
-}
-
 //// AST utilities
 
 func unparen(e ast.Expr) ast.Expr { return astutil.Unparen(e) }
 
 // isBlankIdent returns true iff e is an Ident with name "_".
 // They have no associated types.Object, and thus no type.
 //
 func isBlankIdent(e ast.Expr) bool {
   id, ok := e.(*ast.Ident)
   return ok && id.Name == "_"
 }
 
 //// Type utilities.  Some of these belong in go/types.
 
 // isPointer returns true for types whose underlying type is a pointer.
 func isPointer(typ types.Type) bool {
   _, ok := typ.Underlying().(*types.Pointer)
   return ok
 }
 
-// isInterface reports whether T's underlying type is an interface.
-func isInterface(T types.Type) bool {
-  _, ok := T.Underlying().(*types.Interface)
-  return ok
-}
+func isInterface(T types.Type) bool { return types.IsInterface(T) }
 
 // deref returns a pointer's element type; otherwise it returns typ.
 func deref(typ types.Type) types.Type {
   if p, ok := typ.Underlying().(*types.Pointer); ok {
     return p.Elem()
   }
   return typ
 }

llgo/trunk/third_party/gotools/go/types/assignments.go

func (check *Checker) assignment(x *operand, T Type) bool {
 
   if isUntyped(x.typ) {
     target := T
     // spec: "If an untyped constant is assigned to a variable of interface
     // type or the blank identifier, the constant is first converted to type
     // bool, rune, int, float64, complex128 or string respectively, depending
     // on whether the value is a boolean, rune, integer, floating-point, complex,
     // or string constant."
-    if T == nil || isInterface(T) {
+    if T == nil || IsInterface(T) {
       if T == nil && x.typ == Typ[UntypedNil] {
         check.errorf(x.pos(), "use of untyped nil")
         x.mode = invalid
         return false
       }
       target = defaultType(x.typ)
     }
     check.convertUntyped(x, target)

llgo/trunk/third_party/gotools/go/types/call.go

case *Func:
         // Verify that LookupFieldOrMethod and MethodSet.Lookup agree.
         typ := x.typ
         if x.mode == variable {
           // If typ is not an (unnamed) pointer or an interface,
           // use *typ instead, because the method set of *typ
           // includes the methods of typ.
           // Variables are addressable, so we can always take their
           // address.
-          if _, ok := typ.(*Pointer); !ok && !isInterface(typ) {
+          if _, ok := typ.(*Pointer); !ok && !IsInterface(typ) {
             typ = &Pointer{base: typ}
           }
         }
         // If we created a synthetic pointer type above, we will throw
         // away the method set computed here after use.
         // TODO(gri) Method set computation should probably always compute
         // both, the value and the pointer receiver method set and represent
         // them in a single structure.

llgo/trunk/third_party/gotools/go/types/conversions.go

func (check *Checker) conversion(x *operand, T Type) {
   final := x.typ
   if isUntyped(x.typ) {
     final = T
     // - For conversions to interfaces, use the argument's default type.
     // - For conversions of untyped constants to non-constant types, also
     //   use the default type (e.g., []byte("foo") should report string
     //   not []byte as type for the constant "foo").
     // - Keep untyped nil for untyped nil arguments.
-    if isInterface(T) || constArg && !isConstType(T) {
+    if IsInterface(T) || constArg && !isConstType(T) {
       final = defaultType(x.typ)
     }
     check.updateExprType(x.expr, final, true)
   }
 
   x.typ = T
 }
 

llgo/trunk/third_party/gotools/go/types/expr.go

if e.Type != nil {
           openArray = true
         }
       }
       if typ == nil {
         typ = check.typ(e.Type)
       }
     }
     if typ == nil {
+      // TODO(gri) provide better error messages depending on context
       check.error(e.Pos(), "missing type in composite literal")
       goto Error
     }
 
     switch typ, _ := deref(typ); utyp := typ.Underlying().(type) {
     case *Struct:
       if len(e.Elts) == 0 {
         break
case *Struct:
             continue
           }
           check.expr(x, e)
           if i >= len(fields) {
             check.error(x.pos(), "too many values in struct literal")
             break // cannot continue
           }
           // i < len(fields)
-          etyp := fields[i].typ
+          fld := fields[i]
+          if !fld.Exported() && fld.pkg != check.pkg {
+            check.errorf(x.pos(), "implicit assignment to unexported field %s in %s literal", fld.name, typ)
+            continue
+          }
+          etyp := fld.typ
           if !check.assignment(x, etyp) {
             if x.mode != invalid {
               check.errorf(x.pos(), "cannot use %s as %s value in struct literal", x, etyp)
             }
             continue
           }
         }
         if len(e.Elts) < len(fields) {
case *ast.CompositeLit:
     case *Map:
       visited := make(map[interface{}][]Type, len(e.Elts))
       for _, e := range e.Elts {
         kv, _ := e.(*ast.KeyValueExpr)
         if kv == nil {
           check.error(e.Pos(), "missing key in map literal")
           continue
         }
-        check.expr(x, kv.Key)
+        check.exprWithHint(x, kv.Key, utyp.key)
         if !check.assignment(x, utyp.key) {
           if x.mode != invalid {
             check.errorf(x.pos(), "cannot use %s as %s key in map literal", x, utyp.key)
           }
           continue
         }
         if x.mode == constant {
           duplicate := false

llgo/trunk/third_party/gotools/go/types/predicates.go

func isOrdered(typ Type) bool {
   return ok && t.info&IsOrdered != 0
 }
 
 func isConstType(typ Type) bool {
   t, ok := typ.Underlying().(*Basic)
   return ok && t.info&IsConstType != 0
 }
 
-func isInterface(typ Type) bool {
+// IsInterface reports whether typ is an interface type.
+func IsInterface(typ Type) bool {
   _, ok := typ.Underlying().(*Interface)
   return ok
 }
 
 // Comparable reports whether values of type T are comparable.
 func Comparable(T Type) bool {
   switch t := T.Underlying().(type) {
   case *Basic:

llgo/trunk/third_party/gotools/go/types/stmt.go

case *ast.AssignStmt:
         return
       }
 
       lhs, _ = guard.Lhs[0].(*ast.Ident)
       if lhs == nil {
         check.invalidAST(s.Pos(), "incorrect form of type switch guard")
         return
       }
+
+      if lhs.Name == "_" {
+        // _ := x.(type) is an invalid short variable declaration
+        check.softErrorf(lhs.Pos(), "no new variable on left side of :=")
+        lhs = nil // avoid declared but not used error below
+      } else {
         check.recordDef(lhs, nil) // lhs variable is implicitly declared in each cause clause
+      }
 
       rhs = guard.Rhs[0]
 
     default:
       check.invalidAST(s.Pos(), "incorrect form of type switch guard")
       return
     }
 
case *ast.ForStmt:
     check.stmt(inner, s.Body)
 
   case *ast.RangeStmt:
     inner |= breakOk | continueOk
     check.openScope(s, "for")
     defer check.closeScope()
 
     // check expression to iterate over
-    decl := s.Tok == token.DEFINE
     var x operand
     check.expr(&x, s.X)
-    if x.mode == invalid {
-      // if we don't have a declaration, we can still check the loop's body
-      // (otherwise we can't because we are missing the declared variables)
-      if !decl {
-        check.stmt(inner, s.Body)
-      }
-      return
-    }
 
     // determine key/value types
     var key, val Type
+    if x.mode != invalid {
       switch typ := x.typ.Underlying().(type) {
       case *Basic:
         if isString(typ) {
           key = Typ[Int]
           val = UniverseRune // use 'rune' name
         }
       case *Array:
         key = Typ[Int]
         val = typ.elem
       case *Slice:
         key = Typ[Int]
         val = typ.elem
       case *Pointer:
         if typ, _ := typ.base.Underlying().(*Array); typ != nil {
           key = Typ[Int]
           val = typ.elem
         }
       case *Map:
         key = typ.key
         val = typ.elem
       case *Chan:
         key = typ.elem
         val = Typ[Invalid]
         if typ.dir == SendOnly {
           check.errorf(x.pos(), "cannot range over send-only channel %s", &x)
           // ok to continue
         }
         if s.Value != nil {
           check.errorf(s.Value.Pos(), "iteration over %s permits only one iteration variable", &x)
           // ok to continue
         }
       }
+    }
 
     if key == nil {
       check.errorf(x.pos(), "cannot range over %s", &x)
-      // if we don't have a declaration, we can still check the loop's body
-      if !decl {
-        check.stmt(inner, s.Body)
-      }
-      return
+      // ok to continue
     }
 
     // check assignment to/declaration of iteration variables
     // (irregular assignment, cannot easily map to existing assignment checks)
 
     // lhs expressions and initialization value (rhs) types
     lhs := [2]ast.Expr{s.Key, s.Value}
-    rhs := [2]Type{key, val}
+    rhs := [2]Type{key, val} // key, val may be nil
 
-    if decl {
+    if s.Tok == token.DEFINE {
       // short variable declaration; variable scope starts after the range clause
       // (the for loop opens a new scope, so variables on the lhs never redeclare
       // previously declared variables)
       var vars []*Var
       for i, lhs := range lhs {
         if lhs == nil {
           continue
         }
if s.Tok == token.DEFINE {
             vars = append(vars, obj)
           }
         } else {
           check.errorf(lhs.Pos(), "cannot declare %s", lhs)
           obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
         }
 
         // initialize lhs variable
+        if typ := rhs[i]; typ != nil {
           x.mode = value
           x.expr = lhs // we don't have a better rhs expression to use here
-        x.typ = rhs[i]
+          x.typ = typ
           check.initVar(obj, &x, false)
+        } else {
+          obj.typ = Typ[Invalid]
+          obj.used = true // don't complain about unused variable
+        }
       }
 
       // declare variables
       if len(vars) > 0 {
         for _, obj := range vars {
           check.declare(check.scope, nil /* recordDef already called */, obj)
         }
       } else {
         check.error(s.TokPos, "no new variables on left side of :=")
       }
     } else {
       // ordinary assignment
       for i, lhs := range lhs {
         if lhs == nil {
           continue
         }
+        if typ := rhs[i]; typ != nil {
           x.mode = value
           x.expr = lhs // we don't have a better rhs expression to use here
-        x.typ = rhs[i]
+          x.typ = typ
           check.assignVar(lhs, &x)
         }
       }
+    }
 
     check.stmt(inner, s.Body)
 
   default:
     check.error(s.Pos(), "invalid statement")
   }
 }

llgo/trunk/third_party/gotools/go/types/testdata/constdecl.src

 
 func _() {
   const _ = v /* ERROR "not constant" */
   const _ = math /* ERROR "not constant" */ .Sin(0)
   const _ = int /* ERROR "not an expression" */
 }
 
 // Identifier and expression arity must match.
-const _ /* ERROR "missing init expr for _" */
+// The first error message is produced by the parser.
+// In a real-world scenario, the type-checker would not be run
+// in this case and the 2nd error message would not appear.
+const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
 const _ = 1, 2 /* ERROR "extra init expr 2" */
 
-const _ /* ERROR "missing init expr for _" */ int
+const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
 const _ int = 1, 2 /* ERROR "extra init expr 2" */
 
 const (
-  _ /* ERROR "missing init expr for _" */
+  _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
   _ = 1, 2 /* ERROR "extra init expr 2" */
 
-  _ /* ERROR "missing init expr for _" */ int
+  _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
   _ int = 1, 2 /* ERROR "extra init expr 2" */
 )
 
 const (
   _ = 1
   _
   _, _ /* ERROR "missing init expr for _" */
   _
 )
 
 const (
   _, _ = 1, 2
   _, _
   _ /* ERROR "extra init expr at" */
   _, _
   _, _, _ /* ERROR "missing init expr for _" */
   _, _
 )
 
 func _() {
-  const _ /* ERROR "missing init expr for _" */
+  const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
   const _ = 1, 2 /* ERROR "extra init expr 2" */
 
-  const _ /* ERROR "missing init expr for _" */ int
+  const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
   const _ int = 1, 2 /* ERROR "extra init expr 2" */
 
   const (
-    _ /* ERROR "missing init expr for _" */
+    _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
     _ = 1, 2 /* ERROR "extra init expr 2" */
 
-    _ /* ERROR "missing init expr for _" */ int
+    _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
     _ int = 1, 2 /* ERROR "extra init expr 2" */
   )
 
   const (
     _ = 1
     _
     _, _ /* ERROR "missing init expr for _" */
     _

llgo/trunk/third_party/gotools/go/types/testdata/expr3.src

 // 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 expr3
 
+import "time"
+
 func indexes() {
   _ = 1 /* ERROR "cannot index" */ [0]
   _ = indexes /* ERROR "cannot index" */ [0]
   _ = ( /* ERROR "cannot slice" */ 12 + 3)[1:2]
 
   var a [10]int
   _ = a[true /* ERROR "cannot convert" */ ]
   _ = a["foo" /* ERROR "cannot convert" */ ]
   _ = a[1.1 /* ERROR "truncated" */ ]
   _ = a[1.0]
   _ = a[- /* ERROR "negative" */ 1]
   _ = a[- /* ERROR "negative" */ 1 :]
   _ = a[: - /* ERROR "negative" */ 1]
   _ = a[: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
   _ = a[0: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
   _ = a[0: /* ERROR "2nd index required" */ :10]
   _ = a[:10:10]
 
   var a0 int
   a0 = a[0]
   _ = a0
   var a1 int32
-  a1 = a /* ERROR "cannot assign" */ [1] 
+  a1 = a /* ERROR "cannot assign" */ [1]
   _ = a1
 
   _ = a[9]
   _ = a[10 /* ERROR "index .* out of bounds" */ ]
   _ = a[1 /* ERROR "overflows" */ <<100]
   _ = a[10:]
   _ = a[:10]
   _ = a[10:10]
func indexes() {
   _ = m /* ERROR "cannot slice" */ ["foo" : "bar"]
   _ = m["foo"]
   // ok is of type bool
   type mybool bool
   var ok mybool
   _, ok = m["bar"]
   _ = ok
 
-
   var t string
   _ = t[- /* ERROR "negative" */ 1]
   _ = t[- /* ERROR "negative" */ 1 :]
   _ = t[: - /* ERROR "negative" */ 1]
   _ = t /* ERROR "3-index slice of string" */ [1:2:3]
   _ = "foo" /* ERROR "3-index slice of string" */ [1:2:3]
   var t0 byte
   t0 = t[0]
func struct_literals() {
   // keyed elements
   _ = T1{}
   _ = T1{a: 0, 1 /* ERROR "mixture of .* elements" */ }
   _ = T1{aa /* ERROR "unknown field" */ : 0}
   _ = T1{1 /* ERROR "invalid field name" */ : 0}
   _ = T1{a: 0, s: "foo", u: 0, a /* ERROR "duplicate field" */: 10}
   _ = T1{a: "foo" /* ERROR "cannot convert" */ }
   _ = T1{c /* ERROR "unknown field" */ : 0}
-  _ = T1{T0: { /* ERROR "missing type" */ }}
+  _ = T1{T0: { /* ERROR "missing type" */ }} // struct literal element type may not be elided
   _ = T1{T0: T0{}}
   _ = T1{T0 /* ERROR "invalid field name" */ .a: 0}
 
   // unkeyed elements
   _ = T0{1, 2, 3}
   _ = T0{1, b /* ERROR "mixture" */ : 2, 3}
   _ = T0{1, 2} /* ERROR "too few values" */
   _ = T0{1, 2, 3, 4  /* ERROR "too many values" */ }
   _ = T0{1, "foo" /* ERROR "cannot convert" */, 3.4  /* ERROR "truncated" */}
 
   // invalid type
   type P *struct{
     x int
   }
   _ = P /* ERROR "invalid composite literal type" */ {}
+
+  // unexported fields
+  _ = time.Time{}
+  _ = time.Time{sec /* ERROR "unknown field" */ : 0}
+  _ = time.Time{
+    0 /* ERROR implicit assignment to unexported field sec in time.Time literal */,
+    0 /* ERROR implicit assignment */ ,
+    nil /* ERROR implicit assignment */ ,
+  }
 }
 
 func array_literals() {
   type A0 [0]int
   _ = A0{}
   _ = A0{0 /* ERROR "index .* out of bounds" */}
   _ = A0{0 /* ERROR "index .* out of bounds" */ : 0}
 
func array_literals() {
   const f = 2.1
   const s = "foo"
   _ = A1{i /* ERROR "index i must be integer constant" */ : 0}
   _ = A1{f /* ERROR "truncated" */ : 0}
   _ = A1{s /* ERROR "cannot convert" */ : 0}
 
   a0 := [...]int{}
   assert(len(a0) == 0)
-  
   a1 := [...]int{0, 1, 2}
   assert(len(a1) == 3)
   var a13 [3]int
   var a14 [4]int
   a13 = a1
   a14 = a1 /* ERROR "cannot assign" */
   _, _ = a13, a14
-  
   a2 := [...]int{- /* ERROR "negative" */ 1: 0}
   _ = a2
 
   a3 := [...]int{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
   assert(len(a3) == 5) // somewhat arbitrary
 
   a4 := [...]complex128{0, 1, 2, 1<<10-2: -1i, 1i, 400: 10, 12, 14}
   assert(len(a4) == 1024)
 
+  // composite literal element types may be elided
+  type T []int
+  _ = [10]T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
+  a6 := [...]T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
+  assert(len(a6) == 8)
+
+  // recursively so
+  _ = [10][10]T{{}, [10]T{{}}, {{1, 2, 3}}}
+
   // from the spec
   type Point struct { x, y float32 }
   _ = [...]Point{Point{1.5, -3.5}, Point{0, 0}}
   _ = [...]Point{{1.5, -3.5}, {0, 0}}
   _ = [][]int{[]int{1, 2, 3}, []int{4, 5}}
   _ = [][]int{{1, 2, 3}, {4, 5}}
   _ = [...]*Point{&Point{1.5, -3.5}, &Point{0, 0}}
   _ = [...]*Point{{1.5, -3.5}, {0, 0}}
func slice_literals() {
   // indices must be integer constants
   i := 1
   const f = 2.1
   const s = "foo"
   _ = S0{i /* ERROR "index i must be integer constant" */ : 0}
   _ = S0{f /* ERROR "truncated" */ : 0}
   _ = S0{s /* ERROR "cannot convert" */ : 0}
 
+  // composite literal element types may be elided
+  type T []int
+  _ = []T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
+  _ = [][]int{{1, 2, 3}, {4, 5}}
+
+  // recursively so
+  _ = [][]T{{}, []T{{}}, {{1, 2, 3}}}
 }
 
 const index2 int = 2
 
 type N int
 func (N) f() {}
 
 func map_literals() {
func map_literals() {
   key1 := "foo"
   _ = M0{key1: 1}
   _ = M0{key2: 2}
   _ = M0{key3 /* ERROR "undeclared name" */ : 2}
 
   var value int
   _ = M1{true: 1, false: 0}
   _ = M2{nil: 0, &value: 1}
+
+  // composite literal element types may be elided
+  type T [2]int
+  _ = map[int]T{0: T{3, 4}, 1: {5, 6}}
+
+  // recursively so
+  _ = map[int][]T{0: {}, 1: {{}, T{1, 2}}}
+
+  // composite literal key types may be elided
+  _ = map[T]int{T{3, 4}: 0, {5, 6}: 1}
+
+  // recursively so
+  _ = map[[2]T]int{{}: 0, {{}}: 1, [2]T{{}}: 2, {T{1, 2}}: 3}
+
+  // composite literal element and key types may be elided
+  _ = map[T]T{{}: {}, {1, 2}: T{3, 4}, T{4, 5}: {}}
+  _ = map[T]M0{{} : {}, T{1, 2}: M0{"foo": 0}, {1, 3}: {"foo": 1}}
+
+  // recursively so
+  _ = map[[2]T][]T{{}: {}, {{}}: {{}, T{1, 2}}, [2]T{{}}: nil, {T{1, 2}}: {{}, {}}}
+
+  // from the spec
+  type Point struct { x, y float32 }
+  _ = map[string]Point{"orig": {0, 0}}
+  _ = map[*Point]string{{0, 0}: "orig"}
 }
 
 var key2 string = "bar"
 
 type I interface {
   m()
 }
 

llgo/trunk/third_party/gotools/go/types/testdata/stmt0.src

func typeswitches() {
   switch (x /* ERROR "outside type switch" */ .(type)) {}
 
   switch x.(type) {
   default:
   default /* ERROR "multiple defaults" */ :
   }
 
   switch x /* ERROR "declared but not used" */ := x.(type) {}
+  switch _ /* ERROR "no new variable on left side of :=" */ := x.(type) {}
 
   switch x := x.(type) {
   case int:
     var y int = x
     _ = y
   }
 
   switch x := i /* ERROR "not an interface" */ .(type) {}

 func issue6766b() {
   for _ := /* ERROR no new variables */ range "" {}
   for a, a /* ERROR redeclared */ := range "" { _ = a }
   var a int
   _ = a
   for a, a /* ERROR redeclared */ := range []int{1, 2, 3} { _ = a }
 }
 
+// Test that despite errors in the range clause,
+// the loop body is still type-checked (and thus
+// errors reported).
+func issue10148() {
+  for y /* ERROR declared but not used */ := range "" {
+    _ = "" /* ERROR cannot convert */ + 1
+  }
+  for range 1 /* ERROR cannot range over 1 */ {
+    _ = "" /* ERROR cannot convert */ + 1
+  }
+  for y := range 1 /* ERROR cannot range over 1 */ {
+    _ = "" /* ERROR cannot convert */ + 1
+  }
+}
+
 func labels0() {
   goto L0
   goto L1
   L0:
   L1:
   L1 /* ERROR "already declared" */ :
   if true {
     goto L2   

llgo/trunk/third_party/gotools/go/types/testdata/vardecl.src

 // 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 vardecl
 
 // Prerequisites.
 import "math"
 func f() {}
 func g() (x, y int) { return }
 var m map[string]int
 
 // Var decls must have a type or an initializer.
 var _ int
 var _, _ int
 
-var _ /* ERROR "missing type or init expr" */
-var _ /* ERROR "missing type or init expr" */, _
-var _ /* ERROR "missing type or init expr" */, _, _
+// The first error message is produced by the parser.
+// In a real-world scenario, the type-checker would not be run
+// in this case and the 2nd error message would not appear.
+var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */
+var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */, _
+var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */, _, _
 
 // The initializer must be an expression.
 var _ = int /* ERROR "not an expression" */
 var _ = f /* ERROR "used as value" */ ()
 
 // Identifier and expression arity must match.
 var _, _ = 1, 2
 var _ = 1, 2 /* ERROR "extra init expr 2" */
func _() {
   _, a, b := 0, 1, 2
   _, _, _ := /* ERROR no new variables */ 0, 1, 2
 
   _ = a
   _ = b
 }
 
 // TODO(gri) consolidate other var decl checks in this file
 No newline at end of file

llgo/trunk/update_third_party.sh

 #!/bin/sh -e
 
 gofrontendrepo=https://code.google.com/p/gofrontend
 gofrontendrev=0fde0b6a7eb2
 
 gccrepo=svn://gcc.gnu.org/svn/gcc/trunk
 gccrev=216268
 
 gotoolsrepo=https://go.googlesource.com/tools
-gotoolsrev=47f2109c640e97025f36c98610bd9782e815012e
+gotoolsrev=d4e70101500b43ffe705d4c45e50dd4f1c8e3b2e
 
 tempdir=$(mktemp -d /tmp/update_third_party.XXXXXX)
 gofrontenddir=$tempdir/gofrontend
 gotoolsdir=$tempdir/go.tools
 
 rm -rf third_party
 mkdir -p third_party/gofrontend third_party/gotools
 

 (cd $gotoolsdir && git checkout $gotoolsrev)
 
 cp -r $gotoolsdir/LICENSE $gotoolsdir/go third_party/gotools
 
 # Vendor the go.tools repository.
 find third_party/gotools -name '*.go' | xargs sed -i -e \
   's,"golang.org/x/tools/,"llvm.org/llgo/third_party/gotools/,g'
 
-# Until the version skew between the "go" tool and the compiler is resolved,
-# we patch out Go 1.4 specific code in go.tools.
-sed -i -e '/go1\.4/ d' third_party/gotools/go/exact/go13.go
-rm third_party/gotools/go/exact/go14.go
-
 # --------------------- license check ---------------------
 
 # We don't want any GPL licensed code without an autoconf/libtool
 # exception, or any GPLv3 licensed code.
 
 for i in `grep -lr 'General Public License' third_party` ; do
   if grep -q 'configuration script generated by Autoconf, you may include it under' $i || \
      grep -q 'is built using GNU Libtool, you may include this file under the' $i ; then