[gcc r14-7966] gccrs: Move some simple expression-related methods into base class Backend

[gcc r14-7966] gccrs: Move some simple expression-related methods into base class Backend

[Arthur Cohen]

https://gcc.gnu.org/g:55caa88646a6b2e15ffa3e01fdde487548af692f

commit r14-7966-g55caa88646a6b2e15ffa3e01fdde487548af692f
Author: Owen Avery <powerboat9.gamer@gmail.com>
Date:   Thu Aug 31 16:23:53 2023 -0400

    gccrs: Move some simple expression-related methods into base class Backend
    
    gcc/rust/ChangeLog:
    
            * rust-backend.h
            (Backend::zero_expression): Make non-virtual.
            (Backend::var_expression): Likewise.
            (Backend::integer_constant_expression): Likewise.
            (Backend::float_constant_expression): Likewise.
            (Backend::complex_constant_expression): Likewise.
            (Backend::string_constant_expression): Likewise.
            (Backend::char_constant_literal): Likewise.
            (Backend::wchar_constant_literal): Likewise.
            (Backend::boolean_constant_expression): Likewise.
    
            (Gcc_backend::zero_expression): Remove.
            (Gcc_backend::var_expression): Remove.
            (Gcc_backend::integer_constant_expression): Remove.
            (Gcc_backend::float_constant_expression): Remove.
            (Gcc_backend::complex_constant_expression): Remove.
            (Gcc_backend::string_constant_expression): Remove.
            (Gcc_backend::wchar_constant_expression): Remove.
            (Gcc_backend::char_constant_expression): Remove.
            (Gcc_backend::boolean_constant_expression): Remove.
            * rust-gcc.cc
            (Gcc_backend::zero_expression): Rename to ...
            (Backend::zero_expression): ... here.
            (Gcc_backend::var_expression): Rename to ...
            (Backend::var_expression): ... here.
            (Gcc_backend::integer_constant_expression): Rename to ...
            (Backend::integer_constant_expression): ... here.
            (Gcc_backend::float_constant_expression): Rename to ...
            (Backend::float_constant_expression): ... here.
            (Gcc_backend::complex_constant_expression): Rename to ...
            (Backend::complex_constant_expression): ... here.
            (Gcc_backend::string_constant_expression): Rename to ...
            (Backend::string_constant_expression): ... here.
            (Gcc_backend::wchar_constant_expression): Rename to ...
            (Backend::wchar_constant_expression): ... here.
            (Gcc_backend::char_constant_expression): Rename to ...
            (Backend::char_constant_expression): ... here.
            (Gcc_backend::boolean_constant_expression): Rename to ...
            (Backend::boolean_constant_expression): ... here.
    
    Signed-off-by: Owen Avery <powerboat9.gamer@gmail.com>

Diff:
---
 gcc/rust/rust-backend.h | 36 +++++++++---------------------------
 gcc/rust/rust-gcc.cc    | 18 +++++++++---------
 2 files changed, 18 insertions(+), 36 deletions(-)

diff --git a/gcc/rust/rust-backend.h b/gcc/rust/rust-backend.h
index dd849b8abd9..0633d005d87 100644
--- a/gcc/rust/rust-backend.h
+++ b/gcc/rust/rust-backend.h
@@ -157,31 +157,31 @@ public:
   // Return an expression for a zero value of the given type.  This is
   // used for cases such as local variable initialization and
   // converting nil to other types.
-  virtual tree zero_expression (tree) = 0;
+  tree zero_expression (tree);
 
   // Create a reference to a variable.
-  virtual tree var_expression (Bvariable *var, location_t) = 0;
+  tree var_expression (Bvariable *var, location_t);
 
   // Return an expression for the multi-precision integer VAL in BTYPE.
-  virtual tree integer_constant_expression (tree btype, mpz_t val) = 0;
+  tree integer_constant_expression (tree btype, mpz_t val);
 
   // Return an expression for the floating point value VAL in BTYPE.
-  virtual tree float_constant_expression (tree btype, mpfr_t val) = 0;
+  tree float_constant_expression (tree btype, mpfr_t val);
 
   // Return an expression for the complex value VAL in BTYPE.
-  virtual tree complex_constant_expression (tree btype, mpc_t val) = 0;
+  tree complex_constant_expression (tree btype, mpc_t val);
 
   // Return an expression for the string value VAL.
-  virtual tree string_constant_expression (const std::string &val) = 0;
+  tree string_constant_expression (const std::string &val);
 
   // Get a char literal
-  virtual tree char_constant_expression (char c) = 0;
+  tree char_constant_expression (char c);
 
   // Get a char literal
-  virtual tree wchar_constant_expression (wchar_t c) = 0;
+  tree wchar_constant_expression (wchar_t c);
 
   // Return an expression for the boolean value VAL.
-  virtual tree boolean_constant_expression (bool val) = 0;
+  tree boolean_constant_expression (bool val);
 
   // Return an expression for the real part of BCOMPLEX.
   virtual tree real_part_expression (tree bcomplex, location_t) = 0;
@@ -502,24 +502,6 @@ public:
 
   // Expressions.
 
-  tree zero_expression (tree);
-
-  tree var_expression (Bvariable *var, location_t);
-
-  tree integer_constant_expression (tree type, mpz_t val);
-
-  tree float_constant_expression (tree type, mpfr_t val);
-
-  tree complex_constant_expression (tree type, mpc_t val);
-
-  tree string_constant_expression (const std::string &val);
-
-  tree wchar_constant_expression (wchar_t c);
-
-  tree char_constant_expression (char c);
-
-  tree boolean_constant_expression (bool val);
-
   tree real_part_expression (tree bcomplex, location_t);
 
   tree imag_part_expression (tree bcomplex, location_t);
diff --git a/gcc/rust/rust-gcc.cc b/gcc/rust/rust-gcc.cc
index eddcb0fc9d7..2e3612f45c5 100644
--- a/gcc/rust/rust-gcc.cc
+++ b/gcc/rust/rust-gcc.cc
@@ -781,7 +781,7 @@ Backend::type_field_offset (tree struct_tree, size_t index)
 // Return the zero value for a type.
 
 tree
-Gcc_backend::zero_expression (tree t)
+Backend::zero_expression (tree t)
 {
   tree ret;
   if (t == error_mark_node)
@@ -794,7 +794,7 @@ Gcc_backend::zero_expression (tree t)
 // An expression that references a variable.
 
 tree
-Gcc_backend::var_expression (Bvariable *var, location_t location)
+Backend::var_expression (Bvariable *var, location_t location)
 {
   return var->get_tree (location);
 }
@@ -803,7 +803,7 @@ Gcc_backend::var_expression (Bvariable *var, location_t location)
 // This function does not release the memory of @val
 
 tree
-Gcc_backend::integer_constant_expression (tree t, mpz_t val)
+Backend::integer_constant_expression (tree t, mpz_t val)
 {
   if (t == error_mark_node)
     return error_mark_node;
@@ -815,7 +815,7 @@ Gcc_backend::integer_constant_expression (tree t, mpz_t val)
 // Return a typed value as a constant floating-point number.
 
 tree
-Gcc_backend::float_constant_expression (tree t, mpfr_t val)
+Backend::float_constant_expression (tree t, mpfr_t val)
 {
   tree ret;
   if (t == error_mark_node)
@@ -832,7 +832,7 @@ Gcc_backend::float_constant_expression (tree t, mpfr_t val)
 // Return a typed real and imaginary value as a constant complex number.
 
 tree
-Gcc_backend::complex_constant_expression (tree t, mpc_t val)
+Backend::complex_constant_expression (tree t, mpc_t val)
 {
   tree ret;
   if (t == error_mark_node)
@@ -856,7 +856,7 @@ Gcc_backend::complex_constant_expression (tree t, mpc_t val)
 // Make a constant string expression.
 
 tree
-Gcc_backend::string_constant_expression (const std::string &val)
+Backend::string_constant_expression (const std::string &val)
 {
   tree index_type = build_index_type (size_int (val.length ()));
   tree const_char_type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
@@ -869,13 +869,13 @@ Gcc_backend::string_constant_expression (const std::string &val)
 }
 
 tree
-Gcc_backend::wchar_constant_expression (wchar_t c)
+Backend::wchar_constant_expression (wchar_t c)
 {
   return build_int_cst (wchar_type (), c);
 }
 
 tree
-Gcc_backend::char_constant_expression (char c)
+Backend::char_constant_expression (char c)
 {
   return build_int_cst (char_type_node, c);
 }
@@ -883,7 +883,7 @@ Gcc_backend::char_constant_expression (char c)
 // Make a constant boolean expression.
 
 tree
-Gcc_backend::boolean_constant_expression (bool val)
+Backend::boolean_constant_expression (bool val)
 {
   return val ? boolean_true_node : boolean_false_node;
 }