public inbox for gcc-rust@gcc.gnu.org
 help / color / mirror / Atom feed
* Cleanup some StructExpr related classes
@ 2021-09-01  0:15 Mark Wielaard
  2021-09-01  0:15 ` [PATCH 1/3] StructExprTuple doesn't really exist Mark Wielaard
                   ` (3 more replies)
  0 siblings, 4 replies; 9+ messages in thread
From: Mark Wielaard @ 2021-09-01  0:15 UTC (permalink / raw)
  To: gcc-rust

Hi,

There are various Structure Expressions that don't actually "exist"
because they are syntactically equivalent to other constructs. So we
never really construct or use these classes. But they are still listed
in various visitors, which is somewhat confusing. Removing the AST and
HIR variants of these classes really cleans up the code IMHO.

The following 3 patches can also be found on
https://code.wildebeest.org/git/user/mjw/gccrs/log/?h=structexpr

[PATCH 1/3] StructExprTuple doesn't really exist
[PATCH 2/3] StructExprUnit doesn't really exist
[PATCH 3/3] Remove Enumaration Expression, EnumExpr, classes

Cheers,

Mark

^ permalink raw reply	[flat|nested] 9+ messages in thread

* [PATCH 1/3] StructExprTuple doesn't really exist
  2021-09-01  0:15 Cleanup some StructExpr related classes Mark Wielaard
@ 2021-09-01  0:15 ` Mark Wielaard
  2021-09-01  0:15 ` [PATCH 2/3] StructExprUnit " Mark Wielaard
                   ` (2 subsequent siblings)
  3 siblings, 0 replies; 9+ messages in thread
From: Mark Wielaard @ 2021-09-01  0:15 UTC (permalink / raw)
  To: gcc-rust; +Cc: Mark Wielaard

A StructExprTuple is parsed as a CallExpr. Both (can) start with a
PathInExpression followed by zero or more Expressions between
brackets.

Only, after type checking, when actually generating gcc generic trees
is a distinction made between a function call or tuple constructor.

Remove the AST and HIR StructExprTuple classes which are never used.
---
 gcc/rust/ast/rust-ast-full-decls.h            |  1 -
 gcc/rust/ast/rust-ast-full-test.cc            | 44 -----------
 gcc/rust/ast/rust-ast-visitor.h               |  1 -
 gcc/rust/ast/rust-expr.h                      | 69 -----------------
 gcc/rust/backend/rust-compile-base.h          |  1 -
 gcc/rust/expand/rust-macro-expand.cc          | 30 --------
 gcc/rust/hir/rust-ast-lower-base.h            |  1 -
 gcc/rust/hir/tree/rust-hir-expr.h             | 74 -------------------
 gcc/rust/hir/tree/rust-hir-full-decls.h       |  1 -
 gcc/rust/hir/tree/rust-hir-full-test.cc       | 59 ---------------
 gcc/rust/hir/tree/rust-hir-visitor.h          |  1 -
 gcc/rust/lint/rust-lint-marklive-base.h       |  1 -
 gcc/rust/resolve/rust-ast-resolve-base.h      |  1 -
 gcc/rust/typecheck/rust-hir-const-fold-base.h |  1 -
 gcc/rust/typecheck/rust-hir-type-check-base.h |  1 -
 gcc/rust/typecheck/rust-hir-type-check-util.h |  1 -
 16 files changed, 287 deletions(-)

diff --git a/gcc/rust/ast/rust-ast-full-decls.h b/gcc/rust/ast/rust-ast-full-decls.h
index 7644dfe240c..205da881ed4 100644
--- a/gcc/rust/ast/rust-ast-full-decls.h
+++ b/gcc/rust/ast/rust-ast-full-decls.h
@@ -109,7 +109,6 @@ class StructExprFieldIdentifierValue;
 class StructExprFieldIndexValue;
 class StructExprStructFields;
 class StructExprStructBase;
-class StructExprTuple;
 class StructExprUnit;
 class EnumVariantExpr;
 class EnumExprField;
diff --git a/gcc/rust/ast/rust-ast-full-test.cc b/gcc/rust/ast/rust-ast-full-test.cc
index c18d4c4fd74..1a447ae0198 100644
--- a/gcc/rust/ast/rust-ast-full-test.cc
+++ b/gcc/rust/ast/rust-ast-full-test.cc
@@ -3239,44 +3239,6 @@ StructExpr::as_string () const
   return str;
 }
 
-std::string
-StructExprTuple::as_string () const
-{
-  std::string str = StructExpr::as_string ();
-
-  if (exprs.empty ())
-    {
-      str += "()";
-    }
-  else
-    {
-      auto i = exprs.begin ();
-      auto e = exprs.end ();
-
-      // debug - null pointer check
-      if (*i == nullptr)
-	return "ERROR_MARK_STRING - nullptr struct expr tuple field";
-
-      str += '(';
-      for (; i != e; i++)
-	{
-	  str += (*i)->as_string ();
-	  if (e != i + 1)
-	    str += ", ";
-	}
-      str += ')';
-    }
-
-  indent_spaces (enter);
-  indent_spaces (enter);
-  // inner attributes
-  str += append_attributes (inner_attrs, INNER);
-  indent_spaces (out);
-  indent_spaces (out);
-
-  return str;
-}
-
 std::string
 StructExprStruct::as_string () const
 {
@@ -5222,12 +5184,6 @@ StructExprStructBase::accept_vis (ASTVisitor &vis)
   vis.visit (*this);
 }
 
-void
-StructExprTuple::accept_vis (ASTVisitor &vis)
-{
-  vis.visit (*this);
-}
-
 void
 StructExprUnit::accept_vis (ASTVisitor &vis)
 {
diff --git a/gcc/rust/ast/rust-ast-visitor.h b/gcc/rust/ast/rust-ast-visitor.h
index e0de54d7a98..30e156facbb 100644
--- a/gcc/rust/ast/rust-ast-visitor.h
+++ b/gcc/rust/ast/rust-ast-visitor.h
@@ -93,7 +93,6 @@ public:
   virtual void visit (StructExprFieldIndexValue &field) = 0;
   virtual void visit (StructExprStructFields &expr) = 0;
   virtual void visit (StructExprStructBase &expr) = 0;
-  virtual void visit (StructExprTuple &expr) = 0;
   virtual void visit (StructExprUnit &expr) = 0;
   // virtual void visit(EnumExprField& field) = 0;
   virtual void visit (EnumExprFieldIdentifier &field) = 0;
diff --git a/gcc/rust/ast/rust-expr.h b/gcc/rust/ast/rust-expr.h
index 88e45fef330..effdb230319 100644
--- a/gcc/rust/ast/rust-expr.h
+++ b/gcc/rust/ast/rust-expr.h
@@ -1852,75 +1852,6 @@ protected:
   }
 };
 
-// AST node of a tuple struct creator
-class StructExprTuple : public StructExpr
-{
-  std::vector<Attribute> inner_attrs;
-  std::vector<std::unique_ptr<Expr> > exprs;
-
-  Location locus;
-
-public:
-  std::string as_string () const override;
-
-  const std::vector<Attribute> &get_inner_attrs () const { return inner_attrs; }
-  std::vector<Attribute> &get_inner_attrs () { return inner_attrs; }
-
-  StructExprTuple (PathInExpression struct_path,
-		   std::vector<std::unique_ptr<Expr> > tuple_exprs,
-		   std::vector<Attribute> inner_attribs,
-		   std::vector<Attribute> outer_attribs, Location locus)
-    : StructExpr (std::move (struct_path), std::move (outer_attribs)),
-      inner_attrs (std::move (inner_attribs)), exprs (std::move (tuple_exprs)),
-      locus (locus)
-  {}
-
-  // copy constructor with vector clone
-  StructExprTuple (StructExprTuple const &other)
-    : StructExpr (other), inner_attrs (other.inner_attrs), locus (other.locus)
-  {
-    exprs.reserve (other.exprs.size ());
-    for (const auto &e : other.exprs)
-      exprs.push_back (e->clone_expr ());
-  }
-
-  // overloaded assignment operator with vector clone
-  StructExprTuple &operator= (StructExprTuple const &other)
-  {
-    StructExpr::operator= (other);
-    inner_attrs = other.inner_attrs;
-    locus = other.locus;
-
-    exprs.reserve (other.exprs.size ());
-    for (const auto &e : other.exprs)
-      exprs.push_back (e->clone_expr ());
-
-    return *this;
-  }
-
-  // move constructors
-  StructExprTuple (StructExprTuple &&other) = default;
-  StructExprTuple &operator= (StructExprTuple &&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 exprs;
-  }
-  std::vector<std::unique_ptr<Expr> > &get_elems () { return exprs; }
-
-protected:
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  StructExprTuple *clone_expr_without_block_impl () const override
-  {
-    return new StructExprTuple (*this);
-  }
-};
-
 // AST node of a "unit" struct creator (no fields and no braces)
 class StructExprUnit : public StructExpr
 {
diff --git a/gcc/rust/backend/rust-compile-base.h b/gcc/rust/backend/rust-compile-base.h
index 3daad5ffaaf..d7cc009133b 100644
--- a/gcc/rust/backend/rust-compile-base.h
+++ b/gcc/rust/backend/rust-compile-base.h
@@ -72,7 +72,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &field) {}
   virtual void visit (HIR::StructExprStructFields &expr) {}
   virtual void visit (HIR::StructExprStructBase &expr) {}
-  virtual void visit (HIR::StructExprTuple &expr) {}
   virtual void visit (HIR::StructExprUnit &expr) {}
   // virtual void visit(EnumExprField& field) {}
   virtual void visit (HIR::EnumExprFieldIdentifier &field) {}
diff --git a/gcc/rust/expand/rust-macro-expand.cc b/gcc/rust/expand/rust-macro-expand.cc
index e4855e0144c..060d41ad04c 100644
--- a/gcc/rust/expand/rust-macro-expand.cc
+++ b/gcc/rust/expand/rust-macro-expand.cc
@@ -939,36 +939,6 @@ public:
 		     "cannot strip expression in this position - outer "
 		     "attributes not allowed");
   }
-  void visit (AST::StructExprTuple &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;
-      }
-
-    /* strip test based on inner attrs - spec says these are inner
-     * attributes, not outer attributes of inner expr */
-    expander.expand_cfg_attrs (expr.get_inner_attrs ());
-    if (expander.fails_cfg_with_expand (expr.get_inner_attrs ()))
-      {
-	expr.mark_for_strip ();
-	return;
-      }
-
-    // strip sub-exprs of path
-    auto &struct_name = expr.get_struct_name ();
-    visit (struct_name);
-    if (struct_name.is_marked_for_strip ())
-      rust_error_at (struct_name.get_locus (),
-		     "cannot strip path in this position");
-
-    /* spec says outer attributes are specifically allowed for elements
-     * of tuple-style struct expressions, so full stripping possible */
-    expand_pointer_allow_strip (expr.get_elems ());
-  }
   void visit (AST::StructExprUnit &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 07489f86e23..e4303f2942c 100644
--- a/gcc/rust/hir/rust-ast-lower-base.h
+++ b/gcc/rust/hir/rust-ast-lower-base.h
@@ -96,7 +96,6 @@ public:
   virtual void visit (AST::StructExprFieldIndexValue &field) {}
   virtual void visit (AST::StructExprStructFields &expr) {}
   virtual void visit (AST::StructExprStructBase &expr) {}
-  virtual void visit (AST::StructExprTuple &expr) {}
   virtual void visit (AST::StructExprUnit &expr) {}
   //  virtual void visit(EnumExprField& field) {}
   virtual void visit (AST::EnumExprFieldIdentifier &field) {}
diff --git a/gcc/rust/hir/tree/rust-hir-expr.h b/gcc/rust/hir/tree/rust-hir-expr.h
index bb15d4f9901..d099455f9fb 100644
--- a/gcc/rust/hir/tree/rust-hir-expr.h
+++ b/gcc/rust/hir/tree/rust-hir-expr.h
@@ -1578,80 +1578,6 @@ protected:
   }
 };
 
-// HIR node of a tuple struct creator
-class StructExprTuple : public StructExpr
-{
-  AST::AttrVec inner_attrs;
-  std::vector<std::unique_ptr<Expr> > exprs;
-
-  Location locus;
-
-public:
-  std::string as_string () const override;
-
-  const AST::AttrVec &get_inner_attrs () const { return inner_attrs; }
-
-  /*inline std::vector<std::unique_ptr<Expr>> get_exprs() const {
-      return exprs;
-  }*/
-
-  StructExprTuple (Analysis::NodeMapping mappings, PathInExpression struct_path,
-		   std::vector<std::unique_ptr<Expr> > tuple_exprs,
-		   AST::AttrVec inner_attribs, AST::AttrVec outer_attribs,
-		   Location locus)
-    : StructExpr (std::move (mappings), std::move (struct_path),
-		  std::move (outer_attribs)),
-      inner_attrs (std::move (inner_attribs)), exprs (std::move (tuple_exprs)),
-      locus (locus)
-  {}
-
-  // copy constructor with vector clone
-  StructExprTuple (StructExprTuple const &other)
-    : StructExpr (other), inner_attrs (other.inner_attrs), locus (other.locus)
-  {
-    exprs.reserve (other.exprs.size ());
-    for (const auto &e : other.exprs)
-      exprs.push_back (e->clone_expr ());
-  }
-
-  // overloaded assignment operator with vector clone
-  StructExprTuple &operator= (StructExprTuple const &other)
-  {
-    StructExpr::operator= (other);
-    inner_attrs = other.inner_attrs;
-    locus = other.locus;
-
-    exprs.reserve (other.exprs.size ());
-    for (const auto &e : other.exprs)
-      exprs.push_back (e->clone_expr ());
-
-    return *this;
-  }
-
-  // move constructors
-  StructExprTuple (StructExprTuple &&other) = default;
-  StructExprTuple &operator= (StructExprTuple &&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 */
-  StructExprTuple *clone_expr_impl () const override
-  {
-    return new StructExprTuple (*this);
-  }
-
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  StructExprTuple *clone_expr_without_block_impl () const override
-  {
-    return new StructExprTuple (*this);
-  }
-};
-
 // HIR node of a "unit" struct creator (no fields and no braces)
 class StructExprUnit : public StructExpr
 {
diff --git a/gcc/rust/hir/tree/rust-hir-full-decls.h b/gcc/rust/hir/tree/rust-hir-full-decls.h
index 41ae398bcb8..11b82267333 100644
--- a/gcc/rust/hir/tree/rust-hir-full-decls.h
+++ b/gcc/rust/hir/tree/rust-hir-full-decls.h
@@ -90,7 +90,6 @@ class StructExprFieldIdentifierValue;
 class StructExprFieldIndexValue;
 class StructExprStructFields;
 class StructExprStructBase;
-class StructExprTuple;
 class StructExprUnit;
 class EnumVariantExpr;
 class EnumExprField;
diff --git a/gcc/rust/hir/tree/rust-hir-full-test.cc b/gcc/rust/hir/tree/rust-hir-full-test.cc
index ecc282a57b2..67a193594de 100644
--- a/gcc/rust/hir/tree/rust-hir-full-test.cc
+++ b/gcc/rust/hir/tree/rust-hir-full-test.cc
@@ -2994,59 +2994,6 @@ StructExpr::as_string () const
   return str;
 }
 
-std::string
-StructExprTuple::as_string () const
-{
-  std::string str = StructExpr::as_string ();
-
-  if (exprs.empty ())
-    {
-      str += "()";
-    }
-  else
-    {
-      auto i = exprs.begin ();
-      auto e = exprs.end ();
-
-      // debug - null pointer check
-      if (*i == nullptr)
-	{
-	  return "ERROR_MARK_STRING - nullptr struct expr tuple field";
-	}
-
-      str += '(';
-      for (; i != e; i++)
-	{
-	  str += (*i)->as_string ();
-	  if (e != i + 1)
-	    str += ", ";
-	}
-      str += ')';
-    }
-
-  indent_spaces (enter);
-  indent_spaces (enter);
-  // inner attributes
-  str += "\n" + indent_spaces (stay) + "inner attributes:";
-  if (inner_attrs.empty ())
-    {
-      str += "none";
-    }
-  else
-    {
-      /* note that this does not print them with "inner attribute" syntax -
-       * just the body */
-      for (const auto &attr : inner_attrs)
-	{
-	  str += "\n" + indent_spaces (stay) + attr.as_string ();
-	}
-    }
-  indent_spaces (out);
-  indent_spaces (out);
-
-  return str;
-}
-
 std::string
 StructExprStruct::as_string () const
 {
@@ -3983,12 +3930,6 @@ StructExprStructBase::accept_vis (HIRVisitor &vis)
   vis.visit (*this);
 }
 
-void
-StructExprTuple::accept_vis (HIRVisitor &vis)
-{
-  vis.visit (*this);
-}
-
 void
 StructExprUnit::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 637254349f3..dffd0d565bb 100644
--- a/gcc/rust/hir/tree/rust-hir-visitor.h
+++ b/gcc/rust/hir/tree/rust-hir-visitor.h
@@ -60,7 +60,6 @@ public:
   virtual void visit (StructExprFieldIndexValue &field) = 0;
   virtual void visit (StructExprStructFields &expr) = 0;
   virtual void visit (StructExprStructBase &expr) = 0;
-  virtual void visit (StructExprTuple &expr) = 0;
   virtual void visit (StructExprUnit &expr) = 0;
   virtual void visit (EnumExprFieldIdentifier &field) = 0;
   virtual void visit (EnumExprFieldIdentifierValue &field) = 0;
diff --git a/gcc/rust/lint/rust-lint-marklive-base.h b/gcc/rust/lint/rust-lint-marklive-base.h
index 229643fbd04..0354ad2e6f0 100644
--- a/gcc/rust/lint/rust-lint-marklive-base.h
+++ b/gcc/rust/lint/rust-lint-marklive-base.h
@@ -70,7 +70,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &) override {}
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
-  virtual void visit (HIR::StructExprTuple &) override {}
   virtual void visit (HIR::StructExprUnit &) override {}
 
   virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
diff --git a/gcc/rust/resolve/rust-ast-resolve-base.h b/gcc/rust/resolve/rust-ast-resolve-base.h
index 10e2b1bf6d5..42c938d4fcf 100644
--- a/gcc/rust/resolve/rust-ast-resolve-base.h
+++ b/gcc/rust/resolve/rust-ast-resolve-base.h
@@ -73,7 +73,6 @@ public:
   void visit (AST::StructExprFieldIndexValue &) {}
   void visit (AST::StructExprStructFields &) {}
   void visit (AST::StructExprStructBase &) {}
-  void visit (AST::StructExprTuple &) {}
   void visit (AST::StructExprUnit &) {}
   void visit (AST::EnumExprFieldIdentifier &) {}
   void visit (AST::EnumExprFieldIdentifierValue &) {}
diff --git a/gcc/rust/typecheck/rust-hir-const-fold-base.h b/gcc/rust/typecheck/rust-hir-const-fold-base.h
index 1829b85f125..7a6d6c5c207 100644
--- a/gcc/rust/typecheck/rust-hir-const-fold-base.h
+++ b/gcc/rust/typecheck/rust-hir-const-fold-base.h
@@ -73,7 +73,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &) override {}
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
-  virtual void visit (HIR::StructExprTuple &) override {}
   virtual void visit (HIR::StructExprUnit &) override {}
 
   virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.h b/gcc/rust/typecheck/rust-hir-type-check-base.h
index 30508149852..162df2d5959 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-base.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-base.h
@@ -74,7 +74,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &) override {}
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
-  virtual void visit (HIR::StructExprTuple &) override {}
   virtual void visit (HIR::StructExprUnit &) override {}
 
   virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
diff --git a/gcc/rust/typecheck/rust-hir-type-check-util.h b/gcc/rust/typecheck/rust-hir-type-check-util.h
index 8146c6eaa70..a2f1a43a8fd 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-util.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-util.h
@@ -68,7 +68,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &) override {}
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
-  virtual void visit (HIR::StructExprTuple &) override {}
   virtual void visit (HIR::StructExprUnit &) override {}
 
   virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
-- 
2.32.0


^ permalink raw reply	[flat|nested] 9+ messages in thread

* [PATCH 2/3] StructExprUnit doesn't really exist
  2021-09-01  0:15 Cleanup some StructExpr related classes Mark Wielaard
  2021-09-01  0:15 ` [PATCH 1/3] StructExprTuple doesn't really exist Mark Wielaard
@ 2021-09-01  0:15 ` Mark Wielaard
  2021-09-01  0:15 ` [PATCH 3/3] Remove Enumaration Expression, EnumExpr, classes Mark Wielaard
  2021-09-01 10:11 ` Cleanup some StructExpr related classes Philip Herron
  3 siblings, 0 replies; 9+ messages in thread
From: Mark Wielaard @ 2021-09-01  0:15 UTC (permalink / raw)
  To: gcc-rust; +Cc: Mark Wielaard

A StructExprUnit is parsed as an IdentifierExpr. An IdentifierExpr,
which is what we call a single segment PathInExpression.

After type checking, when generating gcc generic trees, if the
IdentifierExpr is a type reference (which must be a unit struct), then
a unit expression is generated.

Remove the AST and HIR StructExprUnit classes which are never used.
---
 gcc/rust/ast/rust-ast-full-decls.h            |  1 -
 gcc/rust/ast/rust-ast-full-test.cc            |  6 ----
 gcc/rust/ast/rust-ast-visitor.h               |  1 -
 gcc/rust/ast/rust-expr.h                      | 30 ----------------
 gcc/rust/backend/rust-compile-base.h          |  1 -
 gcc/rust/expand/rust-macro-expand.cc          | 17 ---------
 gcc/rust/hir/rust-ast-lower-base.h            |  1 -
 gcc/rust/hir/tree/rust-hir-expr.h             | 35 -------------------
 gcc/rust/hir/tree/rust-hir-full-decls.h       |  1 -
 gcc/rust/hir/tree/rust-hir-full-test.cc       |  6 ----
 gcc/rust/hir/tree/rust-hir-visitor.h          |  1 -
 gcc/rust/lint/rust-lint-marklive-base.h       |  1 -
 gcc/rust/resolve/rust-ast-resolve-base.h      |  1 -
 gcc/rust/typecheck/rust-hir-const-fold-base.h |  1 -
 gcc/rust/typecheck/rust-hir-type-check-base.h |  1 -
 gcc/rust/typecheck/rust-hir-type-check-util.h |  1 -
 16 files changed, 105 deletions(-)

diff --git a/gcc/rust/ast/rust-ast-full-decls.h b/gcc/rust/ast/rust-ast-full-decls.h
index 205da881ed4..09f879c312f 100644
--- a/gcc/rust/ast/rust-ast-full-decls.h
+++ b/gcc/rust/ast/rust-ast-full-decls.h
@@ -109,7 +109,6 @@ class StructExprFieldIdentifierValue;
 class StructExprFieldIndexValue;
 class StructExprStructFields;
 class StructExprStructBase;
-class StructExprUnit;
 class EnumVariantExpr;
 class EnumExprField;
 class EnumExprFieldIdentifier;
diff --git a/gcc/rust/ast/rust-ast-full-test.cc b/gcc/rust/ast/rust-ast-full-test.cc
index 1a447ae0198..8ffc1b20e70 100644
--- a/gcc/rust/ast/rust-ast-full-test.cc
+++ b/gcc/rust/ast/rust-ast-full-test.cc
@@ -5184,12 +5184,6 @@ StructExprStructBase::accept_vis (ASTVisitor &vis)
   vis.visit (*this);
 }
 
-void
-StructExprUnit::accept_vis (ASTVisitor &vis)
-{
-  vis.visit (*this);
-}
-
 void
 EnumExprFieldIdentifier::accept_vis (ASTVisitor &vis)
 {
diff --git a/gcc/rust/ast/rust-ast-visitor.h b/gcc/rust/ast/rust-ast-visitor.h
index 30e156facbb..ffd1d2d3161 100644
--- a/gcc/rust/ast/rust-ast-visitor.h
+++ b/gcc/rust/ast/rust-ast-visitor.h
@@ -93,7 +93,6 @@ public:
   virtual void visit (StructExprFieldIndexValue &field) = 0;
   virtual void visit (StructExprStructFields &expr) = 0;
   virtual void visit (StructExprStructBase &expr) = 0;
-  virtual void visit (StructExprUnit &expr) = 0;
   // virtual void visit(EnumExprField& field) = 0;
   virtual void visit (EnumExprFieldIdentifier &field) = 0;
   virtual void visit (EnumExprFieldIdentifierValue &field) = 0;
diff --git a/gcc/rust/ast/rust-expr.h b/gcc/rust/ast/rust-expr.h
index effdb230319..a6882c75e82 100644
--- a/gcc/rust/ast/rust-expr.h
+++ b/gcc/rust/ast/rust-expr.h
@@ -1852,36 +1852,6 @@ protected:
   }
 };
 
-// AST node of a "unit" struct creator (no fields and no braces)
-class StructExprUnit : public StructExpr
-{
-  Location locus;
-
-public:
-  std::string as_string () const override
-  {
-    return get_struct_name ().as_string ();
-  }
-
-  StructExprUnit (PathInExpression struct_path,
-		  std::vector<Attribute> outer_attribs, Location locus)
-    : StructExpr (std::move (struct_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 */
-  StructExprUnit *clone_expr_without_block_impl () const override
-  {
-    return new StructExprUnit (*this);
-  }
-};
-
 // aka EnumerationVariantExpr
 // Base AST node representing creation of an enum variant instance - abstract
 class EnumVariantExpr : public ExprWithoutBlock
diff --git a/gcc/rust/backend/rust-compile-base.h b/gcc/rust/backend/rust-compile-base.h
index d7cc009133b..2ce7369ecde 100644
--- a/gcc/rust/backend/rust-compile-base.h
+++ b/gcc/rust/backend/rust-compile-base.h
@@ -72,7 +72,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &field) {}
   virtual void visit (HIR::StructExprStructFields &expr) {}
   virtual void visit (HIR::StructExprStructBase &expr) {}
-  virtual void visit (HIR::StructExprUnit &expr) {}
   // virtual void visit(EnumExprField& field) {}
   virtual void visit (HIR::EnumExprFieldIdentifier &field) {}
   virtual void visit (HIR::EnumExprFieldIdentifierValue &field) {}
diff --git a/gcc/rust/expand/rust-macro-expand.cc b/gcc/rust/expand/rust-macro-expand.cc
index 060d41ad04c..65b2ea06039 100644
--- a/gcc/rust/expand/rust-macro-expand.cc
+++ b/gcc/rust/expand/rust-macro-expand.cc
@@ -939,23 +939,6 @@ public:
 		     "cannot strip expression in this position - outer "
 		     "attributes not allowed");
   }
-  void visit (AST::StructExprUnit &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;
-      }
-
-    // strip sub-exprs of path
-    auto &struct_name = expr.get_struct_name ();
-    visit (struct_name);
-    if (struct_name.is_marked_for_strip ())
-      rust_error_at (struct_name.get_locus (),
-		     "cannot strip path in this position");
-  }
   void visit (AST::EnumExprFieldIdentifier &) override
   {
     // as no attrs (at moment, at least), no stripping possible
diff --git a/gcc/rust/hir/rust-ast-lower-base.h b/gcc/rust/hir/rust-ast-lower-base.h
index e4303f2942c..8debf3967b1 100644
--- a/gcc/rust/hir/rust-ast-lower-base.h
+++ b/gcc/rust/hir/rust-ast-lower-base.h
@@ -96,7 +96,6 @@ public:
   virtual void visit (AST::StructExprFieldIndexValue &field) {}
   virtual void visit (AST::StructExprStructFields &expr) {}
   virtual void visit (AST::StructExprStructBase &expr) {}
-  virtual void visit (AST::StructExprUnit &expr) {}
   //  virtual void visit(EnumExprField& field) {}
   virtual void visit (AST::EnumExprFieldIdentifier &field) {}
   virtual void visit (AST::EnumExprFieldIdentifierValue &field) {}
diff --git a/gcc/rust/hir/tree/rust-hir-expr.h b/gcc/rust/hir/tree/rust-hir-expr.h
index d099455f9fb..b8cb7547665 100644
--- a/gcc/rust/hir/tree/rust-hir-expr.h
+++ b/gcc/rust/hir/tree/rust-hir-expr.h
@@ -1578,41 +1578,6 @@ protected:
   }
 };
 
-// HIR node of a "unit" struct creator (no fields and no braces)
-class StructExprUnit : public StructExpr
-{
-  Location locus;
-
-public:
-  std::string as_string () const override { return struct_name.as_string (); }
-
-  StructExprUnit (Analysis::NodeMapping mappings, PathInExpression struct_path,
-		  AST::AttrVec outer_attribs, Location locus)
-    : StructExpr (std::move (mappings), std::move (struct_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 */
-  StructExprUnit *clone_expr_impl () const override
-  {
-    return new StructExprUnit (*this);
-  }
-
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
-  StructExprUnit *clone_expr_without_block_impl () const override
-  {
-    return new StructExprUnit (*this);
-  }
-};
-
 // aka EnumerationVariantExpr
 // Base HIR node representing creation of an enum variant instance - abstract
 class EnumVariantExpr : public ExprWithoutBlock
diff --git a/gcc/rust/hir/tree/rust-hir-full-decls.h b/gcc/rust/hir/tree/rust-hir-full-decls.h
index 11b82267333..b72678a4f40 100644
--- a/gcc/rust/hir/tree/rust-hir-full-decls.h
+++ b/gcc/rust/hir/tree/rust-hir-full-decls.h
@@ -90,7 +90,6 @@ class StructExprFieldIdentifierValue;
 class StructExprFieldIndexValue;
 class StructExprStructFields;
 class StructExprStructBase;
-class StructExprUnit;
 class EnumVariantExpr;
 class EnumExprField;
 class EnumExprFieldIdentifier;
diff --git a/gcc/rust/hir/tree/rust-hir-full-test.cc b/gcc/rust/hir/tree/rust-hir-full-test.cc
index 67a193594de..eda5eaf2c0b 100644
--- a/gcc/rust/hir/tree/rust-hir-full-test.cc
+++ b/gcc/rust/hir/tree/rust-hir-full-test.cc
@@ -3930,12 +3930,6 @@ StructExprStructBase::accept_vis (HIRVisitor &vis)
   vis.visit (*this);
 }
 
-void
-StructExprUnit::accept_vis (HIRVisitor &vis)
-{
-  vis.visit (*this);
-}
-
 void
 EnumExprFieldIdentifier::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 dffd0d565bb..be9bd37b13d 100644
--- a/gcc/rust/hir/tree/rust-hir-visitor.h
+++ b/gcc/rust/hir/tree/rust-hir-visitor.h
@@ -60,7 +60,6 @@ public:
   virtual void visit (StructExprFieldIndexValue &field) = 0;
   virtual void visit (StructExprStructFields &expr) = 0;
   virtual void visit (StructExprStructBase &expr) = 0;
-  virtual void visit (StructExprUnit &expr) = 0;
   virtual void visit (EnumExprFieldIdentifier &field) = 0;
   virtual void visit (EnumExprFieldIdentifierValue &field) = 0;
   virtual void visit (EnumExprFieldIndexValue &field) = 0;
diff --git a/gcc/rust/lint/rust-lint-marklive-base.h b/gcc/rust/lint/rust-lint-marklive-base.h
index 0354ad2e6f0..86dab263e2a 100644
--- a/gcc/rust/lint/rust-lint-marklive-base.h
+++ b/gcc/rust/lint/rust-lint-marklive-base.h
@@ -70,7 +70,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &) override {}
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
-  virtual void visit (HIR::StructExprUnit &) override {}
 
   virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
   virtual void visit (HIR::EnumExprFieldIdentifierValue &) override {}
diff --git a/gcc/rust/resolve/rust-ast-resolve-base.h b/gcc/rust/resolve/rust-ast-resolve-base.h
index 42c938d4fcf..a3aeaba641c 100644
--- a/gcc/rust/resolve/rust-ast-resolve-base.h
+++ b/gcc/rust/resolve/rust-ast-resolve-base.h
@@ -73,7 +73,6 @@ public:
   void visit (AST::StructExprFieldIndexValue &) {}
   void visit (AST::StructExprStructFields &) {}
   void visit (AST::StructExprStructBase &) {}
-  void visit (AST::StructExprUnit &) {}
   void visit (AST::EnumExprFieldIdentifier &) {}
   void visit (AST::EnumExprFieldIdentifierValue &) {}
   void visit (AST::EnumExprFieldIndexValue &) {}
diff --git a/gcc/rust/typecheck/rust-hir-const-fold-base.h b/gcc/rust/typecheck/rust-hir-const-fold-base.h
index 7a6d6c5c207..a8f2423348c 100644
--- a/gcc/rust/typecheck/rust-hir-const-fold-base.h
+++ b/gcc/rust/typecheck/rust-hir-const-fold-base.h
@@ -73,7 +73,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &) override {}
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
-  virtual void visit (HIR::StructExprUnit &) override {}
 
   virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
   virtual void visit (HIR::EnumExprFieldIdentifierValue &) override {}
diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.h b/gcc/rust/typecheck/rust-hir-type-check-base.h
index 162df2d5959..178d78d168a 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-base.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-base.h
@@ -74,7 +74,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &) override {}
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
-  virtual void visit (HIR::StructExprUnit &) override {}
 
   virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
   virtual void visit (HIR::EnumExprFieldIdentifierValue &) override {}
diff --git a/gcc/rust/typecheck/rust-hir-type-check-util.h b/gcc/rust/typecheck/rust-hir-type-check-util.h
index a2f1a43a8fd..e9f2ff4d51c 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-util.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-util.h
@@ -68,7 +68,6 @@ public:
   virtual void visit (HIR::StructExprFieldIndexValue &) override {}
   virtual void visit (HIR::StructExprStructFields &) override {}
   virtual void visit (HIR::StructExprStructBase &) override {}
-  virtual void visit (HIR::StructExprUnit &) override {}
 
   virtual void visit (HIR::EnumExprFieldIdentifier &) override {}
   virtual void visit (HIR::EnumExprFieldIdentifierValue &) override {}
-- 
2.32.0


^ permalink raw reply	[flat|nested] 9+ messages in thread

* [PATCH 3/3] Remove Enumaration Expression, EnumExpr, classes
  2021-09-01  0:15 Cleanup some StructExpr related classes Mark Wielaard
  2021-09-01  0:15 ` [PATCH 1/3] StructExprTuple doesn't really exist Mark Wielaard
  2021-09-01  0:15 ` [PATCH 2/3] StructExprUnit " Mark Wielaard
@ 2021-09-01  0:15 ` Mark Wielaard
  2021-09-01 10:11 ` Cleanup some StructExpr related classes Philip Herron
  3 siblings, 0 replies; 9+ messages in thread
From: Mark Wielaard @ 2021-09-01  0:15 UTC (permalink / raw)
  To: gcc-rust; +Cc: Mark Wielaard

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


^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Cleanup some StructExpr related classes
  2021-09-01  0:15 Cleanup some StructExpr related classes Mark Wielaard
                   ` (2 preceding siblings ...)
  2021-09-01  0:15 ` [PATCH 3/3] Remove Enumaration Expression, EnumExpr, classes Mark Wielaard
@ 2021-09-01 10:11 ` Philip Herron
  2021-09-01 19:23   ` Mark Wielaard
  3 siblings, 1 reply; 9+ messages in thread
From: Philip Herron @ 2021-09-01 10:11 UTC (permalink / raw)
  To: Mark Wielaard; +Cc: gcc-rust

[-- Attachment #1: Type: text/plain, Size: 1218 bytes --]

This is fantastic work Mar. This brings us closer to the AST structures of
rustc and does simplify a lot of the analysis within the compiler.
https://doc.rust-lang.org/nightly/reference/expressions/struct-expr.html

I agree the HIR cleanup will also help reduce a lot of duplication of code
and visitors. It might mean we get alot of enum stuff for free potentially.

Thanks

--Phil


On Wed, 1 Sept 2021 at 01:16, Mark Wielaard <mark@klomp.org> wrote:

> Hi,
>
> There are various Structure Expressions that don't actually "exist"
> because they are syntactically equivalent to other constructs. So we
> never really construct or use these classes. But they are still listed
> in various visitors, which is somewhat confusing. Removing the AST and
> HIR variants of these classes really cleans up the code IMHO.
>
> The following 3 patches can also be found on
> https://code.wildebeest.org/git/user/mjw/gccrs/log/?h=structexpr
>
> [PATCH 1/3] StructExprTuple doesn't really exist
> [PATCH 2/3] StructExprUnit doesn't really exist
> [PATCH 3/3] Remove Enumaration Expression, EnumExpr, classes
>
> Cheers,
>
> Mark
> --
> Gcc-rust mailing list
> Gcc-rust@gcc.gnu.org
> https://gcc.gnu.org/mailman/listinfo/gcc-rust
>

[-- Attachment #2: Type: text/html, Size: 2039 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Cleanup some StructExpr related classes
  2021-09-01 10:11 ` Cleanup some StructExpr related classes Philip Herron
@ 2021-09-01 19:23   ` Mark Wielaard
  2021-09-02 13:23     ` Philip Herron
  0 siblings, 1 reply; 9+ messages in thread
From: Mark Wielaard @ 2021-09-01 19:23 UTC (permalink / raw)
  To: Philip Herron; +Cc: gcc-rust

Hi,

On Wed, Sep 01, 2021 at 11:11:46AM +0100, Philip Herron wrote:
> This is fantastic work Mar. This brings us closer to the AST structures of
> rustc and does simplify a lot of the analysis within the compiler.
> https://doc.rust-lang.org/nightly/reference/expressions/struct-expr.html

The reference does change from time to time. The older one did
describe various constructs that the newer does and for some it still
has comments saying some construct doesn't really construct, like the
tuple expression, which is simply a call (constructor) expression.  I
don't know if there is some kind of change log for the Rust reference.

Note that there are some more StructExpr cleanups at:
https://github.com/Rust-GCC/gccrs/pull/405
Which might be nice to finish.

> I agree the HIR cleanup will also help reduce a lot of duplication of code
> and visitors. It might mean we get alot of enum stuff for free potentially.

Potentially yes, but in practice enum item variants are different
enough to require lots of new code. I have patches for the parser,
resolver, and ast-hir-lowering and working on type-checking. One
tricky issue is that references to an enum item are paths with the
enum name first and the enum item second (Enum::Item). Which is
somewhat more complex than the IdentifierExpr. Another is that a
struct has one constructor, an enum has multiple (depending on the
enum item variant). So you need to add variants to the ADTType.

Work in progress at
https://code.wildebeest.org/git/user/mjw/gccrs/log/?h=enums
cleaned up patches (that I hope are correct) at
https://code.wildebeest.org/git/user/mjw/gccrs/log/?h=enums2

Cheers,

Mark


^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Cleanup some StructExpr related classes
  2021-09-01 19:23   ` Mark Wielaard
@ 2021-09-02 13:23     ` Philip Herron
  2021-09-05 22:47       ` Mark Wielaard
  0 siblings, 1 reply; 9+ messages in thread
From: Philip Herron @ 2021-09-02 13:23 UTC (permalink / raw)
  To: Mark Wielaard; +Cc: gcc-rust

[-- Attachment #1: Type: text/plain, Size: 2432 bytes --]

Hi Mark,

I've been reviewing your branch a bit and noticed this commit
https://code.wildebeest.org/git/user/mjw/gccrs/commit/?h=enums&id=84d27b926e09ef44dd94be20c97d72bd4b865c40
which I really like. I wasn't sure what was the best way to interact with
the AST which contained unique_ptr's to things so I initially added little
lambda's but these don't really help anything at all other than make it
more confusing to work with. So feel free to create patches to remove those.

I also noticed quite a few test cases already are these compiling? And did
you have to add much to the rust-gcc.cc wrapper for the enum type?

Thanks,
--Phil

On Wed, 1 Sept 2021 at 20:24, Mark Wielaard <mark@klomp.org> wrote:

> Hi,
>
> On Wed, Sep 01, 2021 at 11:11:46AM +0100, Philip Herron wrote:
> > This is fantastic work Mar. This brings us closer to the AST structures
> of
> > rustc and does simplify a lot of the analysis within the compiler.
> > https://doc.rust-lang.org/nightly/reference/expressions/struct-expr.html
>
> The reference does change from time to time. The older one did
> describe various constructs that the newer does and for some it still
> has comments saying some construct doesn't really construct, like the
> tuple expression, which is simply a call (constructor) expression.  I
> don't know if there is some kind of change log for the Rust reference.
>
> Note that there are some more StructExpr cleanups at:
> https://github.com/Rust-GCC/gccrs/pull/405
> Which might be nice to finish.
>
> > I agree the HIR cleanup will also help reduce a lot of duplication of
> code
> > and visitors. It might mean we get alot of enum stuff for free
> potentially.
>
> Potentially yes, but in practice enum item variants are different
> enough to require lots of new code. I have patches for the parser,
> resolver, and ast-hir-lowering and working on type-checking. One
> tricky issue is that references to an enum item are paths with the
> enum name first and the enum item second (Enum::Item). Which is
> somewhat more complex than the IdentifierExpr. Another is that a
> struct has one constructor, an enum has multiple (depending on the
> enum item variant). So you need to add variants to the ADTType.
>
> Work in progress at
> https://code.wildebeest.org/git/user/mjw/gccrs/log/?h=enums
> cleaned up patches (that I hope are correct) at
> https://code.wildebeest.org/git/user/mjw/gccrs/log/?h=enums2
>
> Cheers,
>
> Mark
>
>

[-- Attachment #2: Type: text/html, Size: 3513 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Cleanup some StructExpr related classes
  2021-09-02 13:23     ` Philip Herron
@ 2021-09-05 22:47       ` Mark Wielaard
  2021-09-06 16:55         ` Philip Herron
  0 siblings, 1 reply; 9+ messages in thread
From: Mark Wielaard @ 2021-09-05 22:47 UTC (permalink / raw)
  To: Philip Herron; +Cc: gcc-rust

Hi Philip,

On Thu, Sep 02, 2021 at 02:23:33PM +0100, Philip Herron wrote:
> I've been reviewing your branch a bit and noticed this commit
> https://code.wildebeest.org/git/user/mjw/gccrs/commit/?h=enums&id=84d27b926e09ef44dd94be20c97d72bd4b865c40
> which I really like. I wasn't sure what was the best way to interact with
> the AST which contained unique_ptr's to things so I initially added little
> lambda's but these don't really help anything at all other than make it
> more confusing to work with. So feel free to create patches to remove those.

I wasn't sure whether to replicate this for the HIR classes, so at
first I did it with a lambda, but found that not very nice. So instead
I added simple accessors for the fields vector which are the used in
in a simple for loop using get () on the elements. If you also like
that better I can change the AST classes to do the same thing.

> I also noticed quite a few test cases already are these compiling?

Yes, but they are all "negative" tests. I mean, that they check for
errors. After resolving we can check for unused enum item
warnings. After lowering we can detect bad visibility and duplicate
fields in struct variants. And after typechecking (not finished yet)
we can check the denominators of fieldless enums are unique (and
aren't too big).

> you have to add much to the rust-gcc.cc wrapper for the enum type?

I am still stuck at the type check pass. So haven't actually gotten to
that part.

I'll sent the parser, resolve and hit lowering bits, which include the
test cases.

These patches are also on
https://code.wildebeest.org/git/user/mjw/gccrs/log/?h=enums2

Cheers,

Mark

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Cleanup some StructExpr related classes
  2021-09-05 22:47       ` Mark Wielaard
@ 2021-09-06 16:55         ` Philip Herron
  0 siblings, 0 replies; 9+ messages in thread
From: Philip Herron @ 2021-09-06 16:55 UTC (permalink / raw)
  To: Mark Wielaard; +Cc: gcc-rust

[-- Attachment #1: Type: text/plain, Size: 768 bytes --]

Hi Mark,

Well done on the new patches they are currently being merged. I imagine the
typechecking could be a bit more complex since correct me if I am wrong but
I feel like this might end up affecting the whole PathInExpression
resolution which is fairly complicated. There is a nullptr bug there if it
fails to resolve the root segment.

I imagine there might need to be a check in the resolve_segments for if the
tyseg which will be the type of the previous segment, if that is an ADTType
which is an enum then look for the name of the field within the struct but
i am not 100% sure if it does affect the PathInExpression stuff.

Let me know if there is anything I can do to help or review? I don't mind
checking out your branches to play with too.

Thanks

--Phil

[-- Attachment #2: Type: text/html, Size: 908 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

end of thread, other threads:[~2021-09-06 16:55 UTC | newest]

Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-09-01  0:15 Cleanup some StructExpr related classes Mark Wielaard
2021-09-01  0:15 ` [PATCH 1/3] StructExprTuple doesn't really exist Mark Wielaard
2021-09-01  0:15 ` [PATCH 2/3] StructExprUnit " Mark Wielaard
2021-09-01  0:15 ` [PATCH 3/3] Remove Enumaration Expression, EnumExpr, classes Mark Wielaard
2021-09-01 10:11 ` Cleanup some StructExpr related classes Philip Herron
2021-09-01 19:23   ` Mark Wielaard
2021-09-02 13:23     ` Philip Herron
2021-09-05 22:47       ` Mark Wielaard
2021-09-06 16:55         ` Philip Herron

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).