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 35F573858408 for ; Sun, 5 Sep 2021 22:48:28 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 35F573858408 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 (deer0x19.wildebeest.org [172.31.17.155]) (using TLSv1.2 with cipher ADH-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by gnu.wildebeest.org (Postfix) with ESMTPSA id 5338833C5E9B; Mon, 6 Sep 2021 00:48:26 +0200 (CEST) Received: by reform (Postfix, from userid 1000) id EC8DF2E82166; Mon, 6 Sep 2021 00:48:25 +0200 (CEST) From: Mark Wielaard To: gcc-rust@gcc.gnu.org Cc: Mark Wielaard Subject: [PATCH 1/3] Parse optional visibility for enum item Date: Mon, 6 Sep 2021 00:48:09 +0200 Message-Id: <20210905224811.69432-1-mark@klomp.org> X-Mailer: git-send-email 2.32.0 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: Sun, 05 Sep 2021 22:48:30 -0000 Syntactically enum items can have a visibility. The visibility has to be removed (through a cfg attribute or macro) before they get lowered. The semantic checking will be done when we implement lowering enum items. Make the AST EnumItem class a VisItem. This simplifies things a little for cloning items, handling outer attributes and will help when adding EnumItem (sub)classes to AST visitors (so they can be handled as Items). Also add a get_identifier method to Enum and EnumItem. --- gcc/rust/ast/rust-ast-full-test.cc | 6 ++-- gcc/rust/ast/rust-item.h | 58 +++++++++++++++--------------- gcc/rust/parse/rust-parse-impl.h | 12 ++++--- 3 files changed, 38 insertions(+), 38 deletions(-) diff --git a/gcc/rust/ast/rust-ast-full-test.cc b/gcc/rust/ast/rust-ast-full-test.cc index 6241710226d..2477d7400a7 100644 --- a/gcc/rust/ast/rust-ast-full-test.cc +++ b/gcc/rust/ast/rust-ast-full-test.cc @@ -3311,10 +3311,8 @@ StructExprStructFields::as_string () const std::string EnumItem::as_string () const { - // outer attributes - std::string str = append_attributes (outer_attrs, OUTER); - - str += "\n" + variant_name; + std::string str = VisItem::as_string (); + str += variant_name; return str; } diff --git a/gcc/rust/ast/rust-item.h b/gcc/rust/ast/rust-item.h index 0578329f54b..881a888f092 100644 --- a/gcc/rust/ast/rust-item.h +++ b/gcc/rust/ast/rust-item.h @@ -2119,12 +2119,10 @@ protected: }; /* An item used in an "enum" tagged union - not abstract: base represents a - * name-only enum */ -class EnumItem + * name-only enum. EnumItems (variants) syntactically allow a Visibility + * annotation. */ +class EnumItem : public VisItem { - // bool has_attrs; - std::vector outer_attrs; - Identifier variant_name; Location locus; @@ -2132,19 +2130,16 @@ class EnumItem public: virtual ~EnumItem () {} - // Returns whether enum item has outer attributes. - bool has_outer_attrs () const { return !outer_attrs.empty (); } - - EnumItem (Identifier variant_name, std::vector outer_attrs, - Location locus) - : outer_attrs (std::move (outer_attrs)), + EnumItem (Identifier variant_name, Visibility vis, + std::vector outer_attrs, Location locus) + : VisItem (std::move (vis), std::move (outer_attrs)), variant_name (std::move (variant_name)), locus (locus) {} // Unique pointer custom clone function std::unique_ptr clone_enum_item () const { - return std::unique_ptr (clone_enum_item_impl ()); + return std::unique_ptr (clone_item_impl ()); } virtual std::string as_string () const; @@ -2152,20 +2147,16 @@ public: // not pure virtual as not abstract virtual void accept_vis (ASTVisitor &vis); + Location get_locus () const { return locus; } + + Identifier get_identifier () const { return variant_name; } + // Based on idea that name is never empty. void mark_for_strip () { variant_name = ""; } bool is_marked_for_strip () const { return variant_name.empty (); } - // TODO: this mutable getter seems really dodgy. Think up better way. - std::vector &get_outer_attrs () { return outer_attrs; } - const std::vector &get_outer_attrs () const { return outer_attrs; } - protected: - // Clone function implementation as (not pure) virtual method - virtual EnumItem *clone_enum_item_impl () const - { - return new EnumItem (*this); - } + EnumItem *clone_item_impl () const override { return new EnumItem (*this); } }; // A tuple item used in an "enum" tagged union @@ -2178,9 +2169,11 @@ public: // Returns whether tuple enum item has tuple fields. bool has_tuple_fields () const { return !tuple_fields.empty (); } - EnumItemTuple (Identifier variant_name, std::vector tuple_fields, + EnumItemTuple (Identifier variant_name, Visibility vis, + std::vector tuple_fields, std::vector outer_attrs, Location locus) - : EnumItem (std::move (variant_name), std::move (outer_attrs), locus), + : EnumItem (std::move (variant_name), std::move (vis), + std::move (outer_attrs), locus), tuple_fields (std::move (tuple_fields)) {} @@ -2197,7 +2190,7 @@ public: protected: // Clone function implementation as (not pure) virtual method - EnumItemTuple *clone_enum_item_impl () const override + EnumItemTuple *clone_item_impl () const override { return new EnumItemTuple (*this); } @@ -2213,10 +2206,11 @@ public: // Returns whether struct enum item has struct fields. bool has_struct_fields () const { return !struct_fields.empty (); } - EnumItemStruct (Identifier variant_name, + EnumItemStruct (Identifier variant_name, Visibility vis, std::vector struct_fields, std::vector outer_attrs, Location locus) - : EnumItem (std::move (variant_name), std::move (outer_attrs), locus), + : EnumItem (std::move (variant_name), std::move (vis), + std::move (outer_attrs), locus), struct_fields (std::move (struct_fields)) {} @@ -2233,7 +2227,7 @@ public: protected: // Clone function implementation as (not pure) virtual method - EnumItemStruct *clone_enum_item_impl () const override + EnumItemStruct *clone_item_impl () const override { return new EnumItemStruct (*this); } @@ -2245,9 +2239,11 @@ class EnumItemDiscriminant : public EnumItem std::unique_ptr expression; public: - EnumItemDiscriminant (Identifier variant_name, std::unique_ptr expr, + EnumItemDiscriminant (Identifier variant_name, Visibility vis, + std::unique_ptr expr, std::vector outer_attrs, Location locus) - : EnumItem (std::move (variant_name), std::move (outer_attrs), locus), + : EnumItem (std::move (variant_name), std::move (vis), + std::move (outer_attrs), locus), expression (std::move (expr)) {} @@ -2284,7 +2280,7 @@ public: protected: // Clone function implementation as (not pure) virtual method - EnumItemDiscriminant *clone_enum_item_impl () const override + EnumItemDiscriminant *clone_item_impl () const override { return new EnumItemDiscriminant (*this); } @@ -2374,6 +2370,8 @@ public: void accept_vis (ASTVisitor &vis) override; + Identifier get_identifier () const { return enum_name; } + // Invalid if name is empty, so base stripping on that. void mark_for_strip () override { enum_name = ""; } bool is_marked_for_strip () const override { return enum_name.empty (); } diff --git a/gcc/rust/parse/rust-parse-impl.h b/gcc/rust/parse/rust-parse-impl.h index 1c0644d42ae..8cce9332350 100644 --- a/gcc/rust/parse/rust-parse-impl.h +++ b/gcc/rust/parse/rust-parse-impl.h @@ -4431,6 +4431,9 @@ Parser::parse_enum_item () // parse outer attributes if they exist AST::AttrVec outer_attrs = parse_outer_attributes (); + // parse visibility, which may or may not exist + AST::Visibility vis = parse_visibility (); + // parse name for enum item, which is required const_TokenPtr item_name_tok = lexer.peek_token (); if (item_name_tok->get_id () != IDENTIFIER) @@ -4463,7 +4466,7 @@ Parser::parse_enum_item () } return std::unique_ptr (new AST::EnumItemTuple ( - std::move (item_name), std::move (tuple_fields), + std::move (item_name), std::move (vis), std::move (tuple_fields), std::move (outer_attrs), item_name_tok->get_locus ())); } case LEFT_CURLY: { @@ -4480,7 +4483,7 @@ Parser::parse_enum_item () } return std::unique_ptr (new AST::EnumItemStruct ( - std::move (item_name), std::move (struct_fields), + std::move (item_name), std::move (vis), std::move (struct_fields), std::move (outer_attrs), item_name_tok->get_locus ())); } case EQUAL: { @@ -4490,7 +4493,7 @@ Parser::parse_enum_item () std::unique_ptr discriminant_expr = parse_expr (); return std::unique_ptr ( - new AST::EnumItemDiscriminant (std::move (item_name), + new AST::EnumItemDiscriminant (std::move (item_name), std::move (vis), std::move (discriminant_expr), std::move (outer_attrs), item_name_tok->get_locus ())); @@ -4498,7 +4501,8 @@ Parser::parse_enum_item () default: // regular enum with just an identifier return std::unique_ptr ( - new AST::EnumItem (std::move (item_name), std::move (outer_attrs), + new AST::EnumItem (std::move (item_name), std::move (vis), + std::move (outer_attrs), item_name_tok->get_locus ())); } } -- 2.32.0