package main

const s string = "foo";

func main() {
	i := len(s);  // should be legal to take len() of a constant
	_ = i;
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug087.go
bug087.go:6: illegal combination of literals LEN 9
bug087.go:6: illegal combination of literals LEN 9

// license that can be found in the LICENSE file.

package bug109

func f(a float64) float64 {
	e := 1.0
	e = e * a
	return e
}

/*
6g bugs/bug109.go
bugs/bug109.go:5: illegal types for operand: MUL
	(<float64>FLOAT64)
	(<float32>FLOAT32)
bugs/bug109.go:5: illegal types for operand: AS
	(<float64>FLOAT64)
bugs/bug109.go:6: illegal types for operand: RETURN
	(<float32>FLOAT32)
	(<float64>FLOAT64)

package main

func main() {
	x := 0
	x = ^x // unary ^ not yet implemented
	if x != ^0 {
		println(x, " ", ^0)
		panic("fail")
	}
}

/*
uetli:~/Source/go/test/bugs gri$ 6g bug082.go
bug082.go:7: fatal error: optoas: no entry COM-<int32>INT32

func main() {
	if true {
	} else {
	L1:
		goto L1
	}
	if true {
	} else {
		goto L2
	L2:
		main()
	}
}

/*
These should be legal according to the spec.
bug140.go:6: syntax error near L1
bug140.go:7: syntax error near L2

// license that can be found in the LICENSE file.

package P

var x int

func foo() {
	print(P.x);  // ERROR "undefined"
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug085.go
bug085.go:6: P: undefined
Bus error
*/

/* expected scope hierarchy (outermost to innermost)

universe scope (contains predeclared identifiers int, float32, int32, len, etc.)

	}
	switch tag := 0; tag {
		// empty switch is allowed according to syntax
		// unclear why it shouldn't be allowed
	}
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug127.go 
bug127.go:5: switch statement must have case labels
bug127.go:9: switch statement must have case labels

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package bug151

type S string

type Empty interface {}

func (v S) Less(e Empty) bool {
	return v < e.(S);
}

/*
bugs/bug151.go:10: illegal types for operand: CALL
	string
	S

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package bug150

type T int
func (t T) M()

type M interface { M() } 

func g() (T, T)

func f() (a, b M) {
	a, b = g();
	return;
}

/*
bugs/bug150.go:13: reorder2: too many function calls evaluating parameters

// Copyright 2009 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.

package main

const x x = 2 // ERROR "loop|type|cycle"

/*
bug081.go:3: first constant must evaluate an expression
Bus error

package main

func f1() (x int, y float64) {
	return
}

func f2(x int, y float64) {
	return
}

func main() {
	f2(f1()) // this should be a legal call
}

/*
bug080.go:12: illegal types for operand: CALL
	(<int32>INT32)
	({<x><int32>INT32;<y><float32>FLOAT32;})