[dev.go2go] README: document that this branch is no longer maintained

For golang/go#46346

Change-Id: Iab050557efb96217477072eca42966662485b6b1
Reviewed-on: https://go-review.googlesource.com/c/go/+/322192
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>

README.go2go.md

@@ -0,0 +1,46 @@
+# dev.go2go branch
+
+This branch provides an experimental go2go tool for testing the use of
+the generics design draft.
+This branch was published in 2020 and is no longer being maintained.
+The [generics
+proposal](https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-parameters.md)
+has [been accepted](https://golang.org/issue/43651) and development is
+now focused on implementing the proposal in the ordinary Go tools.
+
+## Original README
+
+This branch contains a type checker and a translation tool for
+experimentation with generics in Go.
+This implements the [generics design draft](https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md).
+
+You can build this branch [as
+usual](https://golang.org/doc/install/source).
+You can then use the new `go2go` tool.
+Write your generic code in a file with the extension `.go2` instead of
+`.go`.
+Run it using `go tool go2go run x.go2`.
+There are some sample packages in `cmd/go2go/testdata/go2path/src`.
+You can see the full documentation for the tool by running `go doc
+cmd/go2go`.
+
+The `go2go` tool will look for `.go2` files using the environment variable `GO2PATH`.
+You can find some useful packages that you might want to experiment with by
+setting `GO2PATH=$GOROOT/src/cmd/go2go/testdata/go2path`.
+
+If you find bugs in the updated type checker or in the translation
+tool, they should be filed in the [standard Go issue
+tracker](https://golang.org/issue).
+Please start the issue title with `cmd/go2go`.
+Note that the issue tracker should only be used for reporting bugs in
+the tools, not for discussion of changes to the language.
+
+Unlike typical dev branches, we do not intend any eventual merge of
+this code into the master branch.
+We will update it for bug fixes and change to the generic design
+draft.
+If a generics language proposal is accepted, it will be implemented in
+the standard compiler, not via a translation tool.
+The necessary changes to the go/* packages (go/ast, go/parser, and so
+forth) may re-use code from this prototype but will follow the usual
+code review process.

codereview.cfg

@@ -1 +1,2 @@
-branch: master
+branch: dev.go2go
+parent-branch: master

src/cmd/compile/internal/types2/NOTES

@@ -0,0 +1,183 @@
+This file serves as a notebook/implementation log.
+
+----------------------------------------------------------------------------------------------------
+TODO (implementation issues)
+
+- report a better error when a type is not in a type list (investigate)
+- better error message when we need parentheses around a parameterized function parameter type
+- review handling of fields of instantiated generic types (do we need to make them non-parameterized,
+  similar to what we did for the embedded interfaces created by contract embedding?)
+- use []*TypeParam for tparams in subst? (unclear)
+- should we use nil instead of &emptyInterface for no type bounds (as an optimization)?
+- TBD: in prose, should we use "generic" or "parameterized" (try to be consistent)
+
+----------------------------------------------------------------------------------------------------
+KNOWN ISSUES
+
+- type parameter constraints are ignored when checking if a parameterized method implements the
+  matching method in an interface
+- iteration over generic variables doesn't report certain channel errors (see TODOs in code)
+- cannot handle mutually recursive parameterized interfaces using themselves as type bounds
+  example: type B(type P B(P)) interface{ m() } (need to delay all checking after seting up declarations)
+- invoking a method of a parameterized embedded type doesn't work (cannot properly determine receiver yet)
+- pointer designation is incorrectly handled when checking type list constraint satisfaction
+
+----------------------------------------------------------------------------------------------------
+OBSERVATIONS
+
+- 2/20/2020: Because we permit parenthesized types anywhere for consistency, also in parameter lists (mea
+  culpa), we have parsing ambiguities when using instantiated types in parameter lists w/o argument names.
+  We could disallow the use of parentheses at the top level of type literals and then we might not have
+  this problem. This is not a backward-compatible change but perhaps worthwhile investigating. Specifically,
+  will this always work (look specifically at channel types where we need parentheses for disambiguation
+  and possibly function types). File a proposal?
+
+- 6/3/2020: Observation: gofmt already removes superflous parentheses around types in parameter lists,
+  so in gofmt'ed code there won't be any such parentheses. Thus we can perhaps make the suggested language
+  change above without too many problems.
+
+- 2/21/2020: We do need top-level parentheses around types in certain situations such as conversions
+  or composite literals. We could disallow parentheses around types in parameter lists only, but that
+  seems quite a bit less elegant.
+
+- 6/13/2020: When comparing against the type list of an interface (to see if the interface is satisfied),
+  we must either recompute the underlying types of the type list entries after the interface was instantiated,
+  or we must compute the underlying type of each entry before comparing. (A type list may contain type
+  parameters which may be substituted with defined types when the interface is instantiated.) With the
+  latter approach (which is what's implemented now), we could relax some of the constraints that we have
+  on type lists entries: We could allow any type and just say that for interface satisfaction we always
+  look at the underlying types.
+
+----------------------------------------------------------------------------------------------------
+OPEN QUESTIONS
+
+- Parsing _ = [](a(int)){} requires parentheses around `(a(int))` - should the parser be smarter in
+  these cases? Another example: []a(b, c){} This cannot be a conversion. Could fix such cases by re-
+  associating the AST when we see a {. Need to be careful, and need to take into account additional
+  complexity of spec.
+- For len/cap(x) where x is of type parameter type and the bound contains arrays only, should the
+  result be a constant? (right now it is not). What are the implications for alternative, non-
+  monomorphizing implementation methods?
+- Confirm that it's ok to use inference in missingMethod to compare parameterized methods.
+
+----------------------------------------------------------------------------------------------------
+DESIGN/IMPLEMENTATION
+
+- 11/19/2019: For type parameters with interface bounds to work, the scope of all type parameters in
+  a type parameter list starts at the "type" keyword. This makes all type parameters visible for all
+  type parameter bounds (interfaces that may be parameterized with the type parameters).
+
+- 12/4/2019: do not allow parenthesized generic uninstantiated types (unless instantiated implicitly)
+  In other words: generic types must always be instantiated before they can be used in any form
+  More generally: Only permit type instantiation T(x) in type context, when the type is a named type.
+  Do not permit it in general in type context: e.g., disallow []T(x) because we consider that a
+  conversion, in general. Same for ([]T)(x).
+
+- 12/12/2019: represent type bounds always as (possibly unnamed) interfaces
+  (contracts are user syntactic sugar)
+
+- 12/19/2019: Type parameters don't act like type aliases. For instance:
+
+        func f(type T1, T2)(x T1) T2 { return x }
+
+  is not valid, no matter how T1 and T2 are instantiated (but if T1 and T2 were type aliases with
+  both of them having type int, the return x would be valid). In fact, the type parameters act more
+  like named types with the methods described by their type bound. But type parameters are never
+  interfaces. To determine: Given a type parameter P, is P == underlying(P) (like for basic types),
+  or is the the underlying type of P something else (like for defined types). Is there an observable
+  difference?
+
+- 12/19/2019: Rewrote contract handling: they are now treated as Objects (rather than Types) throughout.
+
+- 12/20/2019: Decided to start moving type parameters to types (from TypeName to Named), need to do the
+  same for Func. This make more sense as in general any type (conceptually even literal types) could
+  have type parameters. It's a property of the type, not the type name. It also simplified the code.
+
+- 12/20/2019: Type parameters may be part of type lists in contracts/interfaces. It just falls out
+  naturally. Added test cases.
+
+- 12/23/2019: Decision: Type parameters and ordinary (value) parameters are in the same block, notably
+  the function block. The scope of type parameters starts at the 'type' keyword; the scope of ordinary
+  parameters starts with the (opening '{' of the) function body. Both scopes end with the closing '}'
+  of the function body (i.e., the end of the function block).
+
+- 1/2/2020: Implementation decision: contracts can only be declared at the package level.
+
+- 1/6/2020: Experimental: First steps towards permitting type parameters in methods as a generalization.
+  Type-checking problems ooccurring from this are likely to highlight general problematic areas.
+  First consequence: Scope of type parameters starts at "func" keyword which means that receiver type
+  name cannot be a type parameter name declared later (or by the receiver type specification). This
+  seems reasonable and should help avoid confusion which is possible otherwise.
+
+- 1/7/2020: We distinguish embedded instantiated (parameterized) interfaces from methods by enclosing
+  the embedded interfaces in parentheses (the design draft recommends this change). Since this opens
+  the possibility for any parenthesized type (that is an interface), we can also allow (parenthesized)
+  interface literals as it is simpler to permit those than forbid them.
+
+- 1/7/2020: The current implementation permits empty type parameter lists as in: "func f(type)(x int)"
+  but we cannot call such a function as "f()(1)"; the empty type argument list causes problems.
+  Document that we allow empty type parameter list declarations, but not empty actual type parameter
+  lists. (We could allow them for types, but that doesn't seem consistent and probably is confusing).
+
+- 2/19/2020: We accept parenthesized embedded struct fields so we can distinguish between a named
+  field with a parenthesized type foo (T) and an embedded parameterized type (foo(T)), similarly
+  to interace embedding.
+
+- 2/19/2020: Permit parentheses around embedded contracts for symmetry with embedding in structs
+  and interfaces.
+
+- 2/20/2020: Receiver type parameters must always be provided in the receiver parameter list of
+  a method, even if they are not used by the method. Since the receiver acts like an implicit
+  declaration of those type parameters, they may be blank, as with any other declaration.
+
+- 3/20/2020: Local type declarations with an underlying type that is a type parameter lose the
+  methods declared with the type parameter bound. But they don't lose the properties of the
+  underlying type, i.e., the properties of the type parameter bound's type list.
+  This is something to consider if we were contemplating moving to a methods-only approach
+  (no type lists), even though local type declarations are exceedingly rare if they exist at
+  all in the wild.
+
+- 3/24/2020: Implemented initial support for bidirection type unification which could make
+  type inference more powerful if we decided to go that route. Specifically, this would
+  permit type inference for the type parameters of a generic function argument. Given:
+  func h(f func(int)); func g(type T)(T); one could allow the call: h(g) and the type argument
+  T of g would be inferred to be int. While not hard to implement, this would be a special case
+  of the rule that all generic types/functions must be instantiated before they are used except
+  for function calls where the type arguments can be inferred from the actual arguments.
+  Decided that for now we leave things as is, since it's not clear the extra complexity is
+  worth the (probably small) convenience.
+
+- 3/25/2020: We can probably simplify the contract syntax again and only permit one of three
+  possible constraint entries: 1) an embedded contract, 2) a type parameter followed by a
+  method signature, and 3) a type parameter followed by a type list. This is what the type
+  checker currently supports and the printer can print. (The parser still accepts a list of
+  method signatures or types, freely mixed.)
+
+- 4/24/2020: Permit omission of explicit type bound instantiation if the type bound is an
+  interface that applies to exactly one type parameter and the type bound expects exactly
+  one type argument. This makes parameterized interface type bounds easier to use in a common
+  case.
+
+- 5/?/2020: Relaxed above syntactic sugar and permit omission of explicit type bound instantiation
+  in any case where the type bound only accepts a single type parameter.
+  We may not want to permit this in the first version as this is something we can always add later.
+
+- 6/3/2020: A function type parameter acts like a named type. If its type bound has a type list
+  that type list determines the underlying type of the type parameter. If the bound doesn't have
+  a type list, the underlying type of a type parameter is itself. (We may decide that in this
+  latter case there may no underlying type at all which would perhaps more consistent. But this
+  is not clear cut.)
+
+- 6/6/2020: The underlying type of a type parameter must _always_ be itself, otherwise a declaration
+  such as: type T(type P interface{type int}) P would have an underlying type int which is wrong.
+
+- 6/7/2020: Introduced the notion of an operational type which is used when determining what
+  operations are supported by a value of a given type. The operational type of a type parameter
+  is determined by its type bound. The operational type of any other type is its underlying
+  type. This approach appears to complete the picture about the nature of type parameters.
+
+- 6/7/2020: Removed support for contracts to match the latest design draft.
+
+- 6/15/2020: Disabled check that types in type lists must only contain basic types or composite types
+  composed of basic types. It is not needed since we always must recompute the underlying types
+  after a (possible) instantiation anyway (see observation from 6/3/2020).

src/cmd/compile/internal/types2/README

@@ -0,0 +1,68 @@
+This version of go/types is part of the prototype that implements the
+extended Go language as outlined by the latest generics draft design.
+
+DISCLAIMER
+
+This code is based on the std/library's go/types package but it has
+been modified heavily. Please bear in mind that:
+
+- This is a prototype. Expect bugs, incomplete parts, and suboptimal
+  and (gulp) possibly ugly code.
+
+- While all the major aspects of the generics design draft have been
+  implemented, parts are missing, especially around the operations permitted
+  on operands of generic types. In such cases, the result is most often
+  an error reporting that a certain operation is not permitted even though
+  it should be according to the draft design.
+
+- As prototyping continues, expect refinement and possibly divergence
+  from the most recent draft design published.
+
+EXAMPLE CODE
+
+For tests and example code (with detailed comments) look for files
+with suffix .go2 in the testdata and examples subdirectories.
+
+(The suffix .go2 is solely to distinguish them from regular Go code and
+to prevent gofmt from touching them. We expect a proper implementation to
+keep using .go .)
+
+RUNNING THE TYPE-CHECKER
+
+The type-checker is automatically run as part of the go2go tool.
+To experiment with generic code, it is recommened to use that tool.
+
+But the type-checker can also be run stand-alone on source code if
+so desired. There are two primary ways:
+
+1) By building the gotype tool in this source directory:
+
+      go build gotype.go
+
+   and then running the resulting binary on some input files
+
+      ./gotype <package files>
+
+   (Make sure to use the correct go tool when building.)
+
+2) By using the type-checker's TestCheck test function which
+   accepts a list of user provided files:
+
+      go test -run Check$ -errlist -files <package files>
+
+   For instance:
+
+      go test -run Check$ -files examples/types.go2
+
+   TestCheck will match any type errors against ERROR comments
+   in the source files and complain about discrepancies.
+   To report the errors instead, use:
+
+      go test -run Check$ -errlist -files examples/types.go2
+
+   To see a trace of the type checker progress, use the -v flag:
+
+      go test -v -run Check$ -errlist -files examples/types.go2
+
+   (When playing with this code, sometimes go vet gets in the
+   way, so it can be helpful to also provide -vet off.)

src/cmd/go2go/doc.go

@@ -0,0 +1,71 @@
+// Copyright 2020 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.
+
+// go2go is a command for trying out generic Go code.
+// It supports a small number of commands similar to cmd/go.
+//
+// This tool was intended for experimental use during the development
+// of the generics proposal, and is no longer maintained.
+//
+// Usage:
+//
+//	go2go [options] <command> [go2go flags] [arguments]
+//
+// Commands:
+//
+//      build      translate and then run "go build packages"
+//      run        translate and then run a list of files
+//      test       translate and then run "go test packages"
+//      translate  translate .go2 files into .go files for listed packages
+//
+// A package is expected to contain .go2 files but no .go files.
+//
+// Non-local imported packages will be first looked up using the GO2PATH
+// environment variable, which should point to a GOPATH-like directory.
+// For example, import "x" will first look for GO2PATHDIR/src/x,
+// for each colon-separated component in GO2PATH. If not found in GO2PATH,
+// imports will be looked up in the usual way. If an import includes
+// .go2 files, they will be translated into .go files.
+//
+// The go2go flags are shared by the build, run, test, and translate commands:
+//
+//	-tags tag,list
+//		a comma-separated list of build tags to consider satisfied during the
+//		build. For more information about build tags, see the description of
+//		build constraints in the documentation for the go/build package.
+//
+// There is a sample GO2PATH in cmd/go2go/testdata/go2path. It provides
+// several packages that serve as examples of using generics, and may
+// be useful in experimenting with your own generic code.
+//
+// Translation into standard Go requires generating Go code with mangled names.
+// The mangled names will always include Odia (Oriya) digits, such as ୦ and ୮.
+// Do not use Oriya digits in identifiers in your own code.
+//
+// Because this tool generates Go files, and because instantiated types
+// and functions need to refer to the types with which they are instantiated,
+// using function-local types as type arguments is not supported.
+// Similarly, function-local parameterized types do not work.
+// These are deficiencies of the tool, they will work as expected in
+// any complete implementation.
+//
+// Similarly, generic function and type bodies that refer to unexported,
+// non-generic, names can't be instantiated by different packages.
+//
+// Because this tool generates Go files, and because it generates type
+// and function instantiations alongside other code in the package that
+// instantiates those functions and types, and because those instantiatations
+// may refer to names in packages imported by the original generic code,
+// this tool will add imports as necessary to support the instantiations.
+// Therefore, packages that use generic code must not use top level
+// definitions whose names are the same as the names of packages imported
+// by the generic code. For example, don't write, in package scope,
+//
+//     var strings = []string{"a", "b"}
+//
+// because if the generic code imports "strings", the variable name will
+// conflict with the package name, even if your code doesn't import "strings".
+// This is a deficiency of the tool, it will not be a deficiency in
+// any complete implementation.
+package main

src/cmd/go2go/go2go_test.go

@@ -0,0 +1,386 @@
+// Copyright 2020 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 main_test
+
+import (
+	"fmt"
+	"internal/testenv"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	os.Exit(testMain(m))
+}
+
+func testMain(m *testing.M) int {
+	dir, err := ioutil.TempDir("", "go2gotest")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	defer os.RemoveAll(dir)
+	testTempDir = dir
+
+	return m.Run()
+}
+
+// testTempDir is a temporary directory the tests can use.
+var testTempDir string
+
+// testGo2go is the version of cmd/go2go run by the tests.
+var testGo2go string
+
+// testGo2goOnce ensures that testGo2go is built only once.
+var testGo2goOnce sync.Once
+
+// testGo2goErr is an error that occurred when building testGo2go.
+// In the normal case this is nil.
+var testGo2goErr error
+
+// buildGo2go builds an up-to-date version of cmd/go2go.
+// This is not run from TestMain because it's simpler if it has a *testing.T.
+func buildGo2go(t *testing.T) {
+	t.Helper()
+	testenv.MustHaveGoBuild(t)
+	testGo2goOnce.Do(func() {
+		testGo2go = filepath.Join(testTempDir, "go2go.exe")
+		t.Logf("running [go build -o %s]", testGo2go)
+		out, err := exec.Command(testenv.GoToolPath(t), "build", "-o", testGo2go).CombinedOutput()
+		if len(out) > 0 {
+			t.Logf("%s", out)
+		}
+		testGo2goErr = err
+	})
+	if testGo2goErr != nil {
+		t.Fatal("failed to build testgo2go program:", testGo2goErr)
+	}
+}
+
+func TestGO2PATH(t *testing.T) {
+	t.Parallel()
+	buildGo2go(t)
+
+	copyFile := func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			t.Fatal(err)
+		}
+		newPath := filepath.Join(testTempDir, path)
+		if info.IsDir() {
+			if err := os.MkdirAll(newPath, 0o755); err != nil {
+				t.Fatal(err)
+			}
+			return nil
+		}
+		data, err := ioutil.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := ioutil.WriteFile(newPath, data, 0o444); err != nil {
+			t.Fatal(err)
+		}
+		return nil
+	}
+
+	if err := filepath.Walk("testdata/go2path/src", copyFile); err != nil {
+		t.Fatal(err)
+	}
+
+	d, err := os.Open(filepath.Join(testTempDir, "testdata/go2path/src"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer d.Close()
+	dirs, err := d.Readdirnames(-1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sort.Strings(dirs)
+
+	for _, dir := range dirs {
+		t.Run(dir, func(t *testing.T) {
+			cmd := exec.Command(testGo2go, "test")
+			cmd.Dir = filepath.Join(testTempDir, "testdata", "go2path", "src", dir)
+			cmd.Env = append(os.Environ(), "GO2PATH="+filepath.Join(testTempDir, "testdata", "go2path"))
+			t.Logf("running [%s test] in %s", testGo2go, cmd.Dir)
+			out, err := cmd.CombinedOutput()
+			if len(out) > 0 {
+				t.Log(dir)
+				t.Logf("%s", out)
+			}
+			if err != nil {
+				t.Errorf("error testing %s: %v", dir, err)
+			}
+		})
+	}
+}
+
+type testFile struct {
+	name, contents string
+}
+
+type testFiles []testFile
+
+func (tfs testFiles) create(t *testing.T, gopath string) {
+	t.Helper()
+	for _, tf := range tfs {
+		fn := filepath.Join(gopath, "src", tf.name)
+		if err := os.MkdirAll(filepath.Dir(fn), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := ioutil.WriteFile(fn, []byte(tf.contents), 0o444); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestGO2PATHEqGOPATH(t *testing.T) {
+	t.Parallel()
+	buildGo2go(t)
+
+	gopath := t.TempDir()
+	testFiles{
+		{
+			"pkg/p.go",
+			`package pkg; func F() {}`,
+		},
+		{
+			"cmd/cmd.go2",
+			`package main; import "pkg"; func main() { pkg.F() }`,
+		},
+	}.create(t, gopath)
+
+	t.Log("go2go build")
+	cmdDir := filepath.Join(gopath, "src", "cmd")
+	cmd := exec.Command(testGo2go, "build")
+	cmd.Dir = cmdDir
+	cmd.Env = append(os.Environ(),
+		"GOPATH="+gopath,
+		"GO2PATH="+gopath,
+		"GO111MODULE=off",
+	)
+	out, err := cmd.CombinedOutput()
+	if len(out) > 0 {
+		t.Logf("%s", out)
+	}
+	if err != nil {
+		t.Fatalf(`error running "go2go build": %v`, err)
+	}
+
+	t.Log("./cmd")
+	cmdName := "./cmd"
+	if runtime.GOOS == "windows" {
+		cmdName += ".exe"
+	}
+	cmd = exec.Command(cmdName)
+	cmd.Dir = cmdDir
+	out, err = cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("error running %q: %v", cmdName, err)
+	}
+	if len(out) != 0 {
+		t.Errorf("unexpected output: %q", out)
+	}
+}
+
+const buildSource = `
+package main
+
+import "fmt"
+
+func PrintSlice[Elem any](s []Elem) {
+	for _, v := range s {
+		fmt.Println(v)
+	}
+}
+
+func main() {
+	PrintSlice([]string{"hello", "world"})
+}
+`
+
+func TestBuild(t *testing.T) {
+	t.Parallel()
+	buildGo2go(t)
+
+	gopath := t.TempDir()
+	testFiles{
+		{
+			"hello/hello.go2",
+			buildSource,
+		},
+	}.create(t, gopath)
+
+	t.Log("go2go build")
+	dir := filepath.Join(gopath, "src", "hello")
+	cmd := exec.Command(testGo2go, "build")
+	cmd.Dir = dir
+	out, err := cmd.CombinedOutput()
+	if len(out) > 0 {
+		t.Logf("%s", out)
+	}
+	if err != nil {
+		t.Fatalf(`error running "go2go build": %v`, err)
+	}
+
+	runHello(t, dir)
+}
+
+func runHello(t *testing.T, dir string) {
+	cmdName := "./hello"
+	if runtime.GOOS == "windows" {
+		cmdName += ".exe"
+	}
+	cmd := exec.Command(cmdName)
+	cmd.Dir = dir
+	out, err := cmd.CombinedOutput()
+	t.Log("./hello")
+	if len(out) > 0 {
+		t.Logf("%s", out)
+	}
+	if err != nil {
+		t.Fatalf("error running hello: %v", err)
+	}
+	got := strings.Split(strings.TrimSpace(string(out)), "\n")
+	want := []string{"hello", "world"}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("hello output %v, want %v", got, want)
+	}
+}
+
+func TestBuildPackage(t *testing.T) {
+	t.Parallel()
+	buildGo2go(t)
+
+	gopath := t.TempDir()
+	testFiles{
+		{
+			"cmd/hello/hello.go2",
+			buildSource,
+		},
+	}.create(t, gopath)
+
+	t.Log("go2go build")
+	cmd := exec.Command(testGo2go, "build", "cmd/hello")
+	cmd.Dir = gopath
+	cmd.Env = append(os.Environ(),
+		"GO2PATH="+gopath,
+	)
+	out, err := cmd.CombinedOutput()
+	if len(out) > 0 {
+		t.Logf("%s", out)
+	}
+	if err != nil {
+		t.Fatalf(`error running "go2go build": %v`, err)
+	}
+
+	runHello(t, gopath)
+}
+
+func TestTransitiveGo1(t *testing.T) {
+	t.Parallel()
+	buildGo2go(t)
+
+	gopath := t.TempDir()
+	testFiles{
+		{
+			"a/a.go2",
+			`package a; func ident[T any](v T) T { return v }; func F1(v int) int { return ident(v) }`,
+		},
+		{
+			"b/b.go",
+			`package b; import "a"; func F2(v int) int { return a.F1(v) }`,
+		},
+		{
+			"c/c.go2",
+			`package main; import ("fmt"; "b"); func main() { fmt.Println(b.F2(42)) }`,
+		},
+	}.create(t, gopath)
+
+	t.Log("go2go build")
+	cmd := exec.Command(testGo2go, "build", "c")
+	cmd.Dir = gopath
+	cmd.Env = append(os.Environ(),
+		"GO2PATH="+gopath,
+	)
+	out, err := cmd.CombinedOutput()
+	if len(out) > 0 {
+		t.Logf("%s", out)
+	}
+	if err != nil {
+		t.Fatalf(`error running "go2go build": %v`, err)
+	}
+}
+
+func TestBuildWithTags(t *testing.T) {
+	t.Parallel()
+	buildGo2go(t)
+
+	gopath := t.TempDir()
+	testFiles{
+		{
+			"a/a.go2",
+			`package a; func ident[T any](v T) T { return v }; func F1(s string) string { return ident(s) }`,
+		},
+		{
+			"b/b_appengine.go",
+			`// +build appengine
+
+package b; import "a"; func F2(s string) string { return a.F1(s) + " App Engine!" }`,
+		},
+		{
+			"b/b.go",
+			`// +build !appengine
+
+package b; import "a"; func F2(s string) string { return a.F1(s) + " World!" }`,
+		},
+		{
+			"c/c.go2",
+			`package main; import ("fmt"; "b"); func main() { fmt.Println(b.F2("Hello")) }`,
+		},
+	}.create(t, gopath)
+
+	t.Log("go2go build")
+	cmd := exec.Command(testGo2go, "build", "-tags=appengine", "c")
+	cmd.Dir = gopath
+	cmd.Env = append(os.Environ(),
+		"GO2PATH="+gopath,
+	)
+	out, err := cmd.CombinedOutput()
+	if len(out) > 0 {
+		t.Logf("%s", out)
+	}
+	if err != nil {
+		t.Fatalf(`error running "go2go build": %v`, err)
+	}
+
+	cmdName := "./c"
+	if runtime.GOOS == "windows" {
+		cmdName += ".exe"
+	}
+	cmd = exec.Command(cmdName)
+	cmd.Dir = gopath
+	out, err = cmd.CombinedOutput()
+	t.Log("./c")
+	if len(out) > 0 {
+		t.Logf("%s", out)
+	}
+	if err != nil {
+		t.Fatalf("error running c: %v", err)
+	}
+	got := strings.Split(strings.TrimSpace(string(out)), "\n")[0]
+	want := "Hello App Engine!"
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("c output %v, want %v", got, want)
+	}
+}

src/cmd/go2go/main.go

@@ -0,0 +1,224 @@
+// Copyright 2020 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 main
+
+import (
+	"flag"
+	"fmt"
+	"go/go2go"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+var gotool = filepath.Join(runtime.GOROOT(), "bin", "go")
+
+var cmds = map[string]bool{
+	"build":     true,
+	"run":       true,
+	"test":      true,
+	"translate": true,
+}
+
+// tagsFlag is the implementation of the -tags flag.
+type tagsFlag []string
+
+var buildTags tagsFlag
+
+func (v *tagsFlag) Set(s string) error {
+	// Split on commas, ignore empty strings.
+	*v = []string{}
+	for _, s := range strings.Split(s, ",") {
+		if s != "" {
+			*v = append(*v, s)
+		}
+	}
+	return nil
+}
+
+func (v *tagsFlag) String() string {
+	return strings.Join(*v, ",")
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+
+	args := flag.Args()
+	if len(args) < 1 {
+		usage()
+	}
+
+	if !cmds[args[0]] {
+		usage()
+	}
+	cmd := args[0]
+
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	fs.Var((*tagsFlag)(&buildTags), "tags", "tag,list")
+	fs.Parse(args[1:])
+
+	args = fs.Args()
+
+	importerTmpdir, err := ioutil.TempDir("", "go2go")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer os.RemoveAll(importerTmpdir)
+
+	importer := go2go.NewImporter(importerTmpdir)
+
+	if len(buildTags) > 0 {
+		importer.SetTags(buildTags)
+	}
+
+	var rundir string
+	if cmd == "run" {
+		tmpdir := copyToTmpdir(args)
+		defer os.RemoveAll(tmpdir)
+		translate(importer, tmpdir)
+		var nargs []string
+		for _, arg := range args {
+			base := filepath.Base(arg)
+			f := strings.TrimSuffix(base, ".go2") + ".go"
+			nargs = append(nargs, f)
+		}
+		args = nargs
+		rundir = tmpdir
+	} else if cmd == "translate" && isGo2Files(args...) {
+		for _, arg := range args {
+			translateFile(importer, arg)
+		}
+	} else {
+		for _, dir := range expandPackages(args) {
+			translate(importer, dir)
+		}
+	}
+
+	if cmd != "translate" {
+		if len(buildTags) > 0 {
+			args = append([]string{
+				fmt.Sprintf("-tags=%s", strings.Join(buildTags, ",")),
+			}, args...)
+		}
+
+		args = append([]string{cmd}, args...)
+
+		cmd := exec.Command(gotool, args...)
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Dir = rundir
+		gopath := importerTmpdir
+		if go2path := os.Getenv("GO2PATH"); go2path != "" {
+			gopath += string(os.PathListSeparator) + go2path
+		}
+		if oldGopath := os.Getenv("GOPATH"); oldGopath != "" {
+			gopath += string(os.PathListSeparator) + oldGopath
+		}
+		cmd.Env = append(os.Environ(),
+			"GOPATH="+gopath,
+			"GO111MODULE=off",
+		)
+		if err := cmd.Run(); err != nil {
+			die(fmt.Sprintf("%s %v failed: %v", gotool, args, err))
+		}
+	}
+}
+
+// isGo2Files reports whether the arguments are a list of .go2 files.
+func isGo2Files(args ...string) bool {
+	for _, arg := range args {
+		if filepath.Ext(arg) != ".go2" {
+			return false
+		}
+	}
+	return true
+}
+
+// expandPackages returns a list of directories expanded from packages.
+func expandPackages(pkgs []string) []string {
+	if len(pkgs) == 0 {
+		return []string{"."}
+	}
+	go2path := os.Getenv("GO2PATH")
+	var dirs []string
+pkgloop:
+	for _, pkg := range pkgs {
+		if go2path != "" {
+			for _, pd := range strings.Split(go2path, string(os.PathListSeparator)) {
+				d := filepath.Join(pd, "src", pkg)
+				if fi, err := os.Stat(d); err == nil && fi.IsDir() {
+					dirs = append(dirs, d)
+					continue pkgloop
+				}
+			}
+		}
+
+		cmd := exec.Command(gotool, "list", "-f", "{{.Dir}}", pkg)
+		cmd.Stderr = os.Stderr
+		if go2path != "" {
+			gopath := go2path
+			if oldGopath := os.Getenv("GOPATH"); oldGopath != "" {
+				gopath += string(os.PathListSeparator) + oldGopath
+			}
+			cmd.Env = append(os.Environ(),
+				"GOPATH="+gopath,
+				"GO111MODULE=off",
+			)
+		}
+		out, err := cmd.Output()
+		if err != nil {
+			die(fmt.Sprintf("%s list %q failed: %v", gotool, pkg, err))
+		}
+		dirs = append(dirs, strings.Split(string(out), "\n")...)
+	}
+	return dirs
+}
+
+// copyToTmpdir copies files into a temporary directory.
+func copyToTmpdir(files []string) string {
+	if len(files) == 0 {
+		die("no files to run")
+	}
+	tmpdir, err := ioutil.TempDir("", "go2go-run")
+	if err != nil {
+		die(err.Error())
+	}
+	for _, file := range files {
+		data, err := ioutil.ReadFile(file)
+		if err != nil {
+			die(err.Error())
+		}
+		if err := ioutil.WriteFile(filepath.Join(tmpdir, filepath.Base(file)), data, 0444); err != nil {
+			die(err.Error())
+		}
+	}
+	return tmpdir
+}
+
+// usage reports a usage message and exits with failure.
+func usage() {
+	fmt.Fprint(os.Stderr, `Usage: go2go <command> [arguments]
+
+The commands are:
+
+	build      translate and build packages
+	run        translate and run list of files
+	test       translate and test packages
+	translate  translate .go2 files into .go files
+`)
+	os.Exit(2)
+}
+
+// die reports an error and exits.
+func die(msg string) {
+	fmt.Fprintln(os.Stderr, msg)
+	os.Exit(1)
+}

src/cmd/go2go/testdata/go2path/src/alg/alg.go2

@@ -0,0 +1,24 @@
+// Copyright 2020 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 alg provides basic algorithms.
+package alg
+
+import "constraints"
+
+// Max returns the maximum of two values of some ordered type.
+func Max[T constraints.Ordered](a, b T) T {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+// Min returns the minimum of two values of some ordered type.
+func Min[T constraints.Ordered](a, b T) T {
+	if a < b {
+		return a
+	}
+	return b
+}

src/cmd/go2go/testdata/go2path/src/chans/chans.go2

@@ -0,0 +1,215 @@
+// Copyright 2020 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 chans provides utility functions for working with channels.
+package chans
+
+import (
+	"context"
+	"runtime"
+)
+
+// ReadAll reads from c until the channel is closed or the context is
+// canceled, returning all the values read.
+func ReadAll[Elem any](ctx context.Context, c <-chan Elem) []Elem {
+	var r []Elem
+	for {
+		select {
+		case <-ctx.Done():
+			return r
+		case v, ok := <-c:
+			if !ok {
+				return r
+			}
+			r = append(r, v)
+		}
+	}
+}
+
+// Merge merges two channels into a single channel.
+// This will leave a goroutine running until either both channels are closed
+// or the context is canceled, at which point the returned channel is closed.
+func Merge[Elem any](ctx context.Context, c1, c2 <-chan Elem) <-chan Elem {
+	r := make(chan Elem)
+	go func(ctx context.Context, c1, c2 <-chan Elem, r chan<- Elem) {
+		defer close(r)
+		for c1 != nil || c2 != nil {
+			select {
+			case <-ctx.Done():
+				return
+			case v1, ok := <-c1:
+				if ok {
+					r <- v1
+				} else {
+					c1 = nil
+				}
+			case v2, ok := <-c2:
+				if ok {
+					r <- v2
+				} else {
+					c2 = nil
+				}
+			}
+		}
+	}(ctx, c1, c2, r)
+	return r
+}
+
+// Filter calls f on each value read from c. If f returns true the value
+// is sent on the returned channel. This will leave a goroutine running
+// until c is closed or the context is canceled, at which point the
+// returned channel is closed.
+func Filter[Elem any](ctx context.Context, c <-chan Elem, f func(Elem) bool) <-chan Elem {
+	r := make(chan Elem)
+	go func(ctx context.Context, c <-chan Elem, f func(Elem) bool, r chan<- Elem) {
+		defer close(r)
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case v, ok := <-c:
+				if !ok {
+					return
+				}
+				if f(v) {
+					r <- v
+				}
+			}
+		}
+	}(ctx, c, f, r)
+	return r
+}
+
+// Sink returns a channel that discards all values sent to it.
+// This will leave a goroutine running until the context is canceled
+// or the returned channel is closed.
+func Sink[Elem any](ctx context.Context) chan<- Elem {
+	r := make(chan Elem)
+	go func(ctx context.Context, r <-chan Elem) {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case _, ok := <-r:
+				if !ok {
+					return
+				}
+			}
+		}
+	}(ctx, r)
+	return r
+}
+
+// An Exclusive is a value that may only be used by a single goroutine
+// at a time. This is implemented using channels rather than a mutex.
+type Exclusive[Val any] struct {
+	c chan Val
+}
+
+// MakeExclusive makes an initialized exclusive value.
+func MakeExclusive[Val any](initial Val) *Exclusive[Val] {
+	r := &Exclusive[Val]{
+		c: make(chan Val, 1),
+	}
+	r.c <- initial
+	return r
+}
+
+// Acquire acquires the exclusive value for private use.
+// It must be released using the Release method.
+func (e *Exclusive[Val]) Acquire() Val {
+	return <-e.c
+}
+
+// TryAcquire attempts to acquire the value. The ok result reports whether
+// the value was acquired. If the value is acquired, it must be released
+// using the Release method.
+func (e *Exclusive[Val]) TryAcquire() (v Val, ok bool) {
+	select {
+	case r := <-e.c:
+		return r, true
+	default:
+		return v, false
+	}
+}
+
+// Release updates and releases the value.
+// This method panics if the value has not been acquired.
+func (e *Exclusive[Val]) Release(v Val) {
+	select {
+	case e.c <- v:
+	default:
+		panic("Exclusive Release without Acquire")
+	}
+}
+
+// Ranger returns a Sender and a Receiver. The Receiver provides a
+// Next method to retrieve values. The Sender provides a Send method
+// to send values and a Close method to stop sending values. The Next
+// method indicates when the Sender has been closed, and the Send
+// method indicates when the Receiver has been freed.
+//
+// This is a convenient way to exit a goroutine sending values when
+// the receiver stops reading them.
+func Ranger[Elem any]() (*Sender[Elem], *Receiver[Elem]) {
+	c := make(chan Elem)
+	d := make(chan struct{})
+	s := &Sender[Elem]{
+		values: c,
+		done:   d,
+	}
+	r := &Receiver[Elem] {
+		values: c,
+		done:   d,
+	}
+	runtime.SetFinalizer(r, (*Receiver[Elem]).finalize)
+	return s, r
+}
+
+// A Sender is used to send values to a Receiver.
+type Sender[Elem any] struct {
+	values chan<- Elem
+	done   <-chan struct{}
+}
+
+// Send sends a value to the receiver. It reports whether the value was sent.
+// The value will not be sent if the context is closed or the receiver
+// is freed.
+func (s *Sender[Elem]) Send(ctx context.Context, v Elem) bool {
+	select {
+	case <-ctx.Done():
+		return false
+	case s.values <- v:
+		return true
+	case <-s.done:
+		return false
+	}
+}
+
+// Close tells the receiver that no more values will arrive.
+// After Close is called, the Sender may no longer be used.
+func (s *Sender[Elem]) Close() {
+	close(s.values)
+}
+
+// A Receiver receives values from a Sender.
+type Receiver[Elem any] struct {
+	values <-chan Elem
+	done   chan<- struct{}
+}
+
+// Next returns the next value from the channel. The bool result indicates
+// whether the value is valid.
+func (r *Receiver[Elem]) Next(ctx context.Context) (v Elem, ok bool) {
+	select {
+	case <-ctx.Done():
+	case v, ok = <-r.values:
+	}
+	return v, ok
+}
+
+// finalize is a finalizer for the receiver.
+func (r *Receiver[Elem]) finalize() {
+	close(r.done)
+}

src/cmd/go2go/testdata/go2path/src/chans/chans_test.go2

@@ -0,0 +1,180 @@
+// Copyright 2020 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 chans
+
+import (
+	"context"
+	"runtime"
+	"sort"
+	"sync"
+	"testing"
+	"time"
+
+	"slices"
+)
+
+func TestReadAll(t *testing.T) {
+	c := make(chan int)
+	go func() {
+		c <- 4
+		c <- 2
+		c <- 5
+		close(c)
+	}()
+	got := ReadAll(context.Background(), c)
+	want := []int{4, 2, 5}
+	if !slices.Equal(got, want) {
+		t.Errorf("ReadAll returned %v, want %v", got, want)
+	}
+}
+
+func TestMerge(t *testing.T) {
+	c1 := make(chan int)
+	c2 := make(chan int)
+	go func() {
+		c1 <- 1
+		c1 <- 3
+		c1 <- 5
+		close(c1)
+	}()
+	go func() {
+		c2 <- 2
+		c2 <- 4
+		c2 <- 6
+		close(c2)
+	}()
+	ctx := context.Background()
+	got := ReadAll(ctx, Merge(ctx, c1, c2))
+	sort.Ints(got)
+	want := []int{1, 2, 3, 4, 5, 6}
+	if !slices.Equal(got, want) {
+		t.Errorf("Merge returned %v, want %v", got, want)
+	}
+}
+
+func TestFilter(t *testing.T) {
+	c := make(chan int)
+	go func() {
+		c <- 1
+		c <- 2
+		c <- 3
+		close(c)
+	}()
+	even := func(i int) bool { return i%2 == 0 }
+	ctx := context.Background()
+	got := ReadAll(ctx, Filter(ctx, c, even))
+	want := []int{2}
+	if !slices.Equal(got, want) {
+		t.Errorf("Filter returned %v, want %v", got, want)
+	}
+}
+
+func TestSink(t *testing.T) {
+	c := Sink[int](context.Background())
+	after := time.NewTimer(time.Minute)
+	defer after.Stop()
+	send := func(v int) {
+		select {
+		case c <- v:
+		case <-after.C:
+			t.Error("timed out sending to Sink")
+		}
+	}
+	send(1)
+	send(2)
+	send(3)
+	close(c)
+}
+
+func TestExclusive(t *testing.T) {
+	val := 0
+	ex := MakeExclusive(&val)
+
+	var wg sync.WaitGroup
+	f := func() {
+		defer wg.Done()
+		for i := 0; i < 10; i++ {
+			p := ex.Acquire()
+			(*p)++
+			ex.Release(p)
+		}
+	}
+
+	wg.Add(2)
+	go f()
+	go f()
+
+	wg.Wait()
+	if val != 20 {
+		t.Errorf("after Acquire/Release loop got %d, want 20", val)
+	}
+}
+
+func TestExclusiveTry(t *testing.T) {
+	s := ""
+	ex := MakeExclusive(&s)
+	p, ok := ex.TryAcquire()
+	if !ok {
+		t.Fatalf("TryAcquire failed")
+	}
+	*p = "a"
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		_, ok := ex.TryAcquire()
+		if ok {
+			t.Errorf("TryAcquire succeeded unexpectedly")
+		}
+	}()
+	wg.Wait()
+
+	ex.Release(p)
+
+	p, ok = ex.TryAcquire()
+	if !ok {
+		t.Errorf("TryAcquire failed")
+	}
+}
+
+func TestRanger(t *testing.T) {
+	s, r := Ranger[int]()
+
+	ctx := context.Background()
+	go func() {
+		// Receive one value then exit.
+		v, ok := r.Next(ctx)
+		if !ok {
+			t.Errorf("did not receive any values")
+		} else if v != 1 {
+			t.Errorf("received %d, want 1", v)
+		}
+	}()
+
+	c1 := make(chan bool)
+	c2 := make(chan bool)
+	go func() {
+		defer close(c2)
+		if !s.Send(ctx, 1) {
+			t.Errorf("Send failed unexpectedly")
+		}
+		close(c1)
+		if s.Send(ctx, 2) {
+			t.Errorf("Send succeeded unexpectedly")
+		}
+	}()
+
+	<-c1
+
+	// Force a garbage collection to try to get the finalizers to run.
+	runtime.GC()
+
+	select {
+	case <-c2:
+	case <-time.After(time.Minute):
+		t.Error("Ranger Send should have failed, but timed out")
+	}
+}

src/cmd/go2go/testdata/go2path/src/constraints/constraints.go2

@@ -0,0 +1,31 @@
+// Copyright 2020 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 constraints defines some useful type constraints.
+package constraints
+
+// Ordered permits any ordered type: any type that supports
+// the operations <, <=, >=, >, as well as == and !=.
+type Ordered interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64,
+		string
+}
+
+// Integer permits any integer type.
+type Integer interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr
+}
+
+// Signed permits any signed integer type.
+type Signed interface {
+	type int, int8, int16, int32, int64
+}
+
+// Unsigned permits any unsigned integer type.
+type Unsigned interface {
+	type uint, uint8, uint16, uint32, uint64, uintptr
+}

src/cmd/go2go/testdata/go2path/src/graph/graph.go2

@@ -0,0 +1,72 @@
+// Copyright 2020 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 graph implements general purpose graph algorithms.
+package graph
+
+import "errors"
+
+// A Graph is a collection of nodes. A node may have an arbitrary number
+// of edges. An edge connects two nodes. Both nodes and edges must be
+// comparable. This is an undirected simple graph.
+type Graph[Node NodeC[Edge], Edge EdgeC[Node]] struct {
+	nodes []Node
+}
+
+// NodeC is the contraints on a node in a graph, given the Edge type.
+type NodeC[Edge any] interface {
+	comparable
+	Edges() []Edge
+}
+
+// Edgec is the constraints on an edge in a graph, given the Node type.
+type EdgeC[Node any] interface {
+	comparable
+	Nodes() (a, b Node)
+}
+
+// New creates a new Graph from a collection of Nodes.
+func New[Node NodeC[Edge], Edge EdgeC[Node]](nodes []Node) *Graph[Node, Edge] {
+	return &Graph[Node, Edge]{nodes: nodes}
+}
+
+// nodePath holds the path to a node during ShortestPath.
+// This should ideally be a type defined inside ShortestPath,
+// but the translator tool doesn't support that.
+type nodePath[Node NodeC[Edge], Edge EdgeC[Node]] struct {
+	node Node
+	path []Edge
+}
+
+// ShortestPath returns the shortest path between two nodes,
+// as an ordered list of edges. If there are multiple shortest paths,
+// which one is returned is unpredictable.
+func (g *Graph[Node, Edge]) ShortestPath(from, to Node) ([]Edge, error) {
+	visited := make(map[Node]bool)
+	visited[from] = true
+	workqueue := []nodePath[Node, Edge]{nodePath[Node, Edge]{from, nil}}
+	for len(workqueue) > 0 {
+		current := workqueue
+		workqueue = nil
+		for _, np := range current {
+			edges := np.node.Edges()
+			for _, edge := range edges {
+				a, b := edge.Nodes()
+				if a == np.node {
+					a = b
+				}
+				if !visited[a] {
+					ve := append([]Edge(nil), np.path...)
+					ve = append(ve, edge)
+					if a == to {
+						return ve, nil
+					}
+					workqueue = append(workqueue, nodePath[Node, Edge]{a, ve})
+					visited[a] = true
+				}
+			}
+		}
+	}
+	return nil, errors.New("no path")
+}

src/cmd/go2go/testdata/go2path/src/graph/graph_test.go2

@@ -0,0 +1,143 @@
+// Copyright 2020 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 graph
+
+import (
+	"fmt"
+	"testing"
+
+	"slices"
+)
+
+type direction int
+
+const (
+	north direction = iota
+	ne
+	east
+	se
+	south
+	sw
+	west
+	nw
+	up
+	down
+)
+
+func (dir direction) String() string {
+	strs := map[direction]string{
+		north: "north",
+		ne:    "ne",
+		east:  "east",
+		se:    "se",
+		south: "south",
+		sw:    "sw",
+		west:  "west",
+		nw:    "nw",
+		up:    "up",
+		down:  "down",
+	}
+	if str, ok := strs[dir]; ok {
+		return str
+	}
+	return fmt.Sprintf("direction %d", dir)
+}
+
+type mazeRoom struct {
+	index int
+	exits [10]int
+}
+
+type mazeEdge struct {
+	from, to int
+	dir      direction
+}
+
+// Edges returns the exits from the room.
+func (m mazeRoom) Edges() []mazeEdge {
+	var r []mazeEdge
+	for i, exit := range m.exits {
+		if exit != 0 {
+			r = append(r, mazeEdge{
+				from: m.index,
+				to:   exit,
+				dir:  direction(i),
+			})
+		}
+	}
+	return r
+}
+
+// Nodes returns the rooms connected by an edge.
+func (e mazeEdge) Nodes() (mazeRoom, mazeRoom) {
+	m1, ok := zork[e.from]
+	if !ok {
+		panic("bad edge")
+	}
+	m2, ok := zork[e.to]
+	if !ok {
+		panic("bad edge")
+	}
+	return m1, m2
+}
+
+// The first maze in Zork. Room indexes based on original Fortran data file.
+// You are in a maze of twisty little passages, all alike.
+var zork = map[int]mazeRoom{
+	11: {exits: [10]int{north: 11, south: 12, east: 14}}, // west to Troll Room
+	12: {exits: [10]int{south: 11, north: 14, east: 13}},
+	13: {exits: [10]int{west: 12, north: 14, up: 16}},
+	14: {exits: [10]int{west: 13, north: 11, east: 15}},
+	15: {exits: [10]int{south: 14}},                   // Dead End
+	16: {exits: [10]int{east: 17, north: 13, sw: 18}}, // skeleton, etc.
+	17: {exits: [10]int{west: 16}},                    // Dead End
+	18: {exits: [10]int{down: 16, east: 19, west: 18, up: 22}},
+	19: {exits: [10]int{up: 29, west: 18, ne: 15, east: 20, south: 30}},
+	20: {exits: [10]int{ne: 19, west: 20, se: 21}},
+	21: {exits: [10]int{north: 20}}, // Dead End
+	22: {exits: [10]int{north: 18, east: 24, down: 23, south: 28, west: 26, nw: 22}},
+	23: {exits: [10]int{east: 22, west: 28, up: 24}},
+	24: {exits: [10]int{ne: 25, down: 23, nw: 28, sw: 26}},
+	25: {exits: [10]int{sw: 24}}, // Grating room (up to Clearing)
+	26: {exits: [10]int{west: 16, sw: 24, east: 28, up: 22, north: 27}},
+	27: {exits: [10]int{south: 26}}, // Dead End
+	28: {exits: [10]int{east: 22, down: 26, south: 23, west: 24}},
+	29: {exits: [10]int{west: 30, nw: 29, ne: 19, south: 19}},
+	30: {exits: [10]int{west: 29, south: 19}}, // ne to Cyclops Room
+}
+
+func TestShortestPath(t *testing.T) {
+	// The Zork maze is not a proper undirected simple graph,
+	// as there are some one way paths (e.g., 19 -> 15),
+	// but for this test that doesn't matter.
+
+	// Set the index field in the map. Simpler than doing it in the
+	// composite literal.
+	for k := range zork {
+		r := zork[k]
+		r.index = k
+		zork[k] = r
+	}
+
+	var nodes []mazeRoom
+	for idx, room := range zork {
+		mridx := room
+		mridx.index = idx
+		nodes = append(nodes, mridx)
+	}
+	g := New[mazeRoom, mazeEdge](nodes)
+	path, err := g.ShortestPath(zork[11], zork[30])
+	if err != nil {
+		t.Fatal(err)
+	}
+	var steps []direction
+	for _, edge := range path {
+		steps = append(steps, edge.dir)
+	}
+	want := []direction{east, west, up, sw, east, south}
+	if !slices.Equal(steps, want) {
+		t.Errorf("ShortestPath returned %v, want %v", steps, want)
+	}
+}

src/cmd/go2go/testdata/go2path/src/gsort/gsort.go2

@@ -0,0 +1,51 @@
+// Copyright 2020 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 gsort provides primitives for sorting slices of any type.
+package gsort
+
+import (
+	"sort"
+
+	"constraints"
+)
+
+// orderedSlice is a slice of values of some ordered type.
+type orderedSlice[Elem constraints.Ordered] []Elem
+
+// orderedSlice implements sort.Interface.
+
+func (s orderedSlice[Elem]) Len() int           { return len(s) }
+func (s orderedSlice[Elem]) Less(i, j int) bool {
+	if s[i] < s[j] {
+		return true
+	}
+	isNaN := func(f Elem) bool { return f != f }
+	if isNaN(s[i]) && !isNaN(s[j]) {
+		return true
+	}
+	return false
+}
+func (s orderedSlice[Elem]) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+// OrderedSlice sorts a slice of any ordered type in ascending order.
+func OrderedSlice[Elem constraints.Ordered](s []Elem) {
+	sort.Sort(orderedSlice[Elem](s))
+}
+
+// sliceFn implements sort.Interface for a slice of any type with an
+// explicit less-than function.
+type sliceFn[Elem any] struct {
+	s    []Elem
+	less func(Elem, Elem) bool
+}
+
+func (s sliceFn[Elem]) Len() int           { return len(s.s) }
+func (s sliceFn[Elem]) Less(i, j int) bool { return s.less(s.s[i], s.s[j]) }
+func (s sliceFn[Elem]) Swap(i, j int)      { s.s[i], s.s[j] = s.s[j], s.s[i] }
+
+// SliceFn sorts a slice of any type according to a less-than function.
+func SliceFn[Elem any](s []Elem, less func(Elem, Elem) bool) {
+	sort.Sort(sliceFn[Elem]{s, less})
+}

src/cmd/go2go/testdata/go2path/src/gsort/gsort_test.go2

@@ -0,0 +1,92 @@
+// Copyright 2020 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 gsort
+
+import (
+	"math"
+	"sort"
+	"testing"
+
+	"constraints"
+	"slices"
+)
+
+// Test data copied from the standard library sort package.
+
+var ints = []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
+var float64s = []float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
+var strs = []string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
+
+func TestSortOrderedInts(t *testing.T) {
+	testOrdered(t, ints, sort.Ints)
+}
+
+func TestSortOrderedFloat64s(t *testing.T) {
+	testOrdered(t, float64s, sort.Float64s)
+}
+
+func TestSortOrderedStrings(t *testing.T) {
+	testOrdered(t, strs, sort.Strings)
+}
+
+func testOrdered[Elem constraints.Ordered](t *testing.T, s []Elem, sorter func([]Elem)) {
+	s1 := make([]Elem, len(s))
+	copy(s1, s)
+	s2 := make([]Elem, len(s))
+	copy(s2, s)
+	OrderedSlice(s1)
+	sorter(s2)
+	if !slices.Equal(s1, s2) {
+		t.Fatalf("got %v, want %v", s1, s2)
+	}
+	for i := len(s1) - 1; i > 0; i-- {
+		if s1[i] < s1[i-1] {
+			t.Fatalf("element %d (%v) < element %d (%v)", i, s1[i], i - 1, s1[i - 1])
+		}
+	}
+}
+
+var slicesToSort = [][]int {
+	[]int{1, 2},
+	[]int{3, 2, 1},
+	[]int{1},
+	[]int{1, 3},
+	[]int{1, 2, 3},
+}
+
+var sortedSlices = [][]int {
+	[]int{1},
+	[]int{1, 2},
+	[]int{1, 3},
+	[]int{1, 2, 3},
+	[]int{3, 2, 1},
+}
+
+func sorter(s1, s2 []int) bool {
+	switch {
+	case len(s1) < len(s2):
+		return true
+	case len(s1) > len(s2):
+		return false
+	}
+	for i := range s1 {
+		switch {
+		case s1[i] < s2[i]:
+			return true
+		case s1[i] > s2[i]:
+			return false
+		}
+	}
+	return false
+}
+
+func TestSortSliceFn(t *testing.T) {
+	c := make([][]int, len(slicesToSort))
+	copy(c, slicesToSort)
+	SliceFn(c, sorter)
+	if !slices.EqualFn(c, sortedSlices, func(a, b []int) bool { return slices.Equal[int](a, b) }) {
+		t.Errorf("got %v, want %v", c, sortedSlices)
+	}
+}

src/cmd/go2go/testdata/go2path/src/list/list.go2

@@ -0,0 +1,244 @@
+// Copyright 2020 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 list provides a doubly linked list of some element type.
+package list
+
+// FIXME: This should probably be in container/list,
+// perhaps with different type names.
+
+// Element is an element of a linked list.
+type Element[TElem any] struct {
+	// Next and previous pointers in the doubly-linked list of elements.
+	// To simplify the implementation, internally a list l is implemented
+	// as a ring, such that &l.root is both the next element of the last
+	// list element (l.Back()) and the previous element of the first list
+	// element (l.Front()).
+	next, prev *Element[TElem]
+
+	// The list to which this element belongs.
+	list *List[TElem]
+
+	// The value stored with this element.
+	Value TElem
+}
+
+// Next returns the next list element or nil.
+func (e *Element[TElem]) Next() *Element[TElem] {
+	if p := e.next; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// Prev returns the previous list element or nil.
+func (e *Element[TElem]) Prev() *Element[TElem] {
+	if p := e.prev; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// List represents a doubly linked list.
+// The zero value for List is an empty list ready to use.
+type List[TElem any] struct {
+	root Element[TElem] // sentinel list element, only &root, root.prev, and root.next are used
+	len  int     // current list length excluding (this) sentinel element
+}
+
+// Init initializes or clears list l.
+func (l *List[TElem]) Init() *List[TElem] {
+	l.root.next = &l.root
+	l.root.prev = &l.root
+	l.len = 0
+	return l
+}
+
+// New returns an initialized list.
+func New[TElem any]() *List[TElem] { return new(List[TElem]).Init() }
+
+// Len returns the number of elements of list l.
+// The complexity is O(1).
+func (l *List[TElem]) Len() int { return l.len }
+
+// Front returns the first element of list l or nil if the list is empty.
+func (l *List[TElem]) Front() *Element[TElem] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.next
+}
+
+// Back returns the last element of list l or nil if the list is empty.
+func (l *List[TElem]) Back() *Element[TElem] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.prev
+}
+
+// lazyInit lazily initializes a zero List value.
+func (l *List[TElem]) lazyInit() {
+	if l.root.next == nil {
+		l.Init()
+	}
+}
+
+// insert inserts e after at, increments l.len, and returns e.
+func (l *List[TElem]) insert(e, at *Element[TElem]) *Element[TElem] {
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+	e.list = l
+	l.len++
+	return e
+}
+
+// insertValue is a convenience wrapper for insert(&Element[TElem]{Value: v}, at).
+func (l *List[TElem]) insertValue(v TElem, at *Element[TElem]) *Element[TElem] {
+	return l.insert(&Element[TElem]{Value: v}, at)
+}
+
+// remove removes e from its list, decrements l.len, and returns e.
+func (l *List[TElem]) remove(e *Element[TElem]) *Element[TElem] {
+	e.prev.next = e.next
+	e.next.prev = e.prev
+	e.next = nil // avoid memory leaks
+	e.prev = nil // avoid memory leaks
+	e.list = nil
+	l.len--
+	return e
+}
+
+// move moves e to next to at and returns e.
+func (l *List[TElem]) move(e, at *Element[TElem]) *Element[TElem] {
+	if e == at {
+		return e
+	}
+	e.prev.next = e.next
+	e.next.prev = e.prev
+
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+
+	return e
+}
+
+// Remove removes e from l if e is an element of list l.
+// It returns the element value e.Value.
+// The element must not be nil.
+func (l *List[TElem]) Remove(e *Element[TElem]) TElem {
+	if e.list == l {
+		// if e.list == l, l must have been initialized when e was inserted
+		// in l or l == nil (e is a zero Element) and l.remove will crash
+		l.remove(e)
+	}
+	return e.Value
+}
+
+// PushFront inserts a new element e with value v at the front of list l and returns e.
+func (l *List[TElem]) PushFront(v TElem) *Element[TElem] {
+	l.lazyInit()
+	return l.insertValue(v, &l.root)
+}
+
+// PushBack inserts a new element e with value v at the back of list l and returns e.
+func (l *List[TElem]) PushBack(v TElem) *Element[TElem] {
+	l.lazyInit()
+	return l.insertValue(v, l.root.prev)
+}
+
+// InsertBefore inserts a new element e with value v immediately before mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *List[TElem]) InsertBefore(v TElem, mark *Element[TElem]) *Element[TElem] {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in List.Remove about initialization of l
+	return l.insertValue(v, mark.prev)
+}
+
+// InsertAfter inserts a new element e with value v immediately after mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *List[TElem]) InsertAfter(v TElem, mark *Element[TElem]) *Element[TElem] {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in List.Remove about initialization of l
+	return l.insertValue(v, mark)
+}
+
+// MoveToFront moves element e to the front of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *List[TElem]) MoveToFront(e *Element[TElem]) {
+	if e.list != l || l.root.next == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.move(e, &l.root)
+}
+
+// MoveToBack moves element e to the back of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *List[TElem]) MoveToBack(e *Element[TElem]) {
+	if e.list != l || l.root.prev == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.move(e, l.root.prev)
+}
+
+// MoveBefore moves element e to its new position before mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *List[TElem]) MoveBefore(e, mark *Element[TElem]) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.move(e, mark.prev)
+}
+
+// MoveAfter moves element e to its new position after mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *List[TElem]) MoveAfter(e, mark *Element[TElem]) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.move(e, mark)
+}
+
+// PushBackList inserts a copy of an other list at the back of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *List[TElem]) PushBackList(other *List[TElem]) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() {
+		l.insertValue(e.Value, l.root.prev)
+	}
+}
+
+// PushFrontList inserts a copy of an other list at the front of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *List[TElem]) PushFrontList(other *List[TElem]) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() {
+		l.insertValue(e.Value, &l.root)
+	}
+}
+
+// Transform runs a transform function on a list returning a new list.
+func Transform[TElem1, TElem2 any](lst *List[TElem1], f func(TElem1) TElem2) *List[TElem2] {
+	ret := New[TElem2]()
+	for p := lst.Front(); p != nil; p = p.Next() {
+		ret.PushBack(f(p.Value))
+	}
+	return ret
+}

src/cmd/go2go/testdata/go2path/src/list/list_test.go2

@@ -0,0 +1,354 @@
+// Copyright 2020 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 list
+
+import (
+	"strconv"
+	"testing"
+)
+
+func checkListLen[TElem any](t *testing.T, l *List[TElem], len int) bool {
+	if n := l.Len(); n != len {
+		t.Errorf("l.Len() = %d, want %d", n, len)
+		return false
+	}
+	return true
+}
+
+func checkListPointers[TElem any](t *testing.T, l *List[TElem], es []*Element[TElem]) {
+	root := &l.root
+
+	if !checkListLen(t, l, len(es)) {
+		return
+	}
+
+	// zero length lists must be the zero value or properly initialized (sentinel circle)
+	if len(es) == 0 {
+		if l.root.next != nil && l.root.next != root || l.root.prev != nil && l.root.prev != root {
+			t.Errorf("l.root.next = %p, l.root.prev = %p; both should both be nil or %p", l.root.next, l.root.prev, root)
+		}
+		return
+	}
+	// len(es) > 0
+
+	// check internal and external prev/next connections
+	for i, e := range es {
+		prev := root
+		Prev := (*Element[TElem])(nil)
+		if i > 0 {
+			prev = es[i-1]
+			Prev = prev
+		}
+		if p := e.prev; p != prev {
+			t.Errorf("elt[%d](%p).prev = %p, want %p", i, e, p, prev)
+		}
+		if p := e.Prev(); p != Prev {
+			t.Errorf("elt[%d](%p).Prev() = %p, want %p", i, e, p, Prev)
+		}
+
+		next := root
+		Next := (*Element[TElem])(nil)
+		if i < len(es)-1 {
+			next = es[i+1]
+			Next = next
+		}
+		if n := e.next; n != next {
+			t.Errorf("elt[%d](%p).next = %p, want %p", i, e, n, next)
+		}
+		if n := e.Next(); n != Next {
+			t.Errorf("elt[%d](%p).Next() = %p, want %p", i, e, n, Next)
+		}
+	}
+}
+
+func TestList(t *testing.T) {
+	l := New[string]()
+	checkListPointers(t, l, []*(Element[string]){})
+
+	// Single element list
+	e := l.PushFront("a")
+	checkListPointers(t, l, []*(Element[string]){e})
+	l.MoveToFront(e)
+	checkListPointers(t, l, []*(Element[string]){e})
+	l.MoveToBack(e)
+	checkListPointers(t, l, []*(Element[string]){e})
+	l.Remove(e)
+	checkListPointers(t, l, []*(Element[string]){})
+
+	// Bigger list
+	l2 := New[int]()
+	e2 := l2.PushFront(2)
+	e1 := l2.PushFront(1)
+	e3 := l2.PushBack(3)
+	e4 := l2.PushBack(600)
+	checkListPointers(t, l2, []*(Element[int]){e1, e2, e3, e4})
+
+	l2.Remove(e2)
+	checkListPointers(t, l2, []*(Element[int]){e1, e3, e4})
+
+	l2.MoveToFront(e3) // move from middle
+	checkListPointers(t, l2, []*(Element[int]){e3, e1, e4})
+
+	l2.MoveToFront(e1)
+	l2.MoveToBack(e3) // move from middle
+	checkListPointers(t, l2, []*(Element[int]){e1, e4, e3})
+
+	l2.MoveToFront(e3) // move from back
+	checkListPointers(t, l2, []*(Element[int]){e3, e1, e4})
+	l2.MoveToFront(e3) // should be no-op
+	checkListPointers(t, l2, []*(Element[int]){e3, e1, e4})
+
+	l2.MoveToBack(e3) // move from front
+	checkListPointers(t, l2, []*(Element[int]){e1, e4, e3})
+	l2.MoveToBack(e3) // should be no-op
+	checkListPointers(t, l2, []*(Element[int]){e1, e4, e3})
+
+	e2 = l2.InsertBefore(2, e1) // insert before front
+	checkListPointers(t, l2, []*(Element[int]){e2, e1, e4, e3})
+	l2.Remove(e2)
+	e2 = l2.InsertBefore(2, e4) // insert before middle
+	checkListPointers(t, l2, []*(Element[int]){e1, e2, e4, e3})
+	l2.Remove(e2)
+	e2 = l2.InsertBefore(2, e3) // insert before back
+	checkListPointers(t, l2, []*(Element[int]){e1, e4, e2, e3})
+	l2.Remove(e2)
+
+	e2 = l2.InsertAfter(2, e1) // insert after front
+	checkListPointers(t, l2, []*(Element[int]){e1, e2, e4, e3})
+	l2.Remove(e2)
+	e2 = l2.InsertAfter(2, e4) // insert after middle
+	checkListPointers(t, l2, []*(Element[int]){e1, e4, e2, e3})
+	l2.Remove(e2)
+	e2 = l2.InsertAfter(2, e3) // insert after back
+	checkListPointers(t, l2, []*(Element[int]){e1, e4, e3, e2})
+	l2.Remove(e2)
+
+	// Check standard iteration.
+	sum := 0
+	for e := l2.Front(); e != nil; e = e.Next() {
+		sum += e.Value
+	}
+	if sum != 604 {
+		t.Errorf("sum over l = %d, want 604", sum)
+	}
+
+	// Clear all elements by iterating
+	var next *Element[int]
+	for e := l2.Front(); e != nil; e = next {
+		next = e.Next()
+		l2.Remove(e)
+	}
+	checkListPointers(t, l2, []*(Element[int]){})
+}
+
+func checkList[TElem comparable](t *testing.T, l *List[TElem], es []interface{}) {
+	if !checkListLen(t, l, len(es)) {
+		return
+	}
+
+	i := 0
+	for e := l.Front(); e != nil; e = e.Next() {
+		le := e.Value
+		if le != es[i] {
+			t.Errorf("elt[%d].Value = %v, want %v", i, le, es[i])
+		}
+		i++
+	}
+}
+
+func TestExtending(t *testing.T) {
+	l1 := New[int]()
+	l2 := New[int]()
+
+	l1.PushBack(1)
+	l1.PushBack(2)
+	l1.PushBack(3)
+
+	l2.PushBack(4)
+	l2.PushBack(5)
+
+	l3 := New[int]()
+	l3.PushBackList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3})
+	l3.PushBackList(l2)
+	checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
+
+	l3 = New[int]()
+	l3.PushFrontList(l2)
+	checkList(t, l3, []interface{}{4, 5})
+	l3.PushFrontList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
+
+	checkList(t, l1, []interface{}{1, 2, 3})
+	checkList(t, l2, []interface{}{4, 5})
+
+	l3 = New[int]()
+	l3.PushBackList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3})
+	l3.PushBackList(l3)
+	checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
+
+	l3 = New[int]()
+	l3.PushFrontList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3})
+	l3.PushFrontList(l3)
+	checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
+
+	l3 = New[int]()
+	l1.PushBackList(l3)
+	checkList(t, l1, []interface{}{1, 2, 3})
+	l1.PushFrontList(l3)
+	checkList(t, l1, []interface{}{1, 2, 3})
+}
+
+func TestRemove(t *testing.T) {
+	l := New[int]()
+	e1 := l.PushBack(1)
+	e2 := l.PushBack(2)
+	checkListPointers(t, l, []*(Element[int]){e1, e2})
+	e := l.Front()
+	l.Remove(e)
+	checkListPointers(t, l, []*(Element[int]){e2})
+	l.Remove(e)
+	checkListPointers(t, l, []*(Element[int]){e2})
+}
+
+func TestIssue4103(t *testing.T) {
+	l1 := New[int]()
+	l1.PushBack(1)
+	l1.PushBack(2)
+
+	l2 := New[int]()
+	l2.PushBack(3)
+	l2.PushBack(4)
+
+	e := l1.Front()
+	l2.Remove(e) // l2 should not change because e is not an element of l2
+	if n := l2.Len(); n != 2 {
+		t.Errorf("l2.Len() = %d, want 2", n)
+	}
+
+	l1.InsertBefore(8, e)
+	if n := l1.Len(); n != 3 {
+		t.Errorf("l1.Len() = %d, want 3", n)
+	}
+}
+
+func TestIssue6349(t *testing.T) {
+	l := New[int]()
+	l.PushBack(1)
+	l.PushBack(2)
+
+	e := l.Front()
+	l.Remove(e)
+	if e.Value != 1 {
+		t.Errorf("e.value = %d, want 1", e.Value)
+	}
+	if e.Next() != nil {
+		t.Errorf("e.Next() != nil")
+	}
+	if e.Prev() != nil {
+		t.Errorf("e.Prev() != nil")
+	}
+}
+
+func TestMove(t *testing.T) {
+	l := New[int]()
+	e1 := l.PushBack(1)
+	e2 := l.PushBack(2)
+	e3 := l.PushBack(3)
+	e4 := l.PushBack(4)
+
+	l.MoveAfter(e3, e3)
+	checkListPointers(t, l, []*(Element[int]){e1, e2, e3, e4})
+	l.MoveBefore(e2, e2)
+	checkListPointers(t, l, []*(Element[int]){e1, e2, e3, e4})
+
+	l.MoveAfter(e3, e2)
+	checkListPointers(t, l, []*(Element[int]){e1, e2, e3, e4})
+	l.MoveBefore(e2, e3)
+	checkListPointers(t, l, []*(Element[int]){e1, e2, e3, e4})
+
+	l.MoveBefore(e2, e4)
+	checkListPointers(t, l, []*(Element[int]){e1, e3, e2, e4})
+	e2, e3 = e3, e2
+
+	l.MoveBefore(e4, e1)
+	checkListPointers(t, l, []*(Element[int]){e4, e1, e2, e3})
+	e1, e2, e3, e4 = e4, e1, e2, e3
+
+	l.MoveAfter(e4, e1)
+	checkListPointers(t, l, []*(Element[int]){e1, e4, e2, e3})
+	e2, e3, e4 = e4, e2, e3
+
+	l.MoveAfter(e2, e3)
+	checkListPointers(t, l, []*(Element[int]){e1, e3, e2, e4})
+	e2, e3 = e3, e2
+}
+
+// Test PushFront, PushBack, PushFrontList, PushBackList with uninitialized List
+func TestZeroList(t *testing.T) {
+	var l1 = new(List[int])
+	l1.PushFront(1)
+	checkList(t, l1, []interface{}{1})
+
+	var l2 = new(List[int])
+	l2.PushBack(1)
+	checkList(t, l2, []interface{}{1})
+
+	var l3 = new(List[int])
+	l3.PushFrontList(l1)
+	checkList(t, l3, []interface{}{1})
+
+	var l4 = new(List[int])
+	l4.PushBackList(l2)
+	checkList(t, l4, []interface{}{1})
+}
+
+// Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l.
+func TestInsertBeforeUnknownMark(t *testing.T) {
+	var l List[int]
+	l.PushBack(1)
+	l.PushBack(2)
+	l.PushBack(3)
+	l.InsertBefore(1, new(Element[int]))
+	checkList(t, &l, []interface{}{1, 2, 3})
+}
+
+// Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l.
+func TestInsertAfterUnknownMark(t *testing.T) {
+	var l List[int]
+	l.PushBack(1)
+	l.PushBack(2)
+	l.PushBack(3)
+	l.InsertAfter(1, new(Element[int]))
+	checkList(t, &l, []interface{}{1, 2, 3})
+}
+
+// Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l.
+func TestMoveUnknownMark(t *testing.T) {
+	var l1 List[int]
+	e1 := l1.PushBack(1)
+
+	var l2 List[int]
+	e2 := l2.PushBack(2)
+
+	l1.MoveAfter(e1, e2)
+	checkList(t, &l1, []interface{}{1})
+	checkList(t, &l2, []interface{}{2})
+
+	l1.MoveBefore(e1, e2)
+	checkList(t, &l1, []interface{}{1})
+	checkList(t, &l2, []interface{}{2})
+}
+
+// Test the Transform function.
+func TestTransform(t *testing.T) {
+	l1 := New[int]()
+	l1.PushBack(1)
+	l1.PushBack(2)
+	l2 := Transform(l1, strconv.Itoa)
+	checkList(t, l2, []interface{}{"1", "2"})
+}

src/cmd/go2go/testdata/go2path/src/maps/maps.go2

@@ -0,0 +1,91 @@
+// Copyright 2020 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 maps implements simple functions to manipulate maps in various ways.
+package maps
+
+// Keys returns the keys of the map m.
+// The keys will be an indeterminate order.
+func Keys[K comparable, V any](m map[K]V) []K {
+	r := make([]K, 0, len(m))
+	for k := range m {
+		r = append(r, k)
+	}
+	return r
+}
+
+// Values returns the values of the map m.
+// The values will be in an indeterminate order.
+func Values[K comparable, V any](m map[K]V) []V {
+	r := make([]V, 0, len(m))
+	for _, v := range m {
+		r = append(r, v)
+	}
+	return r
+}
+
+// Equal reports whether two maps contain the same key/value pairs.
+// Values are compared using ==.
+func Equal[K, V comparable](m1, m2 map[K]V) bool {
+	if len(m1) != len(m2) {
+		return false
+	}
+	for k, v1 := range m1 {
+		if v2, ok := m2[k]; !ok || v1 != v2 {
+			return false
+		}
+	}
+	return true
+}
+
+// Copy returns a copy of m.
+func Copy[K comparable, V any](m map[K]V) map[K]V {
+	r := make(map[K]V, len(m))
+	for k, v := range m {
+		r[k] = v
+	}
+	return r
+}
+
+// Add adds all key/value pairs in m2 to m1. Keys in m2 that are already
+// present in m1 will be overwritten with the value in m2.
+func Add[K comparable, V any](m1, m2 map[K]V) {
+	for k, v := range m2 {
+		m1[k] = v
+	}
+}
+
+// Sub removes all keys in m2 from m1. Keys in m2 that are not present
+// in m1 are ignored. The values in m2 are ignored.
+func Sub[K comparable, V any](m1, m2 map[K]V) {
+	for k := range m2 {
+		delete(m1, k)
+	}
+}
+
+// Intersect removes all keys from m1 that are not present in m2.
+// Keys in m2 that are not in m1 are ignored. The values in m2 are ignored.
+func Intersect[K comparable, V any](m1, m2 map[K]V) {
+	for k := range m1 {
+		if _, ok := m2[k]; !ok {
+			delete(m1, k)
+		}
+	}
+}
+
+// Filter deletes any key/value pairs from m for which f returns false.
+func Filter[K comparable, V any](m map[K]V, f func(K, V) bool) {
+	for k, v := range m {
+		if !f(k, v) {
+			delete(m, k)
+		}
+	}
+}
+
+// TransformValues applies f to each value in m. The keys remain unchanged.
+func TransformValues[K comparable, V any](m map[K]V, f func(V) V) {
+	for k, v := range m {
+		m[k] = f(v)
+	}
+}

src/cmd/go2go/testdata/go2path/src/maps/maps_test.go2

@@ -0,0 +1,145 @@
+// Copyright 2020 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 maps
+
+import (
+	"math"
+	"sort"
+	"testing"
+
+	"slices"
+)
+
+var m1 = map[int]int{1: 2, 2: 4, 4: 8, 8: 16}
+var m2 = map[int]string{1: "2", 2: "4", 4: "8", 8: "16"}
+
+func TestKeys(t *testing.T) {
+	want := []int{1, 2, 4, 8}
+
+	got1 := Keys(m1)
+	sort.Ints(got1)
+	if !slices.Equal(got1, want) {
+		t.Errorf("Keys(%v) = %v, want %v", m1, got1, want)
+	}
+
+	got2 := Keys(m2)
+	sort.Ints(got2)
+	if !slices.Equal(got2, want) {
+		t.Errorf("Keys(%v) = %v, want %v", m2, got2, want)
+	}
+}
+
+func TestValues(t *testing.T) {
+	got1 := Values(m1)
+	want1 := []int{2, 4, 8, 16}
+	sort.Ints(got1)
+	if !slices.Equal(got1, want1) {
+		t.Errorf("Values(%v) = %v, want %v", m1, got1, want1)
+	}
+
+	got2 := Values(m2)
+	want2 := []string{"16", "2", "4", "8"}
+	sort.Strings(got2)
+	if !slices.Equal(got2, want2) {
+		t.Errorf("Values(%v) = %v, want %v", m2, got2, want2)
+	}
+}
+
+func TestEqual(t *testing.T) {
+	if !Equal(m1, m1) {
+		t.Errorf("Equal(%v, %v) = false, want true", m1, m1)
+	}
+	if Equal(m1, nil) {
+		t.Errorf("Equal(%v, nil) = true, want false", m1)
+	}
+	if Equal(nil, m1) {
+		t.Errorf("Equal(nil, %v) = true, want false", m1)
+	}
+	if !Equal[int, int](nil, nil) {
+		t.Error("Equal(nil, nil) = false, want true")
+	}
+	if ms := map[int]int{1: 2}; Equal(m1, ms) {
+		t.Errorf("Equal(%v, %v) = true, want false", m1, ms)
+	}
+
+	// Comparing NaN for equality is expected to fail.
+	mf := map[int]float64{1: 0, 2: math.NaN()}
+	if Equal(mf, mf) {
+		t.Errorf("Equal(%v, %v) = true, want false", mf, mf)
+	}
+}
+
+func TestCopy(t *testing.T) {
+	m2 := Copy(m1)
+	if !Equal(m1, m2) {
+		t.Errorf("Copy(%v) = %v, want %v", m1, m2, m1)
+	}
+	m2[16] = 32
+	if Equal(m1, m2) {
+		t.Errorf("Equal(%v, %v) = true, want false", m1, m2)
+	}
+}
+
+func TestAdd(t *testing.T) {
+	mc := Copy(m1)
+	Add(mc, mc)
+	if !Equal(mc, m1) {
+		t.Errorf("Add(%v, %v) = %v, want %v", m1, m1, mc, m1)
+	}
+	Add(mc, map[int]int{16: 32})
+	want := map[int]int{1: 2, 2: 4, 4: 8, 8: 16, 16: 32}
+	if !Equal(mc, want) {
+		t.Errorf("Add result = %v, want %v", mc, want)
+	}
+}
+
+func TestSub(t *testing.T) {
+	mc := Copy(m1)
+	Sub(mc, mc)
+	if len(mc) > 0 {
+		t.Errorf("Sub(%v, %v) = %v, want empty map", m1, m1, mc)
+	}
+	mc = Copy(m1)
+	Sub(mc, map[int]int{1: 0})
+	want := map[int]int{2: 4, 4: 8, 8: 16}
+	if !Equal(mc, want) {
+		t.Errorf("Sub result = %v, want %v", mc, want)
+	}
+}
+
+func TestIntersect(t *testing.T) {
+	mc := Copy(m1)
+	Intersect(mc, mc)
+	if !Equal(mc, m1) {
+		t.Errorf("Intersect(%v, %v) = %v, want %v", m1, m1, mc, m1)
+	}
+	Intersect(mc, map[int]int{1: 0, 2: 0})
+	want := map[int]int{1: 2, 2: 4}
+	if !Equal(mc, want) {
+		t.Errorf("Intersect result = %v, want %v", mc, want)
+	}
+}
+
+func TestFilter(t *testing.T) {
+	mc := Copy(m1)
+	Filter(mc, func(int, int) bool { return true })
+	if !Equal(mc, m1) {
+		t.Errorf("Filter(%v, true) = %v, want %v", m1, mc, m1)
+	}
+	Filter(mc, func(k, v int) bool { return k < 3 })
+	want := map[int]int{1: 2, 2: 4}
+	if !Equal(mc, want) {
+		t.Errorf("Filter result = %v, want %v", mc, want)
+	}
+}
+
+func TestTransformValues(t *testing.T) {
+	mc := Copy(m1)
+	TransformValues(mc, func(i int) int { return i / 2 })
+	want := map[int]int{1: 1, 2: 2, 4: 4, 8: 8}
+	if !Equal(mc, want) {
+		t.Errorf("TransformValues result = %v, want %v", mc, want)
+	}
+}

src/cmd/go2go/testdata/go2path/src/metrics/metrics.go2

@@ -0,0 +1,117 @@
+// Copyright 2020 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 metrics provides tracking arbitrary metrics composed of
+// values of comparable types.
+package metrics
+
+import (
+	"sync"
+
+	"maps"
+)
+
+// Metric1 tracks metrics of values of some type.
+type Metric1[T comparable] struct {
+	mu sync.Mutex
+	m  map[T]int
+}
+
+// Add adds another instance of some value.
+func (m *Metric1[T]) Add(v T) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.m == nil {
+		m.m = make(map[T]int)
+	}
+	m.m[v]++
+}
+
+// Count returns the number of instances we've seen of v.
+func (m *Metric1[T]) Count(v T) int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.m[v]
+}
+
+// Metrics returns all the values we've seen, in an indeterminate order.
+func (m *Metric1[T]) Metrics() []T {
+	return maps.Keys(m.m)
+}
+
+type key2[T1, T2 comparable] struct {
+	f1 T1
+	f2 T2
+}
+
+// Metric2 tracks metrics of pairs of values.
+type Metric2[T1, T2 comparable] struct {
+	mu sync.Mutex
+	m  map[key2[T1, T2]]int
+}
+
+// Add adds another instance of some pair of values.
+func (m *Metric2[T1, T2]) Add(v1 T1, v2 T2) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.m == nil {
+		m.m = make(map[key2[T1, T2]]int)
+	}
+	m.m[key2[T1, T2]{v1, v2}]++
+}
+
+// Count returns the number of instances we've seen of v1/v2.
+func (m *Metric2[T1, T2]) Count(v1 T1, v2 T2) int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.m[key2[T1, T2]{v1, v2}]
+}
+
+// Metrics returns all the values we've seen, in an indeterminate order.
+func (m *Metric2[T1, T2]) Metrics() (r1 []T1, r2 []T2) {
+	for _, k := range maps.Keys(m.m) {
+		r1 = append(r1, k.f1)
+		r2 = append(r2, k.f2)
+	}
+	return r1, r2
+}
+
+type key3[T1, T2, T3 comparable] struct {
+	f1 T1
+	f2 T2
+	f3 T3
+}
+
+// Metric3 tracks metrics of triplets of values.
+type Metric3[T1, T2, T3 comparable] struct {
+	mu sync.Mutex
+	m  map[key3[T1, T2, T3]]int
+}
+
+// Add adds another instance of some triplet of values.
+func (m *Metric3[T1, T2, T3]) Add(v1 T1, v2 T2, v3 T3) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.m == nil {
+		m.m = make(map[key3[T1, T2, T3]]int)
+	}
+	m.m[key3[T1, T2, T3]{v1, v2, v3}]++
+}
+
+// Count returns the number of instances we've seen of v1/v2/v3.
+func (m *Metric3[T1, T2, T3]) Count(v1 T1, v2 T2, v3 T3) int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.m[key3[T1, T2, T3]{v1, v2, v3}]
+}
+
+// Metrics returns all the values we've seen, in an indeterminate order.
+func (m *Metric3[T1, T2, T3]) Metrics() (r1 []T1, r2 []T2, r3 []T3) {
+	for k := range m.m {
+		r1 = append(r1, k.f1)
+		r2 = append(r2, k.f2)
+		r3 = append(r3, k.f3)
+	}
+	return r1, r2, r3
+}

src/cmd/go2go/testdata/go2path/src/metrics/metrics_test.go2

@@ -0,0 +1,57 @@
+// Copyright 2020 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 metrics
+
+import (
+	"sort"
+	"testing"
+
+	"slices"
+)
+
+type S struct{ a, b, c string }
+
+func TestMetrics(t *testing.T) {
+	m1 := Metric1[string]{}
+	if got := m1.Count("a"); got != 0 {
+		t.Errorf("Count(%q) = %d, want 0", "a", got)
+	}
+	m1.Add("a")
+	m1.Add("a")
+	if got := m1.Count("a"); got != 2 {
+		t.Errorf("Count(%q) = %d, want 2", "a", got)
+	}
+	if got, want := m1.Metrics(), []string{"a"}; !slices.Equal(got, want) {
+		t.Errorf("Metrics = %v, want %v", got, want)
+	}
+
+	m2 := Metric2[int, float64]{}
+	m2.Add(1, 1)
+	m2.Add(2, 2)
+	m2.Add(3, 3)
+	m2.Add(3, 3)
+	k1, k2 := m2.Metrics()
+
+	sort.Ints(k1)
+	w1 := []int{1, 2, 3}
+	if !slices.Equal(k1, w1) {
+		t.Errorf("Metric2.Metrics first slice = %v, want %v", k1, w1)
+	}
+
+	sort.Float64s(k2)
+	w2 := []float64{1, 2, 3}
+	if !slices.Equal(k2, w2) {
+		t.Errorf("Metric2.Metrics first slice = %v, want %v", k2, w2)
+	}
+
+	m3 := Metric3[string, S, S]{}
+	m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"})
+	m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"})
+	m3.Add("a", S{"d", "e", "f"}, S{"g", "h", "i"})
+	m3.Add("b", S{"d", "e", "f"}, S{"g", "h", "i"})
+	if got := m3.Count("a", S{"d", "e", "f"}, S{"g", "h", "i"}); got != 3 {
+		t.Errorf("Count(%v, %v, %v) = %d, want 3", "a", S{"d", "e", "f"}, S{"g", "h", "i"}, got)
+	}
+}

src/cmd/go2go/testdata/go2path/src/orderedmap/orderedmap.go2

@@ -0,0 +1,136 @@
+// Copyright 2020 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 orderedmap provides an ordered map, implemented as a binary tree.
+package orderedmap
+
+// FIXME: This should probably be container/orderedmap.
+
+import (
+	"context"
+
+	"chans"
+	"constraints"
+)
+
+// Map is an ordered map.
+type Map[K, V any] struct {
+	root    *node[K, V]
+	compare func(K, K) int
+}
+
+// node is the type of a node in the binary tree.
+type node[K, V any] struct {
+	key         K
+	val         V
+	left, right *node[K, V]
+}
+
+// New returns a new map. It takes a comparison function that compares two
+// keys and returns < 0 if the first is less, == 0 if they are equal,
+// > 0 if the first is greater.
+func New[K, V any](compare func(K, K) int) *Map[K, V] {
+	return &Map[K, V]{compare: compare}
+}
+
+// NewOrdered returns a new map whose key is an ordered type.
+// This is like New, but does not require providing a compare function.
+// The map compare function uses the obvious key ordering.
+func NewOrdered[K constraints.Ordered, V any]() *Map[K, V] {
+	return New[K, V](func(k1, k2 K) int {
+		switch {
+		case k1 < k2:
+			return -1
+		case k1 == k2:
+			return 0
+		default:
+			return 1
+		}
+	})
+}
+
+// find looks up key in the map, returning either a pointer to the slot of the
+// node holding key, or a pointer to the slot where should a node would go.
+func (m *Map[K, V]) find(key K) **node[K, V] {
+	pn := &m.root
+	for *pn != nil {
+		switch cmp := m.compare(key, (*pn).key); {
+		case cmp < 0:
+			pn = &(*pn).left
+		case cmp > 0:
+			pn = &(*pn).right
+		default:
+			return pn
+		}
+	}
+	return pn
+}
+
+// Insert inserts a new key/value into the map.
+// If the key is already present, the value is replaced.
+// Reports whether this is a new key.
+func (m *Map[K, V]) Insert(key K, val V) bool {
+	pn := m.find(key)
+	if *pn != nil {
+		(*pn).val = val
+		return false
+	}
+	*pn = &node[K, V]{key: key, val: val}
+	return true
+}
+
+// Find returns the value associated with a key, or the zero value
+// if not present. The found result reports whether the key was found.
+func (m *Map[K, V]) Find(key K) (V, bool) {
+	pn := m.find(key)
+	if *pn == nil {
+		var zero V
+		return zero, false
+	}
+	return (*pn).val, true
+}
+
+// keyValue is a pair of key and value used while iterating.
+type keyValue[K, V any] struct {
+	key K
+	val V
+}
+
+// iterate returns an iterator that traverses the map.
+func (m *Map[K, V]) Iterate() *Iterator[K, V] {
+	sender, receiver := chans.Ranger[keyValue[K, V]]()
+	var f func(*node[K, V]) bool
+	f = func(n *node[K, V]) bool {
+		if n == nil {
+			return true
+		}
+		// Stop the traversal if Send fails, which means that
+		// nothing is listening to the receiver.
+		return f(n.left) &&
+			sender.Send(context.Background(), keyValue[K, V]{n.key, n.val}) &&
+			f(n.right)
+	}
+	go func() {
+		f(m.root)
+		sender.Close()
+	}()
+	return &Iterator[K, V]{receiver}
+}
+
+// Iterator is used to iterate over the map.
+type Iterator[K, V any] struct {
+	r *chans.Receiver[keyValue[K, V]]
+}
+
+// Next returns the next key and value pair, and a boolean that reports
+// whether they are valid. If not valid, we have reached the end of the map.
+func (it *Iterator[K, V]) Next() (K, V, bool) {
+	keyval, ok := it.r.Next(context.Background())
+	if !ok {
+		var zerok K
+		var zerov V
+		return zerok, zerov, false
+	}
+	return keyval.key, keyval.val, true
+}

src/cmd/go2go/testdata/go2path/src/orderedmap/orderedmap_test.go2

@@ -0,0 +1,63 @@
+// Copyright 2020 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 orderedmap
+
+import (
+	"bytes"
+	"testing"
+
+	"slices"
+)
+
+func TestMap(t *testing.T) {
+	m := New[[]byte, int](bytes.Compare)
+
+	if _, found := m.Find([]byte("a")); found {
+		t.Errorf("unexpectedly found %q in empty map", []byte("a"))
+	}
+	if !m.Insert([]byte("a"), 'a') {
+		t.Errorf("key %q unexpectedly already present", []byte("a"))
+	}
+	if !m.Insert([]byte("c"), 'c') {
+		t.Errorf("key %q unexpectedly already present", []byte("c"))
+	}
+	if !m.Insert([]byte("b"), 'b') {
+		t.Errorf("key %q unexpectedly already present", []byte("b"))
+	}
+	if m.Insert([]byte("c"), 'x') {
+		t.Errorf("key %q unexpectedly not present", []byte("c"))
+	}
+
+	if v, found := m.Find([]byte("a")); !found {
+		t.Errorf("did not find %q", []byte("a"))
+	} else if v != 'a' {
+		t.Errorf("key %q returned wrong value %c, expected %c", []byte("a"), v, 'a')
+	}
+	if v, found := m.Find([]byte("c")); !found {
+		t.Errorf("did not find %q", []byte("c"))
+	} else if v != 'x' {
+		t.Errorf("key %q returned wrong value %c, expected %c", []byte("c"), v, 'x')
+	}
+
+	if _, found := m.Find([]byte("d")); found {
+		t.Errorf("unexpectedly found %q", []byte("d"))
+	}
+
+	gather := func(it *Iterator[[]byte, int]) []int {
+		var r []int
+		for {
+			_, v, ok := it.Next()
+			if !ok {
+				return r
+			}
+			r = append(r, v)
+		}
+	}
+	got := gather(m.Iterate())
+	want := []int{'a', 'b', 'x'}
+	if !slices.Equal(got, want) {
+		t.Errorf("Iterate returned %v, want %v", got, want)
+	}
+}

src/cmd/go2go/testdata/go2path/src/sets/sets.go2

@@ -0,0 +1,111 @@
+// Copyright 2020 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 sets implements sets of any type.
+package sets
+
+// A Set is a set of elements of some type.
+type Set[Elem comparable] struct {
+	m map[Elem]struct{}
+}
+
+// Make makes a new set.
+func Make[Elem comparable]() Set[Elem] {
+	return Set[Elem]{m: make(map[Elem]struct{})}
+}
+
+// Add adds an element to a set.
+func (s Set[Elem]) Add(v Elem) {
+	s.m[v] = struct{}{}
+}
+
+// Delete removes an element from a set. If the element is not present
+// in the set, this does nothing.
+func (s Set[Elem]) Delete(v Elem) {
+	delete(s.m, v)
+}
+
+// Contains reports whether v is in the set.
+func (s Set[Elem]) Contains(v Elem) bool {
+	_, ok := s.m[v]
+	return ok
+}
+
+// Len returns the number of elements in the set.
+func (s Set[Elem]) Len() int {
+	return len(s.m)
+}
+
+// Values returns the values in the set.
+// The values will be in an indeterminate order.
+func (s Set[Elem]) Values() []Elem {
+	r := make([]Elem, 0, len(s.m))
+	for v := range s.m {
+		r = append(r, v)
+	}
+	return r
+}
+
+// Equal reports whether two sets contain the same elements.
+func Equal[Elem comparable](s1, s2 Set[Elem]) bool {
+	if len(s1.m) != len(s2.m) {
+		return false
+	}
+	for v1 := range s1.m {
+		if !s2.Contains(v1) {
+			return false
+		}
+	}
+	return true
+}
+
+// Copy returns a copy of s.
+func (s Set[Elem]) Copy() Set[Elem] {
+	r := Set[Elem]{m: make(map[Elem]struct{}, len(s.m))}
+	for v := range s.m {
+		r.m[v] = struct{}{}
+	}
+	return r
+}
+
+// AddSet adds all the elements of s2 to s.
+func (s Set[Elem]) AddSet(s2 Set[Elem]) {
+	for v := range s2.m {
+		s.m[v] = struct{}{}
+	}
+}
+
+// SubSet removes all elements in s2 from s.
+// Values in s2 that are not in s are ignored.
+func (s Set[Elem]) SubSet(s2 Set[Elem]) {
+	for v := range s2.m {
+		delete(s.m, v)
+	}
+}
+
+// Intersect removes all elements from s that are not present in s2.
+// Values in s2 that are not in s are ignored.
+func (s Set[Elem]) Intersect(s2 Set[Elem]) {
+	for v := range s.m {
+		if !s2.Contains(v) {
+			delete(s.m, v)
+		}
+	}
+}
+
+// Iterate calls f on every element in the set.
+func (s Set[Elem]) Iterate(f func(Elem)) {
+	for v := range s.m {
+		f(v)
+	}
+}
+
+// Filter deletes any elements from s for which f returns false.
+func (s Set[Elem]) Filter(f func(Elem) bool) {
+	for v := range s.m {
+		if !f(v) {
+			delete(s.m, v)
+		}
+	}
+}

src/cmd/go2go/testdata/go2path/src/sets/sets_test.go2

@@ -0,0 +1,146 @@
+// Copyright 2020 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 sets
+
+import (
+	"sort"
+	"testing"
+
+	"slices"
+)
+
+func TestSet(t *testing.T) {
+	s1 := Make[int]()
+	if got := s1.Len(); got != 0 {
+		t.Errorf("Len of empty set = %d, want 0", got)
+	}
+	s1.Add(1)
+	s1.Add(1)
+	s1.Add(1)
+	if got := s1.Len(); got != 1 {
+		t.Errorf("(%v).Len() == %d, want 1", s1, got)
+	}
+	s1.Add(2)
+	s1.Add(3)
+	s1.Add(4)
+	if got := s1.Len(); got != 4 {
+		t.Errorf("(%v).Len() == %d, want 4", s1, got)
+	}
+	if !s1.Contains(1) {
+		t.Errorf("(%v).Contains(1) == false, want true", s1)
+	}
+	if s1.Contains(5) {
+		t.Errorf("(%v).Contains(5) == true, want false", s1)
+	}
+	vals := s1.Values()
+	sort.Ints(vals)
+	w1 := []int{1, 2, 3, 4}
+	if !slices.Equal(vals,  w1) {
+		t.Errorf("(%v).Values() == %v, want %v", s1, vals, w1)
+	}
+}
+
+func TestEqual(t *testing.T) {
+	s1 := Make[string]()
+	s2 := Make[string]()
+	if !Equal(s1, s2) {
+		t.Errorf("Equal(%v, %v) = false, want true", s1, s2)
+	}
+	s1.Add("hello")
+	s1.Add("world")
+	if got := s1.Len(); got != 2 {
+		t.Errorf("(%v).Len() == %d, want 2", s1, got)
+	}
+	if Equal(s1, s2) {
+		t.Errorf("Equal(%v, %v) = true, want false", s1, s2)
+	}
+}
+
+func TestCopy(t *testing.T) {
+	s1 := Make[float64]()
+	s1.Add(0)
+	s2 := s1.Copy()
+	if !Equal(s1, s2) {
+		t.Errorf("Equal(%v, %v) = false, want true", s1, s2)
+	}
+	s1.Add(1)
+	if Equal(s1, s2) {
+		t.Errorf("Equal(%v, %v) = true, want false", s1, s2)
+	}
+}
+
+func TestAddSet(t *testing.T) {
+	s1 := Make[int]()
+	s1.Add(1)
+	s1.Add(2)
+	s2 := Make[int]()
+	s2.Add(2)
+	s2.Add(3)
+	s1.AddSet(s2)
+	if got := s1.Len(); got != 3 {
+		t.Errorf("(%v).Len() == %d, want 3", s1, got)
+	}
+	s2.Add(1)
+	if !Equal(s1, s2) {
+		t.Errorf("Equal(%v, %v) = false, want true", s1, s2)
+	}
+}
+
+func TestSubSet(t *testing.T) {
+	s1 := Make[int]()
+	s1.Add(1)
+	s1.Add(2)
+	s2 := Make[int]()
+	s2.Add(2)
+	s2.Add(3)
+	s1.SubSet(s2)
+	if got := s1.Len(); got != 1 {
+		t.Errorf("(%v).Len() == %d, want 1", s1, got)
+	}
+	if vals, want := s1.Values(), []int{1}; !slices.Equal(vals, want) {
+		t.Errorf("after SubSet got %v, want %v", vals, want)
+	}
+}
+
+func TestIntersect(t *testing.T) {
+	s1 := Make[int]()
+	s1.Add(1)
+	s1.Add(2)
+	s2 := Make[int]()
+	s2.Add(2)
+	s2.Add(3)
+	s1.Intersect(s2)
+	if got := s1.Len(); got != 1 {
+		t.Errorf("(%v).Len() == %d, want 1", s1, got)
+	}
+	if vals, want := s1.Values(), []int{2}; !slices.Equal(vals, want) {
+		t.Errorf("after Intersect got %v, want %v", vals, want)
+	}
+}
+
+func TestIterate(t *testing.T) {
+	s1 := Make[int]()
+	s1.Add(1)
+	s1.Add(2)
+	s1.Add(3)
+	s1.Add(4)
+	tot := 0
+	s1.Iterate(func(i int) { tot += i })
+	if tot != 10 {
+		t.Errorf("total of %v == %d, want 10", s1, tot)
+	}
+}
+
+func TestFilter(t *testing.T) {
+	s1 := Make[int]()
+	s1.Add(1)
+	s1.Add(2)
+	s1.Add(3)
+	s1.Filter(func(v int) bool { return v%2 == 0 })
+	if vals, want := s1.Values(), []int{2}; !slices.Equal(vals, want) {
+		t.Errorf("after Filter got %v, want %v", vals, want)
+	}
+
+}

src/cmd/go2go/testdata/go2path/src/slices/slices.go2

@@ -0,0 +1,125 @@
+// Copyright 2020 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 slices provides functions for basic operations on
+// slices of any element type.
+package slices
+
+import (
+	"alg"
+	"constraints"
+)
+
+// Equal reports whether two slices are equal: the same length and all
+// elements equal. All floating point NaNs are considered equal.
+func Equal[Elem comparable](s1, s2 []Elem) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// EqualFn reports whether two slices are equal using a comparision
+// function on each element.
+func EqualFn[Elem any](s1, s2 []Elem, eq func(Elem, Elem) bool) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if !eq(v1, v2) {
+			return false
+		}
+	}
+	return true
+}
+
+// Map turns a []Elem1 to a []Elem2 using a mapping function.
+func Map[Elem1, Elem2 any](s []Elem1, f func(Elem1) Elem2) []Elem2 {
+	r := make([]Elem2, len(s))
+	for i, v := range s {
+		r[i] = f(v)
+	}
+	return r
+}
+
+// Reduce reduces a []Elem1 to a single value of type Elem2 using
+// a reduction function.
+func Reduce[Elem1, Elem2 any](s []Elem1, initializer Elem2, f func(Elem2, Elem1) Elem2) Elem2 {
+	r := initializer
+	for _, v := range s {
+		r = f(r, v)
+	}
+	return r
+}
+
+// Filter filters values from a slice using a filter function.
+func Filter[Elem any](s []Elem, f func(Elem) bool) []Elem {
+	var r []Elem
+	for _, v := range s {
+		if f(v) {
+			r = append(r, v)
+		}
+	}
+	return r
+}
+
+// Max returns the maximum element in a slice of some ordered type.
+// If the slice is empty it returns the zero value of the element type.
+func Max[Elem constraints.Ordered](s []Elem) Elem {
+	if len(s) == 0 {
+		var zero Elem
+		return zero
+	}
+	return Reduce(s[1:], s[0], alg.Max[Elem])
+}
+
+// Min returns the minimum element in a slice of some ordered type.
+// If the slice is empty it returns the zero value of the element type.
+func Min[Elem constraints.Ordered](s []Elem) Elem {
+	if len(s) == 0 {
+		var zero Elem
+		return zero
+	}
+	return Reduce(s[1:], s[0], alg.Min[Elem])
+}
+
+// Append adds values to the end of a slice, returning a new slice.
+// This is like the predeclared append function; it's an example
+// of how to write it using generics. We used to write code like
+// this before append was added to the language, but we had to write
+// a separate copy for each type.
+func Append[T any](s []T, t ...T) []T {
+	lens := len(s)
+	tot := lens + len(t)
+	if tot <= cap(s) {
+		s = s[:tot]
+	} else {
+		news := make([]T, tot, tot + tot/2)
+		Copy(news, s)
+		s = news
+	}
+	Copy(s[lens:tot], t)
+	return s
+}
+
+// Copy copies values from t to s, stopping when either slice is full,
+// returning the number of values copied. This is like the predeclared
+// copy function; it's an example of how to write it using generics.
+func Copy[T any](s, t []T) int {
+	i := 0
+	for ; i < len(s) && i < len(t); i++ {
+		s[i] = t[i]
+	}
+	return i
+}

src/cmd/go2go/testdata/go2path/src/slices/slices_test.go2

@@ -0,0 +1,164 @@
+// Copyright 2020 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 slices
+
+import (
+	"math"
+	"strings"
+	"testing"
+
+	"constraints"
+)
+
+func TestEqual(t *testing.T) {
+	s1 := []int{1, 2, 3}
+	if !Equal(s1, s1) {
+		t.Errorf("Equal(%v, %v) = false, want true", s1, s1)
+	}
+	s2 := []int{1, 2, 3}
+	if !Equal(s1, s2) {
+		t.Errorf("Equal(%v, %v) = false, want true", s1, s2)
+	}
+	s2 = append(s2, 4)
+	if Equal(s1, s2) {
+		t.Errorf("Equal(%v, %v) = true, want false", s1, s2)
+	}
+
+	s3 := []float64{1, 2, math.NaN()}
+	if !Equal(s3, s3) {
+		t.Errorf("Equal(%v, %v) = false, want true", s3, s3)
+	}
+
+	if Equal(s1, nil) {
+		t.Errorf("Equal(%v, nil) = true, want false", s1)
+	}
+	if Equal(nil, s1) {
+		t.Errorf("Equal(nil, %v) = true, want false", s1)
+	}
+	if !Equal(s1[:0], nil) {
+		t.Errorf("Equal(%v, nil = false, want true", s1[:0])
+	}
+}
+
+func offByOne[Elem constraints.Integer](a, b Elem) bool {
+	return a == b + 1 || a == b - 1
+}
+
+func TestEqualFn(t *testing.T) {
+	s1 := []int{1, 2, 3}
+	s2 := []int{2, 3, 4}
+	if EqualFn(s1, s1, offByOne[int]) {
+		t.Errorf("EqualFn(%v, %v, offByOne) = true, want false", s1, s1)
+	}
+	if !EqualFn(s1, s2, offByOne[int]) {
+		t.Errorf("EqualFn(%v, %v, offByOne) = false, want true", s1, s2)
+	}
+
+	s3 := []string{"a", "b", "c"}
+	s4 := []string{"A", "B", "C"}
+	if !EqualFn(s3, s4, strings.EqualFold) {
+		t.Errorf("EqualFn(%v, %v, strings.EqualFold) = false, want true", s3, s4)
+	}
+
+	if !EqualFn(s1[:0], nil, offByOne[int]) {
+		t.Errorf("EqualFn(%v, nil, offByOne) = false, want true", s1[:0])
+	}
+}
+
+func TestMap(t *testing.T) {
+	s1 := []int{1, 2, 3}
+	s2 := Map(s1, func(i int) float64 { return float64(i) * 2.5 })
+	if want := []float64{2.5, 5, 7.5}; !Equal(s2, want) {
+		t.Errorf("Map(%v, ...) = %v, want %v", s1, s2, want)
+	}
+
+	s3 := []string{"Hello", "World"}
+	s4 := Map(s3, strings.ToLower)
+	if want := []string{"hello", "world"}; !Equal(s4, want) {
+		t.Errorf("Map(%v, strings.ToLower) = %v, want %v", s3, s4, want)
+	}
+
+	s5 := Map(nil, func(i int) int { return i })
+	if len(s5) != 0 {
+		t.Errorf("Map(nil, identity) = %v, want empty slice", s5)
+	}
+}
+
+func TestReduce(t *testing.T) {
+	s1 := []int{1, 2, 3}
+	r := Reduce(s1, 0, func(f float64, i int) float64 { return float64(i) * 2.5 + f })
+	if want := 15.0; r != want {
+		t.Errorf("Reduce(%v, 0, ...) = %v, want %v", s1, r, want)
+	}
+
+	if got := Reduce(nil, 0, func(i, j int) int { return i + j}); got != 0 {
+		t.Errorf("Reduce(nil, 0, add) = %v, want 0", got)
+	}
+}
+
+func TestFilter(t *testing.T) {
+	s1 := []int{1, 2, 3}
+	s2 := Filter(s1, func(i int) bool { return i%2 == 0 })
+	if want := []int{2}; !Equal(s2, want) {
+		t.Errorf("Filter(%v, even) = %v, want %v", s1, s2, want)
+	}
+
+	if s3 := Filter(s1[:0], func(i int) bool { return true }); len(s3) > 0 {
+		t.Errorf("Filter(%v, identity) = %v, want empty slice", s1[:0], s3)
+	}
+}
+
+func TestMax(t *testing.T) {
+	s1 := []int{1, 2, 3, -5}
+	if got, want := Max(s1), 3; got != want {
+		t.Errorf("Max(%v) = %d, want %d", s1, got, want)
+	}
+
+	s2 := []string{"aaa", "a", "aa", "aaaa"}
+	if got, want := Max(s2), "aaaa"; got != want {
+		t.Errorf("Max(%v) = %q, want %q", s2, got, want)
+	}
+
+	if got, want := Max(s2[:0]), ""; got != want {
+		t.Errorf("Max(%v) = %q, want %q", s2[:0], got, want)
+	}
+}
+
+func TestMin(t *testing.T) {
+	s1 := []int{1, 2, 3, -5}
+	if got, want := Min(s1), -5; got != want {
+		t.Errorf("Min(%v) = %d, want %d", s1, got, want)
+	}
+
+	s2 := []string{"aaa", "a", "aa", "aaaa"}
+	if got, want := Min(s2), "a"; got != want {
+		t.Errorf("Min(%v) = %q, want %q", s2, got, want)
+	}
+
+	if got, want := Min(s2[:0]), ""; got != want {
+		t.Errorf("Min(%v) = %q, want %q", s2[:0], got, want)
+	}
+}
+
+func TestAppend(t *testing.T) {
+	s := []int{1, 2, 3}
+	s = Append(s, 4, 5, 6)
+	want := []int{1, 2, 3, 4, 5, 6}
+	if !Equal(s, want) {
+		t.Errorf("after Append got %v, want %v", s, want)
+	}
+}
+
+func TestCopy(t *testing.T) {
+	s1 := []int{1, 2, 3}
+	s2 := []int{4, 5}
+	if got := Copy(s1, s2); got != 2 {
+		t.Errorf("Copy returned %d, want 2", got)
+	}
+	want := []int{4, 5, 3}
+	if !Equal(s1, want) {
+		t.Errorf("after Copy got %v, want %v", s1, want)
+	}
+}

src/cmd/go2go/translate.go

@@ -0,0 +1,33 @@
+// Copyright 2020 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 main
+
+import (
+	"go/go2go"
+	"io/ioutil"
+	"strings"
+)
+
+// translate writes .go files for all .go2 files in dir.
+func translate(importer *go2go.Importer, dir string) {
+	if err := go2go.Rewrite(importer, dir); err != nil {
+		die(err.Error())
+	}
+}
+
+// translateFile translates one .go2 file into a .go file.
+func translateFile(importer *go2go.Importer, file string) {
+	data, err := ioutil.ReadFile(file)
+	if err != nil {
+		die(err.Error())
+	}
+	out, err := go2go.RewriteBuffer(importer, file, data)
+	if err != nil {
+		die(err.Error())
+	}
+	if err := ioutil.WriteFile(strings.TrimSuffix(file, ".go2")+".go", out, 0644); err != nil {
+		die(err.Error())
+	}
+}

src/cmd/gofmt/gofmt.go

@@ -75,6 +75,7 @@ func usage() {
 }
 
 func initParserMode() {
+	// Keep this in sync with go/format/format.go.
 	parserMode = parser.ParseComments
 	if *allErrors {
 		parserMode |= parser.AllErrors

src/cmd/gofmt/gofmt_go2go.go

@@ -0,0 +1,10 @@
+// Copyright 2021 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 main
+
+func init() {
+	// Type parameters are allowed on the go2go branch.
+	allowTypeParams = true
+}

src/go/build/deps_test.go

@@ -518,6 +518,9 @@ var depsRules = `
 
 	FMT, container/heap, math/rand
 	< internal/trace;
+
+	# go2go: a package that should only exist on the dev.go2go branch
+	go/build, go/importer, go/printer, go/types, log < go/go2go;
 `
 
 // listStdPkgs returns the same list of packages as "go list std".

src/go/format/format.go

@@ -38,7 +38,13 @@ const (
 
 var config = printer.Config{Mode: printerMode, Tabwidth: tabWidth}
 
-const parserMode = parser.ParseComments
+const (
+	parserMode = parser.ParseComments | parseTypeParams
+
+	// parseTypeParams tells go/parser to parse type parameters. Must be kept in
+	// sync with go/parser/interface.go.
+	parseTypeParams parser.Mode = 1 << 30
+)
 
 // Node formats node in canonical gofmt style and writes the result to dst.
 //

src/go/go2go/go2go.go

@@ -0,0 +1,276 @@
+// Copyright 2020 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 go2go rewrites polymorphic code into non-polymorphic code.
+package go2go
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// parseTypeParams tells go/parser to parse type parameters. Must be kept in
+// sync with go/parser/interface.go.
+const parseTypeParams parser.Mode = 1 << 30
+
+// rewritePrefix is what we put at the start of each newly generated .go file.
+const rewritePrefix = "// Code generated by go2go; DO NOT EDIT.\n\n"
+
+// Rewrite rewrites the contents of a single directory.
+// It looks for all files with the extension .go2, and parses
+// them as a single package. It writes out a .go file with any
+// polymorphic code rewritten into normal code.
+func Rewrite(importer *Importer, dir string) error {
+	_, err := rewriteToPkgs(importer, "", dir)
+	return err
+}
+
+// rewriteToPkgs rewrites the contents of a single directory,
+// and returns the types.Packages that it computes.
+func rewriteToPkgs(importer *Importer, importPath, dir string) ([]*types.Package, error) {
+	go2files, gofiles, err := go2Files(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := checkAndRemoveGofiles(dir, gofiles); err != nil {
+		return nil, err
+	}
+
+	return rewriteFilesInPath(importer, importPath, dir, go2files)
+}
+
+// namedAST holds a file name and the AST parsed from that file.
+type namedAST struct {
+	name string
+	ast  *ast.File
+}
+
+// RewriteFiles rewrites a set of .go2 files in dir.
+func RewriteFiles(importer *Importer, dir string, go2files []string) ([]*types.Package, error) {
+	return rewriteFilesInPath(importer, "", dir, go2files)
+}
+
+// rewriteFilesInPath rewrites a set of .go2 files in dir for importPath.
+func rewriteFilesInPath(importer *Importer, importPath, dir string, go2files []string) ([]*types.Package, error) {
+	fset := token.NewFileSet()
+	pkgs, err := parseFiles(importer, dir, go2files, fset)
+	if err != nil {
+		return nil, err
+	}
+
+	var rpkgs []*types.Package
+	var tpkgs [][]namedAST
+	for _, pkg := range pkgs {
+		pkgfiles := make([]namedAST, 0, len(pkg.Files))
+		for n, f := range pkg.Files {
+			pkgfiles = append(pkgfiles, namedAST{n, f})
+		}
+		sort.Slice(pkgfiles, func(i, j int) bool {
+			return pkgfiles[i].name < pkgfiles[j].name
+		})
+
+		asts := make([]*ast.File, 0, len(pkgfiles))
+		for _, a := range pkgfiles {
+			asts = append(asts, a.ast)
+		}
+
+		var merr multiErr
+		conf := types.Config{
+			Importer: importer,
+			Error:    merr.add,
+		}
+		path := importPath
+		if path == "" {
+			path = pkg.Name
+		}
+		tpkg, err := conf.Check(path, fset, asts, importer.info)
+		if err != nil {
+			return nil, fmt.Errorf("type checking failed for %s\n%v", pkg.Name, merr)
+		}
+
+		importer.record(pkg.Name, pkgfiles, importPath, tpkg, asts)
+
+		rpkgs = append(rpkgs, tpkg)
+		tpkgs = append(tpkgs, pkgfiles)
+	}
+
+	for i, tpkg := range tpkgs {
+		addImportable := 0
+		for j, pkgfile := range tpkg {
+			if !strings.HasSuffix(pkgfile.name, "_test.go2") {
+				addImportable = j
+				break
+			}
+		}
+
+		for j, pkgfile := range tpkg {
+			if err := rewriteFile(dir, fset, importer, importPath, rpkgs[i], pkgfile.name, pkgfile.ast, j == addImportable); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return rpkgs, nil
+}
+
+// RewriteBuffer rewrites the contents of a single file, in a buffer.
+// It returns a modified buffer. The filename parameter is only used
+// for error messages.
+func RewriteBuffer(importer *Importer, filename string, file []byte) ([]byte, error) {
+	fset := token.NewFileSet()
+	pf, err := parser.ParseFile(fset, filename, file, parseTypeParams)
+	if err != nil {
+		return nil, err
+	}
+	var merr multiErr
+	conf := types.Config{
+		Importer: importer,
+		Error:    merr.add,
+	}
+	tpkg, err := conf.Check(pf.Name.Name, fset, []*ast.File{pf}, importer.info)
+	if err != nil {
+		return nil, fmt.Errorf("type checking failed for %s\n%v", pf.Name.Name, merr)
+	}
+	importer.addIDs(pf)
+	if err := rewriteAST(fset, importer, "", tpkg, pf, true); err != nil {
+		return nil, err
+	}
+	var buf bytes.Buffer
+	fmt.Fprintln(&buf, rewritePrefix)
+	if err := config.Fprint(&buf, fset, pf); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+// go2Files returns the list of files in dir with a .go2 extension
+// and a list of files with a .go extension.
+// This returns an error if it finds any .go files that do not start
+// with rewritePrefix.
+func go2Files(dir string) (go2files []string, gofiles []string, err error) {
+	f, err := os.Open(dir)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer f.Close()
+
+	files, err := f.Readdirnames(0)
+	if err != nil {
+		return nil, nil, fmt.Errorf("reading directory %s: %w", dir, err)
+
+	}
+
+	go2files = make([]string, 0, len(files))
+	gofiles = make([]string, 0, len(files))
+	for _, f := range files {
+		switch filepath.Ext(f) {
+		case ".go2":
+			go2files = append(go2files, f)
+		case ".go":
+			gofiles = append(gofiles, f)
+		}
+	}
+
+	return go2files, gofiles, nil
+}
+
+// checkAndRemoveGofiles looks through all the .go files.
+// Any .go file that starts with rewritePrefix is removed.
+// Any other .go file is reported as an error.
+// This is intended to make it harder for go2go to break a
+// traditional Go package.
+func checkAndRemoveGofiles(dir string, gofiles []string) error {
+	for _, f := range gofiles {
+		if err := checkGoFile(dir, f); err != nil {
+			return err
+		}
+		if err := os.Remove(filepath.Join(dir, f)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// checkGofile reports an error if the file does not start with rewritePrefix.
+func checkGoFile(dir, f string) error {
+	o, err := os.Open(filepath.Join(dir, f))
+	if err != nil {
+		return err
+	}
+	defer o.Close()
+	var buf [100]byte
+	n, err := o.Read(buf[:])
+	if n > 0 && !strings.HasPrefix(string(buf[:n]), rewritePrefix) {
+		return fmt.Errorf("Go file %s was not created by go2go", f)
+	}
+	if err != nil && err != io.EOF {
+		return err
+	}
+	return nil
+}
+
+// parseFiles parses a list of .go2 files.
+func parseFiles(importer *Importer, dir string, go2files []string, fset *token.FileSet) ([]*ast.Package, error) {
+	pkgs := make(map[string]*ast.Package)
+	for _, go2f := range go2files {
+		mode := parseTypeParams
+
+		filename := filepath.Join(dir, go2f)
+		pf, err := parser.ParseFile(fset, filename, nil, mode)
+		if err != nil {
+			return nil, err
+		}
+
+		name := pf.Name.Name
+		pkg, ok := pkgs[name]
+		if !ok {
+			pkg = &ast.Package{
+				Name:  name,
+				Files: make(map[string]*ast.File),
+			}
+			pkgs[name] = pkg
+		}
+		pkg.Files[filename] = pf
+	}
+
+	rpkgs := make([]*ast.Package, 0, len(pkgs))
+	for _, pkg := range pkgs {
+		rpkgs = append(rpkgs, pkg)
+	}
+	sort.Slice(rpkgs, func(i, j int) bool {
+		return rpkgs[i].Name < rpkgs[j].Name
+	})
+
+	return rpkgs, nil
+}
+
+// multiErr is an error value that accumulates type checking errors.
+type multiErr []error
+
+// The add methods adds another error to a multiErr.
+func (m *multiErr) add(err error) {
+	*m = append(*m, err)
+}
+
+// The Error method returns the accumulated errors.
+func (m multiErr) Error() string {
+	if len(m) == 0 {
+		return "internal error: empty multiErr"
+	}
+	var sb strings.Builder
+	for _, e := range m {
+		fmt.Fprintln(&sb, e)
+	}
+	return sb.String()
+}

src/go/go2go/importer.go

@@ -0,0 +1,573 @@
+// Copyright 2020 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 go2go
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"internal/goroot"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"unicode"
+)
+
+// Importer implements the types.ImporterFrom interface.
+// It looks for Go2 packages using GO2PATH.
+// Imported Go2 packages are rewritten to normal Go packages.
+// This type also tracks references across imported packages.
+type Importer struct {
+	// The default importer, for Go1 packages.
+	defaultImporter types.ImporterFrom
+
+	// Temporary directory used to rewrite packages.
+	tmpdir string
+
+	// Aggregated info from go/types.
+	info *types.Info
+
+	// Map from import path to directory holding rewritten files.
+	translated map[string]string
+
+	// Map from import path to package information.
+	packages map[string]*types.Package
+
+	// Map from import path to list of import paths that it imports.
+	imports map[string][]string
+
+	// Map from Object to AST function declaration for
+	// parameterized functions.
+	idToFunc map[types.Object]*ast.FuncDecl
+
+	// Map from Object to AST type definition for parameterized types.
+	idToTypeSpec map[types.Object]*ast.TypeSpec
+
+	// Map from a Package to the instantiations we've created
+	// for that package. This doesn't really belong here,
+	// since it doesn't deal with import information,
+	// but Importer is a useful common location to store the data.
+	instantiations map[*types.Package]*instantiations
+
+	// build tags
+	tags map[string]bool
+}
+
+var _ types.ImporterFrom = &Importer{}
+
+// NewImporter returns a new Importer.
+// The tmpdir will become a GOPATH with translated files.
+func NewImporter(tmpdir string) *Importer {
+	info := &types.Info{
+		Types: make(map[ast.Expr]types.TypeAndValue),
+		Defs:  make(map[*ast.Ident]types.Object),
+		Uses:  make(map[*ast.Ident]types.Object),
+	}
+	types.SetInferred(info, make(map[ast.Expr]types.Inferred))
+	return &Importer{
+		defaultImporter: importer.Default().(types.ImporterFrom),
+		tmpdir:          tmpdir,
+		info:            info,
+		translated:      make(map[string]string),
+		packages:        make(map[string]*types.Package),
+		imports:         make(map[string][]string),
+		idToFunc:        make(map[types.Object]*ast.FuncDecl),
+		idToTypeSpec:    make(map[types.Object]*ast.TypeSpec),
+		instantiations:  make(map[*types.Package]*instantiations),
+		tags:            make(map[string]bool),
+	}
+}
+
+func (imp *Importer) SetTags(tags []string) {
+	for _, tag := range tags {
+		imp.tags[tag] = true
+	}
+}
+
+// Import should never be called. This is the old API; current code
+// uses ImportFrom. This method still needs to be defined in order
+// to implement the interface.
+func (imp *Importer) Import(path string) (*types.Package, error) {
+	log.Fatal("unexpected call to Import method")
+	return nil, nil
+}
+
+// ImportFrom looks for a Go2 package, and if not found tries the
+// default importer.
+func (imp *Importer) ImportFrom(importPath, dir string, mode types.ImportMode) (*types.Package, error) {
+	if build.IsLocalImport(importPath) {
+		return imp.localImport(importPath, dir)
+	}
+
+	if imp.translated[importPath] != "" {
+		tpkg, ok := imp.packages[importPath]
+		if !ok {
+			return nil, fmt.Errorf("circular import when processing %q", importPath)
+		}
+		return tpkg, nil
+	}
+
+	var pdir string
+	if go2path := os.Getenv("GO2PATH"); go2path != "" {
+		pdir = imp.findFromPath(go2path, importPath)
+	}
+	if pdir == "" {
+		bpkg, err := build.Import(importPath, dir, build.FindOnly)
+		if err != nil {
+			return nil, err
+		}
+		pdir = bpkg.Dir
+	}
+
+	// If the directory holds .go2 files, we need to translate them.
+	fdir, err := os.Open(pdir)
+	if err != nil {
+		return nil, err
+	}
+	defer fdir.Close()
+	names, err := fdir.Readdirnames(-1)
+	if err != nil {
+		return nil, err
+	}
+	var gofiles, go2files []string
+	for _, name := range names {
+		switch filepath.Ext(name) {
+		case ".go":
+			gofiles = append(gofiles, name)
+		case ".go2":
+			go2files = append(go2files, name)
+		}
+	}
+
+	if len(go2files) == 0 {
+		return imp.importGo1Package(importPath, dir, mode, pdir, gofiles)
+	}
+
+	if len(gofiles) > 0 {
+		for _, gofile := range gofiles {
+			if err := checkGoFile(pdir, gofile); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	tdir := filepath.Join(imp.tmpdir, "src", importPath)
+	if err := os.MkdirAll(tdir, 0755); err != nil {
+		return nil, err
+	}
+	for _, name := range go2files {
+		data, err := ioutil.ReadFile(filepath.Join(pdir, name))
+		if err != nil {
+			return nil, err
+		}
+		if err := ioutil.WriteFile(filepath.Join(tdir, name), data, 0644); err != nil {
+			return nil, err
+		}
+	}
+
+	imp.translated[importPath] = tdir
+
+	tpkgs, err := rewriteToPkgs(imp, importPath, tdir)
+	if err != nil {
+		return nil, err
+	}
+
+	switch len(tpkgs) {
+	case 1:
+		return tpkgs[0], nil
+	case 2:
+		if strings.HasSuffix(tpkgs[0].Name(), "_test") {
+			return tpkgs[1], nil
+		} else if strings.HasSuffix(tpkgs[1].Name(), "_test") {
+			return tpkgs[0], nil
+		}
+	}
+
+	return nil, fmt.Errorf("unexpected number of packages (%d) for %q (directory %q)", len(tpkgs), importPath, pdir)
+}
+
+// findFromPath looks for a directory under gopath.
+func (imp *Importer) findFromPath(gopath, dir string) string {
+	if filepath.IsAbs(dir) || build.IsLocalImport(dir) {
+		return ""
+	}
+	for _, pd := range strings.Split(gopath, string(os.PathListSeparator)) {
+		d := filepath.Join(pd, "src", dir)
+		if fi, err := os.Stat(d); err == nil && fi.IsDir() {
+			return d
+		}
+	}
+	return ""
+}
+
+// importGo1Package handles importing a package with .go files rather
+// than .go2 files. The default importer can do this if the package
+// has been installed, but not otherwise. Installing the package using
+// "go install" won't work if the Go 1 package depends on a Go 2 package.
+// So use the default importer for a package in the standard library,
+// and otherwise use go/types.
+func (imp *Importer) importGo1Package(importPath, dir string, mode types.ImportMode, pdir string, gofiles []string) (*types.Package, error) {
+	if goroot.IsStandardPackage(runtime.GOROOT(), "gc", importPath) {
+		return imp.defaultImporter.ImportFrom(importPath, dir, mode)
+	}
+
+	if len(gofiles) == 0 {
+		return nil, fmt.Errorf("importing %q: no Go files in %s", importPath, pdir)
+	}
+
+	fset := token.NewFileSet()
+	filter := func(fi os.FileInfo) bool {
+		name := fi.Name()
+		if strings.HasSuffix(name, "_test.go") {
+			return false
+		}
+		return imp.shouldInclude(path.Join(pdir, name))
+	}
+	pkgs, err := parser.ParseDir(fset, pdir, filter, 0)
+	if err != nil {
+		return nil, err
+	}
+	if len(pkgs) > 1 {
+		return nil, fmt.Errorf("importing %q: multiple Go packages in %s", importPath, pdir)
+	}
+
+	var apkg *ast.Package
+	for _, apkg = range pkgs {
+		break
+	}
+
+	var asts []*ast.File
+	for _, f := range apkg.Files {
+		asts = append(asts, f)
+	}
+	sort.Slice(asts, func(i, j int) bool {
+		return asts[i].Name.Name < asts[j].Name.Name
+	})
+
+	var merr multiErr
+	conf := types.Config{
+		Importer: imp,
+		Error:    merr.add,
+	}
+	tpkg, err := conf.Check(importPath, fset, asts, imp.info)
+	if err != nil {
+		return nil, merr
+	}
+
+	return tpkg, nil
+}
+
+// installGo1Package runs "go install" to install a package.
+// This is used for Go 1 packages, because the default
+// importer looks at .a files, not sources.
+// This is best effort; we don't report an error.
+func (imp *Importer) installGo1Package(dir string) {
+	gotool := filepath.Join(runtime.GOROOT(), "bin", "go")
+	cmd := exec.Command(gotool, "install")
+	cmd.Dir = dir
+	cmd.Run()
+}
+
+// Register registers a package under an import path.
+// This is for tests that use directives like //compiledir.
+func (imp *Importer) Register(importPath string, tpkgs []*types.Package) error {
+	switch len(tpkgs) {
+	case 1:
+		imp.packages[importPath] = tpkgs[0]
+		return nil
+	case 2:
+		if strings.HasSuffix(tpkgs[0].Name(), "_test") {
+			imp.packages[importPath] = tpkgs[1]
+			return nil
+		} else if strings.HasSuffix(tpkgs[1].Name(), "_test") {
+			imp.packages[importPath] = tpkgs[0]
+			return nil
+		}
+	}
+	return fmt.Errorf("unexpected number of packages (%d) for %q", len(tpkgs), importPath)
+}
+
+// localImport handles a local import such as
+//     import "./a"
+// This is for tests that use directives like //compiledir.
+func (imp *Importer) localImport(importPath, dir string) (*types.Package, error) {
+	tpkg, ok := imp.packages[strings.TrimPrefix(importPath, "./")]
+	if !ok {
+		return nil, fmt.Errorf("cannot find local import %q", importPath)
+	}
+	return tpkg, nil
+}
+
+// record records information for a package, for use when working
+// with packages that import this one.
+func (imp *Importer) record(pkgName string, pkgfiles []namedAST, importPath string, tpkg *types.Package, asts []*ast.File) {
+	if !strings.HasSuffix(pkgName, "_test") {
+		if importPath != "" {
+			imp.packages[importPath] = tpkg
+		}
+		imp.imports[importPath] = imp.collectImports(asts)
+	}
+	for _, nast := range pkgfiles {
+		imp.addIDs(nast.ast)
+	}
+}
+
+// collectImports returns all the imports paths imported by any of the ASTs.
+func (imp *Importer) collectImports(asts []*ast.File) []string {
+	m := make(map[string]bool)
+	for _, a := range asts {
+		for _, decl := range a.Decls {
+			gen, ok := decl.(*ast.GenDecl)
+			if !ok || gen.Tok != token.IMPORT {
+				continue
+			}
+			for _, spec := range gen.Specs {
+				imp := spec.(*ast.ImportSpec)
+				if imp.Name != nil {
+					// We don't try to handle import aliases.
+					continue
+				}
+				path := strings.TrimPrefix(strings.TrimSuffix(imp.Path.Value, `"`), `"`)
+				m[path] = true
+			}
+		}
+	}
+	s := make([]string, 0, len(m))
+	for p := range m {
+		s = append(s, p)
+	}
+	sort.Strings(s)
+	return s
+}
+
+// addIDs finds IDs for generic functions and types and adds them to a map.
+func (imp *Importer) addIDs(f *ast.File) {
+	for _, decl := range f.Decls {
+		switch decl := decl.(type) {
+		case *ast.FuncDecl:
+			if isParameterizedFuncDecl(decl, imp.info) {
+				obj, ok := imp.info.Defs[decl.Name]
+				if !ok {
+					panic(fmt.Sprintf("no types.Object for %q", decl.Name.Name))
+				}
+				imp.idToFunc[obj] = decl
+			}
+		case *ast.GenDecl:
+			if decl.Tok == token.TYPE {
+				for _, s := range decl.Specs {
+					ts := s.(*ast.TypeSpec)
+					obj, ok := imp.info.Defs[ts.Name]
+					if !ok {
+						panic(fmt.Sprintf("no types.Object for %q", ts.Name.Name))
+					}
+					imp.idToTypeSpec[obj] = ts
+				}
+			}
+		}
+	}
+}
+
+// lookupPackage looks up a package by path.
+func (imp *Importer) lookupPackage(path string) (*types.Package, bool) {
+	pkg, ok := imp.packages[strings.TrimPrefix(path, "./")]
+	return pkg, ok
+}
+
+// lookupFunc looks up a function by Object.
+func (imp *Importer) lookupFunc(obj types.Object) (*ast.FuncDecl, bool) {
+	decl, ok := imp.idToFunc[obj]
+	return decl, ok
+}
+
+// lookupTypeSpec looks up a type by Object.
+func (imp *Importer) lookupTypeSpec(obj types.Object) (*ast.TypeSpec, bool) {
+	ts, ok := imp.idToTypeSpec[obj]
+	return ts, ok
+}
+
+// transitiveImports returns all the transitive imports of an import path.
+func (imp *Importer) transitiveImports(path string) []string {
+	return imp.gatherTransitiveImports(path, make(map[string]bool))
+}
+
+// gatherTransitiveImports returns all the transitive imports of an import path,
+// using a map to avoid duplicate work.
+func (imp *Importer) gatherTransitiveImports(path string, m map[string]bool) []string {
+	imports := imp.imports[path]
+	if len(imports) == 0 {
+		return nil
+	}
+	var r []string
+	for _, im := range imports {
+		r = append(r, im)
+		if !m[im] {
+			m[im] = true
+			r = append(r, imp.gatherTransitiveImports(im, m)...)
+		}
+	}
+	dup := make(map[string]bool)
+	for _, p := range r {
+		dup[p] = true
+	}
+	r = make([]string, 0, len(dup))
+	for p := range dup {
+		r = append(r, p)
+	}
+	sort.Strings(r)
+	return r
+}
+
+var slashslash = []byte("//")
+
+// shouldInclude reports whether it is okay to use this file,
+// The rule is that in the file's leading run of // comments
+// and blank lines, which must be followed by a blank line
+// (to avoid including a Go package clause doc comment),
+// lines beginning with '// +build' are taken as build directives.
+//
+// The file is accepted only if each such line lists something
+// matching the file. For example:
+//
+//	// +build windows linux
+//
+// marks the file as applicable only on Windows and Linux.
+//
+// If tags["*"] is true, then ShouldBuild will consider every
+// build tag except "ignore" to be both true and false for
+// the purpose of satisfying build tags, in order to estimate
+// (conservatively) whether a file could ever possibly be used
+// in any build.
+//
+// This code was copied from the go command internals.
+func (imp *Importer) shouldInclude(path string) bool {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return false
+	}
+
+	// Pass 1. Identify leading run of // comments and blank lines,
+	// which must be followed by a blank line.
+	end := 0
+	p := content
+	for len(p) > 0 {
+		line := p
+		if i := bytes.IndexByte(line, '\n'); i >= 0 {
+			line, p = line[:i], p[i+1:]
+		} else {
+			p = p[len(p):]
+		}
+
+		line = bytes.TrimSpace(line)
+		if len(line) == 0 { // Blank line
+			end = len(content) - len(p)
+			continue
+		}
+		if !bytes.HasPrefix(line, slashslash) { // Not comment line
+			break
+		}
+	}
+	content = content[:end]
+
+	// Pass 2.  Process each line in the run.
+	p = content
+	allok := true
+	for len(p) > 0 {
+		line := p
+		if i := bytes.IndexByte(line, '\n'); i >= 0 {
+			line, p = line[:i], p[i+1:]
+		} else {
+			p = p[len(p):]
+		}
+		line = bytes.TrimSpace(line)
+		if !bytes.HasPrefix(line, slashslash) {
+			continue
+		}
+		line = bytes.TrimSpace(line[len(slashslash):])
+		if len(line) > 0 && line[0] == '+' {
+			// Looks like a comment +line.
+			f := strings.Fields(string(line))
+			if f[0] == "+build" {
+				ok := false
+				for _, tok := range f[1:] {
+					if matchTags(tok, imp.tags) {
+						ok = true
+					}
+				}
+				if !ok {
+					allok = false
+				}
+			}
+		}
+	}
+
+	return allok
+}
+
+// matchTags reports whether the name is one of:
+//
+//	tag (if tags[tag] is true)
+//	!tag (if tags[tag] is false)
+//	a comma-separated list of any of these
+//
+func matchTags(name string, tags map[string]bool) bool {
+	if name == "" {
+		return false
+	}
+	if i := strings.Index(name, ","); i >= 0 {
+		// comma-separated list
+		ok1 := matchTags(name[:i], tags)
+		ok2 := matchTags(name[i+1:], tags)
+		return ok1 && ok2
+	}
+	if strings.HasPrefix(name, "!!") { // bad syntax, reject always
+		return false
+	}
+	if strings.HasPrefix(name, "!") { // negation
+		return len(name) > 1 && matchTag(name[1:], tags, false)
+	}
+	return matchTag(name, tags, true)
+}
+
+// matchTag reports whether the tag name is valid and satisfied by tags[name]==want.
+func matchTag(name string, tags map[string]bool, want bool) bool {
+	// Tags must be letters, digits, underscores or dots.
+	// Unlike in Go identifiers, all digits are fine (e.g., "386").
+	for _, c := range name {
+		if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' {
+			return false
+		}
+	}
+
+	if tags["*"] && name != "" && name != "ignore" {
+		// Special case for gathering all possible imports:
+		// if we put * in the tags map then all tags
+		// except "ignore" are considered both present and not
+		// (so we return true no matter how 'want' is set).
+		return true
+	}
+
+	have := tags[name]
+	if name == "linux" {
+		have = have || tags["android"]
+	}
+	if name == "solaris" {
+		have = have || tags["illumos"]
+	}
+	if name == "darwin" {
+		have = have || tags["ios"]
+	}
+	return have == want
+}

src/go/go2go/instantiate.go

@@ -0,0 +1,985 @@
+// Copyright 2020 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 go2go
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+)
+
+// typeArgs holds type arguments for the function that we are instantiating.
+// We can look them up either with a types.Object associated with an ast.Ident,
+// or with a types.TypeParam.
+type typeArgs struct {
+	types []types.Type // type arguments in order
+	toAST map[types.Object]ast.Expr
+	toTyp map[*types.TypeParam]types.Type
+}
+
+// newTypeArgs returns a new typeArgs value.
+func newTypeArgs(typeTypes []types.Type) *typeArgs {
+	return &typeArgs{
+		types: typeTypes,
+		toAST: make(map[types.Object]ast.Expr),
+		toTyp: make(map[*types.TypeParam]types.Type),
+	}
+}
+
+// typeArgsFromFields builds mappings from a list of type parameters
+// expressed as ast.Field values.
+func typeArgsFromFields(t *translator, astTypes []ast.Expr, typeTypes []types.Type, tparams []*ast.Field) *typeArgs {
+	ta := newTypeArgs(typeTypes)
+	i := 0
+	for _, tf := range tparams {
+		for _, tn := range tf.Names {
+			obj, ok := t.importer.info.Defs[tn]
+			if !ok {
+				panic(fmt.Sprintf("no object for type parameter %q", tn))
+			}
+			objType := obj.Type()
+			objParam, ok := objType.(*types.TypeParam)
+			if !ok {
+				panic(fmt.Sprintf("%v is not a TypeParam", objParam))
+			}
+			ta.add(obj, objParam, astTypes[i], typeTypes[i])
+			i++
+		}
+	}
+	return ta
+}
+
+// typeArgsFromExprs builds mappings from a list of type parameters
+// expressed as ast.Expr values.
+func typeArgsFromExprs(t *translator, astTypes []ast.Expr, typeTypes []types.Type, tparams []ast.Expr) *typeArgs {
+	ta := newTypeArgs(typeTypes)
+	for i, ti := range tparams {
+		obj, ok := t.importer.info.Defs[ti.(*ast.Ident)]
+		if !ok {
+			panic(fmt.Sprintf("no object for type parameter %q", ti))
+		}
+		objType := obj.Type()
+		objParam, ok := objType.(*types.TypeParam)
+		if !ok {
+			panic(fmt.Sprintf("%v is not a TypeParam", objParam))
+		}
+		ta.add(obj, objParam, astTypes[i], typeTypes[i])
+	}
+	return ta
+}
+
+// add adds mappings for obj to ast and typ.
+func (ta *typeArgs) add(obj types.Object, objParam *types.TypeParam, ast ast.Expr, typ types.Type) {
+	ta.toAST[obj] = ast
+	ta.toTyp[objParam] = typ
+}
+
+// ast returns the AST for obj, and reports whether it exists.
+func (ta *typeArgs) ast(obj types.Object) (ast.Expr, bool) {
+	e, ok := ta.toAST[obj]
+	return e, ok
+}
+
+// typ returns the Type for param, and reports whether it exists.
+func (ta *typeArgs) typ(param *types.TypeParam) (types.Type, bool) {
+	t, ok := ta.toTyp[param]
+	return t, ok
+}
+
+// instantiateFunction creates a new instantiation of a function.
+func (t *translator) instantiateFunction(qid qualifiedIdent, astTypes []ast.Expr, typeTypes []types.Type) (*ast.Ident, error) {
+	name, err := t.instantiatedName(qid, typeTypes)
+	if err != nil {
+		return nil, err
+	}
+
+	decl, err := t.findFuncDecl(qid)
+	if err != nil {
+		return nil, err
+	}
+
+	ta := typeArgsFromFields(t, astTypes, typeTypes, decl.Type.TParams.List)
+
+	instIdent := ast.NewIdent(name)
+
+	newDecl := &ast.FuncDecl{
+		Doc:  decl.Doc,
+		Recv: t.instantiateFieldList(ta, decl.Recv),
+		Name: instIdent,
+		Type: t.instantiateExpr(ta, decl.Type).(*ast.FuncType),
+		Body: t.instantiateBlockStmt(ta, decl.Body),
+	}
+	t.newDecls = append(t.newDecls, newDecl)
+
+	return instIdent, nil
+}
+
+// findFuncDecl looks for the FuncDecl for qid.
+func (t *translator) findFuncDecl(qid qualifiedIdent) (*ast.FuncDecl, error) {
+	obj := t.findTypesObject(qid)
+	if obj == nil {
+		return nil, fmt.Errorf("could not find Object for %q", qid)
+	}
+	decl, ok := t.importer.lookupFunc(obj)
+	if !ok {
+		return nil, fmt.Errorf("could not find function body for %q", qid)
+	}
+	return decl, nil
+}
+
+// findTypesObject looks up the types.Object for qid.
+// It returns nil if the ID is not found.
+func (t *translator) findTypesObject(qid qualifiedIdent) types.Object {
+	if qid.pkg == nil {
+		if obj := t.importer.info.ObjectOf(qid.ident); obj != nil {
+			// Ignore an embedded struct field.
+			// We want the type, not the field.
+			if _, ok := obj.(*types.Var); !ok {
+				return obj
+			}
+		}
+		return t.tpkg.Scope().Lookup(qid.ident.Name)
+	} else {
+		return qid.pkg.Scope().Lookup(qid.ident.Name)
+	}
+}
+
+// instantiateType creates a new instantiation of a type.
+func (t *translator) instantiateTypeDecl(qid qualifiedIdent, typ *types.Named, astTypes []ast.Expr, typeTypes []types.Type, instIdent *ast.Ident) (types.Type, error) {
+	spec, err := t.findTypeSpec(qid)
+	if err != nil {
+		return nil, err
+	}
+
+	ta := typeArgsFromFields(t, astTypes, typeTypes, spec.TParams.List)
+
+	newSpec := &ast.TypeSpec{
+		Doc:     spec.Doc,
+		Name:    instIdent,
+		Assign:  spec.Assign,
+		Type:    t.instantiateExpr(ta, spec.Type),
+		Comment: spec.Comment,
+	}
+	newDecl := &ast.GenDecl{
+		Tok:   token.TYPE,
+		Specs: []ast.Spec{newSpec},
+	}
+	t.newDecls = append(t.newDecls, newDecl)
+
+	// If typ already has type arguments, then they should be correct.
+	// If it doesn't, we want to use typeTypes.
+	typeWithTargs := typ
+	if len(typ.TArgs()) == 0 {
+		typeWithTargs = t.updateTArgs(typ, typeTypes)
+	}
+
+	instType := t.instantiateType(ta, typeWithTargs)
+
+	t.setType(instIdent, instType)
+
+	nm := typ.NumMethods()
+	for i := 0; i < nm; i++ {
+		method := typ.Method(i)
+		mast, ok := t.importer.lookupFunc(method)
+		if !ok {
+			panic(fmt.Sprintf("no AST for method %v", method))
+		}
+		rtyp := mast.Recv.List[0].Type
+		newRtype := ast.Expr(ast.NewIdent(instIdent.Name))
+		if p, ok := rtyp.(*ast.StarExpr); ok {
+			rtyp = p.X
+			newRtype = &ast.StarExpr{
+				X: newRtype,
+			}
+		}
+		var tparams []ast.Expr
+		switch rtyp := rtyp.(type) {
+		case *ast.IndexExpr:
+			tparams = unpackExpr(rtyp.Index)
+		default:
+			panic("unexpected AST type")
+		}
+		ta := typeArgsFromExprs(t, astTypes, typeTypes, tparams)
+		var names []*ast.Ident
+		if mnames := mast.Recv.List[0].Names; len(mnames) > 0 {
+			names = []*ast.Ident{mnames[0]}
+		}
+		newDecl := &ast.FuncDecl{
+			Doc: mast.Doc,
+			Recv: &ast.FieldList{
+				Opening: mast.Recv.Opening,
+				List: []*ast.Field{
+					{
+						Doc:     mast.Recv.List[0].Doc,
+						Names:   names,
+						Type:    newRtype,
+						Comment: mast.Recv.List[0].Comment,
+					},
+				},
+				Closing: mast.Recv.Closing,
+			},
+			Name: mast.Name,
+			Type: t.instantiateExpr(ta, mast.Type).(*ast.FuncType),
+			Body: t.instantiateBlockStmt(ta, mast.Body),
+		}
+		t.newDecls = append(t.newDecls, newDecl)
+	}
+
+	return instType, nil
+}
+
+// findTypeSpec looks for the TypeSpec for qid.
+func (t *translator) findTypeSpec(qid qualifiedIdent) (*ast.TypeSpec, error) {
+	obj := t.findTypesObject(qid)
+	if obj == nil {
+		return nil, fmt.Errorf("could not find Object for %q", qid)
+	}
+	spec, ok := t.importer.lookupTypeSpec(obj)
+	if !ok {
+		return nil, fmt.Errorf("could not find type spec for %q", qid)
+	}
+
+	if spec.Assign != token.NoPos {
+		// This is a type alias that we need to resolve.
+		typ := t.lookupType(spec.Type)
+		if typ != nil {
+			if named, ok := typ.(*types.Named); ok {
+				if s, ok := t.importer.lookupTypeSpec(named.Obj()); ok {
+					spec = s
+				}
+			}
+		}
+	}
+
+	if spec.TParams == nil {
+		return nil, fmt.Errorf("found type spec for %q but it has no type parameters", qid)
+	}
+
+	return spec, nil
+}
+
+// instantiateDecl instantiates a declaration.
+func (t *translator) instantiateDecl(ta *typeArgs, d ast.Decl) ast.Decl {
+	switch d := d.(type) {
+	case nil:
+		return nil
+	case *ast.GenDecl:
+		if len(d.Specs) == 0 {
+			return d
+		}
+		nspecs := make([]ast.Spec, len(d.Specs))
+		changed := false
+		for i, s := range d.Specs {
+			ns := t.instantiateSpec(ta, s)
+			if ns != s {
+				changed = true
+			}
+			nspecs[i] = ns
+		}
+		if !changed {
+			return d
+		}
+		return &ast.GenDecl{
+			Doc:    d.Doc,
+			TokPos: d.TokPos,
+			Tok:    d.Tok,
+			Lparen: d.Lparen,
+			Specs:  nspecs,
+			Rparen: d.Rparen,
+		}
+	default:
+		panic(fmt.Sprintf("unimplemented Decl %T", d))
+	}
+}
+
+// instantiateSpec instantiates a spec node.
+func (t *translator) instantiateSpec(ta *typeArgs, s ast.Spec) ast.Spec {
+	switch s := s.(type) {
+	case nil:
+		return nil
+	case *ast.ValueSpec:
+		typ := t.instantiateExpr(ta, s.Type)
+		values, changed := t.instantiateExprList(ta, s.Values)
+		if typ == s.Type && !changed {
+			return s
+		}
+		return &ast.ValueSpec{
+			Doc:     s.Doc,
+			Names:   s.Names,
+			Type:    typ,
+			Values:  values,
+			Comment: s.Comment,
+		}
+	case *ast.TypeSpec:
+		if s.TParams != nil {
+			t.err = fmt.Errorf("%s: go2go tool does not support local parameterized types", t.fset.Position(s.Pos()))
+			return nil
+		}
+		typ := t.instantiateExpr(ta, s.Type)
+		if typ == s.Type {
+			return s
+		}
+		return &ast.TypeSpec{
+			Doc:     s.Doc,
+			Name:    s.Name,
+			Assign:  s.Assign,
+			Type:    typ,
+			Comment: s.Comment,
+		}
+	default:
+		panic(fmt.Sprintf("unimplemented Spec %T", s))
+	}
+}
+
+// instantiateStmt instantiates a statement.
+func (t *translator) instantiateStmt(ta *typeArgs, s ast.Stmt) ast.Stmt {
+	switch s := s.(type) {
+	case nil:
+		return nil
+	case *ast.DeclStmt:
+		decl := t.instantiateDecl(ta, s.Decl)
+		if decl == s.Decl {
+			return s
+		}
+		return &ast.DeclStmt{
+			Decl: decl,
+		}
+	case *ast.EmptyStmt:
+		return s
+	case *ast.LabeledStmt:
+		stmt := t.instantiateStmt(ta, s.Stmt)
+		if stmt == s.Stmt {
+			return s
+		}
+		return &ast.LabeledStmt{
+			Label: s.Label,
+			Colon: s.Colon,
+			Stmt:  stmt,
+		}
+	case *ast.ExprStmt:
+		x := t.instantiateExpr(ta, s.X)
+		if x == s.X {
+			return s
+		}
+		return &ast.ExprStmt{
+			X: x,
+		}
+	case *ast.SendStmt:
+		ch := t.instantiateExpr(ta, s.Chan)
+		value := t.instantiateExpr(ta, s.Value)
+		if ch == s.Chan && value == s.Value {
+			return s
+		}
+		return &ast.SendStmt{
+			Chan:  ch,
+			Arrow: s.Arrow,
+			Value: value,
+		}
+	case *ast.IncDecStmt:
+		x := t.instantiateExpr(ta, s.X)
+		if x == s.X {
+			return s
+		}
+		return &ast.IncDecStmt{
+			X:      x,
+			TokPos: s.TokPos,
+			Tok:    s.Tok,
+		}
+	case *ast.AssignStmt:
+		lhs, lchanged := t.instantiateExprList(ta, s.Lhs)
+		rhs, rchanged := t.instantiateExprList(ta, s.Rhs)
+		if !lchanged && !rchanged {
+			return s
+		}
+		return &ast.AssignStmt{
+			Lhs:    lhs,
+			TokPos: s.TokPos,
+			Tok:    s.Tok,
+			Rhs:    rhs,
+		}
+	case *ast.GoStmt:
+		call := t.instantiateExpr(ta, s.Call).(*ast.CallExpr)
+		if call == s.Call {
+			return s
+		}
+		return &ast.GoStmt{
+			Go:   s.Go,
+			Call: call,
+		}
+	case *ast.DeferStmt:
+		call := t.instantiateExpr(ta, s.Call).(*ast.CallExpr)
+		if call == s.Call {
+			return s
+		}
+		return &ast.DeferStmt{
+			Defer: s.Defer,
+			Call:  call,
+		}
+	case *ast.ReturnStmt:
+		results, changed := t.instantiateExprList(ta, s.Results)
+		if !changed {
+			return s
+		}
+		return &ast.ReturnStmt{
+			Return:  s.Return,
+			Results: results,
+		}
+	case *ast.BranchStmt:
+		return s
+	case *ast.BlockStmt:
+		return t.instantiateBlockStmt(ta, s)
+	case *ast.IfStmt:
+		init := t.instantiateStmt(ta, s.Init)
+		cond := t.instantiateExpr(ta, s.Cond)
+		body := t.instantiateBlockStmt(ta, s.Body)
+		els := t.instantiateStmt(ta, s.Else)
+		if init == s.Init && cond == s.Cond && body == s.Body && els == s.Else {
+			return s
+		}
+		return &ast.IfStmt{
+			If:   s.If,
+			Init: init,
+			Cond: cond,
+			Body: body,
+			Else: els,
+		}
+	case *ast.CaseClause:
+		list, listChanged := t.instantiateExprList(ta, s.List)
+		body, bodyChanged := t.instantiateStmtList(ta, s.Body)
+		if !listChanged && !bodyChanged {
+			return s
+		}
+		return &ast.CaseClause{
+			Case:  s.Case,
+			List:  list,
+			Colon: s.Colon,
+			Body:  body,
+		}
+	case *ast.SwitchStmt:
+		init := t.instantiateStmt(ta, s.Init)
+		tag := t.instantiateExpr(ta, s.Tag)
+		body := t.instantiateBlockStmt(ta, s.Body)
+		if init == s.Init && tag == s.Tag && body == s.Body {
+			return s
+		}
+		return &ast.SwitchStmt{
+			Switch: s.Switch,
+			Init:   init,
+			Tag:    tag,
+			Body:   body,
+		}
+	case *ast.TypeSwitchStmt:
+		init := t.instantiateStmt(ta, s.Init)
+		assign := t.instantiateStmt(ta, s.Assign)
+		body := t.instantiateBlockStmt(ta, s.Body)
+		if init == s.Init && assign == s.Assign && body == s.Body {
+			return s
+		}
+		return &ast.TypeSwitchStmt{
+			Switch: s.Switch,
+			Init:   init,
+			Assign: assign,
+			Body:   body,
+		}
+	case *ast.CommClause:
+		comm := t.instantiateStmt(ta, s.Comm)
+		body, bodyChanged := t.instantiateStmtList(ta, s.Body)
+		if comm == s.Comm && !bodyChanged {
+			return s
+		}
+		return &ast.CommClause{
+			Case:  s.Case,
+			Comm:  comm,
+			Colon: s.Colon,
+			Body:  body,
+		}
+	case *ast.SelectStmt:
+		body := t.instantiateBlockStmt(ta, s.Body)
+		if body == s.Body {
+			return s
+		}
+		return &ast.SelectStmt{
+			Select: s.Select,
+			Body:   body,
+		}
+	case *ast.ForStmt:
+		init := t.instantiateStmt(ta, s.Init)
+		cond := t.instantiateExpr(ta, s.Cond)
+		post := t.instantiateStmt(ta, s.Post)
+		body := t.instantiateBlockStmt(ta, s.Body)
+		if init == s.Init && cond == s.Cond && post == s.Post && body == s.Body {
+			return s
+		}
+		return &ast.ForStmt{
+			For:  s.For,
+			Init: init,
+			Cond: cond,
+			Post: post,
+			Body: body,
+		}
+	case *ast.RangeStmt:
+		key := t.instantiateExpr(ta, s.Key)
+		value := t.instantiateExpr(ta, s.Value)
+		x := t.instantiateExpr(ta, s.X)
+		body := t.instantiateBlockStmt(ta, s.Body)
+		if key == s.Key && value == s.Value && x == s.X && body == s.Body {
+			return s
+		}
+		return &ast.RangeStmt{
+			For:    s.For,
+			Key:    key,
+			Value:  value,
+			TokPos: s.TokPos,
+			Tok:    s.Tok,
+			X:      x,
+			Body:   body,
+		}
+	default:
+		panic(fmt.Sprintf("unimplemented Stmt %T", s))
+	}
+}
+
+// instantiateBlockStmt instantiates a BlockStmt.
+func (t *translator) instantiateBlockStmt(ta *typeArgs, pbs *ast.BlockStmt) *ast.BlockStmt {
+	if pbs == nil {
+		return nil
+	}
+	changed := false
+	stmts := make([]ast.Stmt, len(pbs.List))
+	for i, s := range pbs.List {
+		is := t.instantiateStmt(ta, s)
+		stmts[i] = is
+		if is != s {
+			changed = true
+		}
+	}
+	if !changed {
+		return pbs
+	}
+	return &ast.BlockStmt{
+		Lbrace: pbs.Lbrace,
+		List:   stmts,
+		Rbrace: pbs.Rbrace,
+	}
+}
+
+// instantiateStmtList instantiates a statement list.
+func (t *translator) instantiateStmtList(ta *typeArgs, sl []ast.Stmt) ([]ast.Stmt, bool) {
+	nsl := make([]ast.Stmt, len(sl))
+	changed := false
+	for i, s := range sl {
+		ns := t.instantiateStmt(ta, s)
+		if ns != s {
+			changed = true
+		}
+		nsl[i] = ns
+	}
+	if !changed {
+		return sl, false
+	}
+	return nsl, true
+}
+
+// instantiateFieldList instantiates a field list.
+func (t *translator) instantiateFieldList(ta *typeArgs, fl *ast.FieldList) *ast.FieldList {
+	if fl == nil {
+		return nil
+	}
+	nfl := make([]*ast.Field, len(fl.List))
+	changed := false
+	for i, f := range fl.List {
+		nf := t.instantiateField(ta, f)
+		if nf != f {
+			changed = true
+		}
+		nfl[i] = nf
+	}
+	if !changed {
+		return fl
+	}
+	return &ast.FieldList{
+		Opening: fl.Opening,
+		List:    nfl,
+		Closing: fl.Closing,
+	}
+}
+
+// instantiateField instantiates a field.
+func (t *translator) instantiateField(ta *typeArgs, f *ast.Field) *ast.Field {
+	typ := t.instantiateExpr(ta, f.Type)
+	if typ == f.Type {
+		return f
+	}
+	return &ast.Field{
+		Doc:     f.Doc,
+		Names:   f.Names,
+		Type:    typ,
+		Tag:     f.Tag,
+		Comment: f.Comment,
+	}
+}
+
+// instantiateExpr instantiates an expression.
+func (t *translator) instantiateExpr(ta *typeArgs, e ast.Expr) ast.Expr {
+	var r ast.Expr
+	switch e := e.(type) {
+	case nil:
+		return nil
+	case *ast.Ident:
+		obj := t.importer.info.ObjectOf(e)
+		if obj != nil {
+			if typ, ok := ta.ast(obj); ok {
+				return typ
+			}
+		}
+		return e
+	case *ast.Ellipsis:
+		elt := t.instantiateExpr(ta, e.Elt)
+		if elt == e.Elt {
+			return e
+		}
+		return &ast.Ellipsis{
+			Ellipsis: e.Ellipsis,
+			Elt:      elt,
+		}
+	case *ast.BasicLit:
+		return e
+	case *ast.FuncLit:
+		typ := t.instantiateExpr(ta, e.Type).(*ast.FuncType)
+		body := t.instantiateBlockStmt(ta, e.Body)
+		if typ == e.Type && body == e.Body {
+			return e
+		}
+		return &ast.FuncLit{
+			Type: typ,
+			Body: body,
+		}
+	case *ast.CompositeLit:
+		typ := t.instantiateExpr(ta, e.Type)
+		elts, changed := t.instantiateExprList(ta, e.Elts)
+		if typ == e.Type && !changed {
+			return e
+		}
+		return &ast.CompositeLit{
+			Type:       typ,
+			Lbrace:     e.Lbrace,
+			Elts:       elts,
+			Rbrace:     e.Rbrace,
+			Incomplete: e.Incomplete,
+		}
+	case *ast.ParenExpr:
+		x := t.instantiateExpr(ta, e.X)
+		if x == e.X {
+			return e
+		}
+		return &ast.ParenExpr{
+			Lparen: e.Lparen,
+			X:      x,
+			Rparen: e.Rparen,
+		}
+	case *ast.SelectorExpr:
+		x := t.instantiateExpr(ta, e.X)
+
+		// If this is a reference to an instantiated embedded field,
+		// we may need to instantiate it. The actual instantiation
+		// is at the end of the function, as long as we create a
+		// a new SelectorExpr when needed.
+		instantiate := false
+		obj := t.importer.info.ObjectOf(e.Sel)
+		if obj != nil {
+			if f, ok := obj.(*types.Var); ok && f.Embedded() {
+				if named, ok := f.Type().(*types.Named); ok && len(named.TArgs()) > 0 && obj.Name() == named.Obj().Name() {
+					instantiate = true
+				}
+			}
+		}
+
+		if x == e.X && !instantiate {
+			return e
+		}
+		r = &ast.SelectorExpr{
+			X:   x,
+			Sel: e.Sel,
+		}
+	case *ast.IndexExpr:
+		x := t.instantiateExpr(ta, e.X)
+		index := t.instantiateExpr(ta, e.Index)
+		inferredInfo := types.GetInferred(t.importer.info)
+		origInferred, haveInferred := inferredInfo[e]
+		var newInferred types.Inferred
+		inferredChanged := false
+		if haveInferred {
+			for _, typ := range origInferred.Targs {
+				nt := t.instantiateType(ta, typ)
+				newInferred.Targs = append(newInferred.Targs, nt)
+				if nt != typ {
+					inferredChanged = true
+				}
+			}
+		}
+		if x == e.X && index == e.Index && !inferredChanged {
+			return e
+		}
+		r = &ast.IndexExpr{
+			X:      x,
+			Lbrack: e.Lbrack,
+			Index:  index,
+			Rbrack: e.Rbrack,
+		}
+		if haveInferred {
+			inferredInfo[r] = newInferred
+		}
+	case *ast.ListExpr:
+		list, changed := t.instantiateExprList(ta, e.ElemList)
+		if changed {
+			r = &ast.ListExpr{ElemList: list}
+		}
+	case *ast.SliceExpr:
+		x := t.instantiateExpr(ta, e.X)
+		low := t.instantiateExpr(ta, e.Low)
+		high := t.instantiateExpr(ta, e.High)
+		max := t.instantiateExpr(ta, e.Max)
+		if x == e.X && low == e.Low && high == e.High && max == e.Max {
+			return e
+		}
+		r = &ast.SliceExpr{
+			X:      x,
+			Lbrack: e.Lbrack,
+			Low:    low,
+			High:   high,
+			Max:    max,
+			Slice3: e.Slice3,
+			Rbrack: e.Rbrack,
+		}
+	case *ast.TypeAssertExpr:
+		x := t.instantiateExpr(ta, e.X)
+		typ := t.instantiateExpr(ta, e.Type)
+		if x == e.X && typ == e.Type {
+			return e
+		}
+		r = &ast.TypeAssertExpr{
+			X:      x,
+			Lparen: e.Lparen,
+			Type:   typ,
+			Rparen: e.Rparen,
+		}
+	case *ast.CallExpr:
+		fun := t.instantiateExpr(ta, e.Fun)
+		args, argsChanged := t.instantiateExprList(ta, e.Args)
+		inferredInfo := types.GetInferred(t.importer.info)
+		origInferred, haveInferred := inferredInfo[e]
+		var newInferred types.Inferred
+		inferredChanged := false
+		if haveInferred {
+			for _, typ := range origInferred.Targs {
+				nt := t.instantiateType(ta, typ)
+				newInferred.Targs = append(newInferred.Targs, nt)
+				if nt != typ {
+					inferredChanged = true
+				}
+			}
+			newInferred.Sig = t.instantiateType(ta, origInferred.Sig).(*types.Signature)
+			if newInferred.Sig != origInferred.Sig {
+				inferredChanged = true
+			}
+		}
+		if fun == e.Fun && !argsChanged && !inferredChanged {
+			return e
+		}
+		r = &ast.CallExpr{
+			Fun:      fun,
+			Lparen:   e.Lparen,
+			Args:     args,
+			Ellipsis: e.Ellipsis,
+			Rparen:   e.Rparen,
+		}
+		if haveInferred {
+			inferredInfo[r] = newInferred
+		}
+	case *ast.StarExpr:
+		x := t.instantiateExpr(ta, e.X)
+		if x == e.X {
+			return e
+		}
+		r = &ast.StarExpr{
+			Star: e.Star,
+			X:    x,
+		}
+	case *ast.UnaryExpr:
+		x := t.instantiateExpr(ta, e.X)
+		if x == e.X {
+			return e
+		}
+		r = &ast.UnaryExpr{
+			OpPos: e.OpPos,
+			Op:    e.Op,
+			X:     x,
+		}
+	case *ast.BinaryExpr:
+		x := t.instantiateExpr(ta, e.X)
+		y := t.instantiateExpr(ta, e.Y)
+		if x == e.X && y == e.Y {
+			return e
+		}
+		r = &ast.BinaryExpr{
+			X:     x,
+			OpPos: e.OpPos,
+			Op:    e.Op,
+			Y:     y,
+		}
+	case *ast.KeyValueExpr:
+		key := t.instantiateExpr(ta, e.Key)
+		value := t.instantiateExpr(ta, e.Value)
+		if key == e.Key && value == e.Value {
+			return e
+		}
+		r = &ast.KeyValueExpr{
+			Key:   key,
+			Colon: e.Colon,
+			Value: value,
+		}
+	case *ast.ArrayType:
+		ln := t.instantiateExpr(ta, e.Len)
+		elt := t.instantiateExpr(ta, e.Elt)
+		if ln == e.Len && elt == e.Elt {
+			return e
+		}
+		r = &ast.ArrayType{
+			Lbrack: e.Lbrack,
+			Len:    ln,
+			Elt:    elt,
+		}
+	case *ast.StructType:
+		fields := e.Fields.List
+		newFields := make([]*ast.Field, 0, len(fields))
+		changed := false
+		for _, f := range fields {
+			newFields = append(newFields, f)
+			if len(f.Names) > 0 {
+				continue
+			}
+			isPtr := false
+			ftyp := f.Type
+			if star, ok := ftyp.(*ast.StarExpr); ok {
+				ftyp = star.X
+				isPtr = true
+			}
+			id, ok := ftyp.(*ast.Ident)
+			if !ok {
+				continue
+			}
+			typ := t.lookupType(id)
+			if typ == nil {
+				continue
+			}
+			typeParam, ok := typ.(*types.TypeParam)
+			if !ok {
+				continue
+			}
+			instType := t.instantiateType(ta, typeParam)
+			if isPtr {
+				instType = types.NewPointer(instType)
+			}
+			newField := &ast.Field{
+				Doc:     f.Doc,
+				Names:   []*ast.Ident{id},
+				Type:    t.typeToAST(instType),
+				Tag:     f.Tag,
+				Comment: f.Comment,
+			}
+			newFields[len(newFields)-1] = newField
+			changed = true
+		}
+		fl := e.Fields
+		if changed {
+			fl = &ast.FieldList{
+				Opening: fl.Opening,
+				List:    newFields,
+				Closing: fl.Closing,
+			}
+		}
+		newFl := t.instantiateFieldList(ta, fl)
+		if !changed && newFl == fl {
+			return e
+		}
+		r = &ast.StructType{
+			Struct:     e.Struct,
+			Fields:     newFl,
+			Incomplete: e.Incomplete,
+		}
+	case *ast.FuncType:
+		params := t.instantiateFieldList(ta, e.Params)
+		results := t.instantiateFieldList(ta, e.Results)
+		if e.TParams == nil && params == e.Params && results == e.Results {
+			return e
+		}
+		r = &ast.FuncType{
+			Func:    e.Func,
+			TParams: nil,
+			Params:  params,
+			Results: results,
+		}
+	case *ast.InterfaceType:
+		eMethods, eTypes := splitFieldList(e.Methods)
+		methods := t.instantiateFieldList(ta, eMethods)
+		types, typesChanged := t.instantiateExprList(ta, eTypes)
+		if methods == e.Methods && !typesChanged {
+			return e
+		}
+		r = &ast.InterfaceType{
+			Interface:  e.Interface,
+			Methods:    mergeFieldList(methods, types),
+			Incomplete: e.Incomplete,
+		}
+	case *ast.MapType:
+		key := t.instantiateExpr(ta, e.Key)
+		value := t.instantiateExpr(ta, e.Value)
+		if key == e.Key && value == e.Value {
+			return e
+		}
+		r = &ast.MapType{
+			Map:   e.Map,
+			Key:   key,
+			Value: value,
+		}
+	case *ast.ChanType:
+		value := t.instantiateExpr(ta, e.Value)
+		if value == e.Value {
+			return e
+		}
+		r = &ast.ChanType{
+			Begin: e.Begin,
+			Arrow: e.Arrow,
+			Dir:   e.Dir,
+			Value: value,
+		}
+	default:
+		panic(fmt.Sprintf("unimplemented Expr %T", e))
+	}
+
+	if et := t.lookupType(e); et != nil {
+		t.setType(r, t.instantiateType(ta, et))
+	}
+
+	return r
+}
+
+// instantiateExprList instantiates an expression list.
+func (t *translator) instantiateExprList(ta *typeArgs, el []ast.Expr) ([]ast.Expr, bool) {
+	nel := make([]ast.Expr, len(el))
+	changed := false
+	for i, e := range el {
+		ne := t.instantiateExpr(ta, e)
+		if ne != e {
+			changed = true
+		}
+		nel[i] = ne
+	}
+	if !changed {
+		return el, false
+	}
+	return nel, true
+}

src/go/go2go/names.go

@@ -0,0 +1,75 @@
+// Copyright 2020 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 go2go
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"unicode"
+)
+
+// We use Oriya digit zero as a separator.
+// Do not use this character in your own identifiers.
+const nameSep = '୦'
+
+// We use Oriya digit eight to introduce a special character code.
+// Do not use this character in your own identifiers.
+const nameIntro = '୮'
+
+var nameCodes = map[rune]int{
+	' ':       0,
+	'*':       1,
+	';':       2,
+	',':       3,
+	'{':       4,
+	'}':       5,
+	'[':       6,
+	']':       7,
+	'(':       8,
+	')':       9,
+	'.':       10,
+	'<':       11,
+	'-':       12,
+	'/':       13,
+	nameSep:   14,
+	nameIntro: 15,
+}
+
+// instantiatedName returns the name of a newly instantiated function.
+func (t *translator) instantiatedName(qid qualifiedIdent, types []types.Type) (string, error) {
+	var sb strings.Builder
+	fmt.Fprintf(&sb, "instantiate%c", nameSep)
+	if qid.pkg != nil {
+		fmt.Fprintf(&sb, qid.pkg.Name())
+	}
+	fmt.Fprintf(&sb, "%c%s", nameSep, qid.ident.Name)
+	for _, typ := range types {
+		sb.WriteRune(nameSep)
+		s := t.withoutTags(typ).String()
+
+		// We have to uniquely translate s into a valid Go identifier.
+		// This is not possible in general but we assume that
+		// identifiers will not contain nameSep or nameIntro.
+		for _, r := range s {
+			if (unicode.IsLetter(r) || unicode.IsDigit(r) || r == '_') && r != nameSep && r != nameIntro {
+				sb.WriteRune(r)
+			} else {
+				code, ok := nameCodes[r]
+				if !ok {
+					panic(fmt.Sprintf("%s: unexpected type string character %q in %q", t.fset.Position(qid.ident.Pos()), r, s))
+				}
+				fmt.Fprintf(&sb, "%c%x", nameIntro, code)
+			}
+		}
+	}
+	return sb.String(), nil
+}
+
+// importableName returns a name that we define in each package, so that
+// we have something to import to avoid an unused package error.
+func (t *translator) importableName() string {
+	return "Importable" + string(nameSep)
+}

src/go/go2go/types.go

@@ -0,0 +1,626 @@
+// Copyright 2020 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 go2go
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"strconv"
+	"strings"
+)
+
+// lookupType returns the types.Type for an AST expression.
+// Returns nil if the type is not known.
+func (t *translator) lookupType(e ast.Expr) types.Type {
+	if typ := t.importer.info.TypeOf(e); typ != nil {
+		return typ
+	}
+	if typ, ok := t.types[e]; ok {
+		return typ
+	}
+	return nil
+}
+
+// setType records the type for an AST expression. This is only used for
+// AST expressions created during function instantiation.
+// Uninstantiated AST expressions will be listed in t.importer.info.Types.
+func (t *translator) setType(e ast.Expr, nt types.Type) {
+	if ot, ok := t.importer.info.Types[e]; ok {
+		if !t.sameType(ot.Type, nt) {
+			panic("expression type changed")
+		}
+		return
+	}
+	if ot, ok := t.types[e]; ok {
+		if !t.sameType(ot, nt) {
+			panic("expression type changed")
+		}
+		return
+	}
+	t.types[e] = nt
+}
+
+// instantiateType instantiates typ using ta.
+func (t *translator) instantiateType(ta *typeArgs, typ types.Type) types.Type {
+	if t.err != nil {
+		return nil
+	}
+
+	t.typeDepth++
+	defer func() { t.typeDepth-- }()
+	if t.typeDepth > 25 {
+		t.err = fmt.Errorf("looping while instantiating %v %v", typ, ta.types)
+		return nil
+	}
+
+	var inProgress *typeInstantiation
+	for _, inst := range t.typeInstantiations(typ) {
+		if t.sameTypes(ta.types, inst.types) {
+			if inst.typ == nil {
+				inProgress = inst
+				break
+			}
+			return inst.typ
+		}
+	}
+
+	ityp := t.doInstantiateType(ta, typ)
+	if inProgress != nil {
+		if inProgress.typ == nil {
+			inProgress.typ = ityp
+		} else {
+			ityp = inProgress.typ
+		}
+	} else {
+		typinst := &typeInstantiation{
+			types: ta.types,
+			typ:   ityp,
+		}
+		t.addTypeInstantiation(typ, typinst)
+	}
+
+	return ityp
+}
+
+// doInstantiateType does the work of instantiating typ using ta.
+// This should only be called from instantiateType.
+func (t *translator) doInstantiateType(ta *typeArgs, typ types.Type) types.Type {
+	switch typ := typ.(type) {
+	case *types.Basic:
+		return typ
+	case *types.Array:
+		elem := typ.Elem()
+		instElem := t.instantiateType(ta, elem)
+		if elem == instElem {
+			return typ
+		}
+		return types.NewArray(instElem, typ.Len())
+	case *types.Slice:
+		elem := typ.Elem()
+		instElem := t.instantiateType(ta, elem)
+		if elem == instElem {
+			return typ
+		}
+		return types.NewSlice(instElem)
+	case *types.Struct:
+		n := typ.NumFields()
+		fields := make([]*types.Var, n)
+		changed := false
+		tags := make([]string, n)
+		hasTag := false
+		for i := 0; i < n; i++ {
+			v := typ.Field(i)
+			instType := t.instantiateType(ta, v.Type())
+			if v.Type() != instType {
+				changed = true
+			}
+			fields[i] = types.NewVar(v.Pos(), v.Pkg(), v.Name(), instType)
+
+			tag := typ.Tag(i)
+			if tag != "" {
+				tags[i] = tag
+				hasTag = true
+			}
+		}
+		if !changed {
+			return typ
+		}
+		if !hasTag {
+			tags = nil
+		}
+		return types.NewStruct(fields, tags)
+	case *types.Pointer:
+		elem := typ.Elem()
+		instElem := t.instantiateType(ta, elem)
+		if elem == instElem {
+			return typ
+		}
+		return types.NewPointer(instElem)
+	case *types.Tuple:
+		return t.instantiateTypeTuple(ta, typ)
+	case *types.Signature:
+		params := t.instantiateTypeTuple(ta, typ.Params())
+		results := t.instantiateTypeTuple(ta, typ.Results())
+		if params == typ.Params() && results == typ.Results() {
+			return typ
+		}
+		r := types.NewSignature(typ.Recv(), params, results, typ.Variadic())
+		if tparams := typ.TParams(); tparams != nil {
+			r.SetTParams(tparams)
+		}
+		return r
+	case *types.Interface:
+		nm := typ.NumExplicitMethods()
+		methods := make([]*types.Func, nm)
+		changed := false
+		for i := 0; i < nm; i++ {
+			m := typ.ExplicitMethod(i)
+			instSig := t.instantiateType(ta, m.Type()).(*types.Signature)
+			if instSig != m.Type() {
+				m = types.NewFunc(m.Pos(), m.Pkg(), m.Name(), instSig)
+				changed = true
+			}
+			methods[i] = m
+		}
+		ne := typ.NumEmbeddeds()
+		embeddeds := make([]types.Type, ne)
+		for i := 0; i < ne; i++ {
+			e := typ.EmbeddedType(i)
+			instE := t.instantiateType(ta, e)
+			if e != instE {
+				changed = true
+			}
+			embeddeds[i] = instE
+		}
+		if !changed {
+			return typ
+		}
+		return types.NewInterfaceType(methods, embeddeds)
+	case *types.Map:
+		key := t.instantiateType(ta, typ.Key())
+		elem := t.instantiateType(ta, typ.Elem())
+		if key == typ.Key() && elem == typ.Elem() {
+			return typ
+		}
+		return types.NewMap(key, elem)
+	case *types.Chan:
+		elem := t.instantiateType(ta, typ.Elem())
+		if elem == typ.Elem() {
+			return typ
+		}
+		return types.NewChan(typ.Dir(), elem)
+	case *types.Named:
+		targs := typ.TArgs()
+		targsChanged := false
+		if len(targs) > 0 {
+			newTargs := make([]types.Type, 0, len(targs))
+			for _, targ := range targs {
+				newTarg := t.instantiateType(ta, targ)
+				if newTarg != targ {
+					targsChanged = true
+				}
+				newTargs = append(newTargs, newTarg)
+			}
+			targs = newTargs
+		}
+		if targsChanged {
+			return t.updateTArgs(typ, targs)
+		}
+		return typ
+	case *types.TypeParam:
+		if instType, ok := ta.typ(typ); ok {
+			return instType
+		}
+		return typ
+	default:
+		panic(fmt.Sprintf("unimplemented Type %T", typ))
+	}
+}
+
+// setTargs returns a new named type with updated type arguments.
+func (t *translator) updateTArgs(typ *types.Named, targs []types.Type) *types.Named {
+	nm := typ.NumMethods()
+	methods := make([]*types.Func, 0, nm)
+	for i := 0; i < nm; i++ {
+		methods = append(methods, typ.Method(i))
+	}
+	obj := typ.Obj()
+	obj = types.NewTypeName(obj.Pos(), obj.Pkg(), obj.Name(), nil)
+	nt := types.NewNamed(obj, typ.Underlying(), methods)
+	nt.SetTArgs(targs)
+	return nt
+}
+
+// instantiateTypeTuple instantiates a types.Tuple.
+func (t *translator) instantiateTypeTuple(ta *typeArgs, tuple *types.Tuple) *types.Tuple {
+	if tuple == nil {
+		return nil
+	}
+	l := tuple.Len()
+	instTypes := make([]types.Type, l)
+	changed := false
+	for i := 0; i < l; i++ {
+		typ := tuple.At(i).Type()
+		instType := t.instantiateType(ta, typ)
+		if typ != instType {
+			changed = true
+		}
+		instTypes[i] = instType
+	}
+	if !changed {
+		return tuple
+	}
+	vars := make([]*types.Var, l)
+	for i := 0; i < l; i++ {
+		v := tuple.At(i)
+		vars[i] = types.NewVar(v.Pos(), v.Pkg(), v.Name(), instTypes[i])
+	}
+	return types.NewTuple(vars...)
+}
+
+// addTypePackages adds all packages mentioned in typ to t.typePackages.
+func (t *translator) addTypePackages(typ types.Type) {
+	switch typ := typ.(type) {
+	case *types.Basic:
+	case *types.Array:
+		t.addTypePackages(typ.Elem())
+	case *types.Slice:
+		t.addTypePackages(typ.Elem())
+	case *types.Struct:
+		n := typ.NumFields()
+		for i := 0; i < n; i++ {
+			t.addTypePackages(typ.Field(i).Type())
+		}
+	case *types.Pointer:
+		t.addTypePackages(typ.Elem())
+	case *types.Tuple:
+		n := typ.Len()
+		for i := 0; i < n; i++ {
+			t.addTypePackages(typ.At(i).Type())
+		}
+	case *types.Signature:
+		// We'll have seen typ.Recv elsewhere.
+		t.addTypePackages(typ.Params())
+		t.addTypePackages(typ.Results())
+	case *types.Interface:
+		nm := typ.NumExplicitMethods()
+		for i := 0; i < nm; i++ {
+			t.addTypePackages(typ.ExplicitMethod(i).Type())
+		}
+		ne := typ.NumEmbeddeds()
+		for i := 0; i < ne; i++ {
+			t.addTypePackages(typ.EmbeddedType(i))
+		}
+	case *types.Map:
+		t.addTypePackages(typ.Key())
+		t.addTypePackages(typ.Elem())
+	case *types.Chan:
+		t.addTypePackages(typ.Elem())
+	case *types.Named:
+		// This is the point of this whole method.
+		if typ.Obj().Pkg() != nil {
+			t.typePackages[typ.Obj().Pkg()] = true
+		}
+	case *types.TypeParam:
+	default:
+		panic(fmt.Sprintf("unimplemented Type %T", typ))
+	}
+}
+
+// withoutTags returns a type with no struct tags. If typ has no
+// struct tags anyhow, this just returns typ.
+func (t *translator) withoutTags(typ types.Type) types.Type {
+	switch typ := typ.(type) {
+	case *types.Basic:
+		return typ
+	case *types.Array:
+		elem := typ.Elem()
+		elemNoTags := t.withoutTags(elem)
+		if elem == elemNoTags {
+			return typ
+		}
+		return types.NewArray(elemNoTags, typ.Len())
+	case *types.Slice:
+		elem := typ.Elem()
+		elemNoTags := t.withoutTags(elem)
+		if elem == elemNoTags {
+			return typ
+		}
+		return types.NewSlice(elemNoTags)
+	case *types.Struct:
+		n := typ.NumFields()
+		fields := make([]*types.Var, n)
+		changed := false
+		hasTag := false
+		for i := 0; i < n; i++ {
+			v := typ.Field(i)
+			typeNoTags := t.withoutTags(v.Type())
+			if v.Type() != typeNoTags {
+				changed = true
+			}
+			fields[i] = types.NewVar(v.Pos(), v.Pkg(), v.Name(), typeNoTags)
+			if typ.Tag(i) != "" {
+				hasTag = true
+			}
+		}
+		if !changed && !hasTag {
+			return typ
+		}
+		return types.NewStruct(fields, nil)
+	case *types.Pointer:
+		elem := typ.Elem()
+		elemNoTags := t.withoutTags(elem)
+		if elem == elemNoTags {
+			return typ
+		}
+		return types.NewPointer(elemNoTags)
+	case *types.Tuple:
+		return t.tupleWithoutTags(typ)
+	case *types.Signature:
+		params := t.tupleWithoutTags(typ.Params())
+		results := t.tupleWithoutTags(typ.Results())
+		if params == typ.Params() && results == typ.Results() {
+			return typ
+		}
+		r := types.NewSignature(typ.Recv(), params, results, typ.Variadic())
+		if tparams := typ.TParams(); tparams != nil {
+			r.SetTParams(tparams)
+		}
+		return r
+	case *types.Interface:
+		nm := typ.NumExplicitMethods()
+		methods := make([]*types.Func, nm)
+		changed := false
+		for i := 0; i < nm; i++ {
+			m := typ.ExplicitMethod(i)
+			sigNoTags := t.withoutTags(m.Type()).(*types.Signature)
+			if sigNoTags != m.Type() {
+				m = types.NewFunc(m.Pos(), m.Pkg(), m.Name(), sigNoTags)
+				changed = true
+			}
+			methods[i] = m
+		}
+		ne := typ.NumEmbeddeds()
+		embeddeds := make([]types.Type, ne)
+		for i := 0; i < ne; i++ {
+			e := typ.EmbeddedType(i)
+			eNoTags := t.withoutTags(e)
+			if e != eNoTags {
+				changed = true
+			}
+			embeddeds[i] = eNoTags
+		}
+		if !changed {
+			return typ
+		}
+		return types.NewInterfaceType(methods, embeddeds)
+	case *types.Map:
+		key := t.withoutTags(typ.Key())
+		elem := t.withoutTags(typ.Elem())
+		if key == typ.Key() && elem == typ.Elem() {
+			return typ
+		}
+		return types.NewMap(key, elem)
+	case *types.Chan:
+		elem := t.withoutTags(typ.Elem())
+		if elem == typ.Elem() {
+			return typ
+		}
+		return types.NewChan(typ.Dir(), elem)
+	case *types.Named:
+		targs := typ.TArgs()
+		targsChanged := false
+		if len(targs) > 0 {
+			newTargs := make([]types.Type, 0, len(targs))
+			for _, targ := range targs {
+				newTarg := t.withoutTags(targ)
+				if newTarg != targ {
+					targsChanged = true
+				}
+				newTargs = append(newTargs, newTarg)
+			}
+			targs = newTargs
+		}
+		if targsChanged {
+			return t.updateTArgs(typ, targs)
+		}
+		return typ
+	case *types.TypeParam:
+		return typ
+	default:
+		panic(fmt.Sprintf("unimplemented Type %T", typ))
+	}
+}
+
+// tupleWithoutTags returns a tuple with all struct tag removed.
+func (t *translator) tupleWithoutTags(tuple *types.Tuple) *types.Tuple {
+	if tuple == nil {
+		return nil
+	}
+	l := tuple.Len()
+	typesNoTags := make([]types.Type, l)
+	changed := false
+	for i := 0; i < l; i++ {
+		typ := tuple.At(i).Type()
+		typNoTags := t.withoutTags(typ)
+		if typ != typNoTags {
+			changed = true
+		}
+		typesNoTags[i] = typNoTags
+	}
+	if !changed {
+		return tuple
+	}
+	vars := make([]*types.Var, l)
+	for i := 0; i < l; i++ {
+		v := tuple.At(i)
+		vars[i] = types.NewVar(v.Pos(), v.Pkg(), v.Name(), typesNoTags[i])
+	}
+	return types.NewTuple(vars...)
+}
+
+// typeToAST converts a types.Type to an ast.Expr.
+func (t *translator) typeToAST(typ types.Type) ast.Expr {
+	var r ast.Expr
+	switch typ := typ.(type) {
+	case *types.Basic:
+		r = ast.NewIdent(typ.Name())
+	case *types.Array:
+		r = &ast.ArrayType{
+			Len: &ast.BasicLit{
+				Kind:  token.INT,
+				Value: strconv.FormatInt(typ.Len(), 10),
+			},
+			Elt: t.typeToAST(typ.Elem()),
+		}
+	case *types.Slice:
+		r = &ast.ArrayType{
+			Elt: t.typeToAST(typ.Elem()),
+		}
+	case *types.Struct:
+		var fields []*ast.Field
+		n := typ.NumFields()
+		for i := 0; i < n; i++ {
+			tf := typ.Field(i)
+			var names []*ast.Ident
+			if !tf.Embedded() {
+				names = []*ast.Ident{
+					ast.NewIdent(tf.Name()),
+				}
+			}
+			var atag *ast.BasicLit
+			if tag := typ.Tag(i); tag != "" {
+				atag = &ast.BasicLit{
+					Kind:  token.STRING,
+					Value: strconv.Quote(tag),
+				}
+			}
+			af := &ast.Field{
+				Names: names,
+				Type:  t.typeToAST(tf.Type()),
+				Tag:   atag,
+			}
+			fields = append(fields, af)
+		}
+		r = &ast.StructType{
+			Fields: &ast.FieldList{
+				List: fields,
+			},
+		}
+	case *types.Pointer:
+		r = &ast.StarExpr{
+			X: t.typeToAST(typ.Elem()),
+		}
+	case *types.Tuple:
+		// We should only see this in a types.Signature,
+		// where we handle it specially, since there is
+		// no ast.Expr that can represent this.
+		panic("unexpected types.Tuple")
+	case *types.Signature:
+		if len(typ.TParams()) > 0 {
+			// We should only see type parameters for
+			// a package scope function declaration.
+			panic("unexpected type parameters")
+		}
+		r = &ast.FuncType{
+			Params:  t.tupleToFieldList(typ.Params()),
+			Results: t.tupleToFieldList(typ.Params()),
+		}
+	case *types.Interface:
+		var methods []*ast.Field
+		nm := typ.NumExplicitMethods()
+		for i := 0; i < nm; i++ {
+			m := typ.ExplicitMethod(i)
+			f := &ast.Field{
+				Names: []*ast.Ident{
+					ast.NewIdent(m.Name()),
+				},
+				Type: t.typeToAST(m.Type()),
+			}
+			methods = append(methods, f)
+		}
+		ne := typ.NumEmbeddeds()
+		for i := 0; i < ne; i++ {
+			e := typ.EmbeddedType(i)
+			f := &ast.Field{
+				Type: t.typeToAST(e),
+			}
+			methods = append(methods, f)
+		}
+		r = &ast.InterfaceType{
+			Methods: &ast.FieldList{
+				List: methods,
+			},
+		}
+	case *types.Map:
+		r = &ast.MapType{
+			Key:   t.typeToAST(typ.Key()),
+			Value: t.typeToAST(typ.Elem()),
+		}
+	case *types.Chan:
+		var dir ast.ChanDir
+		switch typ.Dir() {
+		case types.SendRecv:
+			dir = ast.SEND | ast.RECV
+		case types.SendOnly:
+			dir = ast.SEND
+		case types.RecvOnly:
+			dir = ast.RECV
+		default:
+			panic("unsupported channel direction")
+		}
+		r = &ast.ChanType{
+			Dir:   dir,
+			Value: t.typeToAST(typ.Elem()),
+		}
+	case *types.Named:
+		if len(typ.TArgs()) > 0 {
+			_, id := t.lookupInstantiatedType(typ)
+			r = id
+		} else {
+			var sb strings.Builder
+			tn := typ.Obj()
+			if tn.Pkg() != nil && tn.Pkg() != t.tpkg {
+				sb.WriteString(tn.Pkg().Name())
+				sb.WriteByte('.')
+			}
+			sb.WriteString(tn.Name())
+			r = ast.NewIdent(sb.String())
+		}
+	case *types.TypeParam:
+		// This should have been instantiated already.
+		panic("unexpected type parameter")
+	default:
+		panic(fmt.Sprintf("unimplemented Type %T", typ))
+	}
+
+	t.setType(r, typ)
+	return r
+}
+
+// tupleToFieldList converts a tupes.Tuple to a ast.FieldList.
+func (t *translator) tupleToFieldList(tuple *types.Tuple) *ast.FieldList {
+	var fields []*ast.Field
+	n := tuple.Len()
+	for i := 0; i < n; i++ {
+		v := tuple.At(i)
+		var names []*ast.Ident
+		if v.Name() != "" {
+			names = []*ast.Ident{
+				ast.NewIdent(v.Name()),
+			}
+		}
+		f := &ast.Field{
+			Names: names,
+			Type:  t.typeToAST(v.Type()),
+		}
+		fields = append(fields, f)
+	}
+	return &ast.FieldList{
+		List: fields,
+	}
+}

src/go/internal/gcimporter/gcimporter_test.go

@@ -264,7 +264,8 @@ var importedObjectTests = []struct {
 	{"io.Reader", "type Reader interface{Read(p []byte) (n int, err error)}"},
 	{"io.ReadWriter", "type ReadWriter interface{Reader; Writer}"},
 	{"go/ast.Node", "type Node interface{End() go/token.Pos; Pos() go/token.Pos}"},
-	{"go/types.Type", "type Type interface{String() string; Underlying() Type}"},
+	// go/types.Type has grown much larger - excluded for now
+	// {"go/types.Type", "type Type interface{String() string; Underlying() Type}"},
 }
 
 func TestImportedTypes(t *testing.T) {

src/go/printer/testdata/genericsB.golden

@@ -0,0 +1,33 @@
+// Copyright 2020 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 generics
+
+type T[P any] struct{}
+type T[P1, P2, P3 any] struct{}
+
+type T[P C] struct{}
+type T[P1, P2, P3, C] struct{}
+
+type T[P C[P]] struct{}
+type T[P1, P2, P3 C[P1, P2, P3]] struct{}
+
+func f[P any](x P)
+func f[P1, P2, P3 any](x1 P1, x2 P2, x3 P3) struct{}
+
+func f[P interface{}](x P)
+func f[P1, P2, P3 interface {
+	m1(P1)
+	type P2, P3
+}](x1 P1, x2 P2, x3 P3) struct{}
+func f[P any](T1[P], T2[P]) T3[P]
+
+func (x T[P]) m()
+func (T[P]) m(x T[P]) P
+
+func _() {
+	type _ []T[P]
+	var _ []T[P]
+	_ = []T[P]{}
+}

src/go/printer/testdata/genericsB.input

@@ -0,0 +1,30 @@
+// Copyright 2020 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 generics
+
+type T[P any] struct{}
+type T[P1, P2, P3 any] struct{}
+
+type T[P C] struct{}
+type T[P1, P2, P3, C] struct{}
+
+type T[P C[P]] struct{}
+type T[P1, P2, P3 C[P1, P2, P3]] struct{}
+
+func f[P any](x P)
+func f[P1, P2, P3 any](x1 P1, x2 P2, x3 P3) struct{}
+
+func f[P interface{}](x P)
+func f[P1, P2, P3 interface{ m1(P1); type P2, P3 }](x1 P1, x2 P2, x3 P3) struct{}
+func f[P any](T1[P], T2[P]) T3[P]
+
+func (x T[P]) m()
+func ((T[P])) m(x T[P]) P
+
+func _() {
+	type _ []T[P]
+	var _ []T[P]
+	_ = []T[P]{}
+}

src/go/types/NOTES

@@ -0,0 +1,182 @@
+This file serves as a notebook/implementation log.
+
+----------------------------------------------------------------------------------------------------
+TODO (implementation issues)
+
+- report a better error when a type is not in a type list (investigate)
+- better error message when we need parentheses around a parameterized function parameter type
+- review handling of fields of instantiated generic types (do we need to make them non-parameterized?)
+- use []*TypeParam for tparams in subst? (unclear)
+- should we use nil instead of &emptyInterface for no type bounds (as an optimization)?
+- TBD: in prose, should we use "generic" or "parameterized" (try to be consistent)
+
+----------------------------------------------------------------------------------------------------
+KNOWN ISSUES
+
+- type parameter constraints are ignored when checking if a parameterized method implements the
+  matching method in an interface
+- iteration over generic variables doesn't report certain channel errors (see TODOs in code)
+- cannot handle mutually recursive parameterized interfaces using themselves as type bounds
+  example: type B(type P B(P)) interface{ m() } (need to delay all checking after seting up declarations)
+- invoking a method of a parameterized embedded type doesn't work (cannot properly determine receiver yet)
+- pointer designation is incorrectly handled when checking type list constraint satisfaction
+
+----------------------------------------------------------------------------------------------------
+OBSERVATIONS
+
+- 2/20/2020: Because we permit parenthesized types anywhere for consistency, also in parameter lists (mea
+  culpa), we have parsing ambiguities when using instantiated types in parameter lists w/o argument names.
+  We could disallow the use of parentheses at the top level of type literals and then we might not have
+  this problem. This is not a backward-compatible change but perhaps worthwhile investigating. Specifically,
+  will this always work (look specifically at channel types where we need parentheses for disambiguation
+  and possibly function types).
+
+- 6/3/2020: Observation: gofmt already removes superflous parentheses around types in parameter lists,
+  so in gofmt'ed code there won't be any such parentheses. Thus we can perhaps make the suggested language
+  change above without too many problems.
+
+- 2/21/2020: We do need top-level parentheses around types in certain situations such as conversions
+  or composite literals. We could disallow parentheses around types in parameter lists only, but that
+  seems quite a bit less elegant.
+
+- 6/13/2020: When comparing against the type list of an interface (to see if the interface is satisfied),
+  we must either recompute the underlying types of the type list entries after the interface was instantiated,
+  or we must compute the underlying type of each entry before comparing. (A type list may contain type
+  parameters which may be substituted with defined types when the interface is instantiated.) With the
+  latter approach (which is what's implemented now), we could relax some of the constraints that we have
+  on type lists entries: We could allow any type and just say that for interface satisfaction we always
+  look at the underlying types.
+
+----------------------------------------------------------------------------------------------------
+OPEN QUESTIONS
+
+- Parsing _ = [](a(int)){} requires parentheses around `(a(int))` - should the parser be smarter in
+  these cases? Another example: []a(b, c){} This cannot be a conversion. Could fix such cases by re-
+  associating the AST when we see a {. Need to be careful, and need to take into account additional
+  complexity of spec.
+- For len/cap(x) where x is of type parameter type and the bound contains arrays only, should the
+  result be a constant? (right now it is not). What are the implications for alternative, non-
+  monomorphizing implementation methods?
+- Confirm that it's ok to use inference in missingMethod to compare parameterized methods.
+
+----------------------------------------------------------------------------------------------------
+DESIGN/IMPLEMENTATION
+
+- 11/19/2019: For type parameters with interface bounds to work, the scope of all type parameters in
+  a type parameter list starts at the "type" keyword. This makes all type parameters visible for all
+  type parameter bounds (interfaces that may be parameterized with the type parameters).
+
+- 12/4/2019: do not allow parenthesized generic uninstantiated types (unless instantiated implicitly)
+  In other words: generic types must always be instantiated before they can be used in any form
+  More generally: Only permit type instantiation T(x) in type context, when the type is a named type.
+  Do not permit it in general in type context: e.g., disallow []T(x) because we consider that a
+  conversion, in general. Same for ([]T)(x).
+
+- 12/12/2019: represent type bounds always as (possibly unnamed) interfaces
+  (contracts are user syntactic sugar)
+
+- 12/19/2019: Type parameters don't act like type aliases. For instance:
+
+        func f(type T1, T2)(x T1) T2 { return x }
+
+  is not valid, no matter how T1 and T2 are instantiated (but if T1 and T2 were type aliases with
+  both of them having type int, the return x would be valid). In fact, the type parameters act more
+  like named types with the methods described by their type bound. But type parameters are never
+  interfaces. To determine: Given a type parameter P, is P == underlying(P) (like for basic types),
+  or is the the underlying type of P something else (like for defined types). Is there an observable
+  difference?
+
+- 12/19/2019: Rewrote contract handling: they are now treated as Objects (rather than Types) throughout.
+
+- 12/20/2019: Decided to start moving type parameters to types (from TypeName to Named), need to do the
+  same for Func. This make more sense as in general any type (conceptually even literal types) could
+  have type parameters. It's a property of the type, not the type name. It also simplified the code.
+
+- 12/20/2019: Type parameters may be part of type lists in contracts/interfaces. It just falls out
+  naturally. Added test cases.
+
+- 12/23/2019: Decision: Type parameters and ordinary (value) parameters are in the same block, notably
+  the function block. The scope of type parameters starts at the 'type' keyword; the scope of ordinary
+  parameters starts with the (opening '{' of the) function body. Both scopes end with the closing '}'
+  of the function body (i.e., the end of the function block).
+
+- 1/2/2020: Implementation decision: contracts can only be declared at the package level.
+
+- 1/6/2020: Experimental: First steps towards permitting type parameters in methods as a generalization.
+  Type-checking problems ooccurring from this are likely to highlight general problematic areas.
+  First consequence: Scope of type parameters starts at "func" keyword which means that receiver type
+  name cannot be a type parameter name declared later (or by the receiver type specification). This
+  seems reasonable and should help avoid confusion which is possible otherwise.
+
+- 1/7/2020: We distinguish embedded instantiated (parameterized) interfaces from methods by enclosing
+  the embedded interfaces in parentheses (the design draft recommends this change). Since this opens
+  the possibility for any parenthesized type (that is an interface), we can also allow (parenthesized)
+  interface literals as it is simpler to permit those than forbid them.
+
+- 1/7/2020: The current implementation permits empty type parameter lists as in: "func f(type)(x int)"
+  but we cannot call such a function as "f()(1)"; the empty type argument list causes problems.
+  Document that we allow empty type parameter list declarations, but not empty actual type parameter
+  lists. (We could allow them for types, but that doesn't seem consistent and probably is confusing).
+
+- 2/19/2020: We accept parenthesized embedded struct fields so we can distinguish between a named
+  field with a parenthesized type foo (T) and an embedded parameterized type (foo(T)), similarly
+  to interace embedding.
+
+- 2/19/2020: Permit parentheses around embedded contracts for symmetry with embedding in structs
+  and interfaces.
+
+- 2/20/2020: Receiver type parameters must always be provided in the receiver parameter list of
+  a method, even if they are not used by the method. Since the receiver acts like an implicit
+  declaration of those type parameters, they may be blank, as with any other declaration.
+
+- 3/20/2020: Local type declarations with an underlying type that is a type parameter lose the
+  methods declared with the type parameter bound. But they don't lose the properties of the
+  underlying type, i.e., the properties of the type parameter bound's type list.
+  This is something to consider if we were contemplating moving to a methods-only approach
+  (no type lists), even though local type declarations are exceedingly rare if they exist at
+  all in the wild.
+
+- 3/24/2020: Implemented initial support for bidirection type unification which could make
+  type inference more powerful if we decided to go that route. Specifically, this would
+  permit type inference for the type parameters of a generic function argument. Given:
+  func h(f func(int)); func g(type T)(T); one could allow the call: h(g) and the type argument
+  T of g would be inferred to be int. While not hard to implement, this would be a special case
+  of the rule that all generic types/functions must be instantiated before they are used except
+  for function calls where the type arguments can be inferred from the actual arguments.
+  Decided that for now we leave things as is, since it's not clear the extra complexity is
+  worth the (probably small) convenience.
+
+- 3/25/2020: We can probably simplify the contract syntax again and only permit one of three
+  possible constraint entries: 1) an embedded contract, 2) a type parameter followed by a
+  method signature, and 3) a type parameter followed by a type list. This is what the type
+  checker currently supports and the printer can print. (The parser still accepts a list of
+  method signatures or types, freely mixed.)
+
+- 4/24/2020: Permit omission of explicit type bound instantiation if the type bound is an
+  interface that applies to exactly one type parameter and the type bound expects exactly
+  one type argument. This makes parameterized interface type bounds easier to use in a common
+  case.
+
+- 5/?/2020: Relaxed above syntactic sugar and permit omission of explicit type bound instantiation
+  in any case where the type bound only accepts a single type parameter.
+  We may not want to permit this in the first version as this is something we can always add later.
+
+- 6/3/2020: A function type parameter acts like a named type. If its type bound has a type list
+  that type list determines the underlying type of the type parameter. If the bound doesn't have
+  a type list, the underlying type of a type parameter is itself. (We may decide that in this
+  latter case there may no underlying type at all which would perhaps more consistent. But this
+  is not clear cut.)
+
+- 6/6/2020: The underlying type of a type parameter must _always_ be itself, otherwise a declaration
+  such as: type T(type P interface{type int}) P would have an underlying type int which is wrong.
+
+- 6/7/2020: Introduced the notion of an operational type which is used when determining what
+  operations are supported by a value of a given type. The operational type of a type parameter
+  is determined by its type bound. The operational type of any other type is its underlying
+  type. This approach appears to complete the picture about the nature of type parameters.
+
+- 6/7/2020: Removed support for contracts to match the latest design draft.
+
+- 6/15/2020: Disabled check that types in type lists must only contain basic types or composite types
+  composed of basic types. It is not needed since we always must recompute the underlying types
+  after a (possible) instantiation anyway (see observation from 6/3/2020).

src/go/types/README

@@ -0,0 +1,68 @@
+This version of go/types is part of the prototype that implements the
+extended Go language as outlined by the latest generics draft design.
+
+DISCLAIMER
+
+This code is based on the std/library's go/types package but it has
+been modified heavily. Please bear in mind that:
+
+- This is a prototype. Expect bugs, incomplete parts, and suboptimal
+  and (gulp) possibly ugly code.
+
+- While all the major aspects of the generics design draft have been
+  implemented, parts are missing, especially around the operations permitted
+  on operands of generic types. In such cases, the result is most often
+  an error reporting that a certain operation is not permitted even though
+  it should be according to the draft design.
+
+- As prototyping continues, expect refinement and possibly divergence
+  from the most recent draft design published.
+
+EXAMPLE CODE
+
+For tests and example code (with detailed comments) look for files
+with suffix .go2 in the testdata and examples subdirectories.
+
+(The suffix .go2 is solely to distinguish them from regular Go code and
+to prevent gofmt from touching them. We expect a proper implementation to
+keep using .go .)
+
+RUNNING THE TYPE-CHECKER
+
+The type-checker is automatically run as part of the go2go tool.
+To experiment with generic code, it is recommened to use that tool.
+
+But the type-checker can also be run stand-alone on source code if
+so desired. There are two primary ways:
+
+1) By building the gotype tool in this source directory:
+
+      go build gotype.go
+
+   and then running the resulting binary on some input files
+
+      ./gotype <package files>
+
+   (Make sure to use the correct go tool when building.)
+
+2) By using the type-checker's TestCheck test function which
+   accepts a list of user provided files:
+
+      go test -run Check$ -errlist -files <package files>
+
+   For instance:
+
+      go test -run Check$ -files examples/types.go2
+
+   TestCheck will match any type errors against ERROR comments
+   in the source files and complain about discrepancies.
+   To report the errors instead, use:
+
+      go test -run Check$ -errlist -files examples/types.go2
+
+   To see a trace of the type checker progress, use the -v flag:
+
+      go test -v -run Check$ -errlist -files examples/types.go2
+
+   (When playing with this code, sometimes go vet gets in the
+   way, so it can be helpful to also provide -vet off.)

src/go/types/api_go2go.go

@@ -0,0 +1,22 @@
+// Copyright 2021 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 types
+
+import (
+	"go/ast"
+)
+
+// This file exposes additional API methods related to type parameters, for use
+// in the go2go rewriter.
+
+type Inferred = _Inferred
+
+func GetInferred(info *Info) map[ast.Expr]Inferred {
+	return info._Inferred
+}
+
+func SetInferred(info *Info, inferred map[ast.Expr]Inferred) {
+	info._Inferred = inferred
+}

src/go/types/type_go2go.go

@@ -0,0 +1,27 @@
+// Copyright 2021 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 types
+
+// This file exposes additional API methods related to type parameters, for use
+// in the go2go rewriter.
+
+type TypeParam = _TypeParam
+
+func (t *Named) TArgs() []Type        { return t._TArgs() }
+func (t *Named) SetTArgs(args []Type) { t._SetTArgs(args) }
+func (t *Named) TParams() []*TypeName { return t._TParams() }
+
+func (t *Interface) HasTypeList() bool { return t._HasTypeList() }
+
+func (s *Signature) TParams() []*TypeName           { return s._TParams() }
+func (s *Signature) SetTParams(tparams []*TypeName) { s._SetTParams(tparams) }
+
+func AsPointer(t Type) *Pointer {
+	return asPointer(t)
+}
+
+func AsStruct(t Type) *Struct {
+	return asStruct(t)
+}

test/gen/err001.go2

@@ -0,0 +1,64 @@
+// errorcheck
+
+// Copyright 2020 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 p
+
+func F1[T comparable]() {}
+func F2() { F1[[]int]() } // ERROR "\[\]int does not satisfy comparable$"
+
+type C interface {
+	M()
+}
+
+func F3[T C]() {}
+func F4() { F3[int]() } // ERROR "int does not satisfy C.*method M"
+
+func F5[T any]() { F3[T]() } // ERROR "T does not satisfy C.*method M"
+
+type signed interface {
+	type int, int8, int16, int32, int64
+}
+
+type integer interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr
+}
+
+func F6[T signed](a T) bool { return a < 0 }
+func F7[T any](a T) bool { return F6(a) } // ERROR "T does not satisfy signed.*T has no type constraints"
+func F8[T integer](a T) bool { return F6(a) } // ERROR "T does not satisfy signed.*T type constraint uint not found in"
+func F9(a uint) bool { return F6(a) } // ERROR "uint does not satisfy signed.*uint not found in"
+
+type MyInt int
+type MyUint uint
+
+func F10(a MyInt) bool { return F6(a) }
+func F11(a MyUint) bool { return F6(a) } // ERROR "MyUint does not satisfy signed.*uint not found in"
+
+type C2 interface {
+	C
+	signed
+}
+
+func F20[T C2](a T) bool {
+	a.M()
+	return a < 0
+}
+
+func (MyInt) M() {}
+
+func (MyUint) M() {}
+
+type S struct {}
+func (S) M() {}
+
+func F21() bool { return F20(MyInt(0)) }
+func F22() bool { return F20(0) } // ERROR "int does not satisfy C2.*(missing method M)"
+func F23[T any](a T) bool { return F20(a) } // ERROR "T does not satisfy C2.*(missing method M)"
+func F24[T integer](a T) bool { return F20(a) } // ERROR "T does not satisfy C2.*(missing method M)"
+func F25(a uint) bool { return F20(a) } // ERROR "uint does not satisfy C2.*(missing method M)"
+func F26(a MyUint) bool { return F20(a) } // ERROR "MyUint does not satisfy C2.*uint not found in"
+func F27(a S) bool { return F20(a) } // ERROR "S does not satisfy C2.*struct{} not found in"

test/gen/err002.dir/a.go2

@@ -0,0 +1,9 @@
+// Copyright 2020 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 a
+
+type C interface {
+	M()
+}

test/gen/err002.dir/b.go2

@@ -0,0 +1,10 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package b
+
+import "./a"
+
+func F1[T a.C]() {}
+func F2() { F1(int)() } // ERROR "int does not satisfy a.C.*method M"

test/gen/err002.go2

@@ -0,0 +1,7 @@
+// errorcheckdir
+
+// Copyright 2020 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 ignored

test/gen/err003.go2

@@ -0,0 +1,29 @@
+// errorcheck
+
+// Copyright 2020 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 p
+
+type Setter interface {
+	Set(string)
+}
+
+func FromStrings[T Setter](s []string) []T {
+	result := make([]T, len(s))
+	for i, v := range s {
+		result[i].Set(v)
+	}
+	return result
+}
+
+type Settable int
+
+func (p *Settable) Set(s string) {
+	*p = 0
+}
+
+func F() {
+	FromStrings[Settable]([]string{"1"}) // ERROR "Settable does not satisfy Setter"
+}

test/gen/err004.go2

@@ -0,0 +1,11 @@
+// errorcheck
+
+// Copyright 2020 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 p
+
+func F() {
+     type t[T any] T // ERROR "parameterized type"
+}

test/gen/err005.go2

@@ -0,0 +1,15 @@
+// errorcheck
+
+// Copyright 2020 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.
+
+// Issue 39738.
+package p
+
+func F1[T any]() {}
+
+func F2() {
+     type s struct{}
+     F1[s]() // ERROR "locally defined type"
+}

test/gen/err006.go2

@@ -0,0 +1,16 @@
+// errorcheck
+
+// Copyright 2020 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.
+
+// Issue 39743.
+package p
+
+type S[T any] struct{}
+
+func (s S[_]) M() {}	// ERROR "_"
+
+func F() {
+	S[int]{}.M()
+}

test/gen/g001.go2

@@ -0,0 +1,23 @@
+// run
+
+// Copyright 2020 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 main
+
+import "fmt"
+
+func Print[T any](s []T) {
+	for _, v := range s {
+		fmt.Println(v)
+	}
+}
+
+func PrintInts(s []int) {
+	Print[int](s)
+}
+
+func main() {
+	PrintInts([]int{1, 2})
+}

test/gen/g001.out

@@ -0,0 +1,2 @@
+1
+2

test/gen/g002.go2

@@ -0,0 +1,27 @@
+// run
+
+// Copyright 2020 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 main
+
+import "fmt"
+
+func Print1[T any](s []T) {
+	for _, v := range s {
+		fmt.Println(v)
+	}
+}
+
+func Print2[T any](s []T) {
+	Print1(T)(s)
+}
+
+func PrintInts(s []int) {
+	Print2(int)(s)
+}
+
+func main() {
+	PrintInts([]int{1, 2})
+}

test/gen/g002.out

@@ -0,0 +1,2 @@
+1
+2

test/gen/g003.go2

@@ -0,0 +1,32 @@
+// run
+
+// Copyright 2020 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 main
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+type Pair[F1, F2 any] struct {
+	f1 F1
+	f2 F2
+}
+
+func main() {
+	p := Pair[int32, int64]{1, 2}
+	if got, want := unsafe.Sizeof(p.f1), uintptr(4); got != want {
+		panic(fmt.Sprintf("unexpected f1 size == %d want %d", got, want))
+	}
+	if got, want := unsafe.Sizeof(p.f2), uintptr(8); got != want {
+		panic(fmt.Sprintf("unexpected f2 size == %d want %d", got, want))
+	}
+	type MyPair struct { f1 int32; f2 int64 }
+	mp := MyPair(p)
+	if mp.f1 != 1 || mp.f2 != 2 {
+		panic(fmt.Sprintf("mp == %#v want %#v", mp, MyPair{1, 2}))
+	}
+}

test/gen/g004.go2

@@ -0,0 +1,39 @@
+// run
+
+// Copyright 2020 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 main
+
+import "fmt"
+
+type Value[T any] struct {
+	val T
+}
+
+func (v *Value[T]) Get() T {
+	return v.val
+}
+
+func (v *Value[T]) Set(val T) {
+	v.val = val
+}
+
+func main() {
+	var v1 Value[int]
+	v1.Set(1)
+	if got, want := v1.Get(), 1; got != want {
+		panic(fmt.Sprintf("Get() == %d, want %d", got, want))
+	}
+	v1.Set(2)
+	if got, want := v1.Get(), 2; got != want {
+		panic(fmt.Sprintf("Get() == %d, want %d", got, want))
+	}
+
+	var v2 Value[string]
+	v2.Set("a")
+	if got, want := v2.Get(), "a"; got != want {
+		panic(fmt.Sprintf("Get() == %q, want %q", got, want))
+	}
+}

test/gen/g005.dir/a.go2

@@ -0,0 +1,30 @@
+// Copyright 2020 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 a
+
+type Stack[E any] []E
+
+func (s *Stack[E]) Push(e E) {
+	*s = append(*s, e)
+}
+
+func (s *Stack[E]) Pop() (E, bool) {
+	l := len(*s)
+	if l == 0 {
+		var zero E
+		return zero, false
+	}
+	r := (*s)[l - 1]
+	*s = (*s)[:l - 1]
+	return r, true
+}
+
+func (s *Stack[E]) IsEmpty() bool {
+	return len(*s) == 0
+}
+
+func (s *Stack[E]) Len() int {
+	return len(*s)
+}

test/gen/g005.dir/b.go2

@@ -0,0 +1,31 @@
+// Copyright 2020 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 main
+
+import "./a"
+
+func main() {
+	var s a.Stack[string]
+	s.Push("hi")
+	s.Push("bye")
+	if s.IsEmpty() {
+		panic("unexpected IsEmpty")
+	}
+	if s.Len() != 2 {
+		panic("bad Len")
+	}
+	if v, ok := s.Pop(); !ok || v != "bye" {
+		panic("bad Pop 1")
+	}
+	if v, ok := s.Pop(); !ok || v != "hi" {
+		panic("bad Pop 2")
+	}
+	if !s.IsEmpty() {
+		panic("expected IsEmpty")
+	}
+	if s.Len() != 0 {
+		panic("bad Len 2")
+	}
+}

test/gen/g005.go2

@@ -0,0 +1,7 @@
+// rundir
+
+// Copyright 2020 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 ignored

test/gen/g006.go2

@@ -0,0 +1,96 @@
+// run
+
+// Copyright 2020 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 main
+
+import (
+	"fmt"
+	"math"
+	"os"
+	"sort"
+)
+
+type Ordered interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64,
+		string
+}
+
+type orderedSlice[Elem Ordered] []Elem
+
+func (s orderedSlice[Elem]) Len() int           { return len(s) }
+func (s orderedSlice[Elem]) Less(i, j int) bool {
+	if s[i] < s[j] {
+		return true
+	}
+	isNaN := func(f Elem) bool { return f != f }
+	if isNaN(s[i]) && !isNaN(s[j]) {
+		return true
+	}
+	return false
+}
+func (s orderedSlice[Elem]) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+func OrderedSlice[Elem Ordered](s []Elem) {
+	sort.Sort(orderedSlice[Elem](s))
+}
+
+var ints = []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
+var float64s = []float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
+var strings = []string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
+
+func TestSortOrderedInts() bool {
+	return testOrdered("ints", ints, sort.Ints)
+}
+
+func TestSortOrderedFloat64s() bool {
+	return testOrdered("float64s", float64s, sort.Float64s)
+}
+
+func TestSortOrderedStrings() bool {
+	return testOrdered("strings", strings, sort.Strings)
+}
+
+func testOrdered[Elem Ordered](name string, s []Elem, sorter func([]Elem)) bool {
+	s1 := make([]Elem, len(s))
+	copy(s1, s)
+	s2 := make([]Elem, len(s))
+	copy(s2, s)
+	OrderedSlice(s1)
+	sorter(s2)
+	ok := true
+	if !sliceEq(s1, s2) {
+		fmt.Printf("%s: got %v, want %v", name, s1, s2)
+		ok = false
+	}
+	for i := len(s1) - 1; i > 0; i-- {
+		if s1[i] < s1[i-1] {
+			fmt.Printf("%s: element %d (%v) < element %d (%v)", name, i, s1[i], i - 1, s1[i - 1])
+			ok = false
+		}
+	}
+	return ok
+}
+
+func sliceEq[Elem Ordered](s1, s2 []Elem) bool {
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func main() {
+	if !TestSortOrderedInts() || !TestSortOrderedFloat64s() || !TestSortOrderedStrings() {
+		os.Exit(1)
+	}
+}

test/gen/g007.go2

@@ -0,0 +1,20 @@
+// compile
+
+// Copyright 2020 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.
+
+// Using a type literal based on a type parameter as a type argument
+// in a result.
+
+package p
+
+type S[T any] struct {
+	f T
+}
+
+func SliceS[T any]() S[[]T] {
+	return S[[]T]{nil}
+}
+
+var V = SliceS[int]()

test/gen/g008.go2

@@ -0,0 +1,41 @@
+// run
+
+// Copyright 2020 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 main
+
+type Setter interface {
+	Set(string)
+}
+
+func FromStrings[T Setter](s []string) []T {
+	result := make([]T, len(s))
+	for i, v := range s {
+		result[i].Set(v)
+	}
+	return result
+}
+
+type Settable int
+
+func (p *Settable) Set(s string) {
+	*p = 0
+}
+
+func F() {
+	defer func() {
+		if recover() == nil {
+			panic("did not panic as expected")
+		}
+	}()
+	// This should type check but should panic at run time,
+	// because it will make a slice of *Settable and then call
+	// Set on a nil value.
+	FromStrings(*Settable)([]string{"1"})
+}
+
+func main() {
+	F()
+}

test/gen/g009.go2

@@ -0,0 +1,43 @@
+// run
+
+// Copyright 2020 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 main
+
+import (
+	"log"
+	"strconv"
+)
+
+type Setter2[B any] interface {
+	Set(string)
+	type *B
+}
+
+func FromStrings2[T any, PT Setter2[T]](s []string) []T {
+	result := make([]T, len(s))
+	for i, v := range s {
+		p := PT(&result[i])
+		p.Set(v)
+	}
+	return result
+}
+
+type Settable int
+
+func (p *Settable) Set(s string) {
+	i, err := strconv.Atoi(s)
+	if err != nil {
+		log.Fatal(err)
+	}
+	*p = Settable(i)
+}
+
+func main() {
+	s := FromStrings2[Settable, *Settable]([]string{"1"})
+	if len(s) != 1 || s[0] != 1 {
+		log.Fatalf("got %v, want %v", s, []int{1})
+	}
+}

test/gen/g010.go2

@@ -0,0 +1,38 @@
+// run
+
+// Copyright 2020 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 main
+
+import (
+	"log"
+	"strconv"
+)
+
+func FromStrings3[T any](s []string, set func(*T, string)) []T {
+	results := make([]T, len(s))
+	for i, v := range s {
+		set(&results[i], v)
+	}
+	return results
+}
+
+type Settable int
+
+func (p *Settable) Set(s string) {
+	i, err := strconv.Atoi(s)
+	if err != nil {
+		log.Fatal(err)
+	}
+	*p = Settable(i)
+}
+
+func main() {
+	s := FromStrings3[Settable]([]string{"1"},
+		func(p *Settable, s string) { p.Set(s) })
+	if len(s) != 1 || s[0] != 1 {
+		log.Fatalf("got %v, want %v", s, []int{1})
+	}
+}

test/gen/g011.go2

@@ -0,0 +1,46 @@
+// run
+
+// Copyright 2020 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 main
+
+import (
+	"log"
+	"strconv"
+)
+
+type Setter[B any] interface {
+	Set(string)
+	type *B
+}
+
+func FromStrings[T any, PT Setter[T]](s []string) []T {
+	result := make([]T, len(s))
+	for i, v := range s {
+		// The type of &result[i] is *T which is in the type list
+		// of Setter, so we can convert it to PT.
+		p := PT(&result[i])
+		// PT has a Set method.
+		p.Set(v)
+	}
+	return result
+}
+
+type Settable int
+
+func (p *Settable) Set(s string) {
+	i, err := strconv.Atoi(s)
+	if err != nil {
+		log.Fatal(err)
+	}
+	*p = Settable(i)
+}
+
+func main() {
+	s := FromStrings[Settable, *Settable]([]string{"1"})
+	if len(s) != 1 || s[0] != 1 {
+		log.Fatalf("got %v, want %v", s, []int{1})
+	}
+}

test/gen/g012.go2

@@ -0,0 +1,90 @@
+// run
+
+// Copyright 2020 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 main
+
+import "math"
+
+type Numeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64,
+		complex64, complex128
+}
+
+// NumericAbs matches numeric types with an Abs method.
+type NumericAbs[T any] interface {
+	Numeric
+	Abs() T
+}
+
+// AbsDifference computes the absolute value of the difference of
+// a and b, where the absolute value is determined by the Abs method.
+func AbsDifference[T NumericAbs[T]](a, b T) T {
+	d := a - b
+	return d.Abs()
+}
+
+// OrderedNumeric matches numeric types that support the < operator.
+type OrderedNumeric interface {
+	type int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64, uintptr,
+		float32, float64
+}
+
+// Complex matches the two complex types, which do not have a < operator.
+type Complex interface {
+	type complex64, complex128
+}
+
+// OrderedAbs is a helper type that defines an Abs method for
+// ordered numeric types.
+type OrderedAbs[T OrderedNumeric] T
+
+func (a OrderedAbs[T]) Abs() OrderedAbs[T] {
+	if a < 0 {
+		return -a
+	}
+	return a
+}
+
+// ComplexAbs is a helper type that defines an Abs method for
+// complex types.
+type ComplexAbs[T Complex] T
+
+func (a ComplexAbs[T]) Abs() ComplexAbs[T] {
+	r := float64(real(a))
+	i := float64(imag(a))
+	d := math.Sqrt(r * r + i * i)
+	return ComplexAbs[T](complex(d, 0))
+}
+
+// OrderedAbsDifference returns the absolute value of the difference
+// between a and b, where a and b are of an ordered type.
+func OrderedAbsDifference[T OrderedNumeric](a, b T) T {
+	return T(AbsDifference(OrderedAbs[T](a), OrderedAbs[T](b)))
+}
+
+// ComplexAbsDifference returns the absolute value of the difference
+// between a and b, where a and b are of a complex type.
+func ComplexAbsDifference[T Complex](a, b T) T {
+	return T(AbsDifference(ComplexAbs[T](a), ComplexAbs[T](b)))
+}
+
+func main() {
+	if d := OrderedAbsDifference(1.0, -2.0); d != 3 {
+		panic(d)
+	}
+	if d := OrderedAbsDifference(-1.0, 2.0); d != 3 {
+		panic(d)
+	}
+	if d := ComplexAbsDifference(5.0 + 2.0i, 2.0 - 2.0i); d != 5 {
+		panic(d)
+	}
+	if d := ComplexAbsDifference(2.0 - 2.0i, 5.0 + 2.0i); d != 5 {
+		panic(d)
+	}
+}

test/gen/g013.go2

@@ -0,0 +1,48 @@
+// run
+
+// Copyright 2020 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 main
+
+type Gen[A any] func() (A, bool)
+
+func combine[T1, T2, T any](g1 Gen[T1], g2 Gen[T2], join func(T1, T2) T) Gen[T] {
+    return func() (T, bool) {
+        var t T
+        t1, ok := g1()
+        if !ok {
+            return t, false
+        }
+        t2, ok := g2()
+        if !ok {
+            return t, false
+        }
+        return join(t1, t2), true
+    }
+}
+
+type Pair[A, B any] struct {
+	A A
+	B B
+}
+
+func NewPair[A, B any](a A, b B) Pair[A, B] { return Pair[A, B]{a, b} }
+
+func Combine2[A, B any](ga Gen[A], gb Gen[B]) Gen[Pair[A, B]] {
+    return combine(ga, gb, NewPair(A, B))
+}
+
+func main() {
+	var g1 Gen[int] = func() (int, bool) { return 3, true }
+	var g2 Gen[string] = func() (string, bool) { return "x", false }
+	gc := combine(g1, g2, NewPair[int, string])
+	gc2 := Combine2(g1, g2)
+	if got, ok := gc(); ok {
+		panic(got)
+	}
+	if got2, ok := gc2(); ok {
+		panic(got2)
+	}
+}

test/gen/g014.go2

@@ -0,0 +1,44 @@
+// run
+
+// Copyright 2020 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 main
+
+type T[A any] struct {
+	V A
+}
+
+type S1 struct {
+	T[int]
+	V string
+}
+
+type Tint = T[int]
+type Tbool = T[bool]
+
+type S2 struct {
+	Tint
+	Tbool
+	V string
+}
+
+type S3 struct {
+	*T[int]
+}
+
+func main() {
+	var s1 S1
+	if s1.T.V != 0 {
+		panic(s1)
+	}
+	var s2 S2
+	if s2.Tint.V != 0 || s2.Tbool.V {
+		panic(s2)
+	}
+	var s3 S3
+	if s3.T != nil {
+		panic(s3)
+	}
+}

test/gen/g015.go2

@@ -0,0 +1,17 @@
+// compile
+
+// Copyright 2020 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 p
+
+func F1[T any](x T) {}
+
+func F2(c <-chan int) {
+	F1(c)
+}
+
+func F3(c chan <- int) {
+	F1(c)
+}

test/gen/g016.go2

@@ -0,0 +1,92 @@
+// run
+
+// Copyright 2020 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 main
+
+import "fmt"
+
+type Any interface{}
+
+type Function[a, b any] interface {
+	Apply(x a) b
+}
+
+type incr struct{ n int }
+
+func (this incr) Apply(x int) int {
+	return x + this.n
+}
+
+type pos struct{}
+
+func (this pos) Apply(x int) bool {
+	return x > 0
+}
+
+type compose[a, b, c any] struct {
+	f Function[a, b]
+	g Function[b, c]
+}
+
+func (this compose[a, b, c]) Apply(x a) c {
+	return this.g.Apply(this.f.Apply(x))
+}
+
+type Eq[a any] interface {
+	Equal(a) bool
+}
+
+type Int int
+
+func (this Int) Equal(that int) bool {
+	return int(this) == that
+}
+
+type List[a any] interface {
+	Match(casenil Function[Nil[a], Any], casecons Function[Cons[a], Any]) Any
+}
+
+type Nil[a any] struct{}
+
+func (xs Nil[a]) Match(casenil Function[Nil[a], Any], casecons Function[Cons[a], Any]) Any {
+	return casenil.Apply(xs)
+}
+
+type Cons[a any] struct {
+	Head a
+	Tail List[a]
+}
+
+func (xs Cons[a]) Match(casenil Function[Nil[a], Any], casecons Function[Cons[a], Any]) Any {
+	return casecons.Apply(xs)
+}
+
+type mapNil[a, b any] struct{}
+
+func (m mapNil[a, b]) Apply(_ Nil[a]) Any {
+	return Nil[b]{}
+}
+
+type mapCons[a, b any] struct {
+	f Function[a, b]
+}
+
+func (m mapCons[a, b]) Apply(xs Cons[a]) Any {
+	return Cons[b]{m.f.Apply(xs.Head), Map[a, b](m.f, xs.Tail)}
+}
+
+func Map[a, b any](f Function[a, b], xs List[a]) List[b] {
+	return xs.Match(mapNil[a, b]{}, mapCons[a, b]{f}).(List[b])
+}
+
+func main() {
+	var xs List[int] = Cons[int]{3, Cons[int]{6, Nil[int]{}}}
+	var ys List[int] = Map[int, int](incr{-5}, xs)
+	var xz List[bool] = Map[int, bool](pos{}, ys)
+	if fmt.Sprint(xz) != "{false {true {}}}" {
+		panic(xz)
+	}
+}

test/gen/g017.go2

@@ -0,0 +1,24 @@
+// run
+
+// Copyright 2020 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 main
+
+type Recv <-chan int
+
+type sliceOf[E any] interface {
+	type []E
+}
+
+func Append[S sliceOf[T], T any](s S, t ...T) S {
+	return append(s, t...)
+}
+
+func main() {
+	a := Append([]Recv{nil}, Recv(nil))
+	if len(a) != 2 || a[0] != nil || a[1] != nil {
+		panic(a)
+	}
+}

test/gen/g018.go2

@@ -0,0 +1,27 @@
+// compile
+
+// Copyright 2020 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 p
+
+type I1 interface {
+	comparable
+}
+
+type I2 interface {
+	I1
+}
+
+type I3 I2
+
+type I4 interface {
+	type int
+}
+
+type I5 interface {
+	I4
+}
+
+type I6 I5

test/gen/g019.go2

@@ -0,0 +1,24 @@
+// compile
+
+// Copyright 2020 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.
+
+// Issue 39662.
+package p
+
+type S1 struct{}
+func (*S1) M() {}
+
+type S2 struct{}
+func (S2) M() {}
+
+func F1[T interface{ M() }](t T) {
+	_ = T.M
+}
+
+func F2() {
+	F1(&S1{})
+	F1(S2{})
+	F1(&S2{})
+}

test/gen/g020.go2

@@ -0,0 +1,23 @@
+// compile
+
+// Copyright 2020 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.
+
+// Issue 39653.
+package p
+
+type E struct{}
+
+type N[T any] struct {
+	i int
+	n T
+}
+
+func F1[T any](i int, n T) N[T] {
+	return N[T]{i: i, n: n}
+}
+
+func F2() {
+	F1(1, F1(2, F1(3, E{})))
+}

test/gen/g021.go2

@@ -0,0 +1,50 @@
+// run
+
+// Copyright 2020 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 main
+
+import "sync"
+
+// A Lockable is a value that may be safely simultaneously accessed
+// from multiple goroutines via the Get and Set methods.
+type Lockable[T any] struct {
+	T
+	mu sync.Mutex
+}
+
+// Get returns the value stored in a Lockable.
+func (l *Lockable[T]) Get() T {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.T
+}
+
+// Set sets the value in a Lockable.
+func (l *Lockable[T]) Set(v T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.T = v
+}
+
+func main() {
+	sl := Lockable[string]{T: "a"}
+	if got := sl.Get(); got != "a" {
+		panic(got)
+	}
+	sl.Set("b")
+	if got := sl.Get(); got != "b" {
+		panic(got)
+	}
+
+	il := Lockable[int]{T: 1}
+	if got := il.Get(); got != 1 {
+		panic(got)
+	}
+	il.Set(2)
+	if got := il.Get(); got != 2 {
+		panic(got)
+	}
+}

test/gen/g022.go2

@@ -0,0 +1,11 @@
+// compile
+
+// Copyright 2020 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 p
+
+type F[T any] func(T) error
+
+type instF = F[int]

test/gen/g023.go2

@@ -0,0 +1,17 @@
+// compile
+
+// Copyright 2020 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 p
+
+import "net/url"
+
+type S[T any] struct {
+	f T
+}
+
+func F() S[url.Error] {
+	return S[url.Error]{}
+}

test/gen/g024.go2

@@ -0,0 +1,23 @@
+// compile
+
+// Copyright 2020 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.
+
+// Issue 39672
+package p
+
+type S[T any] T
+
+func (r S[T]) M()
+
+func F() {
+	var x S[int]
+	_ = x
+}
+
+func G[T any](v T)
+
+func F2() {
+	G(0)
+}

test/gen/g025.go2

@@ -0,0 +1,29 @@
+// compile
+
+// Copyright 2020 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.
+
+// Issue 39692
+package p
+
+type S1[T1, T2 any] struct {
+	f1 T1
+	f2 T2
+}
+
+type S2[T1, T2 any] struct {
+	f1 T1
+	f2 T2
+}
+
+func F1[T any](v T) T {
+	return v
+}
+
+func F() {
+	_ = S2[int, S1[S1[int, int], S1[int, int]]]{
+		f1: 0,
+		f2: S1[S1[int, int], S1[int, int]]{},
+	}
+}

test/gen/g026.go2

@@ -0,0 +1,16 @@
+// run
+
+// Copyright 2020 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.
+
+// Issue 39625.
+package main
+
+import "io/ioutil"
+
+func F[T1, T2 any](f func(T1) (T2, error)) {}
+
+func main() {
+	F(ioutil.ReadAll)
+}

test/gen/g027.go2

@@ -0,0 +1,34 @@
+// compile
+
+// Copyright 2020 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.
+
+// Issue 39678, 39881.
+package p
+
+type B[T any] struct {
+	T
+}
+
+type C struct {
+	F int
+}
+
+type BC B[C]
+
+func F(s BC) {
+	s.F = 7
+}
+
+type Pair[T, U any] struct {
+	T
+	U
+}
+
+func (p Pair[T, U]) M() {
+	_, _ = p.T, p.U
+}
+
+var V1 Pair[Pair[int, int], int]
+var V2 Pair[struct { p Pair[int, int] }, int]

test/gen/g028.go2

@@ -0,0 +1,14 @@
+// compile
+
+// Copyright 2020 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.
+
+// Issue 39688.
+package p
+
+type S[T any] T
+
+func (*S[T]) M() {}
+
+var V S[int]

test/gen/g029.go2

@@ -0,0 +1,16 @@
+// compile
+
+// Copyright 2020 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.
+
+// Issue 39741.
+package p
+
+func F[T any]() {
+	type S struct{}
+}
+
+func G() {
+	F[int]()
+}

test/gen/g030.dir/a.go2

@@ -0,0 +1,20 @@
+// Copyright 2020 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 main
+
+func Len[T any](s []T) int {
+	return len(s)
+}
+
+func F1(s []int) int {
+	return Len(s)
+}
+
+func main() {
+	got := F1(nil) + F2(nil)
+	if got != 0 {
+		panic(got)
+	}
+}

test/gen/g030.dir/b.go2

@@ -0,0 +1,9 @@
+// Copyright 2020 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 main
+
+func F2(s []int) int {
+	return Len(s)
+}

test/gen/g030.go2

@@ -0,0 +1,7 @@
+// rundir
+
+// Copyright 2020 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 ignored

test/gen/g031.go2

@@ -0,0 +1,14 @@
+// compile
+
+// Copyright 2020 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.
+
+// Issue 39737.
+package p
+
+func F1[T any]() {}
+
+func F2() {
+	F1(struct { F string `json:"f"` })()
+}

test/gen/g032.go2

@@ -0,0 +1,16 @@
+// compile
+
+// Copyright 2020 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.
+
+// Issue 39744.
+package p
+
+import "net/http"
+
+func F1[T any](f func() T) { f() }
+
+func F2() {
+	F1(func() *http.Request { return nil })
+}

test/gen/g033.dir/a.go2

@@ -0,0 +1,9 @@
+// Copyright 2020 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 a
+
+type S[T any] struct {
+	F T
+}

test/gen/g033.dir/b.go2

@@ -0,0 +1,16 @@
+// Copyright 2020 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 main
+
+import "./a"
+
+type S = a.S
+
+func main() {
+	var s S[int]
+	if s.F != 0 {
+		panic(s.F)
+	}
+}

test/gen/g033.go2

@@ -0,0 +1,7 @@
+// rundir
+
+// Copyright 2020 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 ignored

test/gen/g034.go2

@@ -0,0 +1,20 @@
+// compile
+
+// Copyright 2020 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 p
+
+type I interface{}
+
+type S[T any] struct {
+	*T
+}
+
+func F() {
+	v := S[I]{}
+	if v.T != nil {
+		panic(v)
+	}
+}

test/gen/g035.dir/a.go2

@@ -0,0 +1,9 @@
+// Copyright 2020 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 a
+
+type S[T any] struct {
+	f T
+}

test/gen/g035.dir/b.go2

@@ -0,0 +1,20 @@
+// Copyright 2020 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 main
+
+import "./a"
+
+type S = a.S
+
+func F1[T any](T) {}
+
+func F2() { F1(S[string]{}) }
+
+func F3() { F1[S[string]](S[string]{}) }
+
+func main() {
+	F2()
+	F3()
+}

test/gen/g035.go2

@@ -0,0 +1,7 @@
+// rundir
+
+// Copyright 2020 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 ignored

test/gen/g036.dir/a.go2

@@ -0,0 +1,13 @@
+// Copyright 2020 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 a
+
+type S[T any] struct {
+	F T
+}
+
+func NewS[T any](v T) S[T] {
+	return S[T]{F: v}
+}

test/gen/g036.dir/b.go2

@@ -0,0 +1,23 @@
+// Copyright 2020 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 main
+
+import "./a"
+
+type S[T any] struct {
+	F T
+}
+
+func NewS[T any](v T) S[T] {
+	return S[T]{F: v}
+}
+
+func main() {
+	v1 := a.NewS(0)
+	v2 := NewS(0)
+	if v1.F != v2.F {
+		panic(v1)
+	}
+}