[dev.typealias] cmd/compile: export/import test cases for type aliases

Plus a few minor changes.

For #18130.

Change-Id: Ica6503fe9c888cc05c15b46178423f620c087491
Reviewed-on: https://go-review.googlesource.com/35233Reviewed-by: Alan Donovan <adonovan@google.com>

src/cmd/compile/internal/gc/dcl.go

@@ -1163,14 +1163,14 @@ bad:
 	return nil
 }
 
-func methodname(n *Node, t *Node) *Node {
+func methodname(n, recv *Node) *Node {
 	star := false
-	if t.Op == OIND {
+	if recv.Op == OIND {
 		star = true
-		t = t.Left
+		recv = recv.Left
 	}
 
-	return methodname0(n.Sym, star, t.Sym)
+	return methodname0(n.Sym, star, recv.Sym)
 }
 
 func methodname0(s *Sym, star bool, tsym *Sym) *Node {
@@ -1198,7 +1198,6 @@ func methodname0(s *Sym, star bool, tsym *Sym) *Node {
 // - msym is the method symbol
 // - t is function type (with receiver)
 func addmethod(msym *Sym, t *Type, local, nointerface bool) {
-	// get field sym
 	if msym == nil {
 		Fatalf("no method symbol")
 	}

test/alias2.go

@@ -35,9 +35,11 @@ type (
 )
 
 // Methods can be declared on the original named type and the alias.
-func (T0) m1() {}
-func (A0) m1() {} // TODO(gri) this should be an error
-func (A0) m2() {}
+func (T0) m1()  {}
+func (*T0) m1() {} // ERROR "method redeclared: T0\.m1"
+func (A0) m1()  {} // TODO(gri) this should be an error
+func (A0) m1()  {} // ERROR "A0\.m1 redeclared in this block"
+func (A0) m2()  {}
 
 // Type aliases and the original type name can be used interchangeably.
 var _ A0 = T0{}
@@ -91,6 +93,9 @@ func _() {
 type _ = reflect.ValueOf // ERROR "reflect.ValueOf is not a type"
 
 func (A1) m() {} // ERROR "cannot define new methods on non-local type int"
+func (A2) m() {} // ERROR "invalid receiver type struct {}"
+func (A3) m() {} // ERROR "cannot define new methods on non-local type reflect.Value"
+func (A4) m() {} // ERROR "cannot define new methods on non-local type reflect.Value"
 
 type B1 = struct{}
 

test/alias3.dir/a.go

+// Copyright 2017 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
+
+import "go/build"
+
+type (
+	Float64 = float64
+	Rune    = rune
+)
+
+type (
+	Int       int
+	IntAlias  = Int
+	IntAlias2 = IntAlias
+	S         struct {
+		Int
+		IntAlias
+		IntAlias2
+	}
+)
+
+type (
+	Context = build.Context
+)
+
+type (
+	I1 interface {
+		M1(IntAlias2) Float64
+		M2() Context
+	}
+
+	I2 = interface {
+		M1(Int) float64
+		M2() build.Context
+	}
+)
+
+var i1 I1
+var i2 I2 = i1

test/alias3.dir/b.go

+// Copyright 2017 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"
+	. "go/build"
+)
+
+func F(x float64) a.Float64 {
+	return x
+}
+
+type MyContext = Context // = build.Context
+
+var C a.Context = Default
+
+type S struct{}
+
+func (S) M1(x a.IntAlias) float64 { return a.Float64(x) }
+func (S) M2() Context             { return Default }
+
+var _ a.I1 = S{}
+var _ a.I2 = S{}

test/alias3.dir/c.go

+// Copyright 2017 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"
+	"./b"
+)
+
+func main() {
+	var _ float64 = b.F(0)
+	var _ a.Rune = int32(0)
+
+	// embedded types can have different names but the same types
+	var s a.S
+	s.Int = 1
+	s.IntAlias = s.Int
+	s.IntAlias2 = s.Int
+
+	// aliases denote identical types across packages
+	var c a.Context = b.C
+	var _ b.MyContext = c
+}

test/alias3.go

+// rundir
+
+// Copyright 2017 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