interp: fix assignable check

The assignable check used to be too strict as it lacked the property that
if an untyped const can be represented as a T, then it is assignable to T.

And we can now use that fixed check to add a missing check: in a return
statement, we now make sure that any of the returned elements are
assignable to what the signature tells us they should be.

interp/type.go

@@ -923,7 +923,23 @@ func (t *itype) assignableTo(o *itype) bool {
 	if t.isNil() && o.hasNil() || o.isNil() && t.hasNil() {
 		return true
 	}
-	return t.TypeOf().AssignableTo(o.TypeOf())
+
+	if t.TypeOf().AssignableTo(o.TypeOf()) {
+		return true
+	}
+
+	n := t.node
+	if n == nil || !n.rval.IsValid() {
+		return false
+	}
+	con, ok := n.rval.Interface().(constant.Value)
+	if !ok {
+		return false
+	}
+	if con == nil || !isConstType(o) {
+		return false
+	}
+	return representableConst(con, o.TypeOf())
 }
 
 // convertibleTo returns true if t is convertible to o.
@@ -932,7 +948,7 @@ func (t *itype) convertibleTo(o *itype) bool {
 		return true
 	}
 
-	// unsafe checkes
+	// unsafe checks
 	tt, ot := t.TypeOf(), o.TypeOf()
 	if (tt.Kind() == reflect.Ptr || tt.Kind() == reflect.Uintptr) && ot.Kind() == reflect.UnsafePointer {
 		return true