1 // Copyright 2013 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 package p
6
7 import "unsafe"
8
9 // Check that all methods of T are collected before
10 // determining the result type of m (which embeds
11 // all methods of T).
12
13 type T interface {
14 m() interface {T}
15 E
16 }
17
18 var _ int = T.m(nil).m().e()
19
20 type E interface {
21 e() int
22 }
23
24 // Check that unresolved forward chains are followed
25 // (see also comment in resolver.go, checker.typeDecl).
26
27 var _ int = C.m(nil).m().e()
28
29 type A B
30
31 type B interface {
32 m() interface{C}
33 E
34 }
35
36 type C A
37
38 // Check that interface type comparison for identity
39 // does not recur endlessly.
40
41 type T1 interface {
42 m() interface{T1}
43 }
44
45 type T2 interface {
46 m() interface{T2}
47 }
48
49 func _(x T1, y T2) {
50 // Checking for assignability of interfaces must check
51 // if all methods of x are present in y, and that they
52 // have identical signatures. The signatures recur via
53 // the result type, which is an interface that embeds
54 // a single method m that refers to the very interface
55 // that contains it. This requires cycle detection in
56 // identity checks for interface types.
57 x = y
58 }
59
60 type T3 interface {
61 m() interface{T4}
62 }
63
64 type T4 interface {
65 m() interface{T3}
66 }
67
68 func _(x T1, y T3) {
69 x = y
70 }
71
72 // Check that interfaces are type-checked in order of
73 // (embedded interface) dependencies (was issue 7158).
74
75 var x1 T5 = T7(nil)
76
77 type T5 interface {
78 T6
79 }
80
81 type T6 interface {
82 m() T7
83 }
84 type T7 interface {
85 T5
86 }
87
88 // Actual test case from issue 7158.
89
90 func wrapNode() Node {
91 return wrapElement()
92 }
93
94 func wrapElement() Element {
95 return nil
96 }
97
98 type EventTarget interface {
99 AddEventListener(Event)
100 }
101
102 type Node interface {
103 EventTarget
104 }
105
106 type Element interface {
107 Node
108 }
109
110 type Event interface {
111 Target() Element
112 }
113
114 // Check that accessing an interface method too early doesn't lead
115 // to follow-on errors due to an incorrectly computed type set.
116
117 type T8 interface {
118 m() [unsafe.Sizeof(T8.m /* ERROR undefined */ )]int
119 }
120
121 var _ = T8.m // no error expected here
122
View as plain text