// that this is nearly always a mistake.
//
// For example:
//
//	start := time.Now()
//	...
//	defer recordLatency(time.Since(start)) // error: call to time.Since is not deferred
//
// The correct code is:
//
//	defer func() { recordLatency(time.Since(start)) }()

	n := runtime.Stack(buf[:], false)
	s := string(buf[:n])
	if strings.Contains(s, "issue27201.go:21 ") {
		panic("panic at wrong location")
	}
	if !strings.Contains(s, "issue27201.go:20 ") {
		panic("no panic at correct location")
	}

// errorcheck

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

// Tests correct reporting of line numbers for errors involving iota,
// Issue #8183.
package foo

const (
	ok = byte(iota + 253)
	bad
	barn
	bard // ERROR "constant 256 overflows byte|integer constant overflow|cannot convert"
)

const (

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

// Test that the half multiply resulting from a division
// by a constant generates correct code.

package main

func main() {
	var _ = 7 / "0"[0] // test case from #11369
	var _ = 1 / "."[0] // test case from #11358
	var x = 0 / "0"[0]
	var y = 48 / "0"[0]
	var z = 5 * 48 / "0"[0]
	if x != 0 {

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

// Input for TestTypeNamingOrder

// ensures that the order in which "type A B" declarations are
// processed is correct; this was a problem for unified IR imports.

package g

type Client struct {
	common service
	A      *AService
	B      *BService
}

type service struct {
	client *Client
}

[trimpath] env GOROOT=$TESTGO_GOROOT

[short] stop

# With GOROOT still set, 'go build' and 'go test -c'
# should cause runtime.GOROOT() to report either the correct GOROOT
# (without -trimpath) or no GOROOT at all (with -trimpath).

go build -o example.exe .
go build -trimpath -o example-trimpath.exe .
go test -c -o example.test.exe .

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

// Issue 3925: wrong line number for error message "missing key in map literal"

// also a test for correct line number in other malformed composite literals.

package foo

var _ = map[string]string{
	"1": "2",
	"3", "4", // ERROR "missing key|must have keys"
}

var _ = []string{
	"foo",
	"bar",

// errorcheck

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

// Verify that we get the correct (T vs &T) literal specification
// in the error message.

package p

type S struct {
	f T
}

type P struct {
	f *T
}

type T struct{}

var _ = S{
	f: &T{}, // ERROR "cannot use &T{}|incompatible type"
}

            } catch (IllegalDependencyNotation e) {
                throw new InvalidUserDataException(
                        "Invalid format: '" + notation + "'. The correct notation is a 3-part group:name:version notation, "
                                + "e.g: 'org.gradle:gradle-core:1.0'");
            }

package syntax

import (
	"fmt"
	"io"
	"os"
)

// Mode describes the parser mode.
type Mode uint

// Modes supported by the parser.
const (
	CheckBranches Mode = 1 << iota // check correct use of labels, break, continue, and goto statements
)

// Error describes a syntax error. Error implements the error interface.
type Error struct {
	Pos Pos
	Msg string
}

func (err Error) Error() string {