go/types: Remove unused testdata files.

The go/types package was removed in July 2013, but the
testdata files were accidentally left behind.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@220378 138bc75d-0d04-0410-961f-82ee72b054a4

13 files changed, 0 insertions, 1992 deletions

diff --git a/libgo/go/go/types/testdata/builtins.src b/libgo/go/go/types/testdata/builtins.src
deleted file mode 100644
index 6c848fc2776..00000000000
--- a/libgo/go/go/types/testdata/builtins.src
+++ /dev/null
@@ -1,302 +0,0 @@
-// Copyright 2012 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.
-
-// builtin calls
-
-package builtins
-
-import "unsafe"
-
-func _append() {
-	var x int
-	var s []byte
-	_0 := append /* ERROR "argument" */ ()
-	_1 := append("foo" /* ERROR "not a typed slice" */)
-	_2 := append(nil /* ERROR "not a typed slice" */, s)
-	_3 := append(x /* ERROR "not a typed slice" */, s)
-	_4 := append(s)
-	append /* ERROR "not used" */ (s)
-}
-
-func _cap() {
-	var a [10]bool
-	var p *[20]int
-	var s []int
-	var c chan string
-	_0 := cap /* ERROR "argument" */ ()
-	_1 := cap /* ERROR "argument" */ (1, 2)
-	_2 := cap(42 /* ERROR "invalid" */)
-	const _3 = cap(a)
-	assert(_3 == 10)
-	const _4 = cap(p)
-	assert(_4 == 20)
-	_5 := cap(c)
-	cap /* ERROR "not used" */ (c)
-}
-
-func _close() {
-	var c chan int
-	var r <-chan int
-	close /* ERROR "argument" */ ()
-	close /* ERROR "argument" */ (1, 2)
-	close(42 /* ERROR "not a channel" */)
-	close(r /* ERROR "receive-only channel" */)
-	close(c)
-}
-
-func _complex() {
-	var i32 int32
-	var f32 float32
-	var f64 float64
-	var c64 complex64
-	_ = complex /* ERROR "argument" */ ()
-	_ = complex /* ERROR "argument" */ (1)
-	_ = complex(true /* ERROR "invalid argument" */ , 0)
-	_ = complex(i32 /* ERROR "invalid argument" */ , 0)
-	_ = complex("foo" /* ERROR "invalid argument" */ , 0)
-	_ = complex(c64 /* ERROR "invalid argument" */ , 0)
-	_ = complex(0, true /* ERROR "invalid argument" */ )
-	_ = complex(0, i32 /* ERROR "invalid argument" */ )
-	_ = complex(0, "foo" /* ERROR "invalid argument" */ )
-	_ = complex(0, c64 /* ERROR "invalid argument" */ )
-	_ = complex(f32, f32)
-	_ = complex(f32, 1)
-	_ = complex(f32, 1.0)
-	_ = complex(f32, 'a')
-	_ = complex(f64, f64)
-	_ = complex(f64, 1)
-	_ = complex(f64, 1.0)
-	_ = complex(f64, 'a')
-	_ = complex(f32 /* ERROR "mismatched types" */, f64)
-	_ = complex(f64 /* ERROR "mismatched types" */, f32)
-	_ = complex(1, 1)
-	_ = complex(1, 1.1)
-	_ = complex(1, 'a')
-	complex /* ERROR "not used" */ (1, 2)
-}
-
-func _copy() {
-	copy /* ERROR "not enough arguments" */ ()
-	copy /* ERROR "not enough arguments" */ ("foo")
-	copy([ /* ERROR "copy expects slice arguments" */ ...]int{}, []int{})
-	copy([ /* ERROR "copy expects slice arguments" */ ]int{}, [...]int{})
-	copy([ /* ERROR "different element types" */ ]int8{}, "foo")
-
-	// spec examples
-	var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
-	var s = make([]int, 6)
-	var b = make([]byte, 5)
-	n1 := copy(s, a[0:])            // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
-	n2 := copy(s, s[2:])            // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
-	n3 := copy(b, "Hello, World!")  // n3 == 5, b == []byte("Hello")
-}
-
-func _delete() {
-	var m map[string]int
-	var s string
-	delete /* ERROR "argument" */ ()
-	delete /* ERROR "argument" */ (1)
-	delete /* ERROR "argument" */ (1, 2, 3)
-	delete(m, 0 /* ERROR "not assignable" */)
-	delete(m, s)
-}
-
-func _imag() {
-	var f32 float32
-	var f64 float64
-	var c64 complex64
-	var c128 complex128
-	_ = imag /* ERROR "argument" */ ()
-	_ = imag /* ERROR "argument" */ (1, 2)
-	_ = imag(10 /* ERROR "must be a complex number" */)
-	_ = imag(2.7182818 /* ERROR "must be a complex number" */)
-	_ = imag("foo" /* ERROR "must be a complex number" */)
-	const _5 = imag(1 + 2i)
-	assert(_5 == 2)
-	f32 = _5
-	f64 = _5
-	const _6 = imag(0i)
-	assert(_6 == 0)
-	f32 = imag(c64)
-	f64 = imag(c128)
-	f32 = imag /* ERROR "cannot assign" */ (c128)
-	f64 = imag /* ERROR "cannot assign" */ (c64)
-	imag /* ERROR "not used" */ (c64)
-}
-
-func _len() {
-	const c = "foobar"
-	var a [10]bool
-	var p *[20]int
-	var s []int
-	var m map[string]complex128
-	_ = len /* ERROR "argument" */ ()
-	_ = len /* ERROR "argument" */ (1, 2)
-	_ = len(42 /* ERROR "invalid" */)
-	const _3 = len(c)
-	assert(_3 == 6)
-	const _4 = len(a)
-	assert(_4 == 10)
-	const _5 = len(p)
-	assert(_5 == 20)
-	_ = len(m)
-	len /* ERROR "not used" */ (c)
-
-	// esoteric case
-	var t string
-	var hash map[interface{}][]*[10]int
-	const n = len /* ERROR "not constant" */ (hash[recover()][len(t)])
-	assert /* ERROR "failed" */ (n == 10)
-	var ch <-chan int
-	const nn = len /* ERROR "not constant" */ (hash[<-ch][len(t)])
-	_ = nn // TODO(gri) remove this once unused constants get type-checked
-}
-
-func _make() {
-	n := 0
-
-	_ = make /* ERROR "argument" */ ()
-	_ = make(1 /* ERROR "not a type" */)
-	_ = make(int /* ERROR "cannot make" */)
-
-	// slices
-	_ = make/* ERROR "arguments" */ ([]int)
-	_ = make/* ERROR "arguments" */ ([]int, 2, 3, 4)
-	_ = make([]int, int /* ERROR "not an expression" */)
-	_ = make([]int, 10, float32 /* ERROR "not an expression" */)
-	_ = make([]int, "foo" /* ERROR "must be an integer" */)
-	_ = make([]int, 10, 2.3 /* ERROR "must be an integer" */)
-	_ = make([]int, 5, 10.0)
-	_ = make([]int, 0i)
-	_ = make([]int, - /* ERROR "must not be negative" */ 1, 10)
-	_ = make([]int, 0, - /* ERROR "must not be negative" */ 1)
-	_ = make([]int, - /* ERROR "must not be negative" */ 1, - /* ERROR "must not be negative" */ 1)
-	_ = make([]int, 1<<100, 1<<100)  // run-time panic
-	_ = make([]int, 1 /* ERROR "length and capacity swapped" */ <<100 + 1, 1<<100)
-	_ = make([]int, 1 /* ERROR "length and capacity swapped" */ <<100, 12345)
-
-	// maps
-	_ = make /* ERROR "arguments" */ (map[int]string, 10, 20)
-	_ = make(map[int]float32, int /* ERROR "not an expression" */)
-	_ = make(map[int]float32, "foo" /* ERROR "must be an integer" */)
-	_ = make(map[int]float32, 10)
-	_ = make(map[int]float32, n)
-	_ = make(map[int]float32, int64(n))
-
-	// channels
-	_ = make /* ERROR "arguments" */ (chan int, 10, 20)
-	_ = make(chan int, int /* ERROR "not an expression" */)
-	_ = make(chan<- int, "foo" /* ERROR "must be an integer" */)
-	_ = make(<-chan float64, 10)
-	_ = make(chan chan int, n)
-	_ = make(chan string, int64(n))
-
-	make /* ERROR "not used" */ ([]int, 10)
-}
-
-func _new() {
-	_ = new /* ERROR "argument" */ ()
-	_ = new /* ERROR "argument" */ (1, 2)
-	_ = new("foo" /* ERROR "not a type" */)
-	p := new(float64)
-	_ = new(struct{ x, y int })
-	q := new(*float64)
-	_ = *p == **q
-	new /* ERROR "not used" */ (int)
-}
-
-func _real() {
-	var f32 float32
-	var f64 float64
-	var c64 complex64
-	var c128 complex128
-	_ = real /* ERROR "argument" */ ()
-	_ = real /* ERROR "argument" */ (1, 2)
-	_ = real(10 /* ERROR "must be a complex number" */)
-	_ = real(2.7182818 /* ERROR "must be a complex number" */)
-	_ = real("foo" /* ERROR "must be a complex number" */)
-	const _5 = real(1 + 2i)
-	assert(_5 == 1)
-	f32 = _5
-	f64 = _5
-	const _6 = real(0i)
-	assert(_6 == 0)
-	f32 = real(c64)
-	f64 = real(c128)
-	f32 = real /* ERROR "cannot assign" */ (c128)
-	f64 = real /* ERROR "cannot assign" */ (c64)
-	real /* ERROR "not used" */ (c64)
-}
-
-func _recover() {
-	_ = recover()
-	_ = recover /* ERROR "argument" */ (10)
-	recover()
-}
-
-func _Alignof() {
-	var x int
-	_ = unsafe /* ERROR "argument" */ .Alignof()
-	_ = unsafe /* ERROR "argument" */ .Alignof(1, 2)
-	_ = unsafe.Alignof(int /* ERROR "not an expression" */)
-	_ = unsafe.Alignof(42)
-	_ = unsafe.Alignof(new(struct{}))
-	unsafe /* ERROR "not used" */ .Alignof(x)
-}
-
-func _Offsetof() {
-	var x struct{ f int }
-	_ = unsafe /* ERROR "argument" */ .Offsetof()
-	_ = unsafe /* ERROR "argument" */ .Offsetof(1, 2)
-	_ = unsafe.Offsetof(int /* ERROR "not an expression" */)
-	_ = unsafe.Offsetof(x /* ERROR "not a selector" */)
-	_ = unsafe.Offsetof(x.f)
-	_ = unsafe.Offsetof((x.f))
-	_ = unsafe.Offsetof((((((((x))).f)))))
-	unsafe /* ERROR "not used" */ .Offsetof(x.f)
-}
-
-func _Sizeof() {
-	var x int
-	_ = unsafe /* ERROR "argument" */ .Sizeof()
-	_ = unsafe /* ERROR "argument" */ .Sizeof(1, 2)
-	_ = unsafe.Sizeof(int /* ERROR "not an expression" */)
-	_ = unsafe.Sizeof(42)
-	_ = unsafe.Sizeof(new(complex128))
-	unsafe /* ERROR "not used" */ .Sizeof(x)
-
-	// basic types have size guarantees
-	assert(unsafe.Sizeof(byte(0)) == 1)
-	assert(unsafe.Sizeof(uint8(0)) == 1)
-	assert(unsafe.Sizeof(int8(0)) == 1)
-	assert(unsafe.Sizeof(uint16(0)) == 2)
-	assert(unsafe.Sizeof(int16(0)) == 2)
-	assert(unsafe.Sizeof(uint32(0)) == 4)
-	assert(unsafe.Sizeof(int32(0)) == 4)
-	assert(unsafe.Sizeof(float32(0)) == 4)
-	assert(unsafe.Sizeof(uint64(0)) == 8)
-	assert(unsafe.Sizeof(int64(0)) == 8)
-	assert(unsafe.Sizeof(float64(0)) == 8)
-	assert(unsafe.Sizeof(complex64(0)) == 8)
-	assert(unsafe.Sizeof(complex128(0)) == 16)
-}
-
-// self-testing only
-func _assert() {
-	var x int
-	assert /* ERROR "argument" */ ()
-	assert /* ERROR "argument" */ (1, 2)
-	assert("foo" /* ERROR "boolean constant" */ )
-	assert(x /* ERROR "boolean constant" */)
-	assert(true)
-	assert /* ERROR "failed" */ (false) 
-}
-
-// self-testing only
-func _trace() {
-	// Uncomment the code below to test trace - will produce console output
-	// _ = trace /* ERROR "no value" */ ()
-	// _ = trace(1)
-	// _ = trace(true, 1.2, '\'', "foo", 42i, "foo" <= "bar")
-}
diff --git a/libgo/go/go/types/testdata/const0.src b/libgo/go/go/types/testdata/const0.src
deleted file mode 100644
index a2ca344c788..00000000000
--- a/libgo/go/go/types/testdata/const0.src
+++ /dev/null
@@ -1,215 +0,0 @@
-// Copyright 2012 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.
-
-// constant declarations
-
-package const0
-
-// constants declarations must be initialized by constants
-var x = 0
-const c0 = x /* ERROR "not constant" */
-
-// untyped constants
-const (
-	// boolean values
-	ub0 = false
-	ub1 = true
-	ub2 = 2 < 1
-	ub3 = ui1 == uf1
-	ub4 = true /* ERROR "cannot convert" */ == 0
-
-	// integer values
-	ui0 = 0
-	ui1 = 1
-	ui2 = 42
-	ui3 = 3141592653589793238462643383279502884197169399375105820974944592307816406286
-	ui4 = -10
-
-	ui5 = ui0 + ui1
-	ui6 = ui1 - ui1
-	ui7 = ui2 * ui1
-	ui8 = ui3 / ui3
-	ui9 = ui3 % ui3
-
-	ui10 = 1 / 0 /* ERROR "division by zero" */
-	ui11 = ui1 / 0 /* ERROR "division by zero" */
-	ui12 = ui3 / ui0 /* ERROR "division by zero" */
-	ui13 = 1 % 0 /* ERROR "division by zero" */
-	ui14 = ui1 % 0 /* ERROR "division by zero" */
-	ui15 = ui3 % ui0 /* ERROR "division by zero" */
-
-	ui16 = ui2 & ui3
-	ui17 = ui2 | ui3
-	ui18 = ui2 ^ ui3
-
-	// floating point values
-	uf0 = 0.
-	uf1 = 1.
-	uf2 = 4.2e1
-	uf3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286
-	uf4 = 1e-1
-
-	uf5 = uf0 + uf1
-	uf6 = uf1 - uf1
-	uf7 = uf2 * uf1
-	uf8 = uf3 / uf3
-	uf9 = uf3 /* ERROR "not defined" */ % uf3
-
-	uf10 = 1 / 0 /* ERROR "division by zero" */
-	uf11 = uf1 / 0 /* ERROR "division by zero" */
-	uf12 = uf3 / uf0 /* ERROR "division by zero" */
-
-	uf16 = uf2 /* ERROR "not defined" */ & uf3
-	uf17 = uf2 /* ERROR "not defined" */ | uf3
-	uf18 = uf2 /* ERROR "not defined" */ ^ uf3
-
-	// complex values
-	uc0 = 0.i
-	uc1 = 1.i
-	uc2 = 4.2e1i
-	uc3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286i
-	uc4 = 1e-1i
-
-	uc5 = uc0 + uc1
-	uc6 = uc1 - uc1
-	uc7 = uc2 * uc1
-	uc8 = uc3 / uc3
-	uc9 = uc3 /* ERROR "not defined" */ % uc3
-
-	uc10 = 1 / 0 /* ERROR "division by zero" */
-	uc11 = uc1 / 0 /* ERROR "division by zero" */
-	uc12 = uc3 / uc0 /* ERROR "division by zero" */
-
-	uc16 = uc2 /* ERROR "not defined" */ & uc3
-	uc17 = uc2 /* ERROR "not defined" */ | uc3
-	uc18 = uc2 /* ERROR "not defined" */ ^ uc3
-)
-
-type (
-	mybool bool
-	myint int
-	myfloat float64
-	mycomplex complex128
-)
-
-// typed constants
-const (
-	// boolean values
-	tb0 bool = false
-	tb1 bool = true
-	tb2 mybool = 2 < 1
-	tb3 mybool = ti1 /* ERROR "cannot compare" */ == tf1
-
-	// integer values
-	ti0 int8 = ui0
-	ti1 int32 = ui1
-	ti2 int64 = ui2
-	ti3 myint = ui3 /* ERROR "overflows" */
-	ti4 myint = ui4
-
-	ti5 = ti0 /* ERROR "mismatched types" */ + ti1
-	ti6 = ti1 - ti1
-	ti7 = ti2 /* ERROR "mismatched types" */ * ti1
-	//ti8 = ti3 / ti3 // TODO(gri) enable this
-	//ti9 = ti3 % ti3 // TODO(gri) enable this
-
-	ti10 = 1 / 0 /* ERROR "division by zero" */
-	ti11 = ti1 / 0 /* ERROR "division by zero" */
-	ti12 = ti3 /* ERROR "mismatched types" */ / ti0
-	ti13 = 1 % 0 /* ERROR "division by zero" */
-	ti14 = ti1 % 0 /* ERROR "division by zero" */
-	ti15 = ti3 /* ERROR "mismatched types" */ % ti0
-
-	ti16 = ti2 /* ERROR "mismatched types" */ & ti3
-	ti17 = ti2 /* ERROR "mismatched types" */ | ti4
-	ti18 = ti2 ^ ti5 // no mismatched types error because the type of ti5 is unknown
-
-	// floating point values
-	tf0 float32 = 0.
-	tf1 float32 = 1.
-	tf2 float64 = 4.2e1
-	tf3 myfloat = 3.141592653589793238462643383279502884197169399375105820974944592307816406286
-	tf4 myfloat = 1e-1
-
-	tf5 = tf0 + tf1
-	tf6 = tf1 - tf1
-	tf7 = tf2 /* ERROR "mismatched types" */ * tf1
-	// tf8 = tf3 / tf3 // TODO(gri) enable this
-	tf9 = tf3 /* ERROR "not defined" */ % tf3
-
-	tf10 = 1 / 0 /* ERROR "division by zero" */
-	tf11 = tf1 / 0 /* ERROR "division by zero" */
-	tf12 = tf3 /* ERROR "mismatched types" */ / tf0
-
-	tf16 = tf2 /* ERROR "mismatched types" */ & tf3
-	tf17 = tf2 /* ERROR "mismatched types" */ | tf3
-	tf18 = tf2 /* ERROR "mismatched types" */ ^ tf3
-
-	// complex values
-	tc0 = 0.i
-	tc1 = 1.i
-	tc2 = 4.2e1i
-	tc3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286i
-	tc4 = 1e-1i
-
-	tc5 = tc0 + tc1
-	tc6 = tc1 - tc1
-	tc7 = tc2 * tc1
-	tc8 = tc3 / tc3
-	tc9 = tc3 /* ERROR "not defined" */ % tc3
-
-	tc10 = 1 / 0 /* ERROR "division by zero" */
-	tc11 = tc1 / 0 /* ERROR "division by zero" */
-	tc12 = tc3 / tc0 /* ERROR "division by zero" */
-
-	tc16 = tc2 /* ERROR "not defined" */ & tc3
-	tc17 = tc2 /* ERROR "not defined" */ | tc3
-	tc18 = tc2 /* ERROR "not defined" */ ^ tc3
-)
-
-// initialization cycles
-const (
-	a /* ERROR "cycle" */ = a
-	b /* ERROR "cycle" */ , c /* ERROR "cycle" */, d, e = e, d, c, b // TODO(gri) should only have one cycle error
-	f float64 = d
-)
-
-// multiple initialization
-const (
-	a1, a2, a3 = 7, 3.1415926, "foo"
-	b1, b2, b3 = b3, b1, 42
-	_p0 = assert(a1 == 7)
-	_p1 = assert(a2 == 3.1415926)
-	_p2 = assert(a3 == "foo")
-	_p3 = assert(b1 == 42)
-	_p4 = assert(b2 == 42)
-	_p5 = assert(b3 == 42)
-)
-
-// iota
-const (
-	iota0 = iota
-	iota1 = iota
-	iota2 = iota*2
-	_a0 = assert(iota0 == 0)
-	_a1 = assert(iota1 == 1)
-	_a2 = assert(iota2 == 4)
-	iota6 = iota*3
-
-	iota7
-	iota8
-	_a3 = assert(iota7 == 21)
-	_a4 = assert(iota8 == 24)
-)
-
-const (
-	_b0 = iota
-	_b1 = assert(iota + iota2 == 5)
-)
-
-// special cases
-const (
-	_n0 = nil /* ERROR "invalid constant type" */
-	_n1 = [ /* ERROR "not constant" */ ]int{}
-)
\ No newline at end of file
diff --git a/libgo/go/go/types/testdata/conversions.src b/libgo/go/go/types/testdata/conversions.src
deleted file mode 100644
index 1b1518366f3..00000000000
--- a/libgo/go/go/types/testdata/conversions.src
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2012 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.
-
-// conversions
-
-package conversions
-
-// argument count
-var (
-	_v0 = int /* ERROR "one argument" */ ()
-	_v1 = int /* ERROR "one argument" */ (1, 2)
-)
-
-//
-var (
-	_v2 = int8(0)
-)
\ No newline at end of file
diff --git a/libgo/go/go/types/testdata/decls0.src b/libgo/go/go/types/testdata/decls0.src
deleted file mode 100644
index 33d4b380149..00000000000
--- a/libgo/go/go/types/testdata/decls0.src
+++ /dev/null
@@ -1,177 +0,0 @@
-// 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"
-)
-
-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 "invalid array length" */ ]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
-)
diff --git a/libgo/go/go/types/testdata/decls1.src b/libgo/go/go/types/testdata/decls1.src
deleted file mode 100644
index dd63ba98091..00000000000
--- a/libgo/go/go/types/testdata/decls1.src
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright 2012 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.
-
-// variable declarations
-
-package decls1
-
-import (
-	"math"
-)
-
-// Global variables without initialization
-var (
-	a, b bool
-	c byte
-	d uint8
-	r rune
-	i int
-	j, k, l int
-	x, y float32
-	xx, yy float64
-	u, v complex64
-	uu, vv complex128
-	s, t string
-	array []byte
-	iface interface{}
-	
-	blank _ /* ERROR "cannot use _" */
-)
-
-// Global variables with initialization
-var (
-	s1 = i + j
-	s2 = i /* ERROR "mismatched types" */ + x
-	s3 = c + d
-	s4 = s + t
-	s5 = s /* ERROR "invalid operation" */ / t
-	s6 = array[t1]
-	s7 = array[x /* ERROR "index" */]
-	s8 = &a
-	s10 = &42 /* ERROR "cannot take address" */
-	s11 = &v
-	s12 = -(u + *t11) / *&v
-	s13 = a /* ERROR "shifted operand" */ << d
-	s14 = i << j /* ERROR "must be unsigned" */ 
-	s18 = math.Pi * 10.0
-	s19 = s1 /* ERROR "cannot call" */ ()
- 	s20 = f0 /* ERROR "no value" */ ()
-	s21 = f6(1, s1, i)
-	s22 = f6(1, s1, uu /* ERROR "cannot assign" */ )
-	
-	t1 int = i + j
-	t2 int = i /* ERROR "mismatched types" */ + x
-	t3 int = c /* ERROR "cannot assign" */ + d
-	t4 string = s + t
-	t5 string = s /* ERROR "invalid operation" */ / t
-	t6 byte = array[t1]
-	t7 byte = array[x /* ERROR "index" */]
-	t8 *int = & /* ERROR "cannot assign" */ a
-	t10 *int = &42 /* ERROR "cannot take address" */
-	t11 *complex64 = &v
-	t12 complex64 = -(u + *t11) / *&v
-	t13 int = a /* ERROR "shifted operand" */ << d
-	t14 int = i << j /* ERROR "must be unsigned" */ 
-	t15 math /* ERROR "not in selector" */
-	t16 math.xxx /* ERROR "unexported" */
-	t17 math /* ERROR "not a type" */ .Pi
-	t18 float64 = math.Pi * 10.0
-	t19 int = t1 /* ERROR "cannot call" */ ()
-	t20 int = f0 /* ERROR "no value" */ ()
-)
-
-// Various more complex expressions
-var (
-	u1 = x /* ERROR "not an interface" */ .(int)
-	u2 = iface.([]int)
-	u3 = iface.(a /* ERROR "not a type" */ )
-	u4, ok = iface.(int)
-	u5 /* ERROR "assignment count mismatch" */ , ok2, ok3 = iface.(int)
-)
-
-// Constant expression initializations
-var (
-	v1 = 1 /* ERROR "cannot convert" */ + "foo"
-	v2 = c + 255
-	v3 = c + 256 /* ERROR "overflows" */
-	v4 = r + 2147483647
-	v5 = r + 2147483648 /* ERROR "overflows" */
-	v6 = 42
-	v7 = v6 + 2147483647
-	v8 = v6 + 2147483648 /* ERROR "overflows" */
-	v9 = i + 1 << 10
-	v10 byte = 1024 /* ERROR "overflows" */
-	v11 = xx/yy*yy - xx
-	v12 = true && false
-	v13 = nil /* ERROR "use of untyped nil" */
-)
-
-// Multiple assignment expressions
-var (
-	m1a, m1b = 1, 2
-	m2a /* ERROR "assignment count mismatch" */ , m2b, m2c = 1, 2
-	m3a /* ERROR "assignment count mismatch" */ , m3b = 1, 2, 3
-)
-
-// Declaration of parameters and results
-func f0() {}
-func f1(a /* ERROR "not a type" */) {}
-func f2(a, b, c d /* ERROR "not a type" */) {}
-
-func f3() int {}
-func f4() a /* ERROR "not a type" */ {}
-func f5() (a, b, c d /* ERROR "not a type" */) {}
-
-func f6(a, b, c int) complex128 { return 0 }
-
-// Declaration of receivers
-type T struct{}
-
-func (T) m0() {}
-func (*T) m1() {}
-func (x T) m2() {}
-func (x *T) m3() {}
-
-
-// Initialization functions
-func init() {}
-func /* ERROR "no arguments and no return values" */ init(int) {}
-func /* ERROR "no arguments and no return values" */ init() int { return 0 }
-func /* ERROR "no arguments and no return values" */ init(int) int {}
-func (T) init(int) int { return 0 }
diff --git a/libgo/go/go/types/testdata/decls2a.src b/libgo/go/go/types/testdata/decls2a.src
deleted file mode 100644
index 3867be73765..00000000000
--- a/libgo/go/go/types/testdata/decls2a.src
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2012 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.
-
-// method declarations
-
-package decls2
-
-import "time"
-
-// T1 declared before its methods.
-type T1 struct{
-	f int
-}
-
-func (T1) m() {}
-func (T1) m /* ERROR "redeclared" */ () {}
-func (x *T1) f /* ERROR "field and method" */ () {}
-
-// T2's method declared before the type.
-func (*T2) f /* ERROR "field and method" */ () {}
-
-type T2 struct {
-	f int
-}
-
-// Methods declared without a declared type.
-func (undeclared /* ERROR "undeclared" */) m() {}
-func (x *undeclared /* ERROR "undeclared" */) m() {}
-
-// TODO(gri) try to get rid of double error reporting here
-func (pi /* ERROR "not a type" */) m1() {}
-func (x pi /* ERROR "not a type" */) m2() {}
-func (x *pi /* ERROR "not a type" */ ) m3() {} // TODO(gri) not closing the last /* comment crashes the system
-
-// Blank types.
-type _ struct { m int }
-type _ struct { m int }
-
-// TODO(gri) blank idents not fully checked - disabled for now
-// func (_ /* ERROR "cannot use _" */) m() {}
-// func (_ /* ERROR "cannot use _" */) m() {}
-
-// Methods with receiver base type declared in another file.
-func (T3) m1() {}
-func (*T3) m2() {}
-func (x T3) m3() {}
-func (x *T3) f /* ERROR "field and method" */ () {}
-
-// Methods of non-struct type.
-type T4 func()
-
-func (self T4) m() func() { return self }
-
-// Methods associated with an interface.
-type T5 interface {
-	m() int
-}
-
-func (T5 /* ERROR "invalid receiver" */) m1() {}
-func (T5 /* ERROR "invalid receiver" */) m2() {}
-
-// Methods associated with non-local or unnamed types.
-func (int /* ERROR "non-local type" */ ) m() {}
-func ([ /* ERROR "expected" */ ]int) m() {}
-func (time /* ERROR "expected" */ .Time) m() {}
-func (x interface /* ERROR "expected" */ {}) m() {}
diff --git a/libgo/go/go/types/testdata/decls2b.src b/libgo/go/go/types/testdata/decls2b.src
deleted file mode 100644
index c7f9ddf01ad..00000000000
--- a/libgo/go/go/types/testdata/decls2b.src
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2012 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.
-
-// method declarations
-
-package decls2
-
-const pi = 3.1415
-
-func (T1) m /* ERROR "redeclared" */ () {}
-
-type T3 struct {
-	f *T3
-}
-
-type T6 struct {
-	x int
-}
-
-func (t *T6) m1() int {
-	return t.x
-}
-
-func f() {
-	var t *T6
-	t.m1()
-}
\ No newline at end of file
diff --git a/libgo/go/go/types/testdata/decls3.src b/libgo/go/go/types/testdata/decls3.src
deleted file mode 100644
index 4bc7d414941..00000000000
--- a/libgo/go/go/types/testdata/decls3.src
+++ /dev/null
@@ -1,231 +0,0 @@
-// Copyright 2012 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.
-
-// embedded types
-
-package decls3
-
-// fields with the same name at the same level cancel each other out
-
-func _() {
-	type (
-		T1 struct { X int }
-		T2 struct { X int }
-		T3 struct { T1; T2 } // X is embedded twice at the same level via T1->X, T2->X
-	)
-
-	var t T3
-	_ = t /* ERROR "no single field or method" */ .X
-}
-
-func _() {
-	type (
-		T1 struct { X int }
-		T2 struct { T1 }
-		T3 struct { T1 }
-		T4 struct { T2; T3 } // X is embedded twice at the same level via T2->T1->X, T3->T1->X
-	)
-
-	var t T4
-	_ = t /* ERROR "no single field or method" */ .X
-}
-
-func issue4355() {
-	type (
-	    T1 struct {X int}
-	    T2 struct {T1}
-	    T3 struct {T2}
-	    T4 struct {T2}
-	    T5 struct {T3; T4} // X is embedded twice at the same level via T3->T2->T1->X, T4->T2->T1->X
-	)	
-
-	var t T5
-	_ = t /* ERROR "no single field or method" */ .X
-}
-
-// Borrowed from the FieldByName test cases in reflect/all_test.go.
-
-type D1 struct {
-	d int
-}
-type D2 struct {
-	d int
-}
-
-type S0 struct {
-	A, B, C int
-	D1
-	D2
-}
-
-type S1 struct {
-	B int
-	S0
-}
-
-type S2 struct {
-	A int
-	*S1
-}
-
-type S1x struct {
-	S1
-}
-
-type S1y struct {
-	S1
-}
-
-type S3 struct {
-	S1x
-	S2
-	D, E int
-	*S1y
-}
-
-type S4 struct {
-	*S4
-	A int
-}
-
-// The X in S6 and S7 annihilate, but they also block the X in S8.S9.
-type S5 struct {
-	S6
-	S7
-	S8
-}
-
-type S6 struct {
-	X int
-}
-
-type S7 S6
-
-type S8 struct {
-	S9
-}
-
-type S9 struct {
-	X int
-	Y int
-}
-
-// The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.
-type S10 struct {
-	S11
-	S12
-	S13
-}
-
-type S11 struct {
-	S6
-}
-
-type S12 struct {
-	S6
-}
-
-type S13 struct {
-	S8
-}
-
-func _() {
-	_ = struct /* ERROR "no single field or method" */ {}{}.Foo
-	_ = S0{}.A
-	_ = S0 /* ERROR "no single field or method" */ {}.D
-	_ = S1{}.A
-	_ = S1{}.B
-	_ = S1{}.S0
-	_ = S1{}.C
-	_ = S2{}.A
-	_ = S2{}.S1
-	_ = S2{}.B
-	_ = S2{}.C
-	_ = S2 /* ERROR "no single field or method" */ {}.D
-	_ = S3 /* ERROR "no single field or method" */ {}.S1
-	_ = S3{}.A
-	_ = S3 /* ERROR "no single field or method" */ {}.B
-	_ = S3{}.D
-	_ = S3{}.E
-	_ = S4{}.A
-	_ = S4 /* ERROR "no single field or method" */ {}.B
-	_ = S5 /* ERROR "no single field or method" */ {}.X
-	_ = S5{}.Y
-	_ = S10 /* ERROR "no single field or method" */ {}.X
-	_ = S10{}.Y
-}
-
-// Borrowed from the FieldByName benchmark in reflect/all_test.go.
-
-type R0 struct {
-	*R1
-	*R2
-	*R3
-	*R4
-}
-
-type R1 struct {
-	*R5
-	*R6
-	*R7
-	*R8
-}
-
-type R2 R1
-type R3 R1
-type R4 R1
-
-type R5 struct {
-	*R9
-	*R10
-	*R11
-	*R12
-}
-
-type R6 R5
-type R7 R5
-type R8 R5
-
-type R9 struct {
-	*R13
-	*R14
-	*R15
-	*R16
-}
-
-type R10 R9
-type R11 R9
-type R12 R9
-
-type R13 struct {
-	*R17
-	*R18
-	*R19
-	*R20
-}
-
-type R14 R13
-type R15 R13
-type R16 R13
-
-type R17 struct {
-	*R21
-	*R22
-	*R23
-	*R24
-}
-
-type R18 R17
-type R19 R17
-type R20 R17
-
-type R21 struct {
-	X int
-}
-
-type R22 R21
-type R23 R21
-type R24 R21
-
-var _ = R0 /* ERROR "no single field or method" */ {}.X
\ No newline at end of file
diff --git a/libgo/go/go/types/testdata/expr0.src b/libgo/go/go/types/testdata/expr0.src
deleted file mode 100644
index c3233d36fe1..00000000000
--- a/libgo/go/go/types/testdata/expr0.src
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2012 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.
-
-// unary expressions
-
-package expr0 
-
-var (
-	// bool
-	b0 = true
-	b1 bool = b0
-	b2 = !true
-	b3 = !b1
-	b4 bool = !true
-	b5 bool = !b4
-	b6 = +b0 /* ERROR "not defined" */
-	b7 = -b0 /* ERROR "not defined" */
-	b8 = ^b0 /* ERROR "not defined" */
-	b9 = *b0 /* ERROR "cannot indirect" */
-	b10 = &true /* ERROR "cannot take address" */
-	b11 = &b0
-	b12 = <-b0 /* ERROR "cannot receive" */
-
-	// int
-	i0 = 1
-	i1 int = i0
-	i2 = +1
-	i3 = +i0
-	i4 int = +1
-	i5 int = +i4
-	i6 = -1
-	i7 = -i0
-	i8 int = -1
-	i9 int = -i4
-	i10 = !i0 /* ERROR "not defined" */
-	i11 = ^1
-	i12 = ^i0
-	i13 int = ^1
-	i14 int = ^i4
-	i15 = *i0 /* ERROR "cannot indirect" */
-	i16 = &i0
-	i17 = *i16
-	i18 = <-i16 /* ERROR "cannot receive" */
-
-	// uint
-	u0 = uint(1)
-	u1 uint = u0
-	u2 = +1
-	u3 = +u0
-	u4 uint = +1
-	u5 uint = +u4
-	u6 = -1
-	u7 = -u0
-	u8 uint = - /* ERROR "overflows" */ 1
-	u9 uint = -u4
-	u10 = !u0 /* ERROR "not defined" */
-	u11 = ^1
-	u12 = ^i0
-	u13 uint = ^ /* ERROR "overflows" */ 1
-	u14 uint = ^u4
-	u15 = *u0 /* ERROR "cannot indirect" */
-	u16 = &u0
-	u17 = *u16
-	u18 = <-u16 /* ERROR "cannot receive" */
-	u19 = ^uint(0)
-
-	// float64
-	f0 = float64(1)
-	f1 float64 = f0
-	f2 = +1
-	f3 = +f0
-	f4 float64 = +1
-	f5 float64 = +f4 /* ERROR not defined */
-	f6 = -1
-	f7 = -f0
-	f8 float64 = -1
-	f9 float64 = -f4
-	f10 = !f0 /* ERROR "not defined" */
-	f11 = ^1
-	f12 = ^i0
-	f13 float64 = ^1
-	f14 float64 = ^f4 /* ERROR "not defined" */
-	f15 = *f0 /* ERROR "cannot indirect" */
-	f16 = &f0
-	f17 = *u16
-	f18 = <-u16 /* ERROR "cannot receive" */
-
-	// complex128
-	c0 = complex128(1)
-	c1 complex128 = c0
-	c2 = +1
-	c3 = +c0
-	c4 complex128 = +1
-	c5 complex128 = +c4 /* ERROR not defined */
-	c6 = -1
-	c7 = -c0
-	c8 complex128 = -1
-	c9 complex128 = -c4
-	c10 = !c0 /* ERROR "not defined" */
-	c11 = ^1
-	c12 = ^i0
-	c13 complex128 = ^1
-	c14 complex128 = ^c4 /* ERROR "not defined" */
-	c15 = *c0 /* ERROR "cannot indirect" */
-	c16 = &c0
-	c17 = *u16
-	c18 = <-u16 /* ERROR "cannot receive" */
-
-	// string
-	s0 = "foo"
-	s1 = +"foo" /* ERROR "not defined" */
-	s2 = -s0 /* ERROR "not defined" */
-	s3 = !s0 /* ERROR "not defined" */
-	s4 = ^s0 /* ERROR "not defined" */
-	s5 = *s4 /* ERROR "cannot indirect" */
-	s6 = &s4
-	s7 = *s6
-	s8 = <-s7  /* ERROR "cannot receive" */
-
-	// channel
-	ch chan int
-	rc <-chan float64
-	sc chan <- string
-	ch0 = +ch /* ERROR "not defined" */
-	ch1 = -ch /* ERROR "not defined" */
-	ch2 = !ch /* ERROR "not defined" */
-	ch3 = ^ch /* ERROR "not defined" */
-	ch4 = *ch /* ERROR "cannot indirect" */
-	ch5 = &ch
-	ch6 = *ch5
-	ch7 = <-ch
-	ch8 = <-rc
-	ch9 = <-sc /* ERROR "cannot receive" */
-)
-
-// address of composite literals
-type T struct{x, y int}
-
-func f() T { return T{} }
-
-var (
-	_ = &T{1, 2}
-	_ = &[...]int{}
-	_ = &[]int{}
-	_ = &[]int{}
-	_ = &map[string]T{}
-	_ = &(T{1, 2})
-	_ = &((((T{1, 2}))))
-	_ = &f /* ERROR "cannot take address" */ ()
-)
diff --git a/libgo/go/go/types/testdata/expr1.src b/libgo/go/go/types/testdata/expr1.src
deleted file mode 100644
index 8ef0aed6d2e..00000000000
--- a/libgo/go/go/types/testdata/expr1.src
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2012 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.
-
-// binary expressions
-
-package expr1
diff --git a/libgo/go/go/types/testdata/expr2.src b/libgo/go/go/types/testdata/expr2.src
deleted file mode 100644
index 674be4005dd..00000000000
--- a/libgo/go/go/types/testdata/expr2.src
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2012 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.
-
-// comparisons
-
-package expr2
-
-func _bool() {
-	const t = true == true
-	const f = true == false
-	_ = t /* ERROR "cannot compare" */ < f
-	_ = 0 /* ERROR "cannot convert" */ == t
-	var b bool
-	var x, y float32
-	b = x < y
-	_ = struct{b bool}{x < y}
-}
-
-// corner cases
-var (
-	v0 = nil /* ERROR "cannot compare" */ == nil
-)
\ No newline at end of file
diff --git a/libgo/go/go/types/testdata/expr3.src b/libgo/go/go/types/testdata/expr3.src
deleted file mode 100644
index 519e3f567ac..00000000000
--- a/libgo/go/go/types/testdata/expr3.src
+++ /dev/null
@@ -1,367 +0,0 @@
-// Copyright 2012 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.
-
-// various expressions
-
-package expr3
-
-func shifts1() {
-	var (
-		i0 int
-		u0 uint
-	)
-
-	var (
-		v0 = 1<<0
-		v1 = 1<<i0 /* ERROR "must be unsigned" */
-		v2 = 1<<u0
-		v3 = 1<<"foo" /* ERROR "must be unsigned" */
-		v4 = 1<<- /* ERROR "stupid shift" */ 1
-		v5 = 1<<1025 /* ERROR "stupid shift" */
-		v6 = 1 /* ERROR "overflows" */ <<100
-
-		v10 uint = 1 << 0
-		v11 uint = 1 << u0
-		v12 float32 = 1 /* ERROR "must be integer" */ << u0
-	)
-}
-
-func shifts2() {
-	// TODO(gri) enable commented out tests below.
-	var (
-		s uint = 33
-		i = 1<<s           // 1 has type int
-		j int32 = 1<<s     // 1 has type int32; j == 0
-		k = uint64(1<<s)   // 1 has type uint64; k == 1<<33
-		m int = 1.0<<s     // 1.0 has type int
-	//	n = 1.0<<s != 0    // 1.0 has type int; n == false if ints are 32bits in size
-		o = 1<<s == 2<<s   // 1 and 2 have type int; o == true if ints are 32bits in size
-	//	p = 1<<s == 1 /* ERROR "overflows" */ <<33  // illegal if ints are 32bits in size: 1 has type int, but 1<<33 overflows int
-		u = 1.0 /* ERROR "must be integer" */ <<s         // illegal: 1.0 has type float64, cannot shift
-		v float32 = 1 /* ERROR "must be integer" */ <<s   // illegal: 1 has type float32, cannot shift
-		w int64 = 1.0<<33  // 1.0<<33 is a constant shift expression
-	)
-}
-
-// TODO(gri) The error messages below depond on adjusting the spec
-//           to reflect what gc is doing at the moment (the spec
-//           asks for run-time errors at the moment - see issue 4231).
-//
-func indexes() {
-	_ = 1 /* ERROR "cannot index" */ [0]
-	_ = indexes /* ERROR "cannot index" */ [0]
-	_ = ( /* ERROR "cannot slice" */ 12 + 3)[1:2]
-
-	var a [10]int
-	_ = a[true /* ERROR "must be integer" */ ]
-	_ = a["foo" /* ERROR "must be integer" */ ]
-	_ = a[1.1 /* ERROR "must be integer" */ ]
-	_ = a[1.0]
-	_ = a[- /* ERROR "index .* negative" */ 1]
-	_ = a[- /* ERROR "index .* negative" */ 1 :]
-	_ = a[: - /* ERROR "index .* negative" */ 1]
-	var a0 int
-	a0 = a[0]
-	var a1 int32
-	a1 = a /* ERROR "cannot assign" */ [1] 
-	_ = a[9]
-	_ = a[10 /* ERROR "index .* out of bounds" */ ]
-	_ = a[1 /* ERROR "stupid index" */ <<100]
-	_ = a[10:]
-	_ = a[:10]
-	_ = a[10:10]
-	_ = a[11 /* ERROR "index .* out of bounds" */ :]
-	_ = a[: 11 /* ERROR "index .* out of bounds" */ ]
-	_ = a[: 1 /* ERROR "stupid index" */ <<100]
-
-	pa := &a
-	_ = pa[9]
-	_ = pa[10 /* ERROR "index .* out of bounds" */ ]
-	_ = pa[1 /* ERROR "stupid index" */ <<100]
-	_ = pa[10:]
-	_ = pa[:10]
-	_ = pa[10:10]
-	_ = pa[11 /* ERROR "index .* out of bounds" */ :]
-	_ = pa[: 11 /* ERROR "index .* out of bounds" */ ]
-	_ = pa[: 1 /* ERROR "stupid index" */ <<100]
-
-	var b [0]int
-	_ = b[0 /* ERROR "index .* out of bounds" */ ]
-	_ = b[:]
-	_ = b[0:]
-	_ = b[:0]
-	_ = b[0:0]
-
-	var s []int
-	_ = s[- /* ERROR "index .* negative" */ 1]
-	_ = s[- /* ERROR "index .* negative" */ 1 :]
-	_ = s[: - /* ERROR "index .* negative" */ 1]
-	_ = s[0]
-	_ = s[1 : 2]
-	_ = s[2 /* ERROR "inverted slice range" */ : 1]
-	_ = s[2 :]
-	_ = s[: 1 /* ERROR "stupid index" */ <<100]
-	_ = s[1 /* ERROR "stupid index" */ <<100 :]
-	_ = s[1 /* ERROR "stupid index" */ <<100 : 1 /* ERROR "stupid index" */ <<100]
-
-	var t string
-	_ = t[- /* ERROR "index .* negative" */ 1]
-	_ = t[- /* ERROR "index .* negative" */ 1 :]
-	_ = t[: - /* ERROR "index .* negative" */ 1]
-	var t0 byte
-	t0 = t[0]
-	var t1 rune
-	t1 = t /* ERROR "cannot assign" */ [2]
-	_ = ("foo" + "bar")[5]
-	_ = ("foo" + "bar")[6 /* ERROR "index .* out of bounds" */ ]
-
-	const c = "foo"
-	_ = c[- /* ERROR "index .* negative" */ 1]
-	_ = c[- /* ERROR "index .* negative" */ 1 :]
-	_ = c[: - /* ERROR "index .* negative" */ 1]
-	var c0 byte
-	c0 = c[0]
-	var c2 float32
-	c2 = c /* ERROR "cannot assign" */ [2]
-	_ = c[3 /* ERROR "index .* out of bounds" */ ]
-	_ = ""[0 /* ERROR "index .* out of bounds" */ ]
-
-	_ = s[1<<30] // no compile-time error here
-}
-
-type T struct {
-	x int
-}
-
-func (*T) m() {}
-
-func method_expressions() {
-	_ = T /* ERROR "no single field or method" */ .a
-	_ = T /* ERROR "has no method" */ .x
-	_ = T.m
-	var f func(*T) = (*T).m
-	var g func(*T) = ( /* ERROR "cannot assign" */ T).m
-}
-
-func struct_literals() {
-	type T0 struct {
-		a, b, c int
-	}
-
-	type T1 struct {
-		T0
-		a, b int
-		u float64
-		s string
-	}
-
-	// keyed elements
-	_ = T1{}
-	_ = T1{a: 0, 1 /* ERROR "mixture of .* elements" */ }
-	_ = T1{aa /* ERROR "unknown field" */ : 0}
-	_ = T1{1 /* ERROR "invalid field name" */ : 0}
-	_ = T1{a: 0, s: "foo", u: 0, a /* ERROR "duplicate field" */: 10}
-	_ = T1{a: "foo" /* ERROR "cannot use" */ }
-	_ = T1{c /* ERROR "unknown field" */ : 0}
-	_ = T1{T0: { /* ERROR "missing type" */ }}
-	_ = T1{T0: T0{}}
-	_ = T1{T0 /* ERROR "invalid field name" */ .a: 0}
-
-	// unkeyed elements
-	_ = T0{1, 2, 3}
-	_ = T0{1, b /* ERROR "mixture" */ : 2, 3}
-	_ = T0{1, 2} /* ERROR "too few values" */
-	_ = T0{1, 2, 3, 4  /* ERROR "too many values" */ }
-	_ = T0{1, "foo" /* ERROR "cannot use" */, 3.4  /* ERROR "cannot use" */}
-}
-
-func array_literals() {
-	type A0 [0]int
-	_ = A0{}
-	_ = A0{0 /* ERROR "index .* out of bounds" */}
-	_ = A0{0 /* ERROR "index .* out of bounds" */ : 0}
-
-	type A1 [10]int
-	_ = A1{}
-	_ = A1{0, 1, 2}
-	_ = A1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
-	_ = A1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 /* ERROR "index .* out of bounds" */ }
-	_ = A1{- /* ERROR "index .* negative" */ 1: 0}
-	_ = A1{8: 8, 9}
-	_ = A1{8: 8, 9, 10 /* ERROR "index .* out of bounds" */ }
-	_ = A1{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
-	_ = A1{5: 5, 6, 7, 3: 3, 4}
-	_ = A1{5: 5, 6, 7, 3: 3, 4, 5 /* ERROR "duplicate index" */ }
-	_ = A1{10 /* ERROR "index .* out of bounds" */ : 10, 10 /* ERROR "index .* out of bounds" */ : 10}
-	_ = A1{5: 5, 6, 7, 3: 3, 1 /* ERROR "stupid index" */ <<100: 4, 5 /* ERROR "duplicate index" */ }
-	_ = A1{5: 5, 6, 7, 4: 4, 1 /* ERROR "stupid index" */ <<100: 4}
-	_ = A1{2.0}
-	_ = A1{2.1 /* ERROR "cannot use" */ }
-	_ = A1{"foo" /* ERROR "cannot use" */ }
-
-	a0 := [...]int{}
-	assert(len(a0) == 0)
-	
-	a1 := [...]int{0, 1, 2}
-	assert(len(a1) == 3)
-	var a13 [3]int
-	var a14 [4]int
-	a13 = a1
-	a14 = a1 /* ERROR "cannot assign" */
-	
-	a2 := [...]int{- /* ERROR "index .* negative" */ 1: 0}
-
-	a3 := [...]int{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
-	assert(len(a3) == 5) // somewhat arbitrary
-
-	a4 := [...]complex128{0, 1, 2, 1<<10-2: -1i, 1i, 400: 10, 12, 14}
-	assert(len(a4) == 1024)
-
-	// from the spec
-	type Point struct { x, y float32 }
-	_ = [...]Point{Point{1.5, -3.5}, Point{0, 0}}
-	_ = [...]Point{{1.5, -3.5}, {0, 0}}
-	_ = [][]int{[]int{1, 2, 3}, []int{4, 5}}
-	_ = [][]int{{1, 2, 3}, {4, 5}}
-	_ = [...]*Point{&Point{1.5, -3.5}, &Point{0, 0}}
-	_ = [...]*Point{{1.5, -3.5}, {0, 0}}
-}
-
-func slice_literals() {
-	type S0 []int
-	_ = S0{}
-	_ = S0{0, 1, 2}
-	_ = S0{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
-	_ = S0{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	_ = S0{- /* ERROR "index .* negative" */ 1: 0}
-	_ = S0{8: 8, 9}
-	_ = S0{8: 8, 9, 10}
-	_ = S0{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
-	_ = S0{5: 5, 6, 7, 3: 3, 4}
-	_ = S0{5: 5, 6, 7, 3: 3, 4, 5 /* ERROR "duplicate index" */ }
-	_ = S0{10: 10, 10 /* ERROR "duplicate index" */ : 10}
-	_ = S0{5: 5, 6, 7, 3: 3, 1 /* ERROR "stupid index" */ <<100: 4, 5 /* ERROR "duplicate index" */ }
-	_ = S0{5: 5, 6, 7, 4: 4, 1 /* ERROR "stupid index" */ <<100: 4}
-	_ = S0{2.0}
-	_ = S0{2.1 /* ERROR "cannot use" */ }
-	_ = S0{"foo" /* ERROR "cannot use" */ }
-
-	// indices must be resolved correctly
-	// (for details, see comment in go/parser/parser.go, method parseElement)
-	index1 := 1
-	_ = S0{index1: 1}
-	_ = S0{index2: 2}
-	_ = S0{index3 /* ERROR "undeclared name" */ : 3}
-}
-
-var index2 int = 2
-
-func map_literals() {
-	type M0 map[string]int
-
-	_ = M0{}
-	_ = M0{1 /* ERROR "missing key" */ }
-	_ = M0{1 /* ERROR "cannot use .* as string key" */ : 2}
-	_ = M0{"foo": "bar" /* ERROR "cannot use .* as int value" */ }
-	_ = M0{"foo": 1, "bar": 2, "foo" /* ERROR "duplicate key" */ : 3 }
-
-	// map keys must be resolved correctly
-	// (for detials, see comment in go/parser/parser.go, method parseElement)
-	key1 := "foo"
-	_ = M0{key1: 1}
-	_ = M0{key2: 2}
-	_ = M0{key3 /* ERROR "undeclared name" */ : 2}
-}
-
-var key2 string = "bar"
-
-type I interface {
-	m()
-}
-
-type I2 interface {
-	m(int)
-}
-
-type T1 struct{}
-type T2 struct{}
-
-func (T2) m(int) {}
-
-func type_asserts() {
-	var x int
-	_ = x /* ERROR "not an interface" */ .(int)
-
-	var e interface{}
-	var ok bool
-	x, ok = e.(int)
-
-	var t I
-	_ = t /* ERROR "use of .* outside type switch" */ .(type)
-	_ = t.(T)
-	_ = t.(T1 /* ERROR "missing method m" */ )
-	_ = t.(T2 /* ERROR "wrong type for method m" */ )
-	_ = t.(I2 /* ERROR "wrong type for method m" */ )
-}
-
-func f0() {}
-func f1(x int) {}
-func f2(u float32, s string) {}
-func fs(s []byte) {}
-func fv(x ...int) {}
-func fi(x ... interface{}) {}
-
-func g0() {}
-func g1() int { return 0}
-func g2() (u float32, s string) { return }
-func gs() []byte { return nil }
-
-func _calls() {
-	var x int
-	var y float32
-	var s []int
-
-	f0()
-	_ = f0 /* ERROR "used as value" */ ()
-	f0(g0 /* ERROR "too many arguments" */ )
-
-	f1(0)
-	f1(x)
-	f1(10.0)
-	f1 /* ERROR "too few arguments" */ ()
-	f1(x, y /* ERROR "too many arguments" */ )
-	f1(s /* ERROR "cannot assign" */ )
-	f1(x ... /* ERROR "cannot use ..." */ )
-	f1(g0 /* ERROR "used as value" */ ())
-	f1(g1())
-	// f1(g2()) // TODO(gri) missing position in error message
-
-	f2 /* ERROR "too few arguments" */ ()
-	f2 /* ERROR "too few arguments" */ (3.14)
-	f2(3.14, "foo")
-	f2(x /* ERROR "cannot assign" */ , "foo")
-	f2(g0 /* ERROR "used as value" */ ())
-	f2 /* ERROR "too few arguments" */ (g1 /* ERROR "cannot assign" */ ())
-	f2(g2())
-
-	fs /* ERROR "too few arguments" */ ()
-	fs(g0 /* ERROR "used as value" */ ())
-	fs(g1 /* ERROR "cannot assign" */ ())
-	// fs(g2()) // TODO(gri) missing position in error message
-	fs(gs())
-
-	fv()
-	fv(1, 2.0, x)
-	fv(s /* ERROR "cannot assign" */ )
-	fv(s...)
-	fv(1, s /* ERROR "can only use ... with matching parameter" */ ...)
-	fv(gs /* ERROR "cannot assign" */ ())
-	fv(gs /* ERROR "cannot assign" */ ()...)
-
-	fi()
-	fi(1, 2.0, x, 3.14, "foo")
-	fi(g2())
-	fi(0, g2)
-	fi(0, g2 /* ERROR "2-valued expression" */ ())
-}
\ No newline at end of file
diff --git a/libgo/go/go/types/testdata/stmt0.src b/libgo/go/go/types/testdata/stmt0.src
deleted file mode 100644
index ca36834fde6..00000000000
--- a/libgo/go/go/types/testdata/stmt0.src
+++ /dev/null
@@ -1,274 +0,0 @@
-// Copyright 2012 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.
-
-// statements
-
-package stmt0
-
-func _() {
-	b, i, f, c, s := false, 1, 1.0, 1i, "foo"
-	b = i /* ERROR "cannot assign" */
-	i = f /* ERROR "cannot assign" */
-	f = c /* ERROR "cannot assign" */
-	c = s /* ERROR "cannot assign" */
-	s = b /* ERROR "cannot assign" */
-
-	v0 /* ERROR "mismatch" */, v1, v2 := 1, 2, 3, 4
-
-	b = true
-
-	i += 1
-	i += "foo" /* ERROR "cannot convert.*int" */
-
-	f -= 1
-	f -= "foo" /* ERROR "cannot convert.*float64" */
-
-	c *= 1
-	c /= 0 /* ERROR "division by zero" */
-
-	s += "bar"
-	s += 1 /* ERROR "cannot convert.*string" */
-}
-
-func _incdecs() {
-	const c = 3.14
-	c /* ERROR "cannot assign" */ ++
-	s := "foo"
-	s /* ERROR "cannot convert" */ --
-	3.14 /* ERROR "cannot assign" */ ++
-	var (
-		x int
-		y float32
-		z complex128
-	)
-	x++
-	y--
-	z++
-}
-
-func _sends() {
-	var ch chan int
-	var rch <-chan int
-	var x int
-	x /* ERROR "cannot send" */ <- x
-	rch /* ERROR "cannot send" */ <- x
-	ch /* ERROR "cannot send" */ <- "foo"
-	ch <- x
-}
-
-func _selects() {
-	select {}
-	var (
-		ch chan int
-		sc chan <- bool
-		x int
-	)
-	select {
-	case <-ch:
-		ch <- x
-	case t, ok := <-ch:
-		x = t
-	case <-sc /* ERROR "cannot receive from send-only channel" */ :
-	}
-	select {
-	default:
-	default /* ERROR "multiple defaults" */ :
-	}
-}
-
-func _gos() {
-	go 1 /* ERROR "expected function/method call" */
-	go _gos()
-	var c chan int
-	go close(c)
-	go len(c) // TODO(gri) this should not be legal
-}
-
-func _defers() {
-	defer 1 /* ERROR "expected function/method call" */
-	defer _defers()
-	var c chan int
-	defer close(c)
-	defer len(c) // TODO(gri) this should not be legal
-}
-
-func _switches() {
-	var x int
-
-	switch x {
-	default:
-	default /* ERROR "multiple defaults" */ :
-	}
-
-	switch {
-	case 1  /* ERROR "cannot convert" */ :
-	}
-
-	switch int32(x) {
-	case 1, 2:
-	case x /* ERROR "cannot compare" */ :
-	}
-
-	switch x {
-	case 1 /* ERROR "overflows int" */ << 100:
-	}
-
-	switch x {
-	case 1:
-	case 1 /* ERROR "duplicate case" */ :
-	case 2, 3, 4:
-	case 1 /* ERROR "duplicate case" */ :
-	}
-
-	// TODO(gri) duplicate 64bit values that don't fit into an int64 are not yet detected
-	switch uint64(x) {
-	case 1<<64-1:
-	case 1<<64-1:
-	}
-}
-
-type I interface {
-	m()
-}
-
-type I2 interface {
-	m(int)
-}
-
-type T struct{}
-type T1 struct{}
-type T2 struct{}
-
-func (T) m() {}
-func (T2) m(int) {}
-
-func _typeswitches() {
-	var i int
-	var x interface{}
-
-	switch x.(type) {}
-	switch (x /* ERROR "outside type switch" */ .(type)) {}
-
-	switch x.(type) {
-	default:
-	default /* ERROR "multiple defaults" */ :
-	}
-
-	switch x := x.(type) {}
-
-	switch x := x.(type) {
-	case int:
-		var y int = x
-	}
-
-	switch x := i /* ERROR "not an interface" */ .(type) {}
-
-	switch t := x.(type) {
-	case nil:
-		var v bool = t /* ERROR "cannot assign" */
-	case int:
-		var v int = t
-	case float32, complex64:
-		var v float32 = t /* ERROR "cannot assign" */
-	default:
-		var v float32 = t /* ERROR "cannot assign" */
-	}
-
-	var t I
-	switch t.(type) {
-	case T:
-	case T1 /* ERROR "missing method m" */ :
-	case T2 /* ERROR "wrong type for method m" */ :
-	case I2 /* ERROR "wrong type for method m" */ :
-	}
-}
-
-func _rangeloops() {
-	var (
-		x int
-		a [10]float32
-		b []string
-		p *[10]complex128
-		pp **[10]complex128
-		s string
-		m map[int]bool
-		c chan int
-		sc chan<- int
-		rc <-chan int
-	)
-
-	for _ = range x /* ERROR "cannot range over" */ {}
-	for i := range x /* ERROR "cannot range over" */ {}
-
-	for i := range a {
-		var ii int
-		ii = i
-	}
-	for i, x := range a {
-		var ii int
-		ii = i
-		var xx float64
-		xx = x /* ERROR "cannot assign" */
-	}
-	var ii int
-	var xx float32
-	for ii, xx := range a {}
-
-	for i := range b {
-		var ii int
-		ii = i
-	}
-	for i, x := range b {
-		var ii int
-		ii = i
-		var xx string
-		xx = x
-	}
-
-	for i := range s {
-		var ii int
-		ii = i
-	}
-	for i, x := range s {
-		var ii int
-		ii = i
-		var xx rune
-		xx = x
-	}
-
-	for _, x := range p {
-		var xx complex128
-		xx = x
-	}
-
-	for _, x := range pp /* ERROR "cannot range over" */ {}
-
-	for k := range m {
-		var kk int32
-		kk = k /* ERROR "cannot assign" */
-	}
-	for k, v := range m {
-		var kk int
-		kk = k
-		if v {}
-	}
-
-	for _, _ /* ERROR "only one iteration variable" */ = range c {}
-	for e := range c {
-		var ee int
-		ee = e
-	}
-	for _ = range sc /* ERROR "cannot range over send-only channel" */ {}
-	for _ = range rc {}
-
-	// constant strings
-	const cs = "foo"
-	for i, x := range cs {}
-	for i, x := range "" {
-		var ii int
-		ii = i
-		var xx rune
-		xx = x
-	}
-}
\ No newline at end of file