code review 4643068: exp/template: functions

src/pkg/exp/template/exec.go

 // Copyright 2011 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 template
 
 import (
         "fmt"
         "io"
         "os"
@@ skipping 156 matching lines @@
 func (s *state) evalPipeline(data reflect.Value, pipe []*commandNode) reflect.Value {
         value := reflect.Value{}
         for _, cmd := range pipe {
                 value = s.evalCommand(data, cmd, value) // previous value is this one's final arg.
         }
         return value
 }
 
 func (s *state) evalCommand(data reflect.Value, cmd *commandNode, final reflect.Value) reflect.Value {
         firstWord := cmd.args[0]
-        if field, ok := firstWord.(*fieldNode); ok {
-                return s.evalFieldNode(data, field, cmd.args, final)
+        switch n := firstWord.(type) {
+        case *fieldNode:
+                return s.evalFieldNode(data, n, cmd.args, final)
+        case *identifierNode:
+                return s.evalFieldOrCall(data, n.ident, cmd.args, final)
         }
         if len(cmd.args) > 1 || final.IsValid() {
                 // TODO: functions
                 s.errorf("can't give argument to non-method %s", cmd.args[0])
         }
         switch word := cmd.args[0].(type) {
         case *dotNode:
                 return data
         case *boolNode:
                 return reflect.ValueOf(word.true)
@@ skipping 19 matching lines @@
         panic("not reached")
 }
 
 func (s *state) evalFieldNode(data reflect.Value, field *fieldNode, args []node, final reflect.Value) reflect.Value {
         // Up to the last entry, it must be a field.
         n := len(field.ident)
         for i := 0; i < n-1; i++ {
                 data = s.evalField(data, field.ident[i])
         }
         // Now it can be a field or method and if a method, gets arguments.
-        return s.evalMethodOrField(data, field.ident[n-1], args, final)
+        return s.evalFieldOrCall(data, field.ident[n-1], args, final)
 }
 
 func (s *state) evalField(data reflect.Value, fieldName string) reflect.Value {
         for data.Kind() == reflect.Ptr {
                 data = reflect.Indirect(data)
         }
         switch data.Kind() {
         case reflect.Struct:
                 // Is it a field?
                 field := data.FieldByName(fieldName)
                 // TODO: look higher up the tree if we can't find it here. Also unexported fields
                 // might succeed higher up, as map keys.
                 if field.IsValid() && field.Type().PkgPath() == "" { // valid and exported
                         return field
                 }
                 s.errorf("%s has no field %s", data.Type(), fieldName)
         default:
                 s.errorf("can't evaluate field %s of type %s", fieldName, data.Type())
         }
         panic("not reached")
 }
 
-func (s *state) evalMethodOrField(data reflect.Value, fieldName string, args []node, final reflect.Value) reflect.Value {
+func (s *state) evalFieldOrCall(data reflect.Value, fieldName string, args []node, final reflect.Value) reflect.Value {
+        // Is it a function?
+        if function, ok := findFunction(fieldName, s.tmpl, s.set); ok {
+                return s.evalCall(data, function, fieldName, false, args, final)
+        }
         ptr := data
         for data.Kind() == reflect.Ptr {
                 ptr, data = data, reflect.Indirect(data)
         }
         // Is it a method? We use the pointer because it has value methods too.
         if method, ok := ptr.Type().MethodByName(fieldName); ok {
-                return s.evalMethod(ptr, method, args, final)
+                return s.evalCall(ptr, method.Func, fieldName, true, args, final)
         }
         if len(args) > 1 || final.IsValid() {
                 s.errorf("%s is not a method but has arguments", fieldName)
         }
         switch data.Kind() {
         case reflect.Struct:
                 return s.evalField(data, fieldName)
         default:
                 s.errorf("can't handle evaluation of field %s of type %s", fieldName, data.Type())
         }
         panic("not reached")
 }
 
 var (
         osErrorType = reflect.TypeOf(new(os.Error)).Elem()
 )
 
-func (s *state) evalMethod(v reflect.Value, method reflect.Method, args []node, final reflect.Value) reflect.Value {
-        typ := method.Type
-        fun := method.Func
+func (s *state) evalCall(v, fun reflect.Value, name string, isMethod bool, args []node, final reflect.Value) reflect.Value {
+        typ := fun.Type()
+        if !isMethod && len(args) > 0 { // Args will be nil if it's a niladic call in an argument list
+                args = args[1:] // first arg is name of function; not used in call.
+        }
         numIn := len(args)
         if final.IsValid() {
                 numIn++
         }
-        if !typ.IsVariadic() && numIn < typ.NumIn()-1 || !typ.IsVariadic() && numIn != typ.NumIn() {
-                s.errorf("wrong number of args for %s: want %d got %d", method.Name, typ.NumIn(), len(args))
+        numFixed := len(args)
+        if typ.IsVariadic() {
+                numFixed = typ.NumIn() - 1 // last arg is the variadic one.
+                if numIn < numFixed {
+                        s.errorf("wrong number of args for %s: want at least %d got %d", name, typ.NumIn()-1, len(args))
+                }
+        } else if numIn < typ.NumIn()-1 || !typ.IsVariadic() && numIn != typ.NumIn() {
+                s.errorf("wrong number of args for %s: want %d got %d", name, typ.NumIn(), len(args))
         }
-        // We allow methods with 1 result or 2 results where the second is an os.Error.
+        // We allow functions with 1 result or 2 results where the second is an os.Error.
         switch {
         case typ.NumOut() == 1:
         case typ.NumOut() == 2 && typ.Out(1) == osErrorType:

[dsymonds, 2011/07/05 04:17:04]

This checking could be replicated in addFuncs so that named functions can be
statically checked before failing at evaluation time.

         default:
-                s.errorf("can't handle multiple results from method %q", method.Name)
+                s.errorf("can't handle multiple results from method/function %q", name)
         }
         // Build the arg list.
         argv := make([]reflect.Value, numIn)
         // First arg is the receiver.
-        argv[0] = v
-        // Others must be evaluated.
-        for i := 1; i < len(args); i++ {
+        i := 0
+        if isMethod {
+                argv[0] = v
+                i++
+        }
+        // Others must be evaluated. Fixed args first.
+        for ; i < numFixed; i++ {
                 argv[i] = s.evalArg(v, typ.In(i), args[i])
         }
+        // And now the ... args.
+        if typ.IsVariadic() {
+                argType := typ.In(typ.NumIn() - 1).Elem() // Argument is a slice.
+                for ; i < len(args); i++ {
+                        argv[i] = s.evalArg(v, argType, args[i])
+                }
+        }
         // Add final value if necessary.
         if final.IsValid() {
                 argv[len(args)] = final
         }
         result := fun.Call(argv)
         // If we have an os.Error that is not nil, stop execution and return that error to the caller.
         if len(result) == 2 && !result[1].IsNil() {
                 s.error(result[1].Interface().(os.Error))
         }
         return result[0]
 }
 
 func (s *state) evalArg(data reflect.Value, typ reflect.Type, n node) reflect.Value {
         if field, ok := n.(*fieldNode); ok {
                 value := s.evalFieldNode(data, field, []node{n}, reflect.Value{})
                 if !value.Type().AssignableTo(typ) {
                         s.errorf("wrong type for value; expected %s; got %s", typ, value.Type())
                 }
                 return value
         }
         switch typ.Kind() {
         case reflect.Bool:
-                return s.evalBool(data, typ, n)
+                return s.evalBool(typ, n)
         case reflect.String:
-                return s.evalString(data, typ, n)
+                return s.evalString(typ, n)
         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-                return s.evalInteger(data, typ, n)
+                return s.evalInteger(typ, n)
         case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-                return s.evalUnsignedInteger(data, typ, n)
+                return s.evalUnsignedInteger(typ, n)
         case reflect.Float32, reflect.Float64:
-                return s.evalFloat(data, typ, n)
+                return s.evalFloat(typ, n)
         case reflect.Complex64, reflect.Complex128:
-                return s.evalComplex(data, typ, n)
+                return s.evalComplex(typ, n)
+        case reflect.Interface:
+                if typ.NumMethod() == 0 {
+                        return s.evalEmptyInterface(data, typ, n)
+                }
         }
-        s.errorf("can't handle node %s for method arg of type %s", n, typ)
+        s.errorf("can't handle %s for arg of type %s", n, typ)
         panic("not reached")
 }
 
-func (s *state) evalBool(v reflect.Value, typ reflect.Type, n node) reflect.Value {
+func (s *state) evalBool(typ reflect.Type, n node) reflect.Value {
         if n, ok := n.(*boolNode); ok {
                 value := reflect.New(typ).Elem()
                 value.SetBool(n.true)
                 return value
         }
         s.errorf("expected bool; found %s", n)
         panic("not reached")
 }
 
-func (s *state) evalString(v reflect.Value, typ reflect.Type, n node) reflect.Value {
+func (s *state) evalString(typ reflect.Type, n node) reflect.Value {
         if n, ok := n.(*stringNode); ok {
                 value := reflect.New(typ).Elem()
                 value.SetString(n.text)
                 return value
         }
         s.errorf("expected string; found %s", n)
         panic("not reached")
 }
 
-func (s *state) evalInteger(v reflect.Value, typ reflect.Type, n node) reflect.Value {
+func (s *state) evalInteger(typ reflect.Type, n node) reflect.Value {
         if n, ok := n.(*numberNode); ok && n.isInt {
                 value := reflect.New(typ).Elem()
                 value.SetInt(n.int64)
                 return value
         }
         s.errorf("expected integer; found %s", n)
         panic("not reached")
 }
 
-func (s *state) evalUnsignedInteger(v reflect.Value, typ reflect.Type, n node) reflect.Value {
+func (s *state) evalUnsignedInteger(typ reflect.Type, n node) reflect.Value {
         if n, ok := n.(*numberNode); ok && n.isUint {
                 value := reflect.New(typ).Elem()
                 value.SetUint(n.uint64)
                 return value
         }
         s.errorf("expected unsigned integer; found %s", n)
         panic("not reached")
 }
 
-func (s *state) evalFloat(v reflect.Value, typ reflect.Type, n node) reflect.Value {
+func (s *state) evalFloat(typ reflect.Type, n node) reflect.Value {
         if n, ok := n.(*numberNode); ok && n.isFloat {
                 value := reflect.New(typ).Elem()
                 value.SetFloat(n.float64)
                 return value
         }
         s.errorf("expected float; found %s", n)
         panic("not reached")
 }
 
-func (s *state) evalComplex(v reflect.Value, typ reflect.Type, n node) reflect.Value {
+func (s *state) evalComplex(typ reflect.Type, n node) reflect.Value {
         if n, ok := n.(*numberNode); ok && n.isComplex {
                 value := reflect.New(typ).Elem()
                 value.SetComplex(n.complex128)
                 return value
         }
         s.errorf("expected complex; found %s", n)
         panic("not reached")
 }
 
+func (s *state) evalEmptyInterface(data reflect.Value, typ reflect.Type, n node) reflect.Value {
+        switch n := n.(type) {
+        case *boolNode:
+                return reflect.ValueOf(n.true)
+        case *fieldNode:
+                return s.evalFieldNode(data, n, nil, reflect.Value{})
+        case *identifierNode:
+                return s.evalFieldOrCall(data, n.ident, nil, reflect.Value{})
+        case *numberNode:
+                if n.isComplex {
+                        return reflect.ValueOf(n.complex128)
+                }
+                if n.isInt {
+                        return reflect.ValueOf(n.int64)
+                }
+                if n.isUint {
+                        return reflect.ValueOf(n.uint64)
+                }
+                if n.isFloat {
+                        return reflect.ValueOf(n.float64)
+                }
+        case *stringNode:
+                return reflect.ValueOf(n.text)
+        }
+        s.errorf("can't handle assignment of %s to empty interface argument", n)
+        panic("not reached")
+}
+
 // printValue writes the textual representation of the value to the output of
 // the template.
 func (s *state) printValue(n node, v reflect.Value) {
         if !v.IsValid() {
                 return
         }
         switch v.Kind() {
         case reflect.Ptr:
                 if v.IsNil() {
                         s.errorf("%s: nil value", n)
                 }
         case reflect.Chan, reflect.Func, reflect.Interface:
                 s.errorf("can't print %s of type %s", n, v.Type())
         }
         fmt.Fprint(s.wr, v.Interface())
 }