decls3.go

Documentation: internal/types/testdata/check

     1  // Copyright 2012 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  // embedded types
     6  
     7  package decls3
     8  
     9  import "unsafe"
    10  import "fmt"
    11  
    12  // fields with the same name at the same level cancel each other out
    13  
    14  func _() {
    15  	type (
    16  		T1 struct { X int }
    17  		T2 struct { X int }
    18  		T3 struct { T1; T2 } // X is embedded twice at the same level via T1->X, T2->X
    19  	)
    20  
    21  	var t T3
    22  	_ = t.X /* ERROR "ambiguous selector t.X" */
    23  }
    24  
    25  func _() {
    26  	type (
    27  		T1 struct { X int }
    28  		T2 struct { T1 }
    29  		T3 struct { T1 }
    30  		T4 struct { T2; T3 } // X is embedded twice at the same level via T2->T1->X, T3->T1->X
    31  	)
    32  
    33  	var t T4
    34  	_ = t.X /* ERROR "ambiguous selector t.X" */
    35  }
    36  
    37  func issue4355() {
    38  	type (
    39  	    T1 struct {X int}
    40  	    T2 struct {T1}
    41  	    T3 struct {T2}
    42  	    T4 struct {T2}
    43  	    T5 struct {T3; T4} // X is embedded twice at the same level via T3->T2->T1->X, T4->T2->T1->X
    44  	)
    45  
    46  	var t T5
    47  	_ = t.X /* ERROR "ambiguous selector t.X" */
    48  }
    49  
    50  func _() {
    51  	type State int
    52  	type A struct{ State }
    53  	type B struct{ fmt.State }
    54  	type T struct{ A; B }
    55  
    56  	var t T
    57  	_ = t.State /* ERROR "ambiguous selector t.State" */
    58  }
    59  
    60  // Embedded fields can be predeclared types.
    61  
    62  func _() {
    63  	type T0 struct{
    64  		int
    65  		float32
    66  		f int
    67  	}
    68  	var x T0
    69  	_ = x.int
    70  	_ = x.float32
    71  	_ = x.f
    72  
    73  	type T1 struct{
    74  		T0
    75  	}
    76  	var y T1
    77  	_ = y.int
    78  	_ = y.float32
    79  	_ = y.f
    80  }
    81  
    82  // Restrictions on embedded field types.
    83  
    84  func _() {
    85  	type I1 interface{}
    86  	type I2 interface{}
    87  	type P1 *int
    88  	type P2 *int
    89  	type UP unsafe.Pointer
    90  
    91  	type T1 struct {
    92  		I1
    93  		* /* ERROR "cannot be a pointer to an interface" */ I2
    94  		* /* ERROR "cannot be a pointer to an interface" */ error
    95  		P1 /* ERROR "cannot be a pointer" */
    96  		* /* ERROR "cannot be a pointer" */ P2
    97  	}
    98  
    99  	// unsafe.Pointers are treated like regular pointers when embedded
   100  	type T2 struct {
   101  		unsafe /* ERROR "cannot be unsafe.Pointer" */ .Pointer
   102  		*/* ERROR "cannot be unsafe.Pointer" */ unsafe.Pointer /* ERROR "Pointer redeclared" */
   103  		UP /* ERROR "cannot be unsafe.Pointer" */
   104  		* /* ERROR "cannot be unsafe.Pointer" */ UP /* ERROR "UP redeclared" */
   105  	}
   106  }
   107  
   108  // Named types that are pointers.
   109  
   110  type S struct{ x int }
   111  func (*S) m() {}
   112  type P *S
   113  
   114  func _() {
   115  	var s *S
   116  	_ = s.x
   117  	_ = s.m
   118  
   119  	var p P
   120  	_ = p.x
   121  	_ = p.m /* ERROR "no field or method" */
   122  	_ = P.m /* ERROR "no field or method" */
   123  }
   124  
   125  // Borrowed from the FieldByName test cases in reflect/all_test.go.
   126  
   127  type D1 struct {
   128  	d int
   129  }
   130  type D2 struct {
   131  	d int
   132  }
   133  
   134  type S0 struct {
   135  	A, B, C int
   136  	D1
   137  	D2
   138  }
   139  
   140  type S1 struct {
   141  	B int
   142  	S0
   143  }
   144  
   145  type S2 struct {
   146  	A int
   147  	*S1
   148  }
   149  
   150  type S1x struct {
   151  	S1
   152  }
   153  
   154  type S1y struct {
   155  	S1
   156  }
   157  
   158  type S3 struct {
   159  	S1x
   160  	S2
   161  	D, E int
   162  	*S1y
   163  }
   164  
   165  type S4 struct {
   166  	*S4
   167  	A int
   168  }
   169  
   170  // The X in S6 and S7 annihilate, but they also block the X in S8.S9.
   171  type S5 struct {
   172  	S6
   173  	S7
   174  	S8
   175  }
   176  
   177  type S6 struct {
   178  	X int
   179  }
   180  
   181  type S7 S6
   182  
   183  type S8 struct {
   184  	S9
   185  }
   186  
   187  type S9 struct {
   188  	X int
   189  	Y int
   190  }
   191  
   192  // The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.
   193  type S10 struct {
   194  	S11
   195  	S12
   196  	S13
   197  }
   198  
   199  type S11 struct {
   200  	S6
   201  }
   202  
   203  type S12 struct {
   204  	S6
   205  }
   206  
   207  type S13 struct {
   208  	S8
   209  }
   210  
   211  func _() {
   212  	_ = struct{}{}.Foo /* ERROR "no field or method" */
   213  	_ = S0{}.A
   214  	_ = S0{}.D /* ERROR "no field or method" */
   215  	_ = S1{}.A
   216  	_ = S1{}.B
   217  	_ = S1{}.S0
   218  	_ = S1{}.C
   219  	_ = S2{}.A
   220  	_ = S2{}.S1
   221  	_ = S2{}.B
   222  	_ = S2{}.C
   223  	_ = S2{}.D /* ERROR "no field or method" */
   224  	_ = S3{}.S1 /* ERROR "ambiguous selector S3{}.S1" */
   225  	_ = S3{}.A
   226  	_ = S3{}.B /* ERROR "ambiguous selector S3{}.B" */
   227  	_ = S3{}.D
   228  	_ = S3{}.E
   229  	_ = S4{}.A
   230  	_ = S4{}.B /* ERROR "no field or method" */
   231  	_ = S5{}.X /* ERROR "ambiguous selector S5{}.X" */
   232  	_ = S5{}.Y
   233  	_ = S10{}.X /* ERROR "ambiguous selector S10{}.X" */
   234  	_ = S10{}.Y
   235  }
   236  
   237  // Borrowed from the FieldByName benchmark in reflect/all_test.go.
   238  
   239  type R0 struct {
   240  	*R1
   241  	*R2
   242  	*R3
   243  	*R4
   244  }
   245  
   246  type R1 struct {
   247  	*R5
   248  	*R6
   249  	*R7
   250  	*R8
   251  }
   252  
   253  type R2 R1
   254  type R3 R1
   255  type R4 R1
   256  
   257  type R5 struct {
   258  	*R9
   259  	*R10
   260  	*R11
   261  	*R12
   262  }
   263  
   264  type R6 R5
   265  type R7 R5
   266  type R8 R5
   267  
   268  type R9 struct {
   269  	*R13
   270  	*R14
   271  	*R15
   272  	*R16
   273  }
   274  
   275  type R10 R9
   276  type R11 R9
   277  type R12 R9
   278  
   279  type R13 struct {
   280  	*R17
   281  	*R18
   282  	*R19
   283  	*R20
   284  }
   285  
   286  type R14 R13
   287  type R15 R13
   288  type R16 R13
   289  
   290  type R17 struct {
   291  	*R21
   292  	*R22
   293  	*R23
   294  	*R24
   295  }
   296  
   297  type R18 R17
   298  type R19 R17
   299  type R20 R17
   300  
   301  type R21 struct {
   302  	X int
   303  }
   304  
   305  type R22 R21
   306  type R23 R21
   307  type R24 R21
   308  
   309  var _ = R0{}.X /* ERROR "ambiguous selector R0{}.X" */
View as plain text