package main

type Box struct {};
var m map[string] *Box;

func main() {
	m := make(map[string] *Box);
	s := "foo";
	var x *Box = nil;
	m[s] = x;
}

/*
bug058.go:9: illegal types for operand: INDEX
	(MAP[<string>*STRING]*<Box>{})
	(<string>*STRING)

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;})

// errorcheck

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

// Verify that illegal uses of composite literals are detected.
// Does not compile.

package main

var a = []int { "a" };	// ERROR "conver|incompatible|cannot"
var b = int { 1 };	// ERROR "compos"


func f() int

func main() {

package main

const c = 1;

func main() {
	c := 0;
	_ = c;
}

/*
bug144.go:8: left side of := must be a name
bug144.go:8: operation LITERAL not allowed in assignment context
bug144.go:8: illegal types for operand: AS
	ideal
	int

	SELECT
	STRUCT
	SWITCH
	TYPE
	VAR
	keyword_end

	additional_beg
	// additional tokens, handled in an ad-hoc manner
	TILDE
	additional_end
)

var tokens = [...]string{
	ILLEGAL: "ILLEGAL",

	EOF:     "EOF",
	COMMENT: "COMMENT",

	IDENT:  "IDENT",
	INT:    "INT",
	FLOAT:  "FLOAT",
	IMAG:   "IMAG",
	CHAR:   "CHAR",
	STRING: "STRING",

	ADD: "+",
	SUB: "-",

        then:
        thrown Exception
    }

    def "won't parse string with non-hex chars: #illegal"() {
        when:
        HashCode.fromString(illegal)

        then:
        thrown Exception

        where:
        illegal << ["abcdefgh", "-1235689", "0x123456"]
    }

    def "won't parse too short string: #length"() {
        when:

package main

func main() {
	var a [1000] int64;  // this alone works
	var b [10000] int64;  // this causes a runtime crash
	_, _ = a, b;
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug092.go && 6l bug092.6 && 6.out
Illegal instruction

gri: array size matters, possibly related to stack overflow check?

package main


func f(i int, f float64) {
	i = 8
	f = 8.0
	return
}

func main() {
	f(3, float64(5))
}

/*
bug10.go:5: i undefined
bug10.go:6: illegal conversion of constant to 020({},<_o001>{<i><int32>INT32;<f><float32>FLOAT32;},{})
bug10.go:7: error in shape across assignment

// errorcheck

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

// RESOLUTION: This program is illegal.  We should reject all unnecessary backslashes.

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.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api;

/**
 * A <code>InvalidUserDataException</code> is thrown, if a user is providing illegal data for the build.
 */
public class InvalidUserDataException extends GradleException {
    public InvalidUserDataException() {
    }

    public InvalidUserDataException(String message) {
        super(message);