initorder.go

Documentation: golang.org/x/tools/go/ssa/interp/testdata

     1  package main
     2  
     3  import "fmt"
     4  
     5  // Test of initialization order of package-level vars.
     6  
     7  var counter int
     8  
     9  func next() int {
    10  	c := counter
    11  	counter++
    12  	return c
    13  }
    14  
    15  func next2() (x int, y int) {
    16  	x = next()
    17  	y = next()
    18  	return
    19  }
    20  
    21  func makeOrder() int {
    22  	_, _, _, _ = f, b, d, e
    23  	return 0
    24  }
    25  
    26  func main() {
    27  	// Initialization constraints:
    28  	// - {f,b,c/d,e} < order  (ref graph traversal)
    29  	// - order < {a}          (lexical order)
    30  	// - b < c/d < e < f      (lexical order)
    31  	// Solution: a b c/d e f
    32  	abcdef := [6]int{a, b, c, d, e, f}
    33  	if abcdef != [6]int{0, 1, 2, 3, 4, 5} {
    34  		panic(abcdef)
    35  	}
    36  
    37  	// Initializers of even blank globals are evaluated.
    38  	if g != 1 {
    39  		panic(g)
    40  	}
    41  }
    42  
    43  var order = makeOrder()
    44  
    45  var a, b = next(), next()
    46  var c, d = next2()
    47  var e, f = next(), next()
    48  
    49  var (
    50  	g int
    51  	_ = func() int { g = 1; return 0 }()
    52  )
    53  
    54  // ------------------------------------------------------------------------
    55  
    56  var order2 []string
    57  
    58  func create(x int, name string) int {
    59  	order2 = append(order2, name)
    60  	return x
    61  }
    62  
    63  var C = create(B+1, "C")
    64  var A, B = create(1, "A"), create(2, "B")
    65  
    66  // Initialization order of package-level value specs.
    67  func init() {
    68  	x := fmt.Sprint(order2)
    69  	// Result varies by toolchain.  This is a spec bug.
    70  	if x != "[B C A]" && // gc
    71  		x != "[A B C]" { // go/types
    72  		panic(x)
    73  	}
    74  	if C != 3 {
    75  		panic(c)
    76  	}
    77  }
    78
View as plain text