Go patch committed: Look through aliases for type compatibility

[Ian Lance Taylor]

In Go, aliases are supposed to be identical to the type being aliased,
so questions about type compatibility need to always ignore aliases,
except for error messages involving the type name.  This patch
implements that.  This test case for this is
https://golang.org/cl/94995.  This fixes
https://golang.org/issue/23912.  Bootstrapped and ran Go testsuite  on
x86_64-pc-linux-gnu.  Committed to mainline.

Ian

Index: gcc/go/gofrontend/MERGE
===================================================================
--- gcc/go/gofrontend/MERGE     (revision 257743)
+++ gcc/go/gofrontend/MERGE     (working copy)
@@ -1,4 +1,4 @@
-cef3934fbc63f5e121abb8f88d3799961ac95b59
+459a8a94e04a19bde7173ef7cf2db369c2e62e2d
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.
Index: gcc/go/gofrontend/types.cc
===================================================================
--- gcc/go/gofrontend/types.cc  (revision 257540)
+++ gcc/go/gofrontend/types.cc  (working copy)
@@ -597,10 +597,10 @@ Type::are_compatible_for_comparison(bool
          return false;
        }
 
-      if (t1->named_type() != NULL)
-       return t1->named_type()->named_type_is_comparable(reason);
-      else if (t2->named_type() != NULL)
-       return t2->named_type()->named_type_is_comparable(reason);
+      if (t1->unalias()->named_type() != NULL)
+       return t1->unalias()->named_type()->named_type_is_comparable(reason);
+      else if (t2->unalias()->named_type() != NULL)
+       return t2->unalias()->named_type()->named_type_is_comparable(reason);
       else if (t1->struct_type() != NULL)
        {
          if (t1->struct_type()->is_struct_incomparable())
@@ -678,6 +678,12 @@ Type::are_assignable(const Type* lhs, co
   if (Type::are_identical(lhs, rhs, true, reason))
     return true;
 
+  // Ignore aliases, except for error messages.
+  const Type* lhs_orig = lhs;
+  const Type* rhs_orig = rhs;
+  lhs = lhs->unalias();
+  rhs = rhs->unalias();
+
   // The types are assignable if they have identical underlying types
   // and either LHS or RHS is not a named type.
   if (((lhs->named_type() != NULL && rhs->named_type() == NULL)
@@ -740,15 +746,16 @@ Type::are_assignable(const Type* lhs, co
     {
       if (rhs->interface_type() != NULL)
        reason->assign(_("need explicit conversion"));
-      else if (lhs->named_type() != NULL && rhs->named_type() != NULL)
+      else if (lhs_orig->named_type() != NULL
+              && rhs_orig->named_type() != NULL)
        {
-         size_t len = (lhs->named_type()->name().length()
-                       + rhs->named_type()->name().length()
+         size_t len = (lhs_orig->named_type()->name().length()
+                       + rhs_orig->named_type()->name().length()
                        + 100);
          char* buf = new char[len];
          snprintf(buf, len, _("cannot use type %s as type %s"),
-                  rhs->named_type()->message_name().c_str(),
-                  lhs->named_type()->message_name().c_str());
+                  rhs_orig->named_type()->message_name().c_str(),
+                  lhs_orig->named_type()->message_name().c_str());
          reason->assign(buf);
          delete[] buf;
        }
@@ -768,6 +775,10 @@ Type::are_convertible(const Type* lhs, c
   if (Type::are_assignable(lhs, rhs, reason))
     return true;
 
+  // Ignore aliases.
+  lhs = lhs->unalias();
+  rhs = rhs->unalias();
+
   // A pointer to a regular type may not be converted to a pointer to
   // a type that may not live in the heap, except when converting from
   // unsafe.Pointer.