src/internal/types/testdata/check/decls4.go

   1 // Copyright 2016 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // type aliases
   6
   7 package decls4
   8
   9 type (
  10         T0 [10]int
  11         T1 []byte
  12         T2 struct {
  13                 x int
  14         }
  15         T3 interface{
  16                 m() T2
  17         }
  18         T4 func(int, T0) chan T2
  19 )
  20
  21 type (
  22         Ai = int
  23         A0 = T0
  24         A1 = T1
  25         A2 = T2
  26         A3 = T3
  27         A4 = T4
  28
  29         A10 = [10]int
  30         A11 = []byte
  31         A12 = struct {
  32                 x int
  33         }
  34         A13 = interface{
  35                 m() A2
  36         }
  37         A14 = func(int, A0) chan A2
  38 )
  39
  40 // check assignment compatibility due to equality of types
  41 var (
  42         xi_ int
  43         ai Ai = xi_
  44
  45         x0 T0
  46         a0 A0 = x0
  47
  48         x1 T1
  49         a1 A1 = x1
  50
  51         x2 T2
  52         a2 A2 = x2
  53
  54         x3 T3
  55         a3 A3 = x3
  56
  57         x4 T4
  58         a4 A4 = x4
  59 )
  60
  61 // alias receiver types
  62 func (Ai /* ERROR "cannot define new methods on non-local type int" */) m1() {}
  63 func (T0) m1() {}
  64 func (A0) m1 /* ERROR "already declared" */ () {}
  65 func (A0) m2 () {}
  66 func (A3 /* ERROR "invalid receiver" */ ) m1 () {}
  67 func (A10 /* ERROR "invalid receiver" */ ) m1() {}
  68
  69 // x0 has methods m1, m2 declared via receiver type names T0 and A0
  70 var _ interface{ m1(); m2() } = x0
  71
  72 // alias receiver types (test case for issue #23042)
  73 type T struct{}
  74
  75 var (
  76         _ = T.m
  77         _ = T{}.m
  78         _ interface{m()} = T{}
  79 )
  80
  81 var (
  82         _ = T.n
  83         _ = T{}.n
  84         _ interface{m(); n()} = T{}
  85 )
  86
  87 type U = T
  88 func (U) m() {}
  89
  90 // alias receiver types (long type declaration chains)
  91 type (
  92         V0 = V1
  93         V1 = (V2)
  94         V2 = ((V3))
  95         V3 = T
  96 )
  97
  98 func (V0) m /* ERROR "already declared" */ () {}
  99 func (V1) n() {}
 100
 101 // alias receiver types (invalid due to cycles)
 102 type (
 103         W0 /* ERROR "invalid recursive type" */ = W1
 104         W1 = (W2)
 105         W2 = ((W0))
 106 )
 107
 108 func (W0) m() {} // no error expected (due to above cycle error)
 109 func (W1) n() {}
 110
 111 // alias receiver types (invalid due to builtin underlying type)
 112 type (
 113         B0 = B1
 114         B1 = B2
 115         B2 = int
 116 )
 117
 118 func (B0 /* ERROR "cannot define new methods on non-local type int" */ ) m() {}
 119 func (B1 /* ERROR "cannot define new methods on non-local type int" */ ) n() {}
 120
 121 // cycles
 122 type (
 123         C2 /* ERROR "invalid recursive type" */ = C2
 124         C3 /* ERROR "invalid recursive type" */ = C4
 125         C4 = C3
 126         C5 struct {
 127                 f *C6
 128         }
 129         C6 = C5
 130         C7 /* ERROR "invalid recursive type" */  struct {
 131                 f C8
 132         }
 133         C8 = C7
 134 )
 135
 136 // embedded fields
 137 var (
 138         s0 struct { T0 }
 139         s1 struct { A0 } = s0 /* ERROR "cannot use" */ // embedded field names are different
 140 )
 141
 142 // embedding and lookup of fields and methods
 143 func _(s struct{A0}) { s.A0 = x0 }
 144
 145 type eX struct{xf int}
 146
 147 func (eX) xm()
 148
 149 type eY = struct{eX} // field/method set of eY includes xf, xm
 150
 151 type eZ = *struct{eX} // field/method set of eZ includes xf, xm
 152
 153 type eA struct {
 154         eX // eX contributes xf, xm to eA
 155 }
 156
 157 type eA2 struct {
 158         *eX // *eX contributes xf, xm to eA
 159 }
 160
 161 type eB struct {
 162         eY // eY contributes xf, xm to eB
 163 }
 164
 165 type eB2 struct {
 166         *eY // *eY contributes xf, xm to eB
 167 }
 168
 169 type eC struct {
 170         eZ // eZ contributes xf, xm to eC
 171 }
 172
 173 var (
 174         _ = eA{}.xf
 175         _ = eA{}.xm
 176         _ = eA2{}.xf
 177         _ = eA2{}.xm
 178         _ = eB{}.xf
 179         _ = eB{}.xm
 180         _ = eB2{}.xf
 181         _ = eB2{}.xm
 182         _ = eC{}.xf
 183         _ = eC{}.xm
 184 )
 185
 186 // ambiguous selectors due to embedding via type aliases
 187 type eD struct {
 188         eY
 189         eZ
 190 }
 191
 192 var (
 193         _ = eD{}.xf /* ERROR "ambiguous selector eD{}.xf" */
 194         _ = eD{}.xm /* ERROR "ambiguous selector eD{}.xm" */
 195 )
 196
 197 var (
 198         _ interface{ xm() } = eD /* ERROR "ambiguous selector eD.xm" */ {}
 199 )