compiler: traverse types of constant expressions

    We forgot to ever traverse types of constant expressions.  This rarely
    makes a difference--evidently, since nobody noticed--but it does
    matter when we inline constant expressions: we need to ensure that the
    type is visible to the importing code.

    Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/194317

From-SVN: r275539

diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE
index 7b2d17e56d9c8196ae764f94e3916940be5fe2ab..d966638c2ea7dc94e4543d67a7d026ffeb0ba970 100644 (file)
--- a/gcc/go/gofrontend/MERGE
+++ b/gcc/go/gofrontend/MERGE
@@ -1,4 +1,4 @@
-8f2b844acda70330f7c50b360f8c983d2676ecbb
+28c9053b3d507bef7bd56cb01c6b22deea354cdd
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.

diff --git a/gcc/go/gofrontend/expressions.cc b/gcc/go/gofrontend/expressions.cc
index 4db4e4a59bfd73bb591970915fc12cb49e0c9651..cb09ec0bcbe42e32bc7cd843fc595830c4476045 100644 (file)
--- a/gcc/go/gofrontend/expressions.cc
+++ b/gcc/go/gofrontend/expressions.cc
@@ -1812,6 +1812,9 @@ class Boolean_expression : public Expression
   do_import(Import_expression*, Location);
 
  protected:
+  int
+  do_traverse(Traverse*);
+
   bool
   do_is_constant() const
   { return true; }
@@ -1864,6 +1867,17 @@ class Boolean_expression : public Expression
   Type* type_;
 };
 
+// Traverse a boolean expression.  We just need to traverse the type
+// if there is one.
+
+int
+Boolean_expression::do_traverse(Traverse* traverse)
+{
+  if (this->type_ != NULL)
+    return Type::traverse(this->type_, traverse);
+  return TRAVERSE_CONTINUE;
+}
+
 // Get the type.
 
 Type*
@@ -1916,6 +1930,17 @@ Expression::make_boolean(bool val, Location location)
 
 // Class String_expression.
 
+// Traverse a string expression.  We just need to traverse the type
+// if there is one.
+
+int
+String_expression::do_traverse(Traverse* traverse)
+{
+  if (this->type_ != NULL)
+    return Type::traverse(this->type_, traverse);
+  return TRAVERSE_CONTINUE;
+}
+
 // Get the type.
 
 Type*
@@ -2290,6 +2315,9 @@ class Integer_expression : public Expression
   dump_integer(Ast_dump_context* ast_dump_context, const mpz_t val);
 
  protected:
+  int
+  do_traverse(Traverse*);
+
   bool
   do_is_constant() const
   { return true; }
@@ -2353,6 +2381,17 @@ class Integer_expression : public Expression
   bool is_character_constant_;
 };
 
+// Traverse an integer expression.  We just need to traverse the type
+// if there is one.
+
+int
+Integer_expression::do_traverse(Traverse* traverse)
+{
+  if (this->type_ != NULL)
+    return Type::traverse(this->type_, traverse);
+  return TRAVERSE_CONTINUE;
+}
+
 // Return a numeric constant for this expression.  We have to mark
 // this as a character when appropriate.
 
@@ -2714,6 +2753,9 @@ class Float_expression : public Expression
   dump_float(Ast_dump_context* ast_dump_context, const mpfr_t val);
 
  protected:
+  int
+  do_traverse(Traverse*);
+
   bool
   do_is_constant() const
   { return true; }
@@ -2773,6 +2815,17 @@ class Float_expression : public Expression
   Type* type_;
 };
 
+// Traverse a float expression.  We just need to traverse the type if
+// there is one.
+
+int
+Float_expression::do_traverse(Traverse* traverse)
+{
+  if (this->type_ != NULL)
+    return Type::traverse(this->type_, traverse);
+  return TRAVERSE_CONTINUE;
+}
+
 // Return the current type.  If we haven't set the type yet, we return
 // an abstract float type.
 
@@ -2932,6 +2985,9 @@ class Complex_expression : public Expression
   dump_complex(Ast_dump_context* ast_dump_context, const mpc_t val);
 
  protected:
+  int
+  do_traverse(Traverse*);
+
   bool
   do_is_constant() const
   { return true; }
@@ -2995,6 +3051,17 @@ class Complex_expression : public Expression
   Type* type_;
 };
 
+// Traverse a complex expression.  We just need to traverse the type
+// if there is one.
+
+int
+Complex_expression::do_traverse(Traverse* traverse)
+{
+  if (this->type_ != NULL)
+    return Type::traverse(this->type_, traverse);
+  return TRAVERSE_CONTINUE;
+}
+
 // Return the current type.  If we haven't set the type yet, we return
 // an abstract complex type.
 

diff --git a/gcc/go/gofrontend/expressions.h b/gcc/go/gofrontend/expressions.h
index 4c743daa8472eaf645e9d30d457c7465bc983d25..2e3d1e0ccf6b6750fc171d37bf89b9e0dee9e37d 100644 (file)
--- a/gcc/go/gofrontend/expressions.h
+++ b/gcc/go/gofrontend/expressions.h
@@ -1670,6 +1670,9 @@ class String_expression : public Expression
   do_import(Import_expression*, Location);
 
  protected:
+  int
+  do_traverse(Traverse*);
+
   bool
   do_is_constant() const
   { return true; }