go/packages/packagestest/expect.go - tools - Git at Google

 // 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)
 	}
 	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)
 			}
 			notes = append(notes, l...)
 		}
 	}
 	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)
 	}
 }
	// 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)
	}
	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)
	}
	notes = append(notes, l...)
	}
	}
	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)
	}
	}