exec.go

     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  package template
     6  
     7  import (
     8  	"errors"
     9  	"fmt"
    10  	"internal/fmtsort"
    11  	"io"
    12  	"reflect"
    13  	"runtime"
    14  	"strings"
    15  	"text/template/parse"
    16  )
    17  
    18  // maxExecDepth specifies the maximum stack depth of templates within
    19  // templates. This limit is only practically reached by accidentally
    20  // recursive template invocations. This limit allows us to return
    21  // an error instead of triggering a stack overflow.
    22  var maxExecDepth = initMaxExecDepth()
    23  
    24  func initMaxExecDepth() int {
    25  	if runtime.GOARCH == "wasm" {
    26  		return 1000
    27  	}
    28  	return 100000
    29  }
    30  
    31  // state represents the state of an execution. It's not part of the
    32  // template so that multiple executions of the same template
    33  // can execute in parallel.
    34  type state struct {
    35  	tmpl  *Template
    36  	wr    io.Writer
    37  	node  parse.Node // current node, for errors
    38  	vars  []variable // push-down stack of variable values.
    39  	depth int        // the height of the stack of executing templates.
    40  }
    41  
    42  // variable holds the dynamic value of a variable such as $, $x etc.
    43  type variable struct {
    44  	name  string
    45  	value reflect.Value
    46  }
    47  
    48  // push pushes a new variable on the stack.
    49  func (s *state) push(name string, value reflect.Value) {
    50  	s.vars = append(s.vars, variable{name, value})
    51  }
    52  
    53  // mark returns the length of the variable stack.
    54  func (s *state) mark() int {
    55  	return len(s.vars)
    56  }
    57  
    58  // pop pops the variable stack up to the mark.
    59  func (s *state) pop(mark int) {
    60  	s.vars = s.vars[0:mark]
    61  }
    62  
    63  // setVar overwrites the last declared variable with the given name.
    64  // Used by variable assignments.
    65  func (s *state) setVar(name string, value reflect.Value) {
    66  	for i := s.mark() - 1; i >= 0; i-- {
    67  		if s.vars[i].name == name {
    68  			s.vars[i].value = value
    69  			return
    70  		}
    71  	}
    72  	s.errorf("undefined variable: %s", name)
    73  }
    74  
    75  // setTopVar overwrites the top-nth variable on the stack. Used by range iterations.
    76  func (s *state) setTopVar(n int, value reflect.Value) {
    77  	s.vars[len(s.vars)-n].value = value
    78  }
    79  
    80  // varValue returns the value of the named variable.
    81  func (s *state) varValue(name string) reflect.Value {
    82  	for i := s.mark() - 1; i >= 0; i-- {
    83  		if s.vars[i].name == name {
    84  			return s.vars[i].value
    85  		}
    86  	}
    87  	s.errorf("undefined variable: %s", name)
    88  	return zero
    89  }
    90  
    91  var zero reflect.Value
    92  
    93  type missingValType struct{}
    94  
    95  var missingVal = reflect.ValueOf(missingValType{})
    96  
    97  var missingValReflectType = reflect.TypeFor[missingValType]()
    98  
    99  func isMissing(v reflect.Value) bool {
   100  	return v.IsValid() && v.Type() == missingValReflectType
   101  }
   102  
   103  // at marks the state to be on node n, for error reporting.
   104  func (s *state) at(node parse.Node) {
   105  	s.node = node
   106  }
   107  
   108  // doublePercent returns the string with %'s replaced by %%, if necessary,
   109  // so it can be used safely inside a Printf format string.
   110  func doublePercent(str string) string {
   111  	return strings.ReplaceAll(str, "%", "%%")
   112  }
   113  
   114  // TODO: It would be nice if ExecError was more broken down, but
   115  // the way ErrorContext embeds the template name makes the
   116  // processing too clumsy.
   117  
   118  // ExecError is the custom error type returned when Execute has an
   119  // error evaluating its template. (If a write error occurs, the actual
   120  // error is returned; it will not be of type ExecError.)
   121  type ExecError struct {
   122  	Name string // Name of template.
   123  	Err  error  // Pre-formatted error.
   124  }
   125  
   126  func (e ExecError) Error() string {
   127  	return e.Err.Error()
   128  }
   129  
   130  func (e ExecError) Unwrap() error {
   131  	return e.Err
   132  }
   133  
   134  // errorf records an ExecError and terminates processing.
   135  func (s *state) errorf(format string, args ...any) {
   136  	name := doublePercent(s.tmpl.Name())
   137  	if s.node == nil {
   138  		format = fmt.Sprintf("template: %s: %s", name, format)
   139  	} else {
   140  		location, context := s.tmpl.ErrorContext(s.node)
   141  		format = fmt.Sprintf("template: %s: executing %q at <%s>: %s", location, name, doublePercent(context), format)
   142  	}
   143  	panic(ExecError{
   144  		Name: s.tmpl.Name(),
   145  		Err:  fmt.Errorf(format, args...),
   146  	})
   147  }
   148  
   149  // writeError is the wrapper type used internally when Execute has an
   150  // error writing to its output. We strip the wrapper in errRecover.
   151  // Note that this is not an implementation of error, so it cannot escape
   152  // from the package as an error value.
   153  type writeError struct {
   154  	Err error // Original error.
   155  }
   156  
   157  func (s *state) writeError(err error) {
   158  	panic(writeError{
   159  		Err: err,
   160  	})
   161  }
   162  
   163  // errRecover is the handler that turns panics into returns from the top
   164  // level of Parse.
   165  func errRecover(errp *error) {
   166  	e := recover()
   167  	if e != nil {
   168  		switch err := e.(type) {
   169  		case runtime.Error:
   170  			panic(e)
   171  		case writeError:
   172  			*errp = err.Err // Strip the wrapper.
   173  		case ExecError:
   174  			*errp = err // Keep the wrapper.
   175  		default:
   176  			panic(e)
   177  		}
   178  	}
   179  }
   180  
   181  // ExecuteTemplate applies the template associated with t that has the given name
   182  // to the specified data object and writes the output to wr.
   183  // If an error occurs executing the template or writing its output,
   184  // execution stops, but partial results may already have been written to
   185  // the output writer.
   186  // A template may be executed safely in parallel, although if parallel
   187  // executions share a Writer the output may be interleaved.
   188  func (t *Template) ExecuteTemplate(wr io.Writer, name string, data any) error {
   189  	tmpl := t.Lookup(name)
   190  	if tmpl == nil {
   191  		return fmt.Errorf("template: no template %q associated with template %q", name, t.name)
   192  	}
   193  	return tmpl.Execute(wr, data)
   194  }
   195  
   196  // Execute applies a parsed template to the specified data object,
   197  // and writes the output to wr.
   198  // If an error occurs executing the template or writing its output,
   199  // execution stops, but partial results may already have been written to
   200  // the output writer.
   201  // A template may be executed safely in parallel, although if parallel
   202  // executions share a Writer the output may be interleaved.
   203  //
   204  // If data is a [reflect.Value], the template applies to the concrete
   205  // value that the reflect.Value holds, as in [fmt.Print].
   206  func (t *Template) Execute(wr io.Writer, data any) error {
   207  	return t.execute(wr, data)
   208  }
   209  
   210  func (t *Template) execute(wr io.Writer, data any) (err error) {
   211  	defer errRecover(&err)
   212  	value, ok := data.(reflect.Value)
   213  	if !ok {
   214  		value = reflect.ValueOf(data)
   215  	}
   216  	state := &state{
   217  		tmpl: t,
   218  		wr:   wr,
   219  		vars: []variable{{"$", value}},
   220  	}
   221  	if t.Tree == nil || t.Root == nil {
   222  		state.errorf("%q is an incomplete or empty template", t.Name())
   223  	}
   224  	state.walk(value, t.Root)
   225  	return
   226  }
   227  
   228  // DefinedTemplates returns a string listing the defined templates,
   229  // prefixed by the string "; defined templates are: ". If there are none,
   230  // it returns the empty string. For generating an error message here
   231  // and in [html/template].
   232  func (t *Template) DefinedTemplates() string {
   233  	if t.common == nil {
   234  		return ""
   235  	}
   236  	var b strings.Builder
   237  	t.muTmpl.RLock()
   238  	defer t.muTmpl.RUnlock()
   239  	for name, tmpl := range t.tmpl {
   240  		if tmpl.Tree == nil || tmpl.Root == nil {
   241  			continue
   242  		}
   243  		if b.Len() == 0 {
   244  			b.WriteString("; defined templates are: ")
   245  		} else {
   246  			b.WriteString(", ")
   247  		}
   248  		fmt.Fprintf(&b, "%q", name)
   249  	}
   250  	return b.String()
   251  }
   252  
   253  // Sentinel errors for use with panic to signal early exits from range loops.
   254  var (
   255  	walkBreak    = errors.New("break")
   256  	walkContinue = errors.New("continue")
   257  )
   258  
   259  // Walk functions step through the major pieces of the template structure,
   260  // generating output as they go.
   261  func (s *state) walk(dot reflect.Value, node parse.Node) {
   262  	s.at(node)
   263  	switch node := node.(type) {
   264  	case *parse.ActionNode:
   265  		// Do not pop variables so they persist until next end.
   266  		// Also, if the action declares variables, don't print the result.
   267  		val := s.evalPipeline(dot, node.Pipe)
   268  		if len(node.Pipe.Decl) == 0 {
   269  			s.printValue(node, val)
   270  		}
   271  	case *parse.BreakNode:
   272  		panic(walkBreak)
   273  	case *parse.CommentNode:
   274  	case *parse.ContinueNode:
   275  		panic(walkContinue)
   276  	case *parse.IfNode:
   277  		s.walkIfOrWith(parse.NodeIf, dot, node.Pipe, node.List, node.ElseList)
   278  	case *parse.ListNode:
   279  		for _, node := range node.Nodes {
   280  			s.walk(dot, node)
   281  		}
   282  	case *parse.RangeNode:
   283  		s.walkRange(dot, node)
   284  	case *parse.TemplateNode:
   285  		s.walkTemplate(dot, node)
   286  	case *parse.TextNode:
   287  		if _, err := s.wr.Write(node.Text); err != nil {
   288  			s.writeError(err)
   289  		}
   290  	case *parse.WithNode:
   291  		s.walkIfOrWith(parse.NodeWith, dot, node.Pipe, node.List, node.ElseList)
   292  	default:
   293  		s.errorf("unknown node: %s", node)
   294  	}
   295  }
   296  
   297  // walkIfOrWith walks an 'if' or 'with' node. The two control structures
   298  // are identical in behavior except that 'with' sets dot.
   299  func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse.PipeNode, list, elseList *parse.ListNode) {
   300  	defer s.pop(s.mark())
   301  	val := s.evalPipeline(dot, pipe)
   302  	truth, ok := isTrue(indirectInterface(val))
   303  	if !ok {
   304  		s.errorf("if/with can't use %v", val)
   305  	}
   306  	if truth {
   307  		if typ == parse.NodeWith {
   308  			s.walk(val, list)
   309  		} else {
   310  			s.walk(dot, list)
   311  		}
   312  	} else if elseList != nil {
   313  		s.walk(dot, elseList)
   314  	}
   315  }
   316  
   317  // IsTrue reports whether the value is true, in the sense of being nonzero,
   318  // nonempty, or non-nil, and whether the value has a meaningful truth value.
   319  // This is the definition of truth used in "if" actions and elsewhere in
   320  // templates:
   321  //
   322  //   - A boolean value is true if it is true.
   323  //   - A numeric value is true if it is nonzero.
   324  //   - An array, map, slice, or string value is true if its length is
   325  //     greater than zero.
   326  //   - Any other value is true if it is non-nil; struct values are
   327  //     never nil, and therefore always true.
   328  func IsTrue(val any) (truth, ok bool) {
   329  	return isTrue(reflect.ValueOf(val))
   330  }
   331  
   332  func isTrue(val reflect.Value) (truth, ok bool) {
   333  	if !val.IsValid() {
   334  		// Something like var x interface{}, never set. It's a form of nil.
   335  		return false, true
   336  	}
   337  	switch val.Kind() {
   338  	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
   339  		truth = val.Len() > 0
   340  	case reflect.Bool:
   341  		truth = val.Bool()
   342  	case reflect.Complex64, reflect.Complex128:
   343  		truth = val.Complex() != 0
   344  	case reflect.Chan, reflect.Func, reflect.Pointer, reflect.UnsafePointer, reflect.Interface:
   345  		truth = !val.IsNil()
   346  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   347  		truth = val.Int() != 0
   348  	case reflect.Float32, reflect.Float64:
   349  		truth = val.Float() != 0
   350  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   351  		truth = val.Uint() != 0
   352  	case reflect.Struct:
   353  		truth = true // Struct values are always true.
   354  	default:
   355  		return
   356  	}
   357  	return truth, true
   358  }
   359  
   360  func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
   361  	s.at(r)
   362  	defer func() {
   363  		if r := recover(); r != nil && r != walkBreak {
   364  			panic(r)
   365  		}
   366  	}()
   367  	defer s.pop(s.mark())
   368  	val, _ := indirect(s.evalPipeline(dot, r.Pipe))
   369  	// mark top of stack before any variables in the body are pushed.
   370  	mark := s.mark()
   371  	oneIteration := func(index, elem reflect.Value) {
   372  		if len(r.Pipe.Decl) > 0 {
   373  			if r.Pipe.IsAssign {
   374  				// With two variables, index comes first.
   375  				// With one, we use the element.
   376  				if len(r.Pipe.Decl) > 1 {
   377  					s.setVar(r.Pipe.Decl[0].Ident[0], index)
   378  				} else {
   379  					s.setVar(r.Pipe.Decl[0].Ident[0], elem)
   380  				}
   381  			} else {
   382  				// Set top var (lexically the second if there
   383  				// are two) to the element.
   384  				s.setTopVar(1, elem)
   385  			}
   386  		}
   387  		if len(r.Pipe.Decl) > 1 {
   388  			if r.Pipe.IsAssign {
   389  				s.setVar(r.Pipe.Decl[1].Ident[0], elem)
   390  			} else {
   391  				// Set next var (lexically the first if there
   392  				// are two) to the index.
   393  				s.setTopVar(2, index)
   394  			}
   395  		}
   396  		defer s.pop(mark)
   397  		defer func() {
   398  			// Consume panic(walkContinue)
   399  			if r := recover(); r != nil && r != walkContinue {
   400  				panic(r)
   401  			}
   402  		}()
   403  		s.walk(elem, r.List)
   404  	}
   405  	switch val.Kind() {
   406  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
   407  		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   408  		if len(r.Pipe.Decl) > 1 {
   409  			s.errorf("can't use %v to iterate over more than one variable", val)
   410  			break
   411  		}
   412  		run := false
   413  		for v := range val.Seq() {
   414  			run = true
   415  			// Pass element as second value, as we do for channels.
   416  			oneIteration(reflect.Value{}, v)
   417  		}
   418  		if !run {
   419  			break
   420  		}
   421  		return
   422  	case reflect.Array, reflect.Slice:
   423  		if val.Len() == 0 {
   424  			break
   425  		}
   426  		for i := 0; i < val.Len(); i++ {
   427  			oneIteration(reflect.ValueOf(i), val.Index(i))
   428  		}
   429  		return
   430  	case reflect.Map:
   431  		if val.Len() == 0 {
   432  			break
   433  		}
   434  		om := fmtsort.Sort(val)
   435  		for _, m := range om {
   436  			oneIteration(m.Key, m.Value)
   437  		}
   438  		return
   439  	case reflect.Chan:
   440  		if val.IsNil() {
   441  			break
   442  		}
   443  		if val.Type().ChanDir() == reflect.SendDir {
   444  			s.errorf("range over send-only channel %v", val)
   445  			break
   446  		}
   447  		i := 0
   448  		for ; ; i++ {
   449  			elem, ok := val.Recv()
   450  			if !ok {
   451  				break
   452  			}
   453  			oneIteration(reflect.ValueOf(i), elem)
   454  		}
   455  		if i == 0 {
   456  			break
   457  		}
   458  		return
   459  	case reflect.Invalid:
   460  		break // An invalid value is likely a nil map, etc. and acts like an empty map.
   461  	case reflect.Func:
   462  		if val.Type().CanSeq() {
   463  			if len(r.Pipe.Decl) > 1 {
   464  				s.errorf("can't use %v iterate over more than one variable", val)
   465  				break
   466  			}
   467  			run := false
   468  			for v := range val.Seq() {
   469  				run = true
   470  				// Pass element as second value,
   471  				// as we do for channels.
   472  				oneIteration(reflect.Value{}, v)
   473  			}
   474  			if !run {
   475  				break
   476  			}
   477  			return
   478  		}
   479  		if val.Type().CanSeq2() {
   480  			run := false
   481  			for i, v := range val.Seq2() {
   482  				run = true
   483  				if len(r.Pipe.Decl) > 1 {
   484  					oneIteration(i, v)
   485  				} else {
   486  					// If there is only one range variable,
   487  					// oneIteration will use the
   488  					// second value.
   489  					oneIteration(reflect.Value{}, i)
   490  				}
   491  			}
   492  			if !run {
   493  				break
   494  			}
   495  			return
   496  		}
   497  		fallthrough
   498  	default:
   499  		s.errorf("range can't iterate over %v", val)
   500  	}
   501  	if r.ElseList != nil {
   502  		s.walk(dot, r.ElseList)
   503  	}
   504  }
   505  
   506  func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) {
   507  	s.at(t)
   508  	tmpl := s.tmpl.Lookup(t.Name)
   509  	if tmpl == nil {
   510  		s.errorf("template %q not defined", t.Name)
   511  	}
   512  	if s.depth == maxExecDepth {
   513  		s.errorf("exceeded maximum template depth (%v)", maxExecDepth)
   514  	}
   515  	// Variables declared by the pipeline persist.
   516  	dot = s.evalPipeline(dot, t.Pipe)
   517  	newState := *s
   518  	newState.depth++
   519  	newState.tmpl = tmpl
   520  	// No dynamic scoping: template invocations inherit no variables.
   521  	newState.vars = []variable{{"$", dot}}
   522  	newState.walk(dot, tmpl.Root)
   523  }
   524  
   525  // Eval functions evaluate pipelines, commands, and their elements and extract
   526  // values from the data structure by examining fields, calling methods, and so on.
   527  // The printing of those values happens only through walk functions.
   528  
   529  // evalPipeline returns the value acquired by evaluating a pipeline. If the
   530  // pipeline has a variable declaration, the variable will be pushed on the
   531  // stack. Callers should therefore pop the stack after they are finished
   532  // executing commands depending on the pipeline value.
   533  func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value reflect.Value) {
   534  	if pipe == nil {
   535  		return
   536  	}
   537  	s.at(pipe)
   538  	value = missingVal
   539  	for _, cmd := range pipe.Cmds {
   540  		value = s.evalCommand(dot, cmd, value) // previous value is this one's final arg.
   541  		// If the object has type interface{}, dig down one level to the thing inside.
   542  		if value.Kind() == reflect.Interface && value.Type().NumMethod() == 0 {
   543  			value = value.Elem()
   544  		}
   545  	}
   546  	for _, variable := range pipe.Decl {
   547  		if pipe.IsAssign {
   548  			s.setVar(variable.Ident[0], value)
   549  		} else {
   550  			s.push(variable.Ident[0], value)
   551  		}
   552  	}
   553  	return value
   554  }
   555  
   556  func (s *state) notAFunction(args []parse.Node, final reflect.Value) {
   557  	if len(args) > 1 || !isMissing(final) {
   558  		s.errorf("can't give argument to non-function %s", args[0])
   559  	}
   560  }
   561  
   562  func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final reflect.Value) reflect.Value {
   563  	firstWord := cmd.Args[0]
   564  	switch n := firstWord.(type) {
   565  	case *parse.FieldNode:
   566  		return s.evalFieldNode(dot, n, cmd.Args, final)
   567  	case *parse.ChainNode:
   568  		return s.evalChainNode(dot, n, cmd.Args, final)
   569  	case *parse.IdentifierNode:
   570  		// Must be a function.
   571  		return s.evalFunction(dot, n, cmd, cmd.Args, final)
   572  	case *parse.PipeNode:
   573  		// Parenthesized pipeline. The arguments are all inside the pipeline; final must be absent.
   574  		s.notAFunction(cmd.Args, final)
   575  		return s.evalPipeline(dot, n)
   576  	case *parse.VariableNode:
   577  		return s.evalVariableNode(dot, n, cmd.Args, final)
   578  	}
   579  	s.at(firstWord)
   580  	s.notAFunction(cmd.Args, final)
   581  	switch word := firstWord.(type) {
   582  	case *parse.BoolNode:
   583  		return reflect.ValueOf(word.True)
   584  	case *parse.DotNode:
   585  		return dot
   586  	case *parse.NilNode:
   587  		s.errorf("nil is not a command")
   588  	case *parse.NumberNode:
   589  		return s.idealConstant(word)
   590  	case *parse.StringNode:
   591  		return reflect.ValueOf(word.Text)
   592  	}
   593  	s.errorf("can't evaluate command %q", firstWord)
   594  	panic("not reached")
   595  }
   596  
   597  // idealConstant is called to return the value of a number in a context where
   598  // we don't know the type. In that case, the syntax of the number tells us
   599  // its type, and we use Go rules to resolve. Note there is no such thing as
   600  // a uint ideal constant in this situation - the value must be of int type.
   601  func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value {
   602  	// These are ideal constants but we don't know the type
   603  	// and we have no context.  (If it was a method argument,
   604  	// we'd know what we need.) The syntax guides us to some extent.
   605  	s.at(constant)
   606  	switch {
   607  	case constant.IsComplex:
   608  		return reflect.ValueOf(constant.Complex128) // incontrovertible.
   609  
   610  	case constant.IsFloat &&
   611  		!isHexInt(constant.Text) && !isRuneInt(constant.Text) &&
   612  		strings.ContainsAny(constant.Text, ".eEpP"):
   613  		return reflect.ValueOf(constant.Float64)
   614  
   615  	case constant.IsInt:
   616  		n := int(constant.Int64)
   617  		if int64(n) != constant.Int64 {
   618  			s.errorf("%s overflows int", constant.Text)
   619  		}
   620  		return reflect.ValueOf(n)
   621  
   622  	case constant.IsUint:
   623  		s.errorf("%s overflows int", constant.Text)
   624  	}
   625  	return zero
   626  }
   627  
   628  func isRuneInt(s string) bool {
   629  	return len(s) > 0 && s[0] == '\''
   630  }
   631  
   632  func isHexInt(s string) bool {
   633  	return len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') && !strings.ContainsAny(s, "pP")
   634  }
   635  
   636  func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value {
   637  	s.at(field)
   638  	return s.evalFieldChain(dot, dot, field, field.Ident, args, final)
   639  }
   640  
   641  func (s *state) evalChainNode(dot reflect.Value, chain *parse.ChainNode, args []parse.Node, final reflect.Value) reflect.Value {
   642  	s.at(chain)
   643  	if len(chain.Field) == 0 {
   644  		s.errorf("internal error: no fields in evalChainNode")
   645  	}
   646  	if chain.Node.Type() == parse.NodeNil {
   647  		s.errorf("indirection through explicit nil in %s", chain)
   648  	}
   649  	// (pipe).Field1.Field2 has pipe as .Node, fields as .Field. Eval the pipeline, then the fields.
   650  	pipe := s.evalArg(dot, nil, chain.Node)
   651  	return s.evalFieldChain(dot, pipe, chain, chain.Field, args, final)
   652  }
   653  
   654  func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value {
   655  	// $x.Field has $x as the first ident, Field as the second. Eval the var, then the fields.
   656  	s.at(variable)
   657  	value := s.varValue(variable.Ident[0])
   658  	if len(variable.Ident) == 1 {
   659  		s.notAFunction(args, final)
   660  		return value
   661  	}
   662  	return s.evalFieldChain(dot, value, variable, variable.Ident[1:], args, final)
   663  }
   664  
   665  // evalFieldChain evaluates .X.Y.Z possibly followed by arguments.
   666  // dot is the environment in which to evaluate arguments, while
   667  // receiver is the value being walked along the chain.
   668  func (s *state) evalFieldChain(dot, receiver reflect.Value, node parse.Node, ident []string, args []parse.Node, final reflect.Value) reflect.Value {
   669  	n := len(ident)
   670  	for i := 0; i < n-1; i++ {
   671  		receiver = s.evalField(dot, ident[i], node, nil, missingVal, receiver)
   672  	}
   673  	// Now if it's a method, it gets the arguments.
   674  	return s.evalField(dot, ident[n-1], node, args, final, receiver)
   675  }
   676  
   677  func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd parse.Node, args []parse.Node, final reflect.Value) reflect.Value {
   678  	s.at(node)
   679  	name := node.Ident
   680  	function, isBuiltin, ok := findFunction(name, s.tmpl)
   681  	if !ok {
   682  		s.errorf("%q is not a defined function", name)
   683  	}
   684  	return s.evalCall(dot, function, isBuiltin, cmd, name, args, final)
   685  }
   686  
   687  // evalField evaluates an expression like (.Field) or (.Field arg1 arg2).
   688  // The 'final' argument represents the return value from the preceding
   689  // value of the pipeline, if any.
   690  func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, args []parse.Node, final, receiver reflect.Value) reflect.Value {
   691  	if !receiver.IsValid() {
   692  		if s.tmpl.option.missingKey == mapError { // Treat invalid value as missing map key.
   693  			s.errorf("nil data; no entry for key %q", fieldName)
   694  		}
   695  		return zero
   696  	}
   697  	typ := receiver.Type()
   698  	receiver, isNil := indirect(receiver)
   699  	if receiver.Kind() == reflect.Interface && isNil {
   700  		// Calling a method on a nil interface can't work. The
   701  		// MethodByName method call below would panic.
   702  		s.errorf("nil pointer evaluating %s.%s", typ, fieldName)
   703  		return zero
   704  	}
   705  
   706  	// Unless it's an interface, need to get to a value of type *T to guarantee
   707  	// we see all methods of T and *T.
   708  	ptr := receiver
   709  	if ptr.Kind() != reflect.Interface && ptr.Kind() != reflect.Pointer && ptr.CanAddr() {
   710  		ptr = ptr.Addr()
   711  	}
   712  	if method := ptr.MethodByName(fieldName); method.IsValid() {
   713  		return s.evalCall(dot, method, false, node, fieldName, args, final)
   714  	}
   715  	hasArgs := len(args) > 1 || !isMissing(final)
   716  	// It's not a method; must be a field of a struct or an element of a map.
   717  	switch receiver.Kind() {
   718  	case reflect.Struct:
   719  		tField, ok := receiver.Type().FieldByName(fieldName)
   720  		if ok {
   721  			field, err := receiver.FieldByIndexErr(tField.Index)
   722  			if !tField.IsExported() {
   723  				s.errorf("%s is an unexported field of struct type %s", fieldName, typ)
   724  			}
   725  			if err != nil {
   726  				s.errorf("%v", err)
   727  			}
   728  			// If it's a function, we must call it.
   729  			if hasArgs {
   730  				s.errorf("%s has arguments but cannot be invoked as function", fieldName)
   731  			}
   732  			return field
   733  		}
   734  	case reflect.Map:
   735  		// If it's a map, attempt to use the field name as a key.
   736  		nameVal := reflect.ValueOf(fieldName)
   737  		if nameVal.Type().AssignableTo(receiver.Type().Key()) {
   738  			if hasArgs {
   739  				s.errorf("%s is not a method but has arguments", fieldName)
   740  			}
   741  			result := receiver.MapIndex(nameVal)
   742  			if !result.IsValid() {
   743  				switch s.tmpl.option.missingKey {
   744  				case mapInvalid:
   745  					// Just use the invalid value.
   746  				case mapZeroValue:
   747  					result = reflect.Zero(receiver.Type().Elem())
   748  				case mapError:
   749  					s.errorf("map has no entry for key %q", fieldName)
   750  				}
   751  			}
   752  			return result
   753  		}
   754  	case reflect.Pointer:
   755  		etyp := receiver.Type().Elem()
   756  		if etyp.Kind() == reflect.Struct {
   757  			if _, ok := etyp.FieldByName(fieldName); !ok {
   758  				// If there's no such field, say "can't evaluate"
   759  				// instead of "nil pointer evaluating".
   760  				break
   761  			}
   762  		}
   763  		if isNil {
   764  			s.errorf("nil pointer evaluating %s.%s", typ, fieldName)
   765  		}
   766  	}
   767  	s.errorf("can't evaluate field %s in type %s", fieldName, typ)
   768  	panic("not reached")
   769  }
   770  
   771  var (
   772  	errorType        = reflect.TypeFor[error]()
   773  	fmtStringerType  = reflect.TypeFor[fmt.Stringer]()
   774  	reflectValueType = reflect.TypeFor[reflect.Value]()
   775  )
   776  
   777  // evalCall executes a function or method call. If it's a method, fun already has the receiver bound, so
   778  // it looks just like a function call. The arg list, if non-nil, includes (in the manner of the shell), arg[0]
   779  // as the function itself.
   780  func (s *state) evalCall(dot, fun reflect.Value, isBuiltin bool, node parse.Node, name string, args []parse.Node, final reflect.Value) reflect.Value {
   781  	if args != nil {
   782  		args = args[1:] // Zeroth arg is function name/node; not passed to function.
   783  	}
   784  	typ := fun.Type()
   785  	numIn := len(args)
   786  	if !isMissing(final) {
   787  		numIn++
   788  	}
   789  	numFixed := len(args)
   790  	if typ.IsVariadic() {
   791  		numFixed = typ.NumIn() - 1 // last arg is the variadic one.
   792  		if numIn < numFixed {
   793  			s.errorf("wrong number of args for %s: want at least %d got %d", name, typ.NumIn()-1, len(args))
   794  		}
   795  	} else if numIn != typ.NumIn() {
   796  		s.errorf("wrong number of args for %s: want %d got %d", name, typ.NumIn(), numIn)
   797  	}
   798  	if err := goodFunc(name, typ); err != nil {
   799  		s.errorf("%v", err)
   800  	}
   801  
   802  	unwrap := func(v reflect.Value) reflect.Value {
   803  		if v.Type() == reflectValueType {
   804  			v = v.Interface().(reflect.Value)
   805  		}
   806  		return v
   807  	}
   808  
   809  	// Special case for builtin and/or, which short-circuit.
   810  	if isBuiltin && (name == "and" || name == "or") {
   811  		argType := typ.In(0)
   812  		var v reflect.Value
   813  		for _, arg := range args {
   814  			v = s.evalArg(dot, argType, arg).Interface().(reflect.Value)
   815  			if truth(v) == (name == "or") {
   816  				// This value was already unwrapped
   817  				// by the .Interface().(reflect.Value).
   818  				return v
   819  			}
   820  		}
   821  		if !final.Equal(missingVal) {
   822  			// The last argument to and/or is coming from
   823  			// the pipeline. We didn't short circuit on an earlier
   824  			// argument, so we are going to return this one.
   825  			// We don't have to evaluate final, but we do
   826  			// have to check its type. Then, since we are
   827  			// going to return it, we have to unwrap it.
   828  			v = unwrap(s.validateType(final, argType))
   829  		}
   830  		return v
   831  	}
   832  
   833  	// Build the arg list.
   834  	argv := make([]reflect.Value, numIn)
   835  	// Args must be evaluated. Fixed args first.
   836  	i := 0
   837  	for ; i < numFixed && i < len(args); i++ {
   838  		argv[i] = s.evalArg(dot, typ.In(i), args[i])
   839  	}
   840  	// Now the ... args.
   841  	if typ.IsVariadic() {
   842  		argType := typ.In(typ.NumIn() - 1).Elem() // Argument is a slice.
   843  		for ; i < len(args); i++ {
   844  			argv[i] = s.evalArg(dot, argType, args[i])
   845  		}
   846  	}
   847  	// Add final value if necessary.
   848  	if !isMissing(final) {
   849  		t := typ.In(typ.NumIn() - 1)
   850  		if typ.IsVariadic() {
   851  			if numIn-1 < numFixed {
   852  				// The added final argument corresponds to a fixed parameter of the function.
   853  				// Validate against the type of the actual parameter.
   854  				t = typ.In(numIn - 1)
   855  			} else {
   856  				// The added final argument corresponds to the variadic part.
   857  				// Validate against the type of the elements of the variadic slice.
   858  				t = t.Elem()
   859  			}
   860  		}
   861  		argv[i] = s.validateType(final, t)
   862  	}
   863  
   864  	// Special case for the "call" builtin.
   865  	// Insert the name of the callee function as the first argument.
   866  	if isBuiltin && name == "call" {
   867  		var calleeName string
   868  		if len(args) == 0 {
   869  			// final must be present or we would have errored out above.
   870  			calleeName = final.String()
   871  		} else {
   872  			calleeName = args[0].String()
   873  		}
   874  		argv = append([]reflect.Value{reflect.ValueOf(calleeName)}, argv...)
   875  		fun = reflect.ValueOf(call)
   876  	}
   877  
   878  	v, err := safeCall(fun, argv)
   879  	// If we have an error that is not nil, stop execution and return that
   880  	// error to the caller.
   881  	if err != nil {
   882  		s.at(node)
   883  		s.errorf("error calling %s: %w", name, err)
   884  	}
   885  	return unwrap(v)
   886  }
   887  
   888  // canBeNil reports whether an untyped nil can be assigned to the type. See reflect.Zero.
   889  func canBeNil(typ reflect.Type) bool {
   890  	switch typ.Kind() {
   891  	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice:
   892  		return true
   893  	case reflect.Struct:
   894  		return typ == reflectValueType
   895  	}
   896  	return false
   897  }
   898  
   899  // validateType guarantees that the value is valid and assignable to the type.
   900  func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value {
   901  	if !value.IsValid() {
   902  		if typ == nil {
   903  			// An untyped nil interface{}. Accept as a proper nil value.
   904  			return reflect.ValueOf(nil)
   905  		}
   906  		if canBeNil(typ) {
   907  			// Like above, but use the zero value of the non-nil type.
   908  			return reflect.Zero(typ)
   909  		}
   910  		s.errorf("invalid value; expected %s", typ)
   911  	}
   912  	if typ == reflectValueType && value.Type() != typ {
   913  		return reflect.ValueOf(value)
   914  	}
   915  	if typ != nil && !value.Type().AssignableTo(typ) {
   916  		if value.Kind() == reflect.Interface && !value.IsNil() {
   917  			value = value.Elem()
   918  			if value.Type().AssignableTo(typ) {
   919  				return value
   920  			}
   921  			// fallthrough
   922  		}
   923  		// Does one dereference or indirection work? We could do more, as we
   924  		// do with method receivers, but that gets messy and method receivers
   925  		// are much more constrained, so it makes more sense there than here.
   926  		// Besides, one is almost always all you need.
   927  		switch {
   928  		case value.Kind() == reflect.Pointer && value.Type().Elem().AssignableTo(typ):
   929  			value = value.Elem()
   930  			if !value.IsValid() {
   931  				s.errorf("dereference of nil pointer of type %s", typ)
   932  			}
   933  		case reflect.PointerTo(value.Type()).AssignableTo(typ) && value.CanAddr():
   934  			value = value.Addr()
   935  		default:
   936  			s.errorf("wrong type for value; expected %s; got %s", typ, value.Type())
   937  		}
   938  	}
   939  	return value
   940  }
   941  
   942  func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value {
   943  	s.at(n)
   944  	switch arg := n.(type) {
   945  	case *parse.DotNode:
   946  		return s.validateType(dot, typ)
   947  	case *parse.NilNode:
   948  		if canBeNil(typ) {
   949  			return reflect.Zero(typ)
   950  		}
   951  		s.errorf("cannot assign nil to %s", typ)
   952  	case *parse.FieldNode:
   953  		return s.validateType(s.evalFieldNode(dot, arg, []parse.Node{n}, missingVal), typ)
   954  	case *parse.VariableNode:
   955  		return s.validateType(s.evalVariableNode(dot, arg, nil, missingVal), typ)
   956  	case *parse.PipeNode:
   957  		return s.validateType(s.evalPipeline(dot, arg), typ)
   958  	case *parse.IdentifierNode:
   959  		return s.validateType(s.evalFunction(dot, arg, arg, nil, missingVal), typ)
   960  	case *parse.ChainNode:
   961  		return s.validateType(s.evalChainNode(dot, arg, nil, missingVal), typ)
   962  	}
   963  	switch typ.Kind() {
   964  	case reflect.Bool:
   965  		return s.evalBool(typ, n)
   966  	case reflect.Complex64, reflect.Complex128:
   967  		return s.evalComplex(typ, n)
   968  	case reflect.Float32, reflect.Float64:
   969  		return s.evalFloat(typ, n)
   970  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   971  		return s.evalInteger(typ, n)
   972  	case reflect.Interface:
   973  		if typ.NumMethod() == 0 {
   974  			return s.evalEmptyInterface(dot, n)
   975  		}
   976  	case reflect.Struct:
   977  		if typ == reflectValueType {
   978  			return reflect.ValueOf(s.evalEmptyInterface(dot, n))
   979  		}
   980  	case reflect.String:
   981  		return s.evalString(typ, n)
   982  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   983  		return s.evalUnsignedInteger(typ, n)
   984  	}
   985  	s.errorf("can't handle %s for arg of type %s", n, typ)
   986  	panic("not reached")
   987  }
   988  
   989  func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value {
   990  	s.at(n)
   991  	if n, ok := n.(*parse.BoolNode); ok {
   992  		value := reflect.New(typ).Elem()
   993  		value.SetBool(n.True)
   994  		return value
   995  	}
   996  	s.errorf("expected bool; found %s", n)
   997  	panic("not reached")
   998  }
   999  
  1000  func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value {
  1001  	s.at(n)
  1002  	if n, ok := n.(*parse.StringNode); ok {
  1003  		value := reflect.New(typ).Elem()
  1004  		value.SetString(n.Text)
  1005  		return value
  1006  	}
  1007  	s.errorf("expected string; found %s", n)
  1008  	panic("not reached")
  1009  }
  1010  
  1011  func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value {
  1012  	s.at(n)
  1013  	if n, ok := n.(*parse.NumberNode); ok && n.IsInt {
  1014  		value := reflect.New(typ).Elem()
  1015  		value.SetInt(n.Int64)
  1016  		return value
  1017  	}
  1018  	s.errorf("expected integer; found %s", n)
  1019  	panic("not reached")
  1020  }
  1021  
  1022  func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value {
  1023  	s.at(n)
  1024  	if n, ok := n.(*parse.NumberNode); ok && n.IsUint {
  1025  		value := reflect.New(typ).Elem()
  1026  		value.SetUint(n.Uint64)
  1027  		return value
  1028  	}
  1029  	s.errorf("expected unsigned integer; found %s", n)
  1030  	panic("not reached")
  1031  }
  1032  
  1033  func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value {
  1034  	s.at(n)
  1035  	if n, ok := n.(*parse.NumberNode); ok && n.IsFloat {
  1036  		value := reflect.New(typ).Elem()
  1037  		value.SetFloat(n.Float64)
  1038  		return value
  1039  	}
  1040  	s.errorf("expected float; found %s", n)
  1041  	panic("not reached")
  1042  }
  1043  
  1044  func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value {
  1045  	if n, ok := n.(*parse.NumberNode); ok && n.IsComplex {
  1046  		value := reflect.New(typ).Elem()
  1047  		value.SetComplex(n.Complex128)
  1048  		return value
  1049  	}
  1050  	s.errorf("expected complex; found %s", n)
  1051  	panic("not reached")
  1052  }
  1053  
  1054  func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Value {
  1055  	s.at(n)
  1056  	switch n := n.(type) {
  1057  	case *parse.BoolNode:
  1058  		return reflect.ValueOf(n.True)
  1059  	case *parse.DotNode:
  1060  		return dot
  1061  	case *parse.FieldNode:
  1062  		return s.evalFieldNode(dot, n, nil, missingVal)
  1063  	case *parse.IdentifierNode:
  1064  		return s.evalFunction(dot, n, n, nil, missingVal)
  1065  	case *parse.NilNode:
  1066  		// NilNode is handled in evalArg, the only place that calls here.
  1067  		s.errorf("evalEmptyInterface: nil (can't happen)")
  1068  	case *parse.NumberNode:
  1069  		return s.idealConstant(n)
  1070  	case *parse.StringNode:
  1071  		return reflect.ValueOf(n.Text)
  1072  	case *parse.VariableNode:
  1073  		return s.evalVariableNode(dot, n, nil, missingVal)
  1074  	case *parse.PipeNode:
  1075  		return s.evalPipeline(dot, n)
  1076  	}
  1077  	s.errorf("can't handle assignment of %s to empty interface argument", n)
  1078  	panic("not reached")
  1079  }
  1080  
  1081  // indirect returns the item at the end of indirection, and a bool to indicate
  1082  // if it's nil. If the returned bool is true, the returned value's kind will be
  1083  // either a pointer or interface.
  1084  func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
  1085  	for ; v.Kind() == reflect.Pointer || v.Kind() == reflect.Interface; v = v.Elem() {
  1086  		if v.IsNil() {
  1087  			return v, true
  1088  		}
  1089  	}
  1090  	return v, false
  1091  }
  1092  
  1093  // indirectInterface returns the concrete value in an interface value,
  1094  // or else the zero reflect.Value.
  1095  // That is, if v represents the interface value x, the result is the same as reflect.ValueOf(x):
  1096  // the fact that x was an interface value is forgotten.
  1097  func indirectInterface(v reflect.Value) reflect.Value {
  1098  	if v.Kind() != reflect.Interface {
  1099  		return v
  1100  	}
  1101  	if v.IsNil() {
  1102  		return reflect.Value{}
  1103  	}
  1104  	return v.Elem()
  1105  }
  1106  
  1107  // printValue writes the textual representation of the value to the output of
  1108  // the template.
  1109  func (s *state) printValue(n parse.Node, v reflect.Value) {
  1110  	s.at(n)
  1111  	iface, ok := printableValue(v)
  1112  	if !ok {
  1113  		s.errorf("can't print %s of type %s", n, v.Type())
  1114  	}
  1115  	_, err := fmt.Fprint(s.wr, iface)
  1116  	if err != nil {
  1117  		s.writeError(err)
  1118  	}
  1119  }
  1120  
  1121  // printableValue returns the, possibly indirected, interface value inside v that
  1122  // is best for a call to formatted printer.
  1123  func printableValue(v reflect.Value) (any, bool) {
  1124  	if v.Kind() == reflect.Pointer {
  1125  		v, _ = indirect(v) // fmt.Fprint handles nil.
  1126  	}
  1127  	if !v.IsValid() {
  1128  		return "<no value>", true
  1129  	}
  1130  
  1131  	if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) {
  1132  		if v.CanAddr() && (reflect.PointerTo(v.Type()).Implements(errorType) || reflect.PointerTo(v.Type()).Implements(fmtStringerType)) {
  1133  			v = v.Addr()
  1134  		} else {
  1135  			switch v.Kind() {
  1136  			case reflect.Chan, reflect.Func:
  1137  				return nil, false
  1138  			}
  1139  		}
  1140  	}
  1141  	return v.Interface(), true
  1142  }
  1143
View as plain text