| // Copyright 2011 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. |
| |
| // type declarations |
| |
| package decls0 |
| |
| import ( |
| "unsafe" |
| // we can have multiple blank imports (was bug) |
| _ "math" |
| _ "net/rpc" |
| // reflect defines a type "flag" which shows up in the gc export data |
| "reflect" |
| . "reflect" |
| ) |
| |
| // reflect.flag must not be visible in this package |
| type flag int |
| type _ reflect /* ERROR "not exported" */ .flag |
| |
| // dot-imported exported objects may conflict with local objects |
| type Value /* ERROR "redeclared in this block by dot-import" */ struct{} |
| |
| const pi = 3.1415 |
| |
| type ( |
| N undeclared /* ERROR "undeclared" */ |
| B bool |
| I int32 |
| A [10]P |
| T struct { |
| x, y P |
| } |
| P *T |
| R (*R) |
| F func(A) I |
| Y interface { |
| f(A) I |
| } |
| S [](((P))) |
| M map[I]F |
| C chan<- I |
| |
| // blank types must be typechecked |
| _ pi /* ERROR "not a type" */ |
| _ struct{} |
| _ struct{ pi /* ERROR "not a type" */ } |
| ) |
| |
| |
| // invalid array types |
| type ( |
| iA0 [... /* ERROR "invalid use of '...'" */ ]byte |
| iA1 [1 /* ERROR "invalid array length" */ <<100]int |
| iA2 [- /* ERROR "invalid array length" */ 1]complex128 |
| iA3 ["foo" /* ERROR "must be integer" */ ]string |
| ) |
| |
| |
| type ( |
| p1 pi /* ERROR "no single field or method foo" */ .foo |
| p2 unsafe.Pointer |
| ) |
| |
| |
| type ( |
| Pi pi /* ERROR "not a type" */ |
| |
| a /* ERROR "illegal cycle" */ a |
| a /* ERROR "redeclared" */ int |
| |
| // where the cycle error appears depends on the |
| // order in which declarations are processed |
| // (which depends on the order in which a map |
| // is iterated through) |
| b /* ERROR "illegal cycle" */ c |
| c d |
| d e |
| e b |
| |
| t *t |
| |
| U V |
| V *W |
| W U |
| |
| P1 *S2 |
| P2 P1 |
| |
| S0 struct { |
| } |
| S1 struct { |
| a, b, c int |
| u, v, a /* ERROR "redeclared" */ float32 |
| } |
| S2 struct { |
| U // anonymous field |
| // TODO(gri) recognize double-declaration below |
| // U /* ERROR "redeclared" */ int |
| } |
| S3 struct { |
| x S2 |
| } |
| S4/* ERROR "illegal cycle" */ struct { |
| S4 |
| } |
| S5 /* ERROR "illegal cycle" */ struct { |
| S6 |
| } |
| S6 struct { |
| field S7 |
| } |
| S7 struct { |
| S5 |
| } |
| |
| L1 []L1 |
| L2 []int |
| |
| A1 [10.0]int |
| A2 /* ERROR "illegal cycle" */ [10]A2 |
| A3 /* ERROR "illegal cycle" */ [10]struct { |
| x A4 |
| } |
| A4 [10]A3 |
| |
| F1 func() |
| F2 func(x, y, z float32) |
| F3 func(x, y, x /* ERROR "redeclared" */ float32) |
| F4 func() (x, y, x /* ERROR "redeclared" */ float32) |
| F5 func(x int) (x /* ERROR "redeclared" */ float32) |
| F6 func(x ...int) |
| |
| I1 interface{} |
| I2 interface { |
| m1() |
| } |
| I3 interface { /* ERROR "multiple methods named m1" */ |
| m1() |
| m1 /* ERROR "redeclared" */ () |
| } |
| I4 interface { |
| m1(x, y, x /* ERROR "redeclared" */ float32) |
| m2() (x, y, x /* ERROR "redeclared" */ float32) |
| m3(x int) (x /* ERROR "redeclared" */ float32) |
| } |
| I5 interface { |
| m1(I5) |
| } |
| I6 interface { |
| S0 /* ERROR "not an interface" */ |
| } |
| I7 interface { |
| I1 |
| I1 |
| } |
| I8 /* ERROR "illegal cycle" */ interface { |
| I8 |
| } |
| // Use I09 (rather than I9) because it appears lexically before |
| // I10 so that we get the illegal cycle here rather then in the |
| // declaration of I10. If the implementation sorts by position |
| // rather than name, the error message will still be here. |
| I09 /* ERROR "illegal cycle" */ interface { |
| I10 |
| } |
| I10 interface { |
| I11 |
| } |
| I11 interface { |
| I09 |
| } |
| |
| C1 chan int |
| C2 <-chan int |
| C3 chan<- C3 |
| C4 chan C5 |
| C5 chan C6 |
| C6 chan C4 |
| |
| M1 map[Last]string |
| M2 map[string]M2 |
| |
| Last int |
| ) |