// it decides there are type errors.
	x :=
		len(m0)+
		len(m1)+	// ERROR "illegal|invalid|must be"
		len(m2)+	// ERROR "illegal|invalid|must be"
		len(m3)+
		len(m4)+	// ERROR "illegal|invalid|must be"

		len(s0)+
		len(s1)+	// ERROR "illegal|invalid|must be"
		len(s2)+	// ERROR "illegal|invalid|must be"
		len(s3)+
		len(s4)+	// ERROR "illegal|invalid|must be"

		len(a0)+
		len(a1)+
		len(a2)+

		cap(a0)+

package main
type I int
type S struct { f map[I]int }
var v1 = S{ make(map[int]int) }		// ERROR "cannot|illegal|incompatible|wrong"
var v2 map[I]int = map[int]int{}	// ERROR "cannot|illegal|incompatible|wrong"

package main

func putint(digits *string) {
	var i byte;
	i = (*digits)[7];  // compiles
	i = digits[7];  // ERROR "illegal|is not|invalid"
	_ = i;
}

func main() {
	s := "asdfasdfasdfasdf";
	putint(&s);
}

/*
bug022.go:8: illegal types for operand
	(*<string>*STRING) INDEXPTR (<int32>INT32)
bug022.go:8: illegal types for operand
	(<uint8>UINT8) AS

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

package main
var v1 = ([10]int)(nil);	// ERROR "illegal|nil|invalid"
var v2 [10]int = nil;		// ERROR "illegal|nil|incompatible"
var v3 [10]int;
var v4 = nil;	// ERROR "nil"
func main() {
	v3 = nil;		// ERROR "illegal|nil|incompatible"

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)

var (
	cr <-chan int
	cs chan<- int
	c  chan int
)

func main() {
	cr = c  // ok
	cs = c  // ok
	c = cr  // ERROR "illegal types|incompatible|cannot"
	c = cs  // ERROR "illegal types|incompatible|cannot"
	cr = cs // ERROR "illegal types|incompatible|cannot"
	cs = cr // ERROR "illegal types|incompatible|cannot"

	var n int
	<-n    // ERROR "receive from non-chan|expected channel"

	var px p.Exported
	px = p.X
	
	// this assignment is correctly illegal:
	//	px.private undefined (cannot refer to unexported field or method private)
	// px.private()

	// this assignment is correctly illegal:
	//	*Implementation does not implement p.Exported (missing p.private method)
	// px = new(Implementation)

	// this assignment is correctly illegal:
	//	p.Exported does not implement Exported (missing private method)

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

package p

const (
	_ = iota
	_ // ERROR "illegal character|invalid character"
	_  // ERROR "illegal character|invalid character"
	_  // ERROR "illegal character|invalid character"
	_  // ERROR "illegal character|invalid character"

	token.SHR_ASSIGN:     token.SHR,
	token.AND_NOT_ASSIGN: token.AND_NOT,
}

func TestZeroTok(t *testing.T) {
	// zero value for token.Token must be token.ILLEGAL
	var zero token.Token
	if token.ILLEGAL != zero {
		t.Errorf("%s == %d; want 0", token.ILLEGAL, zero)
	}
}

func TestAssignOp(t *testing.T) {
	// there are fewer than 256 tokens
	for i := 0; i < 256; i++ {
		tok := token.Token(i)
		got := assignOp(tok)

        e.message =~ "contains illegal"

        when:
        ModelPath.validateName("aü")

        then:
        e = thrown(ModelPath.InvalidNameException)
        e.message =~ "contains illegal"

        when:
        ModelPath.validateName("abü")

        then:
        e = thrown(ModelPath.InvalidNameException)
        e.message =~ "contains illegal"

        when: