// This file implements a typechecker test harness. The packages specified
// in tests are typechecked. Error messages reported by the typechecker are
-// compared against the error messages expected in the test files.
+// compared against the errors expected in the test files.
//
-// Expected errors are indicated in the test files by putting a comment
-// of the form /* ERROR "rx" */ immediately following an offending token.
-// The harness will verify that an error matching the regular expression
-// rx is reported at that source position. Consecutive comments may be
-// used to indicate multiple errors for the same token position.
+// Expected errors are indicated in the test files by putting comments
+// of the form /* ERROR pattern */ or /* ERRORx pattern */ (or a similar
+// //-style line comment) immediately following the tokens where errors
+// are reported. There must be exactly one blank before and after the
+// ERROR/ERRORx indicator, and the pattern must be a properly quoted Go
+// string.
//
-// For instance, the following test file indicates that a "not declared"
+// The harness will verify that each ERROR pattern is a substring of the
+// error reported at that source position, and that each ERRORx pattern
+// is a regular expression matching the respective error.
+// Consecutive comments may be used to indicate multiple errors reported
+// at the same position.
+//
+// For instance, the following test source indicates that an "undeclared"
// error should be reported for the undeclared variable x:
//
// package p
// func f() {
-// _ = x /* ERROR "not declared" */ + 1
+// _ = x /* ERROR "undeclared" */ + 1
// }
-// TODO(gri) Also collect strict mode errors of the form /* STRICT ... */
-// and test against strict mode.
-
package types_test
import (
+ "bytes"
"flag"
"fmt"
"go/ast"
"go/importer"
- "go/internal/typeparams"
"go/parser"
"go/scanner"
"go/token"
+ "internal/buildcfg"
"internal/testenv"
+ "internal/types/errors"
"os"
"path/filepath"
+ "reflect"
"regexp"
+ "runtime"
+ "strconv"
"strings"
"testing"
)
var (
- haltOnError = flag.Bool("halt", false, "halt on error")
- listErrors = flag.Bool("errlist", false, "list errors")
- goVersion = flag.String("lang", "", "Go language version (e.g. \"go1.12\") for TestManual")
+ haltOnError = flag.Bool("halt", false, "halt on error")
+ verifyErrors = flag.Bool("verify", false, "verify errors (rather than list them) in TestManual")
)
var fset = token.NewFileSet()
-// Positioned errors are of the form filename:line:column: message .
-var posMsgRx = regexp.MustCompile(`^(.*:[0-9]+:[0-9]+): *(.*)`)
-
-// splitError splits an error's error message into a position string
-// and the actual error message. If there's no position information,
-// pos is the empty string, and msg is the entire error message.
-//
-func splitError(err error) (pos, msg string) {
- msg = err.Error()
- if m := posMsgRx.FindStringSubmatch(msg); len(m) == 3 {
- pos = m[1]
- msg = m[2]
- }
- return
-}
-
func parseFiles(t *testing.T, filenames []string, srcs [][]byte, mode parser.Mode) ([]*ast.File, []error) {
var files []*ast.File
var errlist []error
return files, errlist
}
-// ERROR comments must start with text `ERROR "rx"` or `ERROR rx` where
-// rx is a regular expression that matches the expected error message.
-// Space around "rx" or rx is ignored. Use the form `ERROR HERE "rx"`
-// for error messages that are located immediately after rather than
-// at a token's position.
-//
-var errRx = regexp.MustCompile(`^ *ERROR *(HERE)? *"?([^"]*)"?`)
-
-// errMap collects the regular expressions of ERROR comments found
-// in files and returns them as a map of error positions to error messages.
-//
-// srcs must be a slice of the same length as files, containing the original
-// source for the parsed AST.
-func errMap(t *testing.T, files []*ast.File, srcs [][]byte) map[string][]string {
- // map of position strings to lists of error message patterns
- errmap := make(map[string][]string)
-
- for i, file := range files {
- tok := fset.File(file.Package)
- src := srcs[i]
- var s scanner.Scanner
- s.Init(tok, src, nil, scanner.ScanComments)
- var prev token.Pos // position of last non-comment, non-semicolon token
- var here token.Pos // position immediately after the token at position prev
-
- scanFile:
- for {
- pos, tok, lit := s.Scan()
- switch tok {
- case token.EOF:
- break scanFile
- case token.COMMENT:
- if lit[1] == '*' {
- lit = lit[:len(lit)-2] // strip trailing */
- }
- if s := errRx.FindStringSubmatch(lit[2:]); len(s) == 3 {
- pos := prev
- if s[1] == "HERE" {
- pos = here
- }
- p := fset.Position(pos).String()
- errmap[p] = append(errmap[p], strings.TrimSpace(s[2]))
- }
- case token.SEMICOLON:
- // ignore automatically inserted semicolon
- if lit == "\n" {
- continue scanFile
- }
- fallthrough
- default:
- prev = pos
- var l int // token length
- if tok.IsLiteral() {
- l = len(lit)
- } else {
- l = len(tok.String())
- }
- here = prev + token.Pos(l)
- }
- }
+func unpackError(fset *token.FileSet, err error) (token.Position, string) {
+ switch err := err.(type) {
+ case *scanner.Error:
+ return err.Pos, err.Msg
+ case Error:
+ return fset.Position(err.Pos), err.Msg
}
-
- return errmap
+ panic("unreachable")
}
-func eliminate(t *testing.T, errmap map[string][]string, errlist []error) {
- for _, err := range errlist {
- pos, gotMsg := splitError(err)
- list := errmap[pos]
- index := -1 // list index of matching message, if any
- // we expect one of the messages in list to match the error at pos
- for i, wantRx := range list {
- rx, err := regexp.Compile(wantRx)
- if err != nil {
- t.Errorf("%s: %v", pos, err)
- continue
- }
- if rx.MatchString(gotMsg) {
- index = i
- break
- }
- }
- if index >= 0 {
- // eliminate from list
- if n := len(list) - 1; n > 0 {
- // not the last entry - swap in last element and shorten list by 1
- list[index] = list[n]
- errmap[pos] = list[:n]
- } else {
- // last entry - remove list from map
- delete(errmap, pos)
- }
- } else {
- t.Errorf("%s: no error expected: %q", pos, gotMsg)
- }
+// absDiff returns the absolute difference between x and y.
+func absDiff(x, y int) int {
+ if x < y {
+ return y - x
}
+ return x - y
}
-// goVersionRx matches a Go version string using '_', e.g. "go1_12".
-var goVersionRx = regexp.MustCompile(`^go[1-9][0-9]*_(0|[1-9][0-9]*)$`)
+// parseFlags parses flags from the first line of the given source if the line
+// starts with "//" (line comment) followed by "-" (possibly with spaces
+// between). Otherwise the line is ignored.
+func parseFlags(src []byte, flags *flag.FlagSet) error {
+ // we must have a line comment that starts with a "-"
+ const prefix = "//"
+ if !bytes.HasPrefix(src, []byte(prefix)) {
+ return nil // first line is not a line comment
+ }
+ src = src[len(prefix):]
+ if i := bytes.Index(src, []byte("-")); i < 0 || len(bytes.TrimSpace(src[:i])) != 0 {
+ return nil // comment doesn't start with a "-"
+ }
+ end := bytes.Index(src, []byte("\n"))
+ const maxLen = 256
+ if end < 0 || end > maxLen {
+ return fmt.Errorf("flags comment line too long")
+ }
+
+ return flags.Parse(strings.Fields(string(src[:end])))
+}
-// asGoVersion returns a regular Go language version string
-// if s is a Go version string using '_' rather than '.' to
-// separate the major and minor version numbers (e.g. "go1_12").
-// Otherwise it returns the empty string.
-func asGoVersion(s string) string {
- if goVersionRx.MatchString(s) {
- return strings.Replace(s, "_", ".", 1)
+// testFiles type-checks the package consisting of the given files, and
+// compares the resulting errors with the ERROR annotations in the source.
+// Except for manual tests, each package is type-checked twice, once without
+// use of Alias types, and once with Alias types.
+//
+// The srcs slice contains the file content for the files named in the
+// filenames slice. The colDelta parameter specifies the tolerance for position
+// mismatch when comparing errors. The manual parameter specifies whether this
+// is a 'manual' test.
+//
+// If provided, opts may be used to mutate the Config before type-checking.
+func testFiles(t *testing.T, filenames []string, srcs [][]byte, manual bool, opts ...func(*Config)) {
+ // Alias types are disabled by default
+ testFilesImpl(t, filenames, srcs, manual, opts...)
+ if !manual {
+ t.Setenv("GODEBUG", "gotypesalias=1")
+ testFilesImpl(t, filenames, srcs, manual, opts...)
}
- return ""
}
-func checkFiles(t *testing.T, sizes Sizes, goVersion string, filenames []string, srcs [][]byte) {
+func testFilesImpl(t *testing.T, filenames []string, srcs [][]byte, manual bool, opts ...func(*Config)) {
if len(filenames) == 0 {
t.Fatal("no source files")
}
- mode := parser.AllErrors
- if strings.HasSuffix(filenames[0], ".go2") {
- if !typeparams.Enabled {
- t.Skip("type params are not enabled")
- }
- } else {
- mode |= typeparams.DisallowParsing
- }
-
- // parse files and collect parser errors
- files, errlist := parseFiles(t, filenames, srcs, mode)
-
+ // parse files
+ files, errlist := parseFiles(t, filenames, srcs, parser.AllErrors)
pkgName := "<no package>"
if len(files) > 0 {
pkgName = files[0].Name.Name
}
-
- // if no Go version is given, consider the package name
- if goVersion == "" {
- goVersion = asGoVersion(pkgName)
- }
-
- if *listErrors && len(errlist) > 0 {
+ listErrors := manual && !*verifyErrors
+ if listErrors && len(errlist) > 0 {
t.Errorf("--- %s:", pkgName)
for _, err := range errlist {
t.Error(err)
}
}
- // typecheck and collect typechecker errors
+ // set up typechecker
var conf Config
- conf.Sizes = sizes
- conf.GoVersion = goVersion
-
- // special case for importC.src
- if len(filenames) == 1 {
- if strings.HasSuffix(filenames[0], "importC.src") {
- conf.FakeImportC = true
- }
- }
-
+ *boolFieldAddr(&conf, "_Trace") = manual && testing.Verbose()
conf.Importer = importer.Default()
conf.Error = func(err error) {
if *haltOnError {
defer panic(err)
}
- if *listErrors {
+ if listErrors {
t.Error(err)
return
}
errlist = append(errlist, err)
}
}
- conf.Check(pkgName, fset, files, nil)
- if *listErrors {
+ // apply custom configuration
+ for _, opt := range opts {
+ opt(&conf)
+ }
+
+ // apply flag setting (overrides custom configuration)
+ var goexperiment, gotypesalias string
+ flags := flag.NewFlagSet("", flag.PanicOnError)
+ flags.StringVar(&conf.GoVersion, "lang", "", "")
+ flags.StringVar(&goexperiment, "goexperiment", "", "")
+ flags.BoolVar(&conf.FakeImportC, "fakeImportC", false, "")
+ flags.StringVar(&gotypesalias, "gotypesalias", "", "")
+ if err := parseFlags(srcs[0], flags); err != nil {
+ t.Fatal(err)
+ }
+
+ exp, err := buildcfg.ParseGOEXPERIMENT(runtime.GOOS, runtime.GOARCH, goexperiment)
+ if err != nil {
+ t.Fatal(err)
+ }
+ old := buildcfg.Experiment
+ defer func() {
+ buildcfg.Experiment = old
+ }()
+ buildcfg.Experiment = *exp
+
+ // By default, gotypesalias is not set.
+ if gotypesalias != "" {
+ t.Setenv("GODEBUG", "gotypesalias="+gotypesalias)
+ }
+
+ // Provide Config.Info with all maps so that info recording is tested.
+ info := Info{
+ Types: make(map[ast.Expr]TypeAndValue),
+ Instances: make(map[*ast.Ident]Instance),
+ Defs: make(map[*ast.Ident]Object),
+ Uses: make(map[*ast.Ident]Object),
+ Implicits: make(map[ast.Node]Object),
+ Selections: make(map[*ast.SelectorExpr]*Selection),
+ Scopes: make(map[ast.Node]*Scope),
+ FileVersions: make(map[*ast.File]string),
+ }
+
+ // typecheck
+ conf.Check(pkgName, fset, files, &info)
+ if listErrors {
return
}
+ // collect expected errors
+ errmap := make(map[string]map[int][]comment)
+ for i, filename := range filenames {
+ if m := commentMap(srcs[i], regexp.MustCompile("^ ERRORx? ")); len(m) > 0 {
+ errmap[filename] = m
+ }
+ }
+
+ // match against found errors
+ var indices []int // list indices of matching errors, reused for each error
for _, err := range errlist {
- err, ok := err.(Error)
- if !ok {
+ gotPos, gotMsg := unpackError(fset, err)
+
+ // find list of errors for the respective error line
+ filename := gotPos.Filename
+ filemap := errmap[filename]
+ line := gotPos.Line
+ var errList []comment
+ if filemap != nil {
+ errList = filemap[line]
+ }
+
+ // At least one of the errors in errList should match the current error.
+ indices = indices[:0]
+ for i, want := range errList {
+ pattern, substr := strings.CutPrefix(want.text, " ERROR ")
+ if !substr {
+ var found bool
+ pattern, found = strings.CutPrefix(want.text, " ERRORx ")
+ if !found {
+ panic("unreachable")
+ }
+ }
+ pattern, err := strconv.Unquote(strings.TrimSpace(pattern))
+ if err != nil {
+ t.Errorf("%s:%d:%d: %v", filename, line, want.col, err)
+ continue
+ }
+ if substr {
+ if !strings.Contains(gotMsg, pattern) {
+ continue
+ }
+ } else {
+ rx, err := regexp.Compile(pattern)
+ if err != nil {
+ t.Errorf("%s:%d:%d: %v", filename, line, want.col, err)
+ continue
+ }
+ if !rx.MatchString(gotMsg) {
+ continue
+ }
+ }
+ indices = append(indices, i)
+ }
+ if len(indices) == 0 {
+ t.Errorf("%s: no error expected: %q", gotPos, gotMsg)
continue
}
- code := readCode(err)
- if code == 0 {
- t.Errorf("missing error code: %v", err)
+ // len(indices) > 0
+
+ // If there are multiple matching errors, select the one with the closest column position.
+ index := -1 // index of matching error
+ var delta int
+ for _, i := range indices {
+ if d := absDiff(gotPos.Column, errList[i].col); index < 0 || d < delta {
+ index, delta = i, d
+ }
}
- }
- // match and eliminate errors;
- // we are expecting the following errors
- errmap := errMap(t, files, srcs)
- eliminate(t, errmap, errlist)
+ // The closest column position must be within expected colDelta.
+ const colDelta = 0 // go/types errors are positioned correctly
+ if delta > colDelta {
+ t.Errorf("%s: got col = %d; want %d", gotPos, gotPos.Column, errList[index].col)
+ }
+
+ // eliminate from errList
+ if n := len(errList) - 1; n > 0 {
+ // not the last entry - slide entries down (don't reorder)
+ copy(errList[index:], errList[index+1:])
+ filemap[line] = errList[:n]
+ } else {
+ // last entry - remove errList from filemap
+ delete(filemap, line)
+ }
+
+ // if filemap is empty, eliminate from errmap
+ if len(filemap) == 0 {
+ delete(errmap, filename)
+ }
+ }
// there should be no expected errors left
if len(errmap) > 0 {
- t.Errorf("--- %s: %d source positions with expected (but not reported) errors:", pkgName, len(errmap))
- for pos, list := range errmap {
- for _, rx := range list {
- t.Errorf("%s: %q", pos, rx)
+ t.Errorf("--- %s: unreported errors:", pkgName)
+ for filename, filemap := range errmap {
+ for line, errList := range filemap {
+ for _, err := range errList {
+ t.Errorf("%s:%d:%d: %s", filename, line, err.col, err.text)
+ }
}
}
}
}
-// TestManual is for manual testing of input files, provided as a list
-// of arguments after the test arguments (and a separating "--"). For
-// instance, to check the files foo.go and bar.go, use:
+func readCode(err Error) errors.Code {
+ v := reflect.ValueOf(err)
+ return errors.Code(v.FieldByName("go116code").Int())
+}
+
+// boolFieldAddr(conf, name) returns the address of the boolean field conf.<name>.
+// For accessing unexported fields.
+func boolFieldAddr(conf *Config, name string) *bool {
+ v := reflect.Indirect(reflect.ValueOf(conf))
+ return (*bool)(v.FieldByName(name).Addr().UnsafePointer())
+}
+
+// stringFieldAddr(conf, name) returns the address of the string field conf.<name>.
+// For accessing unexported fields.
+func stringFieldAddr(conf *Config, name string) *string {
+ v := reflect.Indirect(reflect.ValueOf(conf))
+ return (*string)(v.FieldByName(name).Addr().UnsafePointer())
+}
+
+// TestManual is for manual testing of a package - either provided
+// as a list of filenames belonging to the package, or a directory
+// name containing the package files - after the test arguments
+// (and a separating "--"). For instance, to test the package made
+// of the files foo.go and bar.go, use:
//
-// go test -run Manual -- foo.go bar.go
+// go test -run Manual -- foo.go bar.go
//
-// To get an error list rather than having the test check against
-// ERROR comments in the input files, provide the -errlist flag.
-// The accepted Go language version can be controlled with the -lang flag.
+// If no source arguments are provided, the file testdata/manual.go
+// is used instead.
+// Provide the -verify flag to verify errors against ERROR comments
+// in the input files rather than having a list of errors reported.
+// The accepted Go language version can be controlled with the -lang
+// flag.
func TestManual(t *testing.T) {
+ testenv.MustHaveGoBuild(t)
+
filenames := flag.Args()
if len(filenames) == 0 {
- return
+ filenames = []string{filepath.FromSlash("testdata/manual.go")}
}
- testenv.MustHaveGoBuild(t)
+
+ info, err := os.Stat(filenames[0])
+ if err != nil {
+ t.Fatalf("TestManual: %v", err)
+ }
+
DefPredeclaredTestFuncs()
- testPkg(t, filenames, *goVersion)
+ if info.IsDir() {
+ if len(filenames) > 1 {
+ t.Fatal("TestManual: must have only one directory argument")
+ }
+ testDir(t, filenames[0], true)
+ } else {
+ testPkg(t, filenames, true)
+ }
}
func TestLongConstants(t *testing.T) {
- format := "package longconst\n\nconst _ = %s\nconst _ = %s // ERROR excessively long constant"
+ format := `package longconst; const _ = %s /* ERROR "constant overflow" */; const _ = %s // ERROR "excessively long constant"`
src := fmt.Sprintf(format, strings.Repeat("1", 9999), strings.Repeat("1", 10001))
- checkFiles(t, nil, "", []string{"longconst.go"}, [][]byte{[]byte(src)})
+ testFiles(t, []string{"longconst.go"}, [][]byte{[]byte(src)}, false)
+}
+
+func withSizes(sizes Sizes) func(*Config) {
+ return func(cfg *Config) {
+ cfg.Sizes = sizes
+ }
}
// TestIndexRepresentability tests that constant index operands must
// be representable as int even if they already have a type that can
// represent larger values.
func TestIndexRepresentability(t *testing.T) {
- const src = "package index\n\nvar s []byte\nvar _ = s[int64 /* ERROR \"int64\\(1\\) << 40 \\(.*\\) overflows int\" */ (1) << 40]"
- checkFiles(t, &StdSizes{4, 4}, "", []string{"index.go"}, [][]byte{[]byte(src)})
+ const src = `package index; var s []byte; var _ = s[int64 /* ERRORx "int64\\(1\\) << 40 \\(.*\\) overflows int" */ (1) << 40]`
+ testFiles(t, []string{"index.go"}, [][]byte{[]byte(src)}, false, withSizes(&StdSizes{4, 4}))
+}
+
+func TestIssue47243_TypedRHS(t *testing.T) {
+ // The RHS of the shift expression below overflows uint on 32bit platforms,
+ // but this is OK as it is explicitly typed.
+ const src = `package issue47243; var a uint64; var _ = a << uint64(4294967296)` // uint64(1<<32)
+ testFiles(t, []string{"p.go"}, [][]byte{[]byte(src)}, false, withSizes(&StdSizes{4, 4}))
}
-func TestCheck(t *testing.T) { DefPredeclaredTestFuncs(); testDir(t, "check") }
-func TestExamples(t *testing.T) { testDir(t, "examples") }
-func TestFixedbugs(t *testing.T) { testDir(t, "fixedbugs") }
+func TestCheck(t *testing.T) {
+ old := buildcfg.Experiment.RangeFunc
+ defer func() {
+ buildcfg.Experiment.RangeFunc = old
+ }()
+ buildcfg.Experiment.RangeFunc = true
+
+ DefPredeclaredTestFuncs()
+ testDirFiles(t, "../../internal/types/testdata/check", false)
+}
+func TestSpec(t *testing.T) { testDirFiles(t, "../../internal/types/testdata/spec", false) }
+func TestExamples(t *testing.T) { testDirFiles(t, "../../internal/types/testdata/examples", false) }
+func TestFixedbugs(t *testing.T) { testDirFiles(t, "../../internal/types/testdata/fixedbugs", false) }
+func TestLocal(t *testing.T) { testDirFiles(t, "testdata/local", false) }
-func testDir(t *testing.T, dir string) {
+func testDirFiles(t *testing.T, dir string, manual bool) {
testenv.MustHaveGoBuild(t)
+ dir = filepath.FromSlash(dir)
- dir = filepath.Join("testdata", dir)
fis, err := os.ReadDir(dir)
if err != nil {
t.Error(err)
for _, fi := range fis {
path := filepath.Join(dir, fi.Name())
- // if fi is a directory, its files make up a single package
- var filenames []string
+ // If fi is a directory, its files make up a single package.
if fi.IsDir() {
- fis, err := os.ReadDir(path)
- if err != nil {
- t.Error(err)
- continue
- }
- for _, fi := range fis {
- filenames = append(filenames, filepath.Join(path, fi.Name()))
- }
+ testDir(t, path, manual)
} else {
- filenames = []string{path}
+ t.Run(filepath.Base(path), func(t *testing.T) {
+ testPkg(t, []string{path}, manual)
+ })
}
- t.Run(filepath.Base(path), func(t *testing.T) {
- testPkg(t, filenames, "")
- })
}
}
-func testPkg(t *testing.T, filenames []string, goVersion string) {
+func testDir(t *testing.T, dir string, manual bool) {
+ testenv.MustHaveGoBuild(t)
+
+ fis, err := os.ReadDir(dir)
+ if err != nil {
+ t.Error(err)
+ return
+ }
+
+ var filenames []string
+ for _, fi := range fis {
+ filenames = append(filenames, filepath.Join(dir, fi.Name()))
+ }
+
+ t.Run(filepath.Base(dir), func(t *testing.T) {
+ testPkg(t, filenames, manual)
+ })
+}
+
+func testPkg(t *testing.T, filenames []string, manual bool) {
srcs := make([][]byte, len(filenames))
for i, filename := range filenames {
src, err := os.ReadFile(filename)
}
srcs[i] = src
}
- checkFiles(t, nil, goVersion, filenames, srcs)
+ testFiles(t, filenames, srcs, manual)
}