package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"os/exec"
	"path/filepath"
)

func main() {
	err := os.Chdir(filepath.Join(".", "fixedbugs", "bug369.dir"))
	check(err)

	tmpDir, err := ioutil.TempDir("", "bug369")
	check(err)
	defer os.RemoveAll(tmpDir)

	tmp := func(name string) string {
		return filepath.Join(tmpDir, name)
	}

	check(os.Mkdir(tmp("test"), 0777))

func main() {
	gen = 'a'

	if v1 != "aAbB" {
		panic("BUG: bug236a")
	}
	if v2 != "cCdD" {
		panic("BUG: bug236b")
	}
	if v3 != "eEfFgGhHiI" {
		panic("BUG: bug236c")
	}

	switch "aAbB" {
	case f(1) + f(2):
	default:
		panic("BUG: bug236d")
	}

	switch "cCdD" {
	case g(f(3), f(4)):
	default:
		panic("BUG: bug236e")
	}

	switch "eEfFgGhHiI" {
	case f(5) + f(6) + f(7) + f(8) + f(9):

// compile

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

// issue 1016

package bug309

func foo(t interface{}, c chan int) {
	switch v := t.(type) {
	case int:
		select {
		case <-c:
			// bug was: internal compiler error: var without type, init: v
		}
	default:
		_ = v
	}

// 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)

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

package main

type A []int;

func main() {
	a := &A{0};
	b := &A{0, 1};
	_, _ = a, b;
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug096.go && 6l bug096.6 && 6.out
Trace/BPT trap
uetli:~/Source/go1/test/bugs gri$
*/

/*
It appears that the first assignment changes the size of A from open
into a fixed array.

package main

const c = '\'';  // this works
const s = "\'";  // ERROR "invalid|escape"

/*
There is no reason why the escapes need to be different inside strings and chars.

uetli:~/go/test/bugs gri$ 6g bug068.go
bug068.go:6: unknown escape sequence: '

// compile

// 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 bug063

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

package main

type	I1	interface {}
type	I2	interface { pr() }

func	e()	I1;

var	i1	I1;
var	i2	I2;

func
main() {

	i2 = e().(I2);	// bug089.go:16: fatal error: agen_inter i2i

// compile

// 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 bug066

type Scope struct {
	entries map[string] *Object;
}


type Type struct {
	scope *Scope;
}


type Object struct {
	typ *Type;
}


func Lookup(scope *Scope) *Object {
	return scope.entries["foo"];

package main

func main() {
	var s string;
	s = "0000000000000000000000000000000000000000000000000000000000"[0:7];
	_ = s;
}

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