handle native interface elem; handle nil interface equality

gonative.go

@@ -169,6 +169,7 @@ func go2GnoValue(rv reflect.Value) (tv TypedValue) {
 		tv.V = &nativeValue{Value: rv}
 		return
 	}
+REFLECT_KIND_SWITCH:
 	tv.T = go2GnoType(rv.Type())
 	switch rk := rv.Kind(); rk {
 	case reflect.Bool:
@@ -204,7 +205,12 @@ func go2GnoValue(rv reflect.Value) (tv TypedValue) {
 	case reflect.Func:
 		tv.V = &nativeValue{rv}
 	case reflect.Interface:
-		tv.V = &nativeValue{rv}
+		if rv.IsNil() {
+			tv.V = nil // nil-interface, "undefined".
+		} else {
+			rv = rv.Elem()
+			goto REFLECT_KIND_SWITCH
+		}
 	case reflect.Map:
 		tv.V = &nativeValue{rv}
 	case reflect.Ptr:
@@ -594,7 +600,11 @@ func gno2GoType(t Type) reflect.Type {
 // gno.PointerValue.  If rv is nil, an addressable one will be
 // constructed and returned, otherwise returns rv.
 func gno2GoValue(tv *TypedValue, rv reflect.Value) reflect.Value {
-	if tv.IsUndefined() {
+	if tv.IsNilInterface() {
+		rt := gno2GoType(tv.T)
+		rv = reflect.New(rt).Elem()
+		return rv
+	} else if tv.IsUndefined() {
 		if debug {
 			if !rv.IsValid() {
 				panic("unexpected undefined gno value")

op_assign.go

@@ -22,7 +22,7 @@ func (m *Machine) doOpAssign() {
 	// NOTE: PopValues() returns a slice in
 	// forward order, not the usual reverse.
 	rvs := m.PopValues(len(s.Lhs))
-	for i := len(s.Rhs) - 1; 0 <= i; i-- {
+	for i := len(s.Lhs) - 1; 0 <= i; i-- {
 		// Pop lhs value and desired type.
 		lv := m.PopAsPointer(s.Lhs[i])
 		lv.Assign2(m.Realm, rvs[i])

op_binary.go

@@ -351,11 +351,14 @@ func assertTypes(lt, rt Type) {
 
 // TODO: can be much faster.
 func isEql(lv, rv *TypedValue) bool {
+	if lv.IsUndefined() {
+		return rv.IsUndefined()
+	}
 	switch lv.T.Kind() {
 	case BoolKind:
 		return (lv.GetBool() == rv.GetBool())
 	case StringKind:
-		return (lv.V.(StringValue) == rv.V.(StringValue))
+		return (lv.GetString() == rv.GetString())
 	case IntKind:
 		return (lv.GetInt() == rv.GetInt())
 	case Int8Kind:
@@ -557,7 +560,7 @@ func addAssign(lv, rv *TypedValue) {
 	// NOTE this block is replicated in op_assign.go
 	switch lv.T.Kind() {
 	case StringKind:
-		lv.V = lv.GetString() + rv.GetString()
+		lv.V = StringValue(lv.GetString() + rv.GetString())
 	case IntKind:
 		lv.SetInt(lv.GetInt() + rv.GetInt())
 	case Int8Kind:

preprocess.go

@@ -526,7 +526,13 @@ func Preprocess(imp Importer, ctx BlockNode, n Node) Node {
 								assertTypes(lt, rt)
 							}
 						}
-						if lnt, ok := lt.(*nativeType); ok {
+						if n.Op == EQL || n.Op == NEQ {
+							// If == or !=, no conversions.
+						} else if lnt, ok := lt.(*nativeType); ok {
+							// If left and right are native type,
+							// convert left and right to gno, then
+							// convert result back to native.
+							//
 							// get concrete native base type.
 							pt := go2GnoBaseType(lnt.Type).(PrimitiveType)
 							// convert n.Left to (gno) pt type,
@@ -545,7 +551,8 @@ func Preprocess(imp Importer, ctx BlockNode, n Node) Node {
 								Source: n,
 								Type:   lnt,
 							}
-							// reset/create n2 to preprocess children.
+							// reset/create n2 to preprocess
+							// children.
 							n2 := &BinaryExpr{
 								Left:  ln,
 								Op:    n.Op,
@@ -554,8 +561,9 @@ func Preprocess(imp Importer, ctx BlockNode, n Node) Node {
 							resn := Node(Call(tx, n2))
 							resn = Preprocess(imp, last, resn)
 							return resn, TRANS_CONTINUE
-							// NOTE: binary operations are always computed in
-							// gno, never with reflect.
+							// NOTE: binary operations are always
+							// computed in gno, never with
+							// reflect.
 						} else {
 							// nothing to do.
 						}

tests/imports_test.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"bytes"
 	"compress/flate"
+	"context"
 	"crypto/sha1"
 	"encoding/binary"
 	"encoding/xml"
@@ -111,6 +112,12 @@ func testImporter(out io.Writer) gno.Importer {
 			pkg := gno.NewPackageNode("flate", "flate", nil)
 			pkg.DefineGoNativeValue("BestSpeed", flate.BestSpeed)
 			return pkg.NewPackage(nil)
+		case "context":
+			pkg := gno.NewPackageNode("context", "context", nil)
+			pkg.DefineGoNativeType(reflect.TypeOf((*context.Context)(nil)).Elem())
+			pkg.DefineGoNativeValue("WithValue", context.WithValue)
+			pkg.DefineGoNativeValue("Background", context.Background)
+			return pkg.NewPackage(nil)
 		default:
 			panic("unknown package path " + pkgPath)
 		}

values.go

@@ -451,6 +451,24 @@ func (tv *TypedValue) IsUndefined() bool {
 			}
 		}
 		return true
+	} else {
+		return tv.IsNilInterface()
+	}
+}
+
+func (tv *TypedValue) IsNilInterface() bool {
+	if tv.T != nil && tv.T.Kind() == InterfaceKind {
+		if tv.V == nil {
+			return true
+		} else {
+			if debug {
+				if tv.N != [8]byte{} {
+					panic(fmt.Sprintf(
+						"corrupted TypeValue (nil interface)"))
+				}
+			}
+			return false
+		}
 	}
 	return false
 }
@@ -622,7 +640,7 @@ func (tv *TypedValue) GetBool() bool {
 	return *(*bool)(unsafe.Pointer(&tv.N))
 }
 
-func (tv *TypedValue) GetString() StringValue {
+func (tv *TypedValue) GetString() string {
 	if debug {
 		if tv.T != nil && tv.T.Kind() != StringKind {
 			panic(fmt.Sprintf(
@@ -631,9 +649,9 @@ func (tv *TypedValue) GetString() StringValue {
 		}
 	}
 	if tv.V == nil {
-		return StringValue("")
+		return ""
 	} else {
-		return tv.V.(StringValue)
+		return string(tv.V.(StringValue))
 	}
 }