Make the reflection library match the reflection string which
6g generates for functions: expect the keyword "func". The
older reflection syntax, without the "func", is still
recognized for simplicity in parsing interface reflection
strings.
R=r,rsc
DELTA=66 (31 added, 8 deleted, 27 changed)
OCL=27396
CL=27422
diff --git a/src/lib/reflect/all_test.go b/src/lib/reflect/all_test.go
index e3f6b9b..ed1e963 100644
--- a/src/lib/reflect/all_test.go
+++ b/src/lib/reflect/all_test.go
@@ -117,8 +117,8 @@
typedump("map[string]int32", "map[string]int32");
typedump("chan<-string", "chan<-string");
typedump("struct {c chan *int32; d float32}", "struct{c chan*int32; d float32}");
- typedump("*(a int8, b int32)", "*(a int8, b int32)");
- typedump("struct {c *(? chan *P.integer, ? *int8)}", "struct{c *(chan*P.integer, *int8)}");
+ typedump("func(a int8, b int32)", "func(a int8, b int32)");
+ typedump("struct {c func(? chan *P.integer, ? *int8)}", "struct{c func(chan*P.integer, *int8)}");
typedump("struct {a int8; b int32}", "struct{a int8; b int32}");
typedump("struct {a int8; b int8; b int32}", "struct{a int8; b int8; b int32}");
typedump("struct {a int8; b int8; c int8; b int32}", "struct{a int8; b int8; c int8; b int32}");
@@ -126,7 +126,8 @@
typedump("struct {a int8; b int8; c int8; d int8; e int8; b int32}", "struct{a int8; b int8; c int8; d int8; e int8; b int32}");
typedump("struct {a int8 \"hi there\"; }", "struct{a int8 \"hi there\"}");
typedump("struct {a int8 \"hi \\x00there\\t\\n\\\"\\\\\"; }", "struct{a int8 \"hi \\x00there\\t\\n\\\"\\\\\"}");
- typedump("struct {f *(args ...)}", "struct{f *(args ...)}");
+ typedump("struct {f func(args ...)}", "struct{f func(args ...)}");
+ typedump("interface { a(? func(? func(? int) int) func(? func(? int)) int); b() }", "interface{a (func(func(int)(int))(func(func(int))(int))); b ()}");
// Values
valuedump("int8", "8");
@@ -148,8 +149,8 @@
valuedump("map[string]int32", "map[string]int32{<can't iterate on maps>}");
valuedump("chan<-string", "chan<-string");
valuedump("struct {c chan *int32; d float32}", "struct{c chan*int32; d float32}{chan*int32, 0}");
- valuedump("*(a int8, b int32)", "*(a int8, b int32)(0)");
- valuedump("struct {c *(? chan *P.integer, ? *int8)}", "struct{c *(chan*P.integer, *int8)}{*(chan*P.integer, *int8)(0)}");
+ valuedump("func(a int8, b int32)", "func(a int8, b int32)(0)");
+ valuedump("struct {c func(? chan *P.integer, ? *int8)}", "struct{c func(chan*P.integer, *int8)}{func(chan*P.integer, *int8)(0)}");
valuedump("struct {a int8; b int32}", "struct{a int8; b int32}{0, 0}");
valuedump("struct {a int8; b int8; b int32}", "struct{a int8; b int8; b int32}{0, 0, 0}");
@@ -243,14 +244,14 @@
t = reflect.ParseTypeString("", "interface {a() *int}");
assert(t.String(), "interface {a() *int}");
- t = reflect.ParseTypeString("", "*(a int8, b int32)");
- assert(t.String(), "*(a int8, b int32)");
+ t = reflect.ParseTypeString("", "func(a int8, b int32)");
+ assert(t.String(), "func(a int8, b int32)");
- t = reflect.ParseTypeString("", "*(a int8, b int32) float");
- assert(t.String(), "*(a int8, b int32) float");
+ t = reflect.ParseTypeString("", "func(a int8, b int32) float");
+ assert(t.String(), "func(a int8, b int32) float");
- t = reflect.ParseTypeString("", "*(a int8, b int32) (a float, b float)");
- assert(t.String(), "*(a int8, b int32) (a float, b float)");
+ t = reflect.ParseTypeString("", "func(a int8, b int32) (a float, b float)");
+ assert(t.String(), "func(a int8, b int32) (a float, b float)");
t = reflect.ParseTypeString("", "[32]int32");
assert(t.String(), "[32]int32");
@@ -311,6 +312,14 @@
assert(v3.Type().String(), "float");
}
+func TestFunctionValue(t *testing.T) {
+ v := reflect.NewValue(func() {});
+ if v.Interface() != v.Interface() {
+ t.Fatalf("TestFunction != itself");
+ }
+ assert(v.Type().String(), "func()");
+}
+
func TestCopyArray(t *testing.T) {
a := []int{ 1, 2, 3, 4, 10, 9, 8, 7 };
b := []int{ 11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44 };
diff --git a/src/lib/reflect/tostring.go b/src/lib/reflect/tostring.go
index bb673fc..43be4b9 100644
--- a/src/lib/reflect/tostring.go
+++ b/src/lib/reflect/tostring.go
@@ -45,14 +45,18 @@
Len() int;
}
-func typeFieldsToString(t hasFields, sep string) string {
+func typeFieldsToString(t hasFields, sep string, iface bool) string {
var str string;
for i := 0; i < t.Len(); i++ {
str1, typ, tag, offset := t.Field(i);
if str1 != "" {
str1 += " "
}
- str1 += typeToString(typ, false);
+ str2 := typeToString(typ, false);
+ if iface && str2[0:4] == "func" {
+ str2 = str2[4:len(str2)]
+ }
+ str1 += str2;
if tag != "" {
str1 += " " + doubleQuote(tag);
}
@@ -111,14 +115,14 @@
}
return str + typeToString(c.Elem(), false);
case StructKind:
- return "struct{" + typeFieldsToString(typ.(StructType), ";") + "}";
+ return "struct{" + typeFieldsToString(typ.(StructType), ";", false) + "}";
case InterfaceKind:
- return "interface{" + typeFieldsToString(typ.(InterfaceType), ";") + "}";
+ return "interface{" + typeFieldsToString(typ.(InterfaceType), ";", true) + "}";
case FuncKind:
f := typ.(FuncType);
- str = "(" + typeFieldsToString(f.In(), ",") + ")";
+ str = "func(" + typeFieldsToString(f.In(), ",", false) + ")";
if f.Out() != nil {
- str += "(" + typeFieldsToString(f.Out(), ",") + ")";
+ str += "(" + typeFieldsToString(f.Out(), ",", false) + ")";
}
return str;
default:
@@ -221,7 +225,8 @@
case InterfaceKind:
return "can't print interfaces yet";
case FuncKind:
- return "can't print funcs yet";
+ v := val.(FuncValue);
+ return typeToString(typ, false) + "(" + integer(int64(uintptr(v.Get()))) + ")";
default:
panicln("reflect.valueToString: can't print type ", val.Kind());
}
diff --git a/src/lib/reflect/type.go b/src/lib/reflect/type.go
index 7e992a8..6fb84c8 100644
--- a/src/lib/reflect/type.go
+++ b/src/lib/reflect/type.go
@@ -61,6 +61,7 @@
xfloat float;
xfloat32 float32;
xfloat64 float64;
+ xfunc func();
xint int;
xint16 int16;
xint32 int32;
@@ -466,17 +467,11 @@
}
func newFuncTypeStruct(name, typestring string, in, out *structTypeStruct) *funcTypeStruct {
- return &funcTypeStruct{ commonType{FuncKind, typestring, name, 0}, in, out }
+ return &funcTypeStruct{ commonType{FuncKind, typestring, name, ptrsize}, in, out }
}
func (t *funcTypeStruct) FieldAlign() int {
- panic("reflect.type: func.FieldAlign(): cannot happen");
- return 0
-}
-
-func (t *funcTypeStruct) Size() int {
- panic("reflect.type: func.Size(): cannot happen");
- return 0
+ return unsafe.Alignof(x.xfunc);
}
func (t *funcTypeStruct) In() StructType {
@@ -602,15 +597,18 @@
interfacetype =
'interface' '{' fieldlist '}'
chantype =
- '<-' chan stubtype
- chan '<-' stubtype
- chan stubtype
+ '<-' 'chan' stubtype
+ 'chan' '<-' stubtype
+ 'chan' stubtype
maptype =
'map' '[' stubtype ']' stubtype
pointertype =
'*' stubtype
functiontype =
- '(' fieldlist ')'
+ [ 'func' ] '(' fieldlist ')' [ '(' fieldlist ')' | stubtype ]
+
+ In functiontype 'func' is optional because it is omitted in
+ the reflection string for interface types.
*/
@@ -860,7 +858,8 @@
p.Next();
if p.token != "(" {
// 1 list: the in parameters are a list. Is there a single out parameter?
- if p.token == "" || p.token == "}" || p.token == "," || p.token == ";" {
+ switch p.token {
+ case "", "}", ")", ",", ";":
return newStubType(name, newFuncTypeStruct(name, p.TypeString(tokstart), f1, nil));
}
// A single out parameter.
@@ -918,6 +917,13 @@
}
p.Next();
return p.Interface(name, tokstart);
+ case p.token == "func":
+ p.Next();
+ if p.token != "(" {
+ return missingStub
+ }
+ p.Next();
+ return p.Func(name, tokstart);
case p.token == "(":
p.Next();
return p.Func(name, tokstart);
diff --git a/src/lib/reflect/value.go b/src/lib/reflect/value.go
index af43de9..3548803 100644
--- a/src/lib/reflect/value.go
+++ b/src/lib/reflect/value.go
@@ -776,12 +776,17 @@
// Its implementation is incomplete.
type FuncValue interface {
Value;
+ Get() Addr; // The address of the function.
}
type funcValueStruct struct {
commonValue
}
+func (v *funcValueStruct) Get() Addr {
+ return *(*Addr)(v.addr)
+}
+
func funcCreator(typ Type, addr Addr) Value {
return &funcValueStruct{ commonValue{FuncKind, typ, addr} }
}
@@ -827,8 +832,6 @@
func NewInitValue(typ Type) Value {
// Some values cannot be made this way.
switch typ.Kind() {
- case FuncKind: // must be pointers, at least for now (TODO?)
- return nil;
case ArrayKind:
if typ.(ArrayType).IsSlice() {
return nil
