[PATCH 3/3] Remove Enumaration Expression, EnumExpr, classes

[Mark Wielaard <mark@klomp.org>]

An Enumaration Expression is just like a Struct Expression. Old
versions of the Rust Reference described them separately. But since
they are syntactically exactly like a Struct Expression they are never
actually parsed. A Struct Expression can also be used to initialize
enums (and unions).

Remove the AST and HIR classes EnumExprField, EnumExprFieldIdentifier,
EnumExprFieldWithVal, EnumExprFieldIdentifierValue,
EnumExprFieldIndexValue, EnumExprStruct, EnumExprTuple,
EnumExprFieldless and EnumVariantExpr.
---
 gcc/rust/ast/rust-ast-full-decls.h            |   9 -
 gcc/rust/ast/rust-ast-full-test.cc            |  78 ----
 gcc/rust/ast/rust-ast-visitor.h               |   7 -
 gcc/rust/ast/rust-expr.h                      | 346 ------------------
 gcc/rust/backend/rust-compile-base.h          |   7 -
 gcc/rust/expand/rust-macro-expand.cc          |  89 -----
 gcc/rust/hir/rust-ast-lower-base.h            |   7 -
 gcc/rust/hir/tree/rust-hir-expr.h             | 326 -----------------
 gcc/rust/hir/tree/rust-hir-full-decls.h       |   9 -
 gcc/rust/hir/tree/rust-hir-full-test.cc       |  36 --
 gcc/rust/hir/tree/rust-hir-visitor.h          |   6 -
 gcc/rust/lint/rust-lint-marklive-base.h       |   7 -
 gcc/rust/resolve/rust-ast-resolve-base.h      |   6 -
 gcc/rust/typecheck/rust-hir-const-fold-base.h |   7 -
 gcc/rust/typecheck/rust-hir-type-check-base.h |   7 -
 gcc/rust/typecheck/rust-hir-type-check-util.h |   7 -
 16 files changed, 954 deletions(-)

diff --git a/gcc/rust/ast/rust-ast-full-decls.h b/gcc/rust/ast/rust-ast-full-decls.h
index 09f879c312f..2be7e777234 100644
--- a/gcc/rust/ast/rust-ast-full-decls.h
+++ b/gcc/rust/ast/rust-ast-full-decls.h
@@ -109,15 +109,6 @@ class StructExprFieldIdentifierValue;
 class StructExprFieldIndexValue;
 class StructExprStructFields;
 class StructExprStructBase;
-class EnumVariantExpr;
-class EnumExprField;
-class EnumExprFieldIdentifier;
-class EnumExprFieldWithVal;
-class EnumExprFieldIdentifierValue;
-class EnumExprFieldIndexValue;
-class EnumExprStruct;
-class EnumExprTuple;
-class EnumExprFieldless;
 class CallExpr;
 class MethodCallExpr;
 class FieldAccessExpr;
diff --git a/gcc/rust/ast/rust-ast-full-test.cc b/gcc/rust/ast/rust-ast-full-test.cc
index 8ffc1b20e70..6241710226d 100644
--- a/gcc/rust/ast/rust-ast-full-test.cc
+++ b/gcc/rust/ast/rust-ast-full-test.cc
@@ -3308,48 +3308,6 @@ StructExprStructFields::as_string () const
   return str;
 }
 
-std::string
-EnumExprStruct::as_string () const
-{
-  std::string str ("EnumExprStruct (or subclass): ");
-
-  str += "\n Path: " + get_enum_variant_path ().as_string ();
-
-  str += "\n Fields: ";
-  if (fields.empty ())
-    {
-      str += "none";
-    }
-  else
-    {
-      for (const auto &field : fields)
-	str += "\n  " + field->as_string ();
-    }
-
-  return str;
-}
-
-std::string
-EnumExprFieldWithVal::as_string () const
-{
-  // used to get value string
-  return value->as_string ();
-}
-
-std::string
-EnumExprFieldIdentifierValue::as_string () const
-{
-  // TODO: rewrite to work with non-linearisable exprs
-  return field_name + " : " + EnumExprFieldWithVal::as_string ();
-}
-
-std::string
-EnumExprFieldIndexValue::as_string () const
-{
-  // TODO: rewrite to work with non-linearisable exprs
-  return std::to_string (index) + " : " + EnumExprFieldWithVal::as_string ();
-}
-
 std::string
 EnumItem::as_string () const
 {
@@ -5184,42 +5142,6 @@ StructExprStructBase::accept_vis (ASTVisitor &vis)
   vis.visit (*this);
 }
 
-void
-EnumExprFieldIdentifier::accept_vis (ASTVisitor &vis)
-{
-  vis.visit (*this);
-}
-
-void
-EnumExprFieldIdentifierValue::accept_vis (ASTVisitor &vis)
-{
-  vis.visit (*this);
-}
-
-void
-EnumExprFieldIndexValue::accept_vis (ASTVisitor &vis)
-{
-  vis.visit (*this);
-}
-
-void
-EnumExprStruct::accept_vis (ASTVisitor &vis)
-{
-  vis.visit (*this);
-}
-
-void
-EnumExprTuple::accept_vis (ASTVisitor &vis)
-{
-  vis.visit (*this);
-}
-
-void
-EnumExprFieldless::accept_vis (ASTVisitor &vis)
-{
-  vis.visit (*this);
-}
-
 void
 CallExpr::accept_vis (ASTVisitor &vis)
 {
diff --git a/gcc/rust/ast/rust-ast-visitor.h b/gcc/rust/ast/rust-ast-visitor.h
index ffd1d2d3161..15bf0864ddb 100644
--- a/gcc/rust/ast/rust-ast-visitor.h
+++ b/gcc/rust/ast/rust-ast-visitor.h
@@ -93,13 +93,6 @@ public:
   virtual void visit (StructExprFieldIndexValue &field) = 0;
   virtual void visit (StructExprStructFields &expr) = 0;
   virtual void visit (StructExprStructBase &expr) = 0;
-  // virtual void visit(EnumExprField& field) = 0;
-  virtual void visit (EnumExprFieldIdentifier &field) = 0;
-  virtual void visit (EnumExprFieldIdentifierValue &field) = 0;
-  virtual void visit (EnumExprFieldIndexValue &field) = 0;
-  virtual void visit (EnumExprStruct &expr) = 0;
-  virtual void visit (EnumExprTuple &expr) = 0;
-  virtual void visit (EnumExprFieldless &expr) = 0;
   virtual void visit (CallExpr &expr) = 0;
   virtual void visit (MethodCallExpr &expr) = 0;
   virtual void visit (FieldAccessExpr &expr) = 0;
diff --git a/gcc/rust/ast/rust-expr.h b/gcc/rust/ast/rust-expr.h
index a6882c75e82..f26ed988a02 100644
--- a/gcc/rust/ast/rust-expr.h
+++ b/gcc/rust/ast/rust-expr.h
@@ -1852,352 +1852,6 @@ protected:
   }
 };
 
-// aka EnumerationVariantExpr
-// Base AST node representing creation of an enum variant instance - abstract
-class EnumVariantExpr : public ExprWithoutBlock
-{
-  std::vector<Attribute> outer_attrs;
-  PathInExpression enum_variant_path;
-
-protected:
-  // Protected constructor for initialising enum_variant_path
-  EnumVariantExpr (PathInExpression path_to_enum_variant,
-		   std::vector<Attribute> outer_attribs)
-    : outer_attrs (std::move (outer_attribs)),
-      enum_variant_path (std::move (path_to_enum_variant))
-  {}
-
-public:
-  const PathInExpression &get_enum_variant_path () const
-  {
-    return enum_variant_path;
-  }
-  PathInExpression &get_enum_variant_path () { return enum_variant_path; }
-
-  // Invalid if path is in error state, so base stripping on that.
-  void mark_for_strip () override
-  {
-    enum_variant_path = PathInExpression::create_error ();
-  }
-  bool is_marked_for_strip () const override
-  {
-    return enum_variant_path.is_error ();
-  }
-
-  const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
-  std::vector<Attribute> &get_outer_attrs () { return outer_attrs; }
-
-  void set_outer_attrs (std::vector<Attribute> new_attrs) override
-  {
-    outer_attrs = std::move (new_attrs);
-  }
-};
-
-/* Base AST node for a single enum expression field (in enum instance creation)
- * - abstract */
-class EnumExprField
-{
-public:
-  virtual ~EnumExprField () {}
-
-  // Unique pointer custom clone function
-  std::unique_ptr<EnumExprField> clone_enum_expr_field () const
-  {
-    return std::unique_ptr<EnumExprField> (clone_enum_expr_field_impl ());
-  }
-
-  virtual std::string as_string () const = 0;
-
-  virtual void accept_vis (ASTVisitor &vis) = 0;
-
-  virtual Location get_locus () const = 0;
-
-protected:
-  // Clone function implementation as pure virtual method
-  virtual EnumExprField *clone_enum_expr_field_impl () const = 0;
-};
-
-// Identifier-only variant of EnumExprField AST node
-class EnumExprFieldIdentifier : public EnumExprField
-{
-  Identifier field_name;
-  Location locus;
-
-public:
-  EnumExprFieldIdentifier (Identifier field_identifier, Location locus)
-    : field_name (std::move (field_identifier)), locus (locus)
-  {}
-
-  void accept_vis (ASTVisitor &vis) override;
-
-  std::string as_string () const override { return field_name; }
-
-  Location get_locus () const override final { return locus; }
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprFieldIdentifier *clone_enum_expr_field_impl () const override
-  {
-    return new EnumExprFieldIdentifier (*this);
-  }
-};
-
-/* Base AST node for a single enum expression field with an assigned value -
- * abstract */
-class EnumExprFieldWithVal : public EnumExprField
-{
-  std::unique_ptr<Expr> value;
-
-protected:
-  EnumExprFieldWithVal (std::unique_ptr<Expr> field_value)
-    : value (std::move (field_value))
-  {}
-
-  // Copy constructor must clone unique_ptr value
-  EnumExprFieldWithVal (EnumExprFieldWithVal const &other)
-    : value (other.value->clone_expr ())
-  {}
-
-  // Overload assignment operator to clone
-  EnumExprFieldWithVal &operator= (EnumExprFieldWithVal const &other)
-  {
-    value = other.value->clone_expr ();
-
-    return *this;
-  }
-
-  // move constructors
-  EnumExprFieldWithVal (EnumExprFieldWithVal &&other) = default;
-  EnumExprFieldWithVal &operator= (EnumExprFieldWithVal &&other) = default;
-
-public:
-  std::string as_string () const override;
-
-  // TODO: is this better? Or is a "vis_block" better?
-  std::unique_ptr<Expr> &get_value ()
-  {
-    rust_assert (value != nullptr);
-    return value;
-  }
-};
-
-// Identifier and value variant of EnumExprField AST node
-class EnumExprFieldIdentifierValue : public EnumExprFieldWithVal
-{
-  Identifier field_name;
-  Location locus;
-
-public:
-  EnumExprFieldIdentifierValue (Identifier field_name,
-				std::unique_ptr<Expr> field_value,
-				Location locus)
-    : EnumExprFieldWithVal (std::move (field_value)),
-      field_name (std::move (field_name)), locus (locus)
-  {}
-
-  std::string as_string () const override;
-
-  void accept_vis (ASTVisitor &vis) override;
-
-  Location get_locus () const override final { return locus; }
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprFieldIdentifierValue *clone_enum_expr_field_impl () const override
-  {
-    return new EnumExprFieldIdentifierValue (*this);
-  }
-};
-
-// Tuple index and value variant of EnumExprField AST node
-class EnumExprFieldIndexValue : public EnumExprFieldWithVal
-{
-  TupleIndex index;
-  // TODO: implement "with val" as a template with EnumExprField as type param?
-
-  Location locus;
-
-public:
-  EnumExprFieldIndexValue (TupleIndex field_index,
-			   std::unique_ptr<Expr> field_value, Location locus)
-    : EnumExprFieldWithVal (std::move (field_value)), index (field_index),
-      locus (locus)
-  {}
-
-  std::string as_string () const override;
-
-  void accept_vis (ASTVisitor &vis) override;
-
-  Location get_locus () const override final { return locus; }
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprFieldIndexValue *clone_enum_expr_field_impl () const override
-  {
-    return new EnumExprFieldIndexValue (*this);
-  }
-};
-
-// Struct-like syntax enum variant instance creation AST node
-class EnumExprStruct : public EnumVariantExpr
-{
-  std::vector<std::unique_ptr<EnumExprField> > fields;
-  Location locus;
-
-public:
-  std::string as_string () const override;
-
-  EnumExprStruct (PathInExpression enum_variant_path,
-		  std::vector<std::unique_ptr<EnumExprField> > variant_fields,
-		  std::vector<Attribute> outer_attribs, Location locus)
-    : EnumVariantExpr (std::move (enum_variant_path),
-		       std::move (outer_attribs)),
-      fields (std::move (variant_fields)), locus (locus)
-  {}
-
-  // copy constructor with vector clone
-  EnumExprStruct (EnumExprStruct const &other)
-    : EnumVariantExpr (other), locus (other.locus)
-  {
-    fields.reserve (other.fields.size ());
-    for (const auto &e : other.fields)
-      fields.push_back (e->clone_enum_expr_field ());
-  }
-
-  // overloaded assignment operator with vector clone
-  EnumExprStruct &operator= (EnumExprStruct const &other)
-  {
-    EnumVariantExpr::operator= (other);
-    locus = other.locus;
-
-    fields.reserve (other.fields.size ());
-    for (const auto &e : other.fields)
-      fields.push_back (e->clone_enum_expr_field ());
-
-    return *this;
-  }
-
-  // move constructors
-  EnumExprStruct (EnumExprStruct &&other) = default;
-  EnumExprStruct &operator= (EnumExprStruct &&other) = default;
-
-  Location get_locus () const override final { return locus; }
-
-  void accept_vis (ASTVisitor &vis) override;
-
-  // TODO: this mutable getter seems really dodgy. Think up better way.
-  std::vector<std::unique_ptr<EnumExprField> > &get_fields () { return fields; }
-  const std::vector<std::unique_ptr<EnumExprField> > &get_fields () const
-  {
-    return fields;
-  }
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprStruct *clone_expr_without_block_impl () const override
-  {
-    return new EnumExprStruct (*this);
-  }
-};
-
-// Tuple-like syntax enum variant instance creation AST node
-class EnumExprTuple : public EnumVariantExpr
-{
-  std::vector<std::unique_ptr<Expr> > values;
-  Location locus;
-
-public:
-  std::string as_string () const override;
-
-  EnumExprTuple (PathInExpression enum_variant_path,
-		 std::vector<std::unique_ptr<Expr> > variant_values,
-		 std::vector<Attribute> outer_attribs, Location locus)
-    : EnumVariantExpr (std::move (enum_variant_path),
-		       std::move (outer_attribs)),
-      values (std::move (variant_values)), locus (locus)
-  {}
-
-  // copy constructor with vector clone
-  EnumExprTuple (EnumExprTuple const &other)
-    : EnumVariantExpr (other), locus (other.locus)
-  {
-    values.reserve (other.values.size ());
-    for (const auto &e : other.values)
-      values.push_back (e->clone_expr ());
-  }
-
-  // overloaded assignment operator with vector clone
-  EnumExprTuple &operator= (EnumExprTuple const &other)
-  {
-    EnumVariantExpr::operator= (other);
-    locus = other.locus;
-
-    values.reserve (other.values.size ());
-    for (const auto &e : other.values)
-      values.push_back (e->clone_expr ());
-
-    return *this;
-  }
-
-  // move constructors
-  EnumExprTuple (EnumExprTuple &&other) = default;
-  EnumExprTuple &operator= (EnumExprTuple &&other) = default;
-
-  Location get_locus () const override final { return locus; }
-
-  void accept_vis (ASTVisitor &vis) override;
-
-  const std::vector<std::unique_ptr<Expr> > &get_elems () const
-  {
-    return values;
-  }
-  std::vector<std::unique_ptr<Expr> > &get_elems () { return values; }
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprTuple *clone_expr_without_block_impl () const override
-  {
-    return new EnumExprTuple (*this);
-  }
-};
-
-// No-field enum variant instance creation AST node
-class EnumExprFieldless : public EnumVariantExpr
-{
-  Location locus;
-
-public:
-  std::string as_string () const override
-  {
-    // return enum_variant_path.as_string();
-    return get_enum_variant_path ().as_string ();
-  }
-
-  EnumExprFieldless (PathInExpression enum_variant_path,
-		     std::vector<Attribute> outer_attribs, Location locus)
-    : EnumVariantExpr (std::move (enum_variant_path),
-		       std::move (outer_attribs)),
-      locus (locus)
-  {}
-
-  Location get_locus () const override final { return locus; }
-
-  void accept_vis (ASTVisitor &vis) override;
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprFieldless *clone_expr_without_block_impl () const override
-  {
-    return new EnumExprFieldless (*this);
-  }
-};
-
 // Forward decl for Function - used in CallExpr
 class Function;
 
diff --git a/gcc/rust/backend/rust-compile-base.h b/gcc/rust/backend/rust-compile-base.h
index 2ce7369ecde..c0cfacf4e57 100644
--- a/gcc/rust/backend/rust-compile-base.h
+++ b/gcc/rust/backend/rust-compile-base.h
@@ -72,13 +72,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &field) {}
   virtual void visit (HIR::StructExprStructFields &expr) {}
   virtual void visit (HIR::StructExprStructBase &expr) {}
-  // virtual void visit(EnumExprField& field) {}
-  virtual void visit (HIR::EnumExprFieldIdentifier &field) {}
-  virtual void visit (HIR::EnumExprFieldIdentifierValue &field) {}
-  virtual void visit (HIR::EnumExprFieldIndexValue &field) {}
-  virtual void visit (HIR::EnumExprStruct &expr) {}
-  virtual void visit (HIR::EnumExprTuple &expr) {}
-  virtual void visit (HIR::EnumExprFieldless &expr) {}
   virtual void visit (HIR::CallExpr &expr) {}
   virtual void visit (HIR::MethodCallExpr &expr) {}
   virtual void visit (HIR::FieldAccessExpr &expr) {}
diff --git a/gcc/rust/expand/rust-macro-expand.cc b/gcc/rust/expand/rust-macro-expand.cc
index 65b2ea06039..8134f7e59aa 100644
--- a/gcc/rust/expand/rust-macro-expand.cc
+++ b/gcc/rust/expand/rust-macro-expand.cc
@@ -939,95 +939,6 @@ public:
 		     "cannot strip expression in this position - outer "
 		     "attributes not allowed");
   }
-  void visit (AST::EnumExprFieldIdentifier &) override
-  {
-    // as no attrs (at moment, at least), no stripping possible
-  }
-  void visit (AST::EnumExprFieldIdentifierValue &field) override
-  {
-    /* as no attrs possible (at moment, at least), only sub-expression
-     * stripping is possible */
-    auto &value = field.get_value ();
-    value->accept_vis (*this);
-    if (value->is_marked_for_strip ())
-      rust_error_at (value->get_locus (),
-		     "cannot strip expression in this position - outer "
-		     "attributes not allowed");
-  }
-  void visit (AST::EnumExprFieldIndexValue &field) override
-  {
-    /* as no attrs possible (at moment, at least), only sub-expression
-     * stripping is possible */
-    auto &value = field.get_value ();
-    value->accept_vis (*this);
-    if (value->is_marked_for_strip ())
-      rust_error_at (value->get_locus (),
-		     "cannot strip expression in this position - outer "
-		     "attributes not allowed");
-  }
-  void visit (AST::EnumExprStruct &expr) override
-  {
-    // initial strip test based on outer attrs
-    expander.expand_cfg_attrs (expr.get_outer_attrs ());
-    if (expander.fails_cfg_with_expand (expr.get_outer_attrs ()))
-      {
-	expr.mark_for_strip ();
-	return;
-      }
-
-    // supposedly spec doesn't allow inner attributes in enum exprs
-
-    // strip sub-exprs of path
-    auto &enum_path = expr.get_enum_variant_path ();
-    visit (enum_path);
-    if (enum_path.is_marked_for_strip ())
-      rust_error_at (enum_path.get_locus (),
-		     "cannot strip path in this position");
-
-    /* spec does not specify whether expressions are allowed to be
-     * stripped at top level of expression fields, but I wouldn't think
-     * that they would be, so operating under the assumption that only
-     * sub-expressions can be stripped. */
-    for (auto &field : expr.get_fields ())
-      {
-	field->accept_vis (*this);
-	// shouldn't strip in this
-      }
-  }
-  void visit (AST::EnumExprTuple &expr) override
-  {
-    // initial strip test based on outer attrs
-    expander.expand_cfg_attrs (expr.get_outer_attrs ());
-    if (expander.fails_cfg_with_expand (expr.get_outer_attrs ()))
-      {
-	expr.mark_for_strip ();
-	return;
-      }
-
-    // supposedly spec doesn't allow inner attributes in enum exprs
-
-    // strip sub-exprs of path
-    auto &enum_path = expr.get_enum_variant_path ();
-    visit (enum_path);
-    if (enum_path.is_marked_for_strip ())
-      rust_error_at (enum_path.get_locus (),
-		     "cannot strip path in this position");
-
-    /* spec says outer attributes are specifically allowed for elements
-     * of tuple-style enum expressions, so full stripping possible */
-    expand_pointer_allow_strip (expr.get_elems ());
-  }
-  void visit (AST::EnumExprFieldless &expr) override
-  {
-    // can't be stripped as no attrs
-
-    // strip sub-exprs of path
-    auto &enum_path = expr.get_enum_variant_path ();
-    visit (enum_path);
-    if (enum_path.is_marked_for_strip ())
-      rust_error_at (enum_path.get_locus (),
-		     "cannot strip path in this position");
-  }
   void visit (AST::CallExpr &expr) override
   {
     // initial strip test based on outer attrs
diff --git a/gcc/rust/hir/rust-ast-lower-base.h b/gcc/rust/hir/rust-ast-lower-base.h
index 8debf3967b1..d4455998301 100644
--- a/gcc/rust/hir/rust-ast-lower-base.h
+++ b/gcc/rust/hir/rust-ast-lower-base.h
@@ -96,13 +96,6 @@ public:
   virtual void visit (AST::StructExprFieldIndexValue &field) {}
   virtual void visit (AST::StructExprStructFields &expr) {}
   virtual void visit (AST::StructExprStructBase &expr) {}
-  //  virtual void visit(EnumExprField& field) {}
-  virtual void visit (AST::EnumExprFieldIdentifier &field) {}
-  virtual void visit (AST::EnumExprFieldIdentifierValue &field) {}
-  virtual void visit (AST::EnumExprFieldIndexValue &field) {}
-  virtual void visit (AST::EnumExprStruct &expr) {}
-  virtual void visit (AST::EnumExprTuple &expr) {}
-  virtual void visit (AST::EnumExprFieldless &expr) {}
   virtual void visit (AST::CallExpr &expr) {}
   virtual void visit (AST::MethodCallExpr &expr) {}
   virtual void visit (AST::FieldAccessExpr &expr) {}
diff --git a/gcc/rust/hir/tree/rust-hir-expr.h b/gcc/rust/hir/tree/rust-hir-expr.h
index b8cb7547665..05bc1f9f055 100644
--- a/gcc/rust/hir/tree/rust-hir-expr.h
+++ b/gcc/rust/hir/tree/rust-hir-expr.h
@@ -1578,332 +1578,6 @@ protected:
   }
 };
 
-// aka EnumerationVariantExpr
-// Base HIR node representing creation of an enum variant instance - abstract
-class EnumVariantExpr : public ExprWithoutBlock
-{
-  PathInExpression enum_variant_path;
-
-protected:
-  // Protected constructor for initialising enum_variant_path
-  EnumVariantExpr (Analysis::NodeMapping mappings,
-		   PathInExpression path_to_enum_variant,
-		   AST::AttrVec outer_attribs)
-    : ExprWithoutBlock (std::move (mappings), std::move (outer_attribs)),
-      enum_variant_path (std::move (path_to_enum_variant))
-  {}
-
-public:
-  // TODO: maybe remove and have string version gotten here directly
-  PathInExpression get_enum_variant_path () const { return enum_variant_path; }
-};
-
-/* Base HIR node for a single enum expression field (in enum instance creation)
- * - abstract */
-class EnumExprField
-{
-public:
-  virtual ~EnumExprField () {}
-
-  // Unique pointer custom clone function
-  std::unique_ptr<EnumExprField> clone_enum_expr_field () const
-  {
-    return std::unique_ptr<EnumExprField> (clone_enum_expr_field_impl ());
-  }
-
-  virtual void accept_vis (HIRVisitor &vis) = 0;
-
-protected:
-  // Clone function implementation as pure virtual method
-  virtual EnumExprField *clone_enum_expr_field_impl () const = 0;
-};
-
-// Identifier-only variant of EnumExprField HIR node
-class EnumExprFieldIdentifier : public EnumExprField
-{
-  Identifier field_name;
-
-  // TODO: should this store location data?
-
-public:
-  EnumExprFieldIdentifier (Identifier field_identifier)
-    : field_name (std::move (field_identifier))
-  {}
-
-  void accept_vis (HIRVisitor &vis) override;
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprFieldIdentifier *clone_enum_expr_field_impl () const override
-  {
-    return new EnumExprFieldIdentifier (*this);
-  }
-};
-
-/* Base HIR node for a single enum expression field with an assigned value -
- * abstract */
-class EnumExprFieldWithVal : public EnumExprField
-{
-  std::unique_ptr<Expr> value;
-
-  // TODO: should this store location data?
-
-protected:
-  EnumExprFieldWithVal (std::unique_ptr<Expr> field_value)
-    : value (std::move (field_value))
-  {}
-
-  // Copy constructor must clone unique_ptr value
-  EnumExprFieldWithVal (EnumExprFieldWithVal const &other)
-    : value (other.value->clone_expr ())
-  {}
-
-  // Overload assignment operator to clone
-  EnumExprFieldWithVal &operator= (EnumExprFieldWithVal const &other)
-  {
-    value = other.value->clone_expr ();
-
-    return *this;
-  }
-
-  // move constructors
-  EnumExprFieldWithVal (EnumExprFieldWithVal &&other) = default;
-  EnumExprFieldWithVal &operator= (EnumExprFieldWithVal &&other) = default;
-};
-
-// Identifier and value variant of EnumExprField HIR node
-class EnumExprFieldIdentifierValue : public EnumExprFieldWithVal
-{
-  Identifier field_name;
-
-  // TODO: should this store location data?
-
-public:
-  EnumExprFieldIdentifierValue (Identifier field_name,
-				std::unique_ptr<Expr> field_value)
-    : EnumExprFieldWithVal (std::move (field_value)),
-      field_name (std::move (field_name))
-  {}
-
-  // copy constructor, destructor, and assignment operator should not need
-  // defining
-
-  void accept_vis (HIRVisitor &vis) override;
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprFieldIdentifierValue *clone_enum_expr_field_impl () const override
-  {
-    return new EnumExprFieldIdentifierValue (*this);
-  }
-};
-
-// Tuple index and value variant of EnumExprField HIR node
-class EnumExprFieldIndexValue : public EnumExprFieldWithVal
-{
-  TupleIndex index;
-  // TODO: implement "with val" as a template with EnumExprField as type param?
-
-  // TODO: should this store location data?
-
-public:
-  EnumExprFieldIndexValue (TupleIndex field_index,
-			   std::unique_ptr<Expr> field_value)
-    : EnumExprFieldWithVal (std::move (field_value)), index (field_index)
-  {}
-
-  void accept_vis (HIRVisitor &vis) override;
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprFieldIndexValue *clone_enum_expr_field_impl () const override
-  {
-    return new EnumExprFieldIndexValue (*this);
-  }
-};
-
-// Struct-like syntax enum variant instance creation HIR node
-class EnumExprStruct : public EnumVariantExpr
-{
-  // std::vector<EnumExprField> fields;
-  std::vector<std::unique_ptr<EnumExprField> > fields;
-
-  Location locus;
-
-public:
-  std::string as_string () const override;
-
-  /*inline std::vector<std::unique_ptr<EnumExprField>> get_fields() const
-  { return fields;
-  }*/
-
-  EnumExprStruct (Analysis::NodeMapping mappings,
-		  PathInExpression enum_variant_path,
-		  std::vector<std::unique_ptr<EnumExprField> > variant_fields,
-		  AST::AttrVec outer_attribs, Location locus)
-    : EnumVariantExpr (std::move (mappings), std::move (enum_variant_path),
-		       std::move (outer_attribs)),
-      fields (std::move (variant_fields)), locus (locus)
-  {}
-
-  // copy constructor with vector clone
-  EnumExprStruct (EnumExprStruct const &other)
-    : EnumVariantExpr (other), locus (other.locus)
-  {
-    fields.reserve (other.fields.size ());
-    for (const auto &e : other.fields)
-      fields.push_back (e->clone_enum_expr_field ());
-  }
-
-  // overloaded assignment operator with vector clone
-  EnumExprStruct &operator= (EnumExprStruct const &other)
-  {
-    EnumVariantExpr::operator= (other);
-    locus = other.locus;
-
-    fields.reserve (other.fields.size ());
-    for (const auto &e : other.fields)
-      fields.push_back (e->clone_enum_expr_field ());
-
-    return *this;
-  }
-
-  // move constructors
-  EnumExprStruct (EnumExprStruct &&other) = default;
-  EnumExprStruct &operator= (EnumExprStruct &&other) = default;
-
-  Location get_locus () const override final { return locus; }
-
-  void accept_vis (HIRVisitor &vis) override;
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprStruct *clone_expr_impl () const override
-  {
-    return new EnumExprStruct (*this);
-  }
-
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprStruct *clone_expr_without_block_impl () const override
-  {
-    return new EnumExprStruct (*this);
-  }
-};
-
-// Tuple-like syntax enum variant instance creation HIR node
-class EnumExprTuple : public EnumVariantExpr
-{
-  std::vector<std::unique_ptr<Expr> > values;
-
-  Location locus;
-
-public:
-  std::string as_string () const override;
-
-  /*inline std::vector<std::unique_ptr<Expr>> get_values() const {
-      return values;
-  }*/
-
-  EnumExprTuple (Analysis::NodeMapping mappings,
-		 PathInExpression enum_variant_path,
-		 std::vector<std::unique_ptr<Expr> > variant_values,
-		 AST::AttrVec outer_attribs, Location locus)
-    : EnumVariantExpr (std::move (mappings), std::move (enum_variant_path),
-		       std::move (outer_attribs)),
-      values (std::move (variant_values)), locus (locus)
-  {}
-
-  // copy constructor with vector clone
-  EnumExprTuple (EnumExprTuple const &other)
-    : EnumVariantExpr (other), locus (other.locus)
-  {
-    values.reserve (other.values.size ());
-    for (const auto &e : other.values)
-      values.push_back (e->clone_expr ());
-  }
-
-  // overloaded assignment operator with vector clone
-  EnumExprTuple &operator= (EnumExprTuple const &other)
-  {
-    EnumVariantExpr::operator= (other);
-    locus = other.locus;
-
-    values.reserve (other.values.size ());
-    for (const auto &e : other.values)
-      values.push_back (e->clone_expr ());
-
-    return *this;
-  }
-
-  // move constructors
-  EnumExprTuple (EnumExprTuple &&other) = default;
-  EnumExprTuple &operator= (EnumExprTuple &&other) = default;
-
-  Location get_locus () const override final { return locus; }
-
-  void accept_vis (HIRVisitor &vis) override;
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprTuple *clone_expr_impl () const override
-  {
-    return new EnumExprTuple (*this);
-  }
-
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprTuple *clone_expr_without_block_impl () const override
-  {
-    return new EnumExprTuple (*this);
-  }
-};
-
-// No-field enum variant instance creation HIR node
-class EnumExprFieldless : public EnumVariantExpr
-{
-  Location locus;
-
-public:
-  std::string as_string () const override
-  {
-    // return enum_variant_path.as_string();
-    return get_enum_variant_path ().as_string ();
-  }
-
-  EnumExprFieldless (Analysis::NodeMapping mappings,
-		     PathInExpression enum_variant_path,
-		     AST::AttrVec outer_attribs, Location locus)
-    : EnumVariantExpr (std::move (mappings), std::move (enum_variant_path),
-		       std::move (outer_attribs)),
-      locus (locus)
-  {}
-
-  Location get_locus () const override final { return locus; }
-
-  void accept_vis (HIRVisitor &vis) override;
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprFieldless *clone_expr_impl () const override
-  {
-    return new EnumExprFieldless (*this);
-  }
-
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  EnumExprFieldless *clone_expr_without_block_impl () const override
-  {
-    return new EnumExprFieldless (*this);
-  }
-};
-
 // Forward decl for Function - used in CallExpr
 class Function;
 
diff --git a/gcc/rust/hir/tree/rust-hir-full-decls.h b/gcc/rust/hir/tree/rust-hir-full-decls.h
index b72678a4f40..ffa08127ddc 100644
--- a/gcc/rust/hir/tree/rust-hir-full-decls.h
+++ b/gcc/rust/hir/tree/rust-hir-full-decls.h
@@ -90,15 +90,6 @@ class StructExprFieldIdentifierValue;
 class StructExprFieldIndexValue;
 class StructExprStructFields;
 class StructExprStructBase;
-class EnumVariantExpr;
-class EnumExprField;
-class EnumExprFieldIdentifier;
-class EnumExprFieldWithVal;
-class EnumExprFieldIdentifierValue;
-class EnumExprFieldIndexValue;
-class EnumExprStruct;
-class EnumExprTuple;
-class EnumExprFieldless;
 class CallExpr;
 class MethodCallExpr;
 class FieldAccessExpr;
diff --git a/gcc/rust/hir/tree/rust-hir-full-test.cc b/gcc/rust/hir/tree/rust-hir-full-test.cc
index eda5eaf2c0b..f328ae67abe 100644
--- a/gcc/rust/hir/tree/rust-hir-full-test.cc
+++ b/gcc/rust/hir/tree/rust-hir-full-test.cc
@@ -3930,42 +3930,6 @@ StructExprStructBase::accept_vis (HIRVisitor &vis)
   vis.visit (*this);
 }
 
-void
-EnumExprFieldIdentifier::accept_vis (HIRVisitor &vis)
-{
-  vis.visit (*this);
-}
-
-void
-EnumExprFieldIdentifierValue::accept_vis (HIRVisitor &vis)
-{
-  vis.visit (*this);
-}
-
-void
-EnumExprFieldIndexValue::accept_vis (HIRVisitor &vis)
-{
-  vis.visit (*this);
-}
-
-void
-EnumExprStruct::accept_vis (HIRVisitor &vis)
-{
-  vis.visit (*this);
-}
-
-void
-EnumExprTuple::accept_vis (HIRVisitor &vis)
-{
-  vis.visit (*this);
-}
-
-void
-EnumExprFieldless::accept_vis (HIRVisitor &vis)
-{
-  vis.visit (*this);
-}
-
 void
 CallExpr::accept_vis (HIRVisitor &vis)
 {
diff --git a/gcc/rust/hir/tree/rust-hir-visitor.h b/gcc/rust/hir/tree/rust-hir-visitor.h
index be9bd37b13d..d5fbff99bc6 100644
--- a/gcc/rust/hir/tree/rust-hir-visitor.h
+++ b/gcc/rust/hir/tree/rust-hir-visitor.h
@@ -60,12 +60,6 @@ public:
   virtual void visit (StructExprFieldIndexValue &field) = 0;
   virtual void visit (StructExprStructFields &expr) = 0;
   virtual void visit (StructExprStructBase &expr) = 0;
-  virtual void visit (EnumExprFieldIdentifier &field) = 0;
-  virtual void visit (EnumExprFieldIdentifierValue &field) = 0;
-  virtual void visit (EnumExprFieldIndexValue &field) = 0;
-  virtual void visit (EnumExprStruct &expr) = 0;
-  virtual void visit (EnumExprTuple &expr) = 0;
-  virtual void visit (EnumExprFieldless &expr) = 0;
   virtual void visit (CallExpr &expr) = 0;
   virtual void visit (MethodCallExpr &expr) = 0;
   virtual void visit (FieldAccessExpr &expr) = 0;
diff --git a/gcc/rust/lint/rust-lint-marklive-base.h b/gcc/rust/lint/rust-lint-marklive-base.h
index 86dab263e2a..e7b01945b1c 100644
--- a/gcc/rust/lint/rust-lint-marklive-base.h
+++ b/gcc/rust/lint/rust-lint-marklive-base.h
@@ -71,13 +71,6 @@ public:
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
 
-  virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
-  virtual void visit (HIR::EnumExprFieldIdentifierValue &) override {}
-
-  virtual void visit (HIR::EnumExprFieldIndexValue &) override {}
-  virtual void visit (HIR::EnumExprStruct &) override {}
-  virtual void visit (HIR::EnumExprTuple &) override {}
-  virtual void visit (HIR::EnumExprFieldless &) override {}
   virtual void visit (HIR::CallExpr &) override {}
   virtual void visit (HIR::MethodCallExpr &) override {}
   virtual void visit (HIR::FieldAccessExpr &) override {}
diff --git a/gcc/rust/resolve/rust-ast-resolve-base.h b/gcc/rust/resolve/rust-ast-resolve-base.h
index a3aeaba641c..025052d290b 100644
--- a/gcc/rust/resolve/rust-ast-resolve-base.h
+++ b/gcc/rust/resolve/rust-ast-resolve-base.h
@@ -73,12 +73,6 @@ public:
   void visit (AST::StructExprFieldIndexValue &) {}
   void visit (AST::StructExprStructFields &) {}
   void visit (AST::StructExprStructBase &) {}
-  void visit (AST::EnumExprFieldIdentifier &) {}
-  void visit (AST::EnumExprFieldIdentifierValue &) {}
-  void visit (AST::EnumExprFieldIndexValue &) {}
-  void visit (AST::EnumExprStruct &) {}
-  void visit (AST::EnumExprTuple &) {}
-  void visit (AST::EnumExprFieldless &) {}
   void visit (AST::CallExpr &) {}
   void visit (AST::MethodCallExpr &) {}
   void visit (AST::FieldAccessExpr &) {}
diff --git a/gcc/rust/typecheck/rust-hir-const-fold-base.h b/gcc/rust/typecheck/rust-hir-const-fold-base.h
index a8f2423348c..0c23ec81efb 100644
--- a/gcc/rust/typecheck/rust-hir-const-fold-base.h
+++ b/gcc/rust/typecheck/rust-hir-const-fold-base.h
@@ -74,13 +74,6 @@ public:
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
 
-  virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
-  virtual void visit (HIR::EnumExprFieldIdentifierValue &) override {}
-
-  virtual void visit (HIR::EnumExprFieldIndexValue &) override {}
-  virtual void visit (HIR::EnumExprStruct &) override {}
-  virtual void visit (HIR::EnumExprTuple &) override {}
-  virtual void visit (HIR::EnumExprFieldless &) override {}
   virtual void visit (HIR::CallExpr &) override {}
   virtual void visit (HIR::MethodCallExpr &) override {}
   virtual void visit (HIR::FieldAccessExpr &) override {}
diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.h b/gcc/rust/typecheck/rust-hir-type-check-base.h
index 178d78d168a..26fb5061227 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-base.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-base.h
@@ -75,13 +75,6 @@ public:
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
 
-  virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
-  virtual void visit (HIR::EnumExprFieldIdentifierValue &) override {}
-
-  virtual void visit (HIR::EnumExprFieldIndexValue &) override {}
-  virtual void visit (HIR::EnumExprStruct &) override {}
-  virtual void visit (HIR::EnumExprTuple &) override {}
-  virtual void visit (HIR::EnumExprFieldless &) override {}
   virtual void visit (HIR::CallExpr &) override {}
   virtual void visit (HIR::MethodCallExpr &) override {}
   virtual void visit (HIR::FieldAccessExpr &) override {}
diff --git a/gcc/rust/typecheck/rust-hir-type-check-util.h b/gcc/rust/typecheck/rust-hir-type-check-util.h
index e9f2ff4d51c..78d35a6fadd 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-util.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-util.h
@@ -69,13 +69,6 @@ public:
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
 
-  virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
-  virtual void visit (HIR::EnumExprFieldIdentifierValue &) override {}
-
-  virtual void visit (HIR::EnumExprFieldIndexValue &) override {}
-  virtual void visit (HIR::EnumExprStruct &) override {}
-  virtual void visit (HIR::EnumExprTuple &) override {}
-  virtual void visit (HIR::EnumExprFieldless &) override {}
   virtual void visit (HIR::CallExpr &) override {}
   virtual void visit (HIR::MethodCallExpr &) override {}
   virtual void visit (HIR::FieldAccessExpr &) override {}
-- 
2.32.0