// in which is available in custom formatters through
// the state parameter.
//
-func (f Format) Eval(env Environment, args ...) ([]byte, os.Error) {
+func (f Format) Eval(env Environment, args ...interface{}) ([]byte, os.Error) {
if f == nil {
return nil, os.NewError("format is nil")
}
s := newState(f, env, errors)
go func() {
- value := reflect.NewValue(args).(*reflect.StructValue)
- for i := 0; i < value.NumField(); i++ {
- fld := value.Field(i)
+ for _, v := range args {
+ fld := reflect.NewValue(v)
+ if fld == nil {
+ errors <- os.NewError("nil argument")
+ return
+ }
mark := s.save()
if !s.eval(s.getFormat(typename(fld.Type())), fld, 0) { // TODO is 0 index correct?
s.restore(mark)
// and writes to w. The result is the total number of bytes
// written and an os.Error, if any.
//
-func (f Format) Fprint(w io.Writer, env Environment, args ...) (int, os.Error) {
+func (f Format) Fprint(w io.Writer, env Environment, args ...interface{}) (int, os.Error) {
data, err := f.Eval(env, args)
if err != nil {
// TODO should we print partial result in case of error?
// and writes to standard output. The result is the total
// number of bytes written and an os.Error, if any.
//
-func (f Format) Print(args ...) (int, os.Error) {
+func (f Format) Print(args ...interface{}) (int, os.Error) {
return f.Fprint(os.Stdout, nil, args)
}
// during formatting, the result string contains the
// partially formatted result followed by an error message.
//
-func (f Format) Sprint(args ...) string {
+func (f Format) Sprint(args ...interface{}) string {
var buf bytes.Buffer
_, err := f.Fprint(&buf, nil, args)
if err != nil {
}
-func verify(t *testing.T, f Format, expected string, args ...) {
+func verify(t *testing.T, f Format, expected string, args ...interface{}) {
if f == nil {
return // allow other tests to run
}
// ----------------------------------------------------------------------------
// Formatting of basic and simple composite types
-func check(t *testing.T, form, expected string, args ...) {
+func check(t *testing.T, form, expected string, args ...interface{}) {
f := parse(t, form, nil)
if f == nil {
return // allow other tests to run
}
-func TestInterfaceTypes(t *testing.T) {
- var i0 interface{}
- check(t, `interface="interface"`, `interface`, i0)
-
- i0 = "foo"
- check(t, `interface="interface"`, `interface`, i0)
- check(t, `interface=*; string="%s"`, `foo`, i0)
-}
-
-
func TestMapTypes(t *testing.T) {
var m0 map[string]int
check(t, `map="map"`, `map`, m0)
import (
"container/vector"
+ "fmt"
"io"
"os"
. "reflect"
},
pair{struct {
x struct {
- f func(args ...)
+ f func(args ...int)
}
}{},
- "struct { f func(...) }",
+ "struct { f func(...int) }",
},
pair{struct {
x (interface {
t.Errorf("Typeof(vector.Vector{}).PkgPath() = %q, want \"container/vector\"", path)
}
}
+
+func TestDotDotDot(t *testing.T) {
+ // Test example from FuncType.DotDotDot documentation.
+ var f func(x int, y ...float)
+ typ := Typeof(f).(*FuncType)
+ if typ.NumIn() == 2 && typ.In(0) == Typeof(int(0)) {
+ sl, ok := typ.In(1).(*SliceType)
+ if ok {
+ if sl.Elem() == Typeof(float(0)) {
+ // ok
+ return
+ }
+ }
+ }
+
+ // Failed
+ t.Errorf("want NumIn() = 2, In(0) = int, In(1) = []float")
+ s := fmt.Sprintf("have NumIn() = %d", typ.NumIn())
+ for i := 0; i < typ.NumIn(); i++ {
+ s += fmt.Sprintf(", In(%d) = %s", i, typ.In(i))
+ }
+ t.Error(s)
+}
}
// DotDotDot returns true if the final function input parameter
-// is a "..." parameter. If so, the parameter's underlying static
-// type - either interface{} or []T - is returned by t.In(t.NumIn() - 1).
+// is a "..." parameter. If so, t.In(t.NumIn() - 1) returns the
+// parameter's underlying static type []T.
//
// For concreteness, if t is func(x int, y ... float), then
//
func (s Send) getChannel() interface{} { return s.Channel }
-func newEmptyInterface(args ...) reflect.Value {
- return reflect.NewValue(args).(*reflect.StructValue).Field(0)
+type empty struct {
+ x interface{}
+}
+
+func newEmptyInterface(e empty) reflect.Value {
+ return reflect.NewValue(e).(*reflect.StructValue).Field(0)
}
func (s Send) send() {
c := reflect.NewValue(s.Channel).(*reflect.ChanValue)
var v reflect.Value
if iface, ok := c.Type().(*reflect.ChanType).Elem().(*reflect.InterfaceType); ok && iface.NumMethod() == 0 {
- v = newEmptyInterface(s.Value)
+ v = newEmptyInterface(empty{s.Value})
} else {
v = reflect.NewValue(s.Value)
}
+++ /dev/null
-// errchk $G $D/$F.go
-
-// Copyright 2009 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 main
-
-func f(args ...) {
-}
-
-func main() {
- f(nil); // ERROR "nil"
-}
package main
-func f(x int, y ...) // ok
+func f(x int, y ...int) // ok
func g(x int, y float) (...) // ERROR "[.][.][.]"
-func h(x, y ...) // ERROR "[.][.][.]"
+func h(x, y ...int) // ERROR "[.][.][.]"
-func i(x int, y ..., z float) // ERROR "[.][.][.]"
+func i(x int, y ...int, z float) // ERROR "[.][.][.]"
-var x ...; // ERROR "[.][.][.]|syntax|type"
+var x ...int; // ERROR "[.][.][.]|syntax|type"
-type T ...; // ERROR "[.][.][.]|syntax|type"
+type T ...int; // ERROR "[.][.][.]|syntax|type"
// license that can be found in the LICENSE file.
package main
-type I interface { X(...) }
+type I interface { X(...int) }
package main
-func f(args ...) {
+func f(args ...int) {
g(args) // ERROR "[.][.][.] mismatch"
}