Go patch committed: Permit conversions between string and named slice

[Ian Lance Taylor]

The Go language permits converting between string and []byte or []rune.
It was recently changed to permit converting between string a named type
whose base type is []byte or []rune.  This patch implements that in
gccgo.  Bootstrapped and ran Go testsuite on x86_64-unknown-linux-gnu.
Committed to mainline.

Ian


Index: gcc/go/gofrontend/types.cc
===================================================================
--- gcc/go/gofrontend/types.cc	(revision 182143)
+++ gcc/go/gofrontend/types.cc	(working copy)
@@ -662,7 +662,7 @@ Type::are_convertible(const Type* lhs, c
     {
       if (rhs->integer_type() != NULL)
 	return true;
-      if (rhs->is_slice_type() && rhs->named_type() == NULL)
+      if (rhs->is_slice_type())
 	{
 	  const Type* e = rhs->array_type()->element_type()->forwarded();
 	  if (e->integer_type() != NULL
@@ -673,9 +673,7 @@ Type::are_convertible(const Type* lhs, c
     }
 
   // A string may be converted to []byte or []int.
-  if (rhs->is_string_type()
-      && lhs->is_slice_type()
-      && lhs->named_type() == NULL)
+  if (rhs->is_string_type() && lhs->is_slice_type())
     {
       const Type* e = lhs->array_type()->element_type()->forwarded();
       if (e->integer_type() != NULL
Index: gcc/go/gofrontend/expressions.cc
===================================================================
--- gcc/go/gofrontend/expressions.cc	(revision 182154)
+++ gcc/go/gofrontend/expressions.cc	(working copy)
@@ -3322,7 +3322,7 @@ Type_conversion_expression::do_lower(Gog
       mpfr_clear(imag);
     }
 
-  if (type->is_slice_type() && type->named_type() == NULL)
+  if (type->is_slice_type())
     {
       Type* element_type = type->array_type()->element_type()->forwarded();
       bool is_byte = element_type == Type::lookup_integer_type("uint8");
@@ -3621,20 +3621,11 @@ Type_conversion_expression::do_get_tree(
 			       integer_type_node,
 			       fold_convert(integer_type_node, expr_tree));
     }
-  else if (type->is_string_type()
-	   && (expr_type->array_type() != NULL
-	       || (expr_type->points_to() != NULL
-		   && expr_type->points_to()->array_type() != NULL)))
+  else if (type->is_string_type() && expr_type->is_slice_type())
     {
-      Type* t = expr_type;
-      if (t->points_to() != NULL)
-	{
-	  t = t->points_to();
-	  expr_tree = build_fold_indirect_ref(expr_tree);
-	}
       if (!DECL_P(expr_tree))
 	expr_tree = save_expr(expr_tree);
-      Array_type* a = t->array_type();
+      Array_type* a = expr_type->array_type();
       Type* e = a->element_type()->forwarded();
       go_assert(e->integer_type() != NULL);
       tree valptr = fold_convert(const_ptr_type_node,
Index: gcc/testsuite/go.test/test/convlit.go
===================================================================
--- gcc/testsuite/go.test/test/convlit.go	(revision 181963)
+++ gcc/testsuite/go.test/test/convlit.go	(working copy)
@@ -36,7 +36,7 @@ var good3 int = 1e9
 var good4 float64 = 1e20
 
 // explicit conversion of string is okay
-var _ = []int("abc")
+var _ = []rune("abc")
 var _ = []byte("abc")
 
 // implicit is not
@@ -47,20 +47,20 @@ var _ []byte = "abc" // ERROR "cannot us
 type Tstring string
 
 var ss Tstring = "abc"
-var _ = []int(ss)
+var _ = []rune(ss)
 var _ = []byte(ss)
 
 // implicit is still not
-var _ []int = ss  // ERROR "cannot use|incompatible|invalid"
+var _ []rune = ss // ERROR "cannot use|incompatible|invalid"
 var _ []byte = ss // ERROR "cannot use|incompatible|invalid"
 
-// named slice is not
-type Tint []int
+// named slice is now ok
+type Trune []rune
 type Tbyte []byte
 
-var _ = Tint("abc")  // ERROR "convert|incompatible|invalid"
-var _ = Tbyte("abc") // ERROR "convert|incompatible|invalid"
+var _ = Trune("abc") // ok
+var _ = Tbyte("abc") // ok
 
 // implicit is still not
-var _ Tint = "abc"  // ERROR "cannot use|incompatible|invalid"
+var _ Trune = "abc" // ERROR "cannot use|incompatible|invalid"
 var _ Tbyte = "abc" // ERROR "cannot use|incompatible|invalid"
Index: gcc/testsuite/go.test/test/named1.go
===================================================================
--- gcc/testsuite/go.test/test/named1.go	(revision 181963)
+++ gcc/testsuite/go.test/test/named1.go	(working copy)
@@ -41,7 +41,6 @@ func main() {
 	asBool(i < j)  // ERROR "cannot use.*type bool.*as type Bool"
 
 	_, b = m[2] // ERROR "cannot .* bool.*type Bool"
-	m[2] = 1, b // ERROR "cannot use.*type Bool.*as type bool"
 
 	var inter interface{}
 	_, b = inter.(Map) // ERROR "cannot .* bool.*type Bool"
@@ -55,8 +54,8 @@ func main() {
 
 	_, bb := <-c
 	asBool(bb) // ERROR "cannot use.*type bool.*as type Bool"
-	_, b = <-c     // ERROR "cannot .* bool.*type Bool"
+	_, b = <-c // ERROR "cannot .* bool.*type Bool"
 	_ = b
 
-	asString(String(slice)) // ERROR "cannot .*type Slice.*type String"
+	asString(String(slice)) // ok
 }