[dev.typeparams] cmd/compile: move to new export version, keep reading previous version

I added constants for the previous export versions, and for the final
generics export version. I also added a const for the current export
version. We can increment the current export version for unstable
changes in dev.typeparams, and eventally set it back to the generics
version (2) before release. Added the same constants in
typecheck/iexport.go, importer/iimport.go, and gcimporter/iimport.go,
must be kept in sync.

Put in the needed conditionals to be able to read old versions.

Added new export/import test listimp.dir.

Change-Id: I166d17d943e07951aa752562e952b067704aeeca
Reviewed-on: https://go-review.googlesource.com/c/go/+/319931
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

2 files changed, 98 insertions, 0 deletions

diff --git a/test/typeparam/listimp.dir/a.go b/test/typeparam/listimp.dir/a.go
new file mode 100644
index 0000000000..ea569751a6
--- /dev/null
+++ b/test/typeparam/listimp.dir/a.go
@@ -0,0 +1,50 @@
+package a
+
+type Ordered interface {
+        type int, int8, int16, int32, int64,
+                uint, uint8, uint16, uint32, uint64, uintptr,
+                float32, float64,
+                string
+}
+
+// List is a linked list of ordered values of type T.
+type List[T Ordered] struct {
+        Next *List[T]
+        Val  T
+}
+
+func (l *List[T]) Largest() T {
+        var max T
+        for p := l; p != nil; p = p.Next {
+                if p.Val > max {
+                        max = p.Val
+                }
+        }
+        return max
+}
+
+type OrderedNum interface {
+        type int, int8, int16, int32, int64,
+                uint, uint8, uint16, uint32, uint64, uintptr,
+                float32, float64
+}
+
+// ListNum is a linked _List of ordered numeric values of type T.
+type ListNum[T OrderedNum] struct {
+        Next *ListNum[T]
+        Val  T
+}
+
+const Clip = 5
+
+// clippedLargest returns the largest in the list of OrderNums, but a max of 5.
+// TODO(danscales): fix export/import of an untype constant with typeparam type
+func (l *ListNum[T]) ClippedLargest() T {
+        var max T
+        for p := l; p != nil; p = p.Next {
+                if p.Val > max && p.Val < T(Clip) {
+                        max = p.Val
+                }
+        }
+        return max
+}
diff --git a/test/typeparam/listimp.dir/main.go b/test/typeparam/listimp.dir/main.go
new file mode 100644
index 0000000000..4c1aa3e493
--- /dev/null
+++ b/test/typeparam/listimp.dir/main.go
@@ -0,0 +1,48 @@
+package main
+
+import (
+	"a"
+	"fmt"
+)
+
+func main() {
+        i3 := &a.List[int]{nil, 1}
+        i2 := &a.List[int]{i3, 3}
+        i1 := &a.List[int]{i2, 2}
+        if got, want := i1.Largest(), 3; got != want {
+                panic(fmt.Sprintf("got %d, want %d", got, want))
+        }
+
+        b3 := &a.List[byte]{nil, byte(1)}
+        b2 := &a.List[byte]{b3, byte(3)}
+        b1 := &a.List[byte]{b2, byte(2)}
+        if got, want := b1.Largest(), byte(3); got != want {
+                panic(fmt.Sprintf("got %d, want %d", got, want))
+        }
+
+        f3 := &a.List[float64]{nil, 13.5}
+        f2 := &a.List[float64]{f3, 1.2}
+        f1 := &a.List[float64]{f2, 4.5}
+        if got, want := f1.Largest(), 13.5; got != want {
+                panic(fmt.Sprintf("got %f, want %f", got, want))
+        }
+
+        s3 := &a.List[string]{nil, "dd"}
+        s2 := &a.List[string]{s3, "aa"}
+        s1 := &a.List[string]{s2, "bb"}
+        if got, want := s1.Largest(), "dd"; got != want {
+                panic(fmt.Sprintf("got %s, want %s", got, want))
+        }
+        j3 := &a.ListNum[int]{nil, 1}
+        j2 := &a.ListNum[int]{j3, 32}
+        j1 := &a.ListNum[int]{j2, 2}
+        if got, want := j1.ClippedLargest(), 2; got != want {
+                panic(fmt.Sprintf("got %d, want %d", got, want))
+        }
+        g3 := &a.ListNum[float64]{nil, 13.5}
+        g2 := &a.ListNum[float64]{g3, 1.2}
+        g1 := &a.ListNum[float64]{g2, 4.5}
+        if got, want := g1.ClippedLargest(), 4.5; got != want {
+                panic(fmt.Sprintf("got %f, want %f", got, want))
+        }
+}