[dev.typeparams] cmd/compile/internal/syntax: add utility functions for testing

Preparation step for types2 package.

Change-Id: I8f9557b1a48ad570ba38aac7b720e639218dc6a7
Reviewed-on: https://go-review.googlesource.com/c/go/+/263623
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

diff --git a/src/cmd/compile/fmtmap_test.go b/src/cmd/compile/fmtmap_test.go
index 179c60187fe9d6328fe250fa31c6478d0b9c8446..a3d09576a73b034d3fe3967bec84535627e4d28d 100644 (file)
--- a/src/cmd/compile/fmtmap_test.go
+++ b/src/cmd/compile/fmtmap_test.go
@@ -123,6 +123,7 @@ var knownFormats = map[string]string{
        "cmd/compile/internal/ssa.register %d":            "",
        "cmd/compile/internal/ssa.relation %s":            "",
        "cmd/compile/internal/syntax.Error %q":            "",
+       "cmd/compile/internal/syntax.Error %v":            "",
        "cmd/compile/internal/syntax.Expr %#v":            "",
        "cmd/compile/internal/syntax.LitKind %d":          "",
        "cmd/compile/internal/syntax.Node %T":             "",

diff --git a/src/cmd/compile/internal/syntax/testing.go b/src/cmd/compile/internal/syntax/testing.go
new file mode 100644 (file)
index 0000000..3e02dc1
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testing.go
@@ -0,0 +1,72 @@
+// Copyright 2020 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.
+
+// This file implements testing support.
+
+package syntax
+
+import (
+       "io"
+       "regexp"
+       "strings"
+)
+
+// CommentsDo parses the given source and calls the provided handler for each
+// comment or error. If the text provided to handler starts with a '/' it is
+// the comment text; otherwise it is the error message.
+func CommentsDo(src io.Reader, handler func(line, col uint, text string)) {
+       var s scanner
+       s.init(src, handler, comments)
+       for s.tok != _EOF {
+               s.next()
+       }
+}
+
+// ERROR comments must start with text `ERROR "msg"` or `ERROR msg`.
+// Space around "msg" or msg is ignored.
+var errRx = regexp.MustCompile(`^ *ERROR *"?([^"]*)"?`)
+
+// ErrorMap collects all comments with comment text of the form
+// `ERROR "msg"` or `ERROR msg` from the given src and returns them
+// as []Error lists in a map indexed by line number. The position
+// for each Error is the position of the token immediately preceding
+// the comment, the Error message is the message msg extracted from
+// the comment, with all errors that are on the same line collected
+// in a slice. If there is no preceding token (the `ERROR` comment
+// appears in the beginning of the file), then the recorded position
+// is unknown (line, col = 0, 0). If there are no ERROR comments, the
+// result is nil.
+func ErrorMap(src io.Reader) (errmap map[uint][]Error) {
+       // position of previous token
+       var base *PosBase
+       var prev struct{ line, col uint }
+
+       var s scanner
+       s.init(src, func(_, _ uint, text string) {
+               if text[0] != '/' {
+                       return // error, ignore
+               }
+               if text[1] == '*' {
+                       text = text[:len(text)-2] // strip trailing */
+               }
+               if s := errRx.FindStringSubmatch(text[2:]); len(s) == 2 {
+                       pos := MakePos(base, prev.line, prev.col)
+                       err := Error{pos, strings.TrimSpace(s[1])}
+                       if errmap == nil {
+                               errmap = make(map[uint][]Error)
+                       }
+                       errmap[prev.line] = append(errmap[prev.line], err)
+               }
+       }, comments)
+
+       for s.tok != _EOF {
+               s.next()
+               if s.tok == _Semi && s.lit != "semicolon" {
+                       continue // ignore automatically inserted semicolons
+               }
+               prev.line, prev.col = s.line, s.col
+       }
+
+       return
+}

diff --git a/src/cmd/compile/internal/syntax/testing_test.go b/src/cmd/compile/internal/syntax/testing_test.go
new file mode 100644 (file)
index 0000000..d34e5ea
--- /dev/null
+++ b/src/cmd/compile/internal/syntax/testing_test.go
@@ -0,0 +1,45 @@
+// Copyright 2020 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.
+
+package syntax
+
+import (
+       "fmt"
+       "strings"
+       "testing"
+)
+
+func TestErrorMap(t *testing.T) {
+       const src = `/* ERROR 0:0 */ /* ERROR "0:0" */ // ERROR 0:0
+// ERROR "0:0"
+x /* ERROR 3:1 */                // ignore automatically inserted semicolon here
+/* ERROR 3:1 */                  // position of x on previous line
+   x /* ERROR 5:4 */ ;           // do not ignore this semicolon
+/* ERROR 5:22 */                 // position of ; on previous line
+       package /* ERROR 7:2 */  // indented with tab
+        import  /* ERROR 8:9 */  // indented with blanks
+`
+       m := ErrorMap(strings.NewReader(src))
+       got := 0 // number of errors found
+       for line, errlist := range m {
+               for _, err := range errlist {
+                       if err.Pos.Line() != line {
+                               t.Errorf("%v: got map line %d; want %d", err, err.Pos.Line(), line)
+                               continue
+                       }
+                       // err.Pos.Line() == line
+                       msg := fmt.Sprintf("%d:%d", line, err.Pos.Col())
+                       if err.Msg != msg {
+                               t.Errorf("%v: got msg %q; want %q", err, err.Msg, msg)
+                               continue
+                       }
+               }
+               got += len(errlist)
+       }
+
+       want := strings.Count(src, "ERROR")
+       if got != want {
+               t.Errorf("ErrorMap got %d errors; want %d", got, want)
+       }
+}