From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from gnu.wildebeest.org (wildebeest.demon.nl [212.238.236.112]) by sourceware.org (Postfix) with ESMTPS id 256043858C27 for ; Wed, 1 Sep 2021 00:16:58 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 256043858C27 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=klomp.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=klomp.org Received: from reform (deer0x1b.wildebeest.org [172.31.17.157]) (using TLSv1.2 with cipher ADH-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by gnu.wildebeest.org (Postfix) with ESMTPSA id D6B3B3000F0D; Wed, 1 Sep 2021 02:16:50 +0200 (CEST) Received: by reform (Postfix, from userid 1000) id B13ED2E81023; Wed, 1 Sep 2021 02:16:50 +0200 (CEST) From: Mark Wielaard To: gcc-rust@gcc.gnu.org Cc: Mark Wielaard Subject: [PATCH 3/3] Remove Enumaration Expression, EnumExpr, classes Date: Wed, 1 Sep 2021 02:15:42 +0200 Message-Id: <20210901001542.160965-4-mark@klomp.org> X-Mailer: git-send-email 2.32.0 In-Reply-To: <20210901001542.160965-1-mark@klomp.org> References: <20210901001542.160965-1-mark@klomp.org> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-10.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, JMQ_SPF_NEUTRAL, KAM_DMARC_STATUS, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-rust@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: gcc-rust mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 01 Sep 2021 00:17:08 -0000 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 outer_attrs; - PathInExpression enum_variant_path; - -protected: - // Protected constructor for initialising enum_variant_path - EnumVariantExpr (PathInExpression path_to_enum_variant, - std::vector 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 &get_outer_attrs () const { return outer_attrs; } - std::vector &get_outer_attrs () { return outer_attrs; } - - void set_outer_attrs (std::vector 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 clone_enum_expr_field () const - { - return std::unique_ptr (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 value; - -protected: - EnumExprFieldWithVal (std::unique_ptr 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 &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 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 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 > fields; - Location locus; - -public: - std::string as_string () const override; - - EnumExprStruct (PathInExpression enum_variant_path, - std::vector > variant_fields, - std::vector 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 > &get_fields () { return fields; } - const std::vector > &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 > values; - Location locus; - -public: - std::string as_string () const override; - - EnumExprTuple (PathInExpression enum_variant_path, - std::vector > variant_values, - std::vector 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 > &get_elems () const - { - return values; - } - std::vector > &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 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 clone_enum_expr_field () const - { - return std::unique_ptr (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 value; - - // TODO: should this store location data? - -protected: - EnumExprFieldWithVal (std::unique_ptr 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 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 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 fields; - std::vector > fields; - - Location locus; - -public: - std::string as_string () const override; - - /*inline std::vector> get_fields() const - { return fields; - }*/ - - EnumExprStruct (Analysis::NodeMapping mappings, - PathInExpression enum_variant_path, - std::vector > 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 > values; - - Location locus; - -public: - std::string as_string () const override; - - /*inline std::vector> get_values() const { - return values; - }*/ - - EnumExprTuple (Analysis::NodeMapping mappings, - PathInExpression enum_variant_path, - std::vector > 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