+++ /dev/null
-// Copyright 2018 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 packagestest
-
-import (
- "fmt"
- "go/token"
- "io/ioutil"
- "os"
- "path/filepath"
- "reflect"
- "regexp"
- "strings"
-
- "golang.org/x/tools/go/expect"
- "golang.org/x/tools/go/packages"
- "golang.org/x/tools/internal/span"
-)
-
-const (
- markMethod = "mark"
- eofIdentifier = "EOF"
-)
-
-// Expect invokes the supplied methods for all expectation notes found in
-// the exported source files.
-//
-// All exported go source files are parsed to collect the expectation
-// notes.
-// See the documentation for expect.Parse for how the notes are collected
-// and parsed.
-//
-// The methods are supplied as a map of name to function, and those functions
-// will be matched against the expectations by name.
-// Notes with no matching function will be skipped, and functions with no
-// matching notes will not be invoked.
-// If there are no registered markers yet, a special pass will be run first
-// which adds any markers declared with @mark(Name, pattern) or @name. These
-// call the Mark method to add the marker to the global set.
-// You can register the "mark" method to override these in your own call to
-// Expect. The bound Mark function is usable directly in your method map, so
-// exported.Expect(map[string]interface{}{"mark": exported.Mark})
-// replicates the built in behavior.
-//
-// Method invocation
-//
-// When invoking a method the expressions in the parameter list need to be
-// converted to values to be passed to the method.
-// There are a very limited set of types the arguments are allowed to be.
-// expect.Note : passed the Note instance being evaluated.
-// string : can be supplied either a string literal or an identifier.
-// int : can only be supplied an integer literal.
-// *regexp.Regexp : can only be supplied a regular expression literal
-// token.Pos : has a file position calculated as described below.
-// token.Position : has a file position calculated as described below.
-// expect.Range: has a start and end position as described below.
-// interface{} : will be passed any value
-//
-// Position calculation
-//
-// There is some extra handling when a parameter is being coerced into a
-// token.Pos, token.Position or Range type argument.
-//
-// If the parameter is an identifier, it will be treated as the name of an
-// marker to look up (as if markers were global variables).
-//
-// If it is a string or regular expression, then it will be passed to
-// expect.MatchBefore to look up a match in the line at which it was declared.
-//
-// It is safe to call this repeatedly with different method sets, but it is
-// not safe to call it concurrently.
-func (e *Exported) Expect(methods map[string]interface{}) error {
- if err := e.getNotes(); err != nil {
- return err
- }
- if err := e.getMarkers(); err != nil {
- return err
- }
- var err error
- ms := make(map[string]method, len(methods))
- for name, f := range methods {
- mi := method{f: reflect.ValueOf(f)}
- mi.converters = make([]converter, mi.f.Type().NumIn())
- for i := 0; i < len(mi.converters); i++ {
- mi.converters[i], err = e.buildConverter(mi.f.Type().In(i))
- if err != nil {
- return fmt.Errorf("invalid method %v: %v", name, err)
- }
- }
- ms[name] = mi
- }
- for _, n := range e.notes {
- if n.Args == nil {
- // simple identifier form, convert to a call to mark
- n = &expect.Note{
- Pos: n.Pos,
- Name: markMethod,
- Args: []interface{}{n.Name, n.Name},
- }
- }
- mi, ok := ms[n.Name]
- if !ok {
- continue
- }
- params := make([]reflect.Value, len(mi.converters))
- args := n.Args
- for i, convert := range mi.converters {
- params[i], args, err = convert(n, args)
- if err != nil {
- return fmt.Errorf("%v: %v", e.ExpectFileSet.Position(n.Pos), err)
- }
- }
- if len(args) > 0 {
- return fmt.Errorf("%v: unwanted args got %+v extra", e.ExpectFileSet.Position(n.Pos), args)
- }
- //TODO: catch the error returned from the method
- mi.f.Call(params)
- }
- return nil
-}
-
-// Range is a type alias for span.Range for backwards compatibility, prefer
-// using span.Range directly.
-type Range = span.Range
-
-// Mark adds a new marker to the known set.
-func (e *Exported) Mark(name string, r Range) {
- if e.markers == nil {
- e.markers = make(map[string]span.Range)
- }
- e.markers[name] = r
-}
-
-func (e *Exported) getNotes() error {
- if e.notes != nil {
- return nil
- }
- notes := []*expect.Note{}
- var dirs []string
- for _, module := range e.written {
- for _, filename := range module {
- dirs = append(dirs, filepath.Dir(filename))
- }
- }
- for filename := range e.Config.Overlay {
- dirs = append(dirs, filepath.Dir(filename))
- }
- pkgs, err := packages.Load(e.Config, dirs...)
- if err != nil {
- return fmt.Errorf("unable to load packages for directories %s: %v", dirs, err)
- }
- seen := make(map[token.Position]struct{})
- for _, pkg := range pkgs {
- for _, filename := range pkg.GoFiles {
- content, err := e.FileContents(filename)
- if err != nil {
- return err
- }
- l, err := expect.Parse(e.ExpectFileSet, filename, content)
- if err != nil {
- return fmt.Errorf("failed to extract expectations: %v", err)
- }
- for _, note := range l {
- pos := e.ExpectFileSet.Position(note.Pos)
- if _, ok := seen[pos]; ok {
- continue
- }
- notes = append(notes, note)
- seen[pos] = struct{}{}
- }
- }
- }
- if _, ok := e.written[e.primary]; !ok {
- e.notes = notes
- return nil
- }
- // Check go.mod markers regardless of mode, we need to do this so that our marker count
- // matches the counts in the summary.txt.golden file for the test directory.
- if gomod, found := e.written[e.primary]["go.mod"]; found {
- // If we are in Modules mode, then we need to check the contents of the go.mod.temp.
- if e.Exporter == Modules {
- gomod += ".temp"
- }
- l, err := goModMarkers(e, gomod)
- if err != nil {
- return fmt.Errorf("failed to extract expectations for go.mod: %v", err)
- }
- notes = append(notes, l...)
- }
- e.notes = notes
- return nil
-}
-
-func goModMarkers(e *Exported, gomod string) ([]*expect.Note, error) {
- if _, err := os.Stat(gomod); os.IsNotExist(err) {
- // If there is no go.mod file, we want to be able to continue.
- return nil, nil
- }
- content, err := e.FileContents(gomod)
- if err != nil {
- return nil, err
- }
- if e.Exporter == GOPATH {
- return expect.Parse(e.ExpectFileSet, gomod, content)
- }
- gomod = strings.TrimSuffix(gomod, ".temp")
- // If we are in Modules mode, copy the original contents file back into go.mod
- if err := ioutil.WriteFile(gomod, content, 0644); err != nil {
- return nil, nil
- }
- return expect.Parse(e.ExpectFileSet, gomod, content)
-}
-
-func (e *Exported) getMarkers() error {
- if e.markers != nil {
- return nil
- }
- // set markers early so that we don't call getMarkers again from Expect
- e.markers = make(map[string]span.Range)
- return e.Expect(map[string]interface{}{
- markMethod: e.Mark,
- })
-}
-
-var (
- noteType = reflect.TypeOf((*expect.Note)(nil))
- identifierType = reflect.TypeOf(expect.Identifier(""))
- posType = reflect.TypeOf(token.Pos(0))
- positionType = reflect.TypeOf(token.Position{})
- rangeType = reflect.TypeOf(span.Range{})
- spanType = reflect.TypeOf(span.Span{})
- fsetType = reflect.TypeOf((*token.FileSet)(nil))
- regexType = reflect.TypeOf((*regexp.Regexp)(nil))
- exportedType = reflect.TypeOf((*Exported)(nil))
-)
-
-// converter converts from a marker's argument parsed from the comment to
-// reflect values passed to the method during Invoke.
-// It takes the args remaining, and returns the args it did not consume.
-// This allows a converter to consume 0 args for well known types, or multiple
-// args for compound types.
-type converter func(*expect.Note, []interface{}) (reflect.Value, []interface{}, error)
-
-// method is used to track information about Invoke methods that is expensive to
-// calculate so that we can work it out once rather than per marker.
-type method struct {
- f reflect.Value // the reflect value of the passed in method
- converters []converter // the parameter converters for the method
-}
-
-// buildConverter works out what function should be used to go from an ast expressions to a reflect
-// value of the type expected by a method.
-// It is called when only the target type is know, it returns converters that are flexible across
-// all supported expression types for that target type.
-func (e *Exported) buildConverter(pt reflect.Type) (converter, error) {
- switch {
- case pt == noteType:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- return reflect.ValueOf(n), args, nil
- }, nil
- case pt == fsetType:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- return reflect.ValueOf(e.ExpectFileSet), args, nil
- }, nil
- case pt == exportedType:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- return reflect.ValueOf(e), args, nil
- }, nil
- case pt == posType:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- r, remains, err := e.rangeConverter(n, args)
- if err != nil {
- return reflect.Value{}, nil, err
- }
- return reflect.ValueOf(r.Start), remains, nil
- }, nil
- case pt == positionType:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- r, remains, err := e.rangeConverter(n, args)
- if err != nil {
- return reflect.Value{}, nil, err
- }
- return reflect.ValueOf(e.ExpectFileSet.Position(r.Start)), remains, nil
- }, nil
- case pt == rangeType:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- r, remains, err := e.rangeConverter(n, args)
- if err != nil {
- return reflect.Value{}, nil, err
- }
- return reflect.ValueOf(r), remains, nil
- }, nil
- case pt == spanType:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- r, remains, err := e.rangeConverter(n, args)
- if err != nil {
- return reflect.Value{}, nil, err
- }
- spn, err := r.Span()
- if err != nil {
- return reflect.Value{}, nil, err
- }
- return reflect.ValueOf(spn), remains, nil
- }, nil
- case pt == identifierType:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- if len(args) < 1 {
- return reflect.Value{}, nil, fmt.Errorf("missing argument")
- }
- arg := args[0]
- args = args[1:]
- switch arg := arg.(type) {
- case expect.Identifier:
- return reflect.ValueOf(arg), args, nil
- default:
- return reflect.Value{}, nil, fmt.Errorf("cannot convert %v to string", arg)
- }
- }, nil
-
- case pt == regexType:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- if len(args) < 1 {
- return reflect.Value{}, nil, fmt.Errorf("missing argument")
- }
- arg := args[0]
- args = args[1:]
- if _, ok := arg.(*regexp.Regexp); !ok {
- return reflect.Value{}, nil, fmt.Errorf("cannot convert %v to *regexp.Regexp", arg)
- }
- return reflect.ValueOf(arg), args, nil
- }, nil
-
- case pt.Kind() == reflect.String:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- if len(args) < 1 {
- return reflect.Value{}, nil, fmt.Errorf("missing argument")
- }
- arg := args[0]
- args = args[1:]
- switch arg := arg.(type) {
- case expect.Identifier:
- return reflect.ValueOf(string(arg)), args, nil
- case string:
- return reflect.ValueOf(arg), args, nil
- default:
- return reflect.Value{}, nil, fmt.Errorf("cannot convert %v to string", arg)
- }
- }, nil
- case pt.Kind() == reflect.Int64:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- if len(args) < 1 {
- return reflect.Value{}, nil, fmt.Errorf("missing argument")
- }
- arg := args[0]
- args = args[1:]
- switch arg := arg.(type) {
- case int64:
- return reflect.ValueOf(arg), args, nil
- default:
- return reflect.Value{}, nil, fmt.Errorf("cannot convert %v to int", arg)
- }
- }, nil
- case pt.Kind() == reflect.Bool:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- if len(args) < 1 {
- return reflect.Value{}, nil, fmt.Errorf("missing argument")
- }
- arg := args[0]
- args = args[1:]
- b, ok := arg.(bool)
- if !ok {
- return reflect.Value{}, nil, fmt.Errorf("cannot convert %v to bool", arg)
- }
- return reflect.ValueOf(b), args, nil
- }, nil
- case pt.Kind() == reflect.Slice:
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- converter, err := e.buildConverter(pt.Elem())
- if err != nil {
- return reflect.Value{}, nil, err
- }
- result := reflect.MakeSlice(reflect.SliceOf(pt.Elem()), 0, len(args))
- for range args {
- value, remains, err := converter(n, args)
- if err != nil {
- return reflect.Value{}, nil, err
- }
- result = reflect.Append(result, value)
- args = remains
- }
- return result, args, nil
- }, nil
- default:
- if pt.Kind() == reflect.Interface && pt.NumMethod() == 0 {
- return func(n *expect.Note, args []interface{}) (reflect.Value, []interface{}, error) {
- if len(args) < 1 {
- return reflect.Value{}, nil, fmt.Errorf("missing argument")
- }
- return reflect.ValueOf(args[0]), args[1:], nil
- }, nil
- }
- return nil, fmt.Errorf("param has unexpected type %v (kind %v)", pt, pt.Kind())
- }
-}
-
-func (e *Exported) rangeConverter(n *expect.Note, args []interface{}) (span.Range, []interface{}, error) {
- if len(args) < 1 {
- return span.Range{}, nil, fmt.Errorf("missing argument")
- }
- arg := args[0]
- args = args[1:]
- switch arg := arg.(type) {
- case expect.Identifier:
- // handle the special identifiers
- switch arg {
- case eofIdentifier:
- // end of file identifier, look up the current file
- f := e.ExpectFileSet.File(n.Pos)
- eof := f.Pos(f.Size())
- return span.Range{FileSet: e.ExpectFileSet, Start: eof, End: token.NoPos}, args, nil
- default:
- // look up an marker by name
- mark, ok := e.markers[string(arg)]
- if !ok {
- return span.Range{}, nil, fmt.Errorf("cannot find marker %v", arg)
- }
- return mark, args, nil
- }
- case string:
- start, end, err := expect.MatchBefore(e.ExpectFileSet, e.FileContents, n.Pos, arg)
- if err != nil {
- return span.Range{}, nil, err
- }
- if start == token.NoPos {
- return span.Range{}, nil, fmt.Errorf("%v: pattern %s did not match", e.ExpectFileSet.Position(n.Pos), arg)
- }
- return span.Range{FileSet: e.ExpectFileSet, Start: start, End: end}, args, nil
- case *regexp.Regexp:
- start, end, err := expect.MatchBefore(e.ExpectFileSet, e.FileContents, n.Pos, arg)
- if err != nil {
- return span.Range{}, nil, err
- }
- if start == token.NoPos {
- return span.Range{}, nil, fmt.Errorf("%v: pattern %s did not match", e.ExpectFileSet.Position(n.Pos), arg)
- }
- return span.Range{FileSet: e.ExpectFileSet, Start: start, End: end}, args, nil
- default:
- return span.Range{}, nil, fmt.Errorf("cannot convert %v to pos", arg)
- }
-}
projects / dotfiles / .git / blobdiff