Source file src/go/types/check_test.go

Documentation: go/types

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // This file implements a typechecker test harness. The packages specified
     6  // in tests are typechecked. Error messages reported by the typechecker are
     7  // compared against the error messages expected in the test files.
     8  //
     9  // Expected errors are indicated in the test files by putting a comment
    10  // of the form /* ERROR "rx" */ immediately following an offending token.
    11  // The harness will verify that an error matching the regular expression
    12  // rx is reported at that source position. Consecutive comments may be
    13  // used to indicate multiple errors for the same token position.
    14  //
    15  // For instance, the following test file indicates that a "not declared"
    16  // error should be reported for the undeclared variable x:
    17  //
    18  //	package p
    19  //	func f() {
    20  //		_ = x /* ERROR "not declared" */ + 1
    21  //	}
    22  
    23  // TODO(gri) Also collect strict mode errors of the form /* STRICT ... */
    24  //           and test against strict mode.
    25  
    26  package types_test
    27  
    28  import (
    29  	"flag"
    30  	"go/ast"
    31  	"go/importer"
    32  	"go/parser"
    33  	"go/scanner"
    34  	"go/token"
    35  	"internal/testenv"
    36  	"io/ioutil"
    37  	"regexp"
    38  	"strings"
    39  	"testing"
    40  
    41  	. "go/types"
    42  )
    43  
    44  var (
    45  	listErrors = flag.Bool("errlist", false, "list errors")
    46  	testFiles  = flag.String("files", "", "space-separated list of test files")
    47  )
    48  
    49  // The test filenames do not end in .go so that they are invisible
    50  // to gofmt since they contain comments that must not change their
    51  // positions relative to surrounding tokens.
    52  
    53  // Each tests entry is list of files belonging to the same package.
    54  var tests = [][]string{
    55  	{"testdata/errors.src"},
    56  	{"testdata/importdecl0a.src", "testdata/importdecl0b.src"},
    57  	{"testdata/importdecl1a.src", "testdata/importdecl1b.src"},
    58  	{"testdata/importC.src"}, // special handling in checkFiles
    59  	{"testdata/cycles.src"},
    60  	{"testdata/cycles1.src"},
    61  	{"testdata/cycles2.src"},
    62  	{"testdata/cycles3.src"},
    63  	{"testdata/cycles4.src"},
    64  	{"testdata/cycles5.src"},
    65  	{"testdata/init0.src"},
    66  	{"testdata/init1.src"},
    67  	{"testdata/init2.src"},
    68  	{"testdata/decls0.src"},
    69  	{"testdata/decls1.src"},
    70  	{"testdata/decls2a.src", "testdata/decls2b.src"},
    71  	{"testdata/decls3.src"},
    72  	{"testdata/decls4.src"},
    73  	{"testdata/decls5.src"},
    74  	{"testdata/const0.src"},
    75  	{"testdata/const1.src"},
    76  	{"testdata/constdecl.src"},
    77  	{"testdata/vardecl.src"},
    78  	{"testdata/expr0.src"},
    79  	{"testdata/expr1.src"},
    80  	{"testdata/expr2.src"},
    81  	{"testdata/expr3.src"},
    82  	{"testdata/methodsets.src"},
    83  	{"testdata/shifts.src"},
    84  	{"testdata/builtins.src"},
    85  	{"testdata/conversions.src"},
    86  	{"testdata/conversions2.src"},
    87  	{"testdata/stmt0.src"},
    88  	{"testdata/stmt1.src"},
    89  	{"testdata/gotos.src"},
    90  	{"testdata/labels.src"},
    91  	{"testdata/issues.src"},
    92  	{"testdata/blank.src"},
    93  	{"testdata/issue25008b.src", "testdata/issue25008a.src"}, // order (b before a) is crucial!
    94  	{"testdata/issue26390.src"},                              // stand-alone test to ensure case is triggered
    95  	{"testdata/issue23203a.src"},
    96  	{"testdata/issue23203b.src"},
    97  	{"testdata/issue28251.src"},
    98  }
    99  
   100  var fset = token.NewFileSet()
   101  
   102  // Positioned errors are of the form filename:line:column: message .
   103  var posMsgRx = regexp.MustCompile(`^(.*:[0-9]+:[0-9]+): *(.*)`)
   104  
   105  // splitError splits an error's error message into a position string
   106  // and the actual error message. If there's no position information,
   107  // pos is the empty string, and msg is the entire error message.
   108  //
   109  func splitError(err error) (pos, msg string) {
   110  	msg = err.Error()
   111  	if m := posMsgRx.FindStringSubmatch(msg); len(m) == 3 {
   112  		pos = m[1]
   113  		msg = m[2]
   114  	}
   115  	return
   116  }
   117  
   118  func parseFiles(t *testing.T, filenames []string) ([]*ast.File, []error) {
   119  	var files []*ast.File
   120  	var errlist []error
   121  	for _, filename := range filenames {
   122  		file, err := parser.ParseFile(fset, filename, nil, parser.AllErrors)
   123  		if file == nil {
   124  			t.Fatalf("%s: %s", filename, err)
   125  		}
   126  		files = append(files, file)
   127  		if err != nil {
   128  			if list, _ := err.(scanner.ErrorList); len(list) > 0 {
   129  				for _, err := range list {
   130  					errlist = append(errlist, err)
   131  				}
   132  			} else {
   133  				errlist = append(errlist, err)
   134  			}
   135  		}
   136  	}
   137  	return files, errlist
   138  }
   139  
   140  // ERROR comments must start with text `ERROR "rx"` or `ERROR rx` where
   141  // rx is a regular expression that matches the expected error message.
   142  // Space around "rx" or rx is ignored. Use the form `ERROR HERE "rx"`
   143  // for error messages that are located immediately after rather than
   144  // at a token's position.
   145  //
   146  var errRx = regexp.MustCompile(`^ *ERROR *(HERE)? *"?([^"]*)"?`)
   147  
   148  // errMap collects the regular expressions of ERROR comments found
   149  // in files and returns them as a map of error positions to error messages.
   150  //
   151  func errMap(t *testing.T, testname string, files []*ast.File) map[string][]string {
   152  	// map of position strings to lists of error message patterns
   153  	errmap := make(map[string][]string)
   154  
   155  	for _, file := range files {
   156  		filename := fset.Position(file.Package).Filename
   157  		src, err := ioutil.ReadFile(filename)
   158  		if err != nil {
   159  			t.Fatalf("%s: could not read %s", testname, filename)
   160  		}
   161  
   162  		var s scanner.Scanner
   163  		s.Init(fset.AddFile(filename, -1, len(src)), src, nil, scanner.ScanComments)
   164  		var prev token.Pos // position of last non-comment, non-semicolon token
   165  		var here token.Pos // position immediately after the token at position prev
   166  
   167  	scanFile:
   168  		for {
   169  			pos, tok, lit := s.Scan()
   170  			switch tok {
   171  			case token.EOF:
   172  				break scanFile
   173  			case token.COMMENT:
   174  				if lit[1] == '*' {
   175  					lit = lit[:len(lit)-2] // strip trailing */
   176  				}
   177  				if s := errRx.FindStringSubmatch(lit[2:]); len(s) == 3 {
   178  					pos := prev
   179  					if s[1] == "HERE" {
   180  						pos = here
   181  					}
   182  					p := fset.Position(pos).String()
   183  					errmap[p] = append(errmap[p], strings.TrimSpace(s[2]))
   184  				}
   185  			case token.SEMICOLON:
   186  				// ignore automatically inserted semicolon
   187  				if lit == "\n" {
   188  					continue scanFile
   189  				}
   190  				fallthrough
   191  			default:
   192  				prev = pos
   193  				var l int // token length
   194  				if tok.IsLiteral() {
   195  					l = len(lit)
   196  				} else {
   197  					l = len(tok.String())
   198  				}
   199  				here = prev + token.Pos(l)
   200  			}
   201  		}
   202  	}
   203  
   204  	return errmap
   205  }
   206  
   207  func eliminate(t *testing.T, errmap map[string][]string, errlist []error) {
   208  	for _, err := range errlist {
   209  		pos, gotMsg := splitError(err)
   210  		list := errmap[pos]
   211  		index := -1 // list index of matching message, if any
   212  		// we expect one of the messages in list to match the error at pos
   213  		for i, wantRx := range list {
   214  			rx, err := regexp.Compile(wantRx)
   215  			if err != nil {
   216  				t.Errorf("%s: %v", pos, err)
   217  				continue
   218  			}
   219  			if rx.MatchString(gotMsg) {
   220  				index = i
   221  				break
   222  			}
   223  		}
   224  		if index >= 0 {
   225  			// eliminate from list
   226  			if n := len(list) - 1; n > 0 {
   227  				// not the last entry - swap in last element and shorten list by 1
   228  				list[index] = list[n]
   229  				errmap[pos] = list[:n]
   230  			} else {
   231  				// last entry - remove list from map
   232  				delete(errmap, pos)
   233  			}
   234  		} else {
   235  			t.Errorf("%s: no error expected: %q", pos, gotMsg)
   236  		}
   237  	}
   238  }
   239  
   240  func checkFiles(t *testing.T, testfiles []string) {
   241  	// parse files and collect parser errors
   242  	files, errlist := parseFiles(t, testfiles)
   243  
   244  	pkgName := "<no package>"
   245  	if len(files) > 0 {
   246  		pkgName = files[0].Name.Name
   247  	}
   248  
   249  	if *listErrors && len(errlist) > 0 {
   250  		t.Errorf("--- %s:", pkgName)
   251  		for _, err := range errlist {
   252  			t.Error(err)
   253  		}
   254  	}
   255  
   256  	// typecheck and collect typechecker errors
   257  	var conf Config
   258  	// special case for importC.src
   259  	if len(testfiles) == 1 && testfiles[0] == "testdata/importC.src" {
   260  		conf.FakeImportC = true
   261  	}
   262  	conf.Importer = importer.Default()
   263  	conf.Error = func(err error) {
   264  		if *listErrors {
   265  			t.Error(err)
   266  			return
   267  		}
   268  		// Ignore secondary error messages starting with "\t";
   269  		// they are clarifying messages for a primary error.
   270  		if !strings.Contains(err.Error(), ": \t") {
   271  			errlist = append(errlist, err)
   272  		}
   273  	}
   274  	conf.Check(pkgName, fset, files, nil)
   275  
   276  	if *listErrors {
   277  		return
   278  	}
   279  
   280  	// match and eliminate errors;
   281  	// we are expecting the following errors
   282  	errmap := errMap(t, pkgName, files)
   283  	eliminate(t, errmap, errlist)
   284  
   285  	// there should be no expected errors left
   286  	if len(errmap) > 0 {
   287  		t.Errorf("--- %s: %d source positions with expected (but not reported) errors:", pkgName, len(errmap))
   288  		for pos, list := range errmap {
   289  			for _, rx := range list {
   290  				t.Errorf("%s: %q", pos, rx)
   291  			}
   292  		}
   293  	}
   294  }
   295  
   296  func TestCheck(t *testing.T) {
   297  	testenv.MustHaveGoBuild(t)
   298  
   299  	// Declare builtins for testing.
   300  	DefPredeclaredTestFuncs()
   301  
   302  	// If explicit test files are specified, only check those.
   303  	if files := *testFiles; files != "" {
   304  		checkFiles(t, strings.Split(files, " "))
   305  		return
   306  	}
   307  
   308  	// Otherwise, run all the tests.
   309  	for _, files := range tests {
   310  		checkFiles(t, files)
   311  	}
   312  }
   313  

View as plain text