From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1643) id 2646A3858288; Sat, 22 Oct 2022 10:47:41 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 2646A3858288 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1666435661; bh=Clm9cPVoKs6eA+LKLMK2mym06PzMuwjteKIFYitQD5k=; h=From:To:Subject:Date:From; b=to6JgnE4UTYVeoXvbnJc0rNiS1X6T4X8f18lThm2qJo759aah/TPfYtfC6B8PjcJv +Vhk676qZFqH68TdpNQvPYvUaY25ZHDd0fwBz+CTLYzUHn7/QHXAxcgVYh7hCItSti uwpY65Y2JkqqO7Q1yMO/vGWnBrPXRvdGVI1bxrgI= Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Thomas Schwinge To: gcc-cvs@gcc.gnu.org Subject: [gcc/devel/rust/master] Add hir lowering of closure expressions X-Act-Checkin: gcc X-Git-Author: Philip Herron X-Git-Refname: refs/heads/devel/rust/master X-Git-Oldrev: 851b9e14585160f70eb17a9b312c14e3a0d4c3ed X-Git-Newrev: 5f25f457eca1e04e577aae8e60fe640bb32d36fc Message-Id: <20221022104741.2646A3858288@sourceware.org> Date: Sat, 22 Oct 2022 10:47:41 +0000 (GMT) List-Id: https://gcc.gnu.org/g:5f25f457eca1e04e577aae8e60fe640bb32d36fc commit 5f25f457eca1e04e577aae8e60fe640bb32d36fc Author: Philip Herron Date: Mon Oct 17 17:18:30 2022 +0100 Add hir lowering of closure expressions In the AST we have ClosureExprInner and ClosureExprInnerTyped the first is the closure expression of the form: let closure_inferred = |i| i + 1; The second is of the form: let closure_annotated = |i: i32| -> i32 { i + 1 }; Both of these can be seguared into a single HIR::ClosureExpr with an optional return type and parameter types. Addresses #195 Diff: --- gcc/rust/ast/rust-expr.h | 9 +- gcc/rust/backend/rust-compile-block.h | 6 +- gcc/rust/backend/rust-compile-expr.cc | 6 + gcc/rust/backend/rust-compile-expr.h | 3 +- .../checks/errors/privacy/rust-privacy-reporter.cc | 8 +- .../checks/errors/privacy/rust-privacy-reporter.h | 3 +- gcc/rust/checks/errors/rust-const-checker.cc | 6 +- gcc/rust/checks/errors/rust-const-checker.h | 3 +- gcc/rust/checks/errors/rust-unsafe-checker.cc | 6 +- gcc/rust/checks/errors/rust-unsafe-checker.h | 3 +- gcc/rust/hir/rust-ast-lower-base.h | 2 + gcc/rust/hir/rust-ast-lower-expr.cc | 53 +++++ gcc/rust/hir/rust-ast-lower-expr.h | 2 + gcc/rust/hir/rust-ast-lower.cc | 23 +++ gcc/rust/hir/rust-hir-dump.cc | 6 +- gcc/rust/hir/rust-hir-dump.h | 3 +- gcc/rust/hir/tree/rust-hir-expr.h | 213 +++++++++------------ gcc/rust/hir/tree/rust-hir-full-decls.h | 2 - gcc/rust/hir/tree/rust-hir-full-test.cc | 37 +--- gcc/rust/hir/tree/rust-hir-visitor.h | 9 +- gcc/rust/hir/tree/rust-hir.h | 1 + gcc/rust/typecheck/rust-hir-type-check-expr.cc | 6 + gcc/rust/typecheck/rust-hir-type-check-expr.h | 3 +- 23 files changed, 206 insertions(+), 207 deletions(-) diff --git a/gcc/rust/ast/rust-expr.h b/gcc/rust/ast/rust-expr.h index c764f9c4c66..c58fae5e564 100644 --- a/gcc/rust/ast/rust-expr.h +++ b/gcc/rust/ast/rust-expr.h @@ -2134,8 +2134,6 @@ struct ClosureParam private: std::vector outer_attrs; std::unique_ptr pattern; - - // bool has_type_given; std::unique_ptr type; Location locus; @@ -2202,19 +2200,19 @@ public: const std::vector &get_outer_attrs () const { return outer_attrs; } std::vector &get_outer_attrs () { return outer_attrs; } - // TODO: is this better? Or is a "vis_block" better? std::unique_ptr &get_pattern () { rust_assert (pattern != nullptr); return pattern; } - // TODO: is this better? Or is a "vis_block" better? std::unique_ptr &get_type () { rust_assert (has_type_given ()); return type; } + + Location get_locus () const { return locus; } }; // Base closure definition expression AST node - abstract @@ -2248,6 +2246,8 @@ public: { outer_attrs = std::move (new_attrs); } + + bool get_has_move () const { return has_move; } }; // Represents a non-type-specified closure expression AST node @@ -2307,7 +2307,6 @@ public: return closure_inner == nullptr; } - // TODO: is this better? Or is a "vis_block" better? std::unique_ptr &get_definition_expr () { rust_assert (closure_inner != nullptr); diff --git a/gcc/rust/backend/rust-compile-block.h b/gcc/rust/backend/rust-compile-block.h index cdd17f19ca2..8f62f45a4c3 100644 --- a/gcc/rust/backend/rust-compile-block.h +++ b/gcc/rust/backend/rust-compile-block.h @@ -57,8 +57,7 @@ public: // Empty visit for unused Expression HIR nodes. void visit (HIR::PathInExpression &) override {} void visit (HIR::QualifiedPathInExpression &) override {} - void visit (HIR::ClosureExprInner &) override {} - void visit (HIR::ClosureExprInnerTyped &) override {} + void visit (HIR::ClosureExpr &) override {} void visit (HIR::StructExprFieldIdentifier &) override {} void visit (HIR::StructExprFieldIdentifierValue &) override {} void visit (HIR::StructExprFieldIndexValue &) override {} @@ -146,8 +145,7 @@ public: // Empty visit for unused Expression HIR nodes. void visit (HIR::PathInExpression &) override {} void visit (HIR::QualifiedPathInExpression &) override {} - void visit (HIR::ClosureExprInner &) override {} - void visit (HIR::ClosureExprInnerTyped &) override {} + void visit (HIR::ClosureExpr &) override {} void visit (HIR::StructExprFieldIdentifier &) override {} void visit (HIR::StructExprFieldIdentifierValue &) override {} void visit (HIR::StructExprFieldIndexValue &) override {} diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index 9ff2be64845..d66aa5d89f3 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -2798,5 +2798,11 @@ CompileExpr::visit (HIR::ArrayIndexExpr &expr) expr.get_locus ()); } +void +CompileExpr::visit (HIR::ClosureExpr &expr) +{ + gcc_unreachable (); +} + } // namespace Compile } // namespace Rust diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h index f5cb06dba81..fee2ba73d70 100644 --- a/gcc/rust/backend/rust-compile-expr.h +++ b/gcc/rust/backend/rust-compile-expr.h @@ -67,10 +67,9 @@ public: void visit (HIR::RangeToExpr &expr) override; void visit (HIR::RangeFullExpr &expr) override; void visit (HIR::RangeFromToInclExpr &expr) override; + void visit (HIR::ClosureExpr &expr) override; // TODO - void visit (HIR::ClosureExprInner &) override {} - void visit (HIR::ClosureExprInnerTyped &) override {} void visit (HIR::ErrorPropagationExpr &) override {} void visit (HIR::RangeToInclExpr &) override {} void visit (HIR::ForLoopExpr &) override {} diff --git a/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc b/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc index 35fde40782e..a8280583a64 100644 --- a/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc +++ b/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc @@ -408,7 +408,7 @@ PrivacyReporter::visit (HIR::FieldAccessExpr &expr) } void -PrivacyReporter::visit (HIR::ClosureExprInner &expr) +PrivacyReporter::visit (HIR::ClosureExpr &expr) { // Not handled yet } @@ -424,12 +424,6 @@ PrivacyReporter::visit (HIR::BlockExpr &expr) last_expr->accept_vis (*this); } -void -PrivacyReporter::visit (HIR::ClosureExprInnerTyped &expr) -{ - // Not handled yet -} - void PrivacyReporter::visit (HIR::ContinueExpr &expr) {} diff --git a/gcc/rust/checks/errors/privacy/rust-privacy-reporter.h b/gcc/rust/checks/errors/privacy/rust-privacy-reporter.h index 546b108f36d..38a5f08fcdd 100644 --- a/gcc/rust/checks/errors/privacy/rust-privacy-reporter.h +++ b/gcc/rust/checks/errors/privacy/rust-privacy-reporter.h @@ -83,8 +83,7 @@ types virtual void visit (HIR::QualifiedPathInExpression &expr); virtual void visit (HIR::PathInExpression &expr); - virtual void visit (HIR::ClosureExprInnerTyped &); - virtual void visit (HIR::ClosureExprInner &expr); + virtual void visit (HIR::ClosureExpr &expr); virtual void visit (HIR::StructExprStructFields &); virtual void visit (HIR::StructExprStruct &); virtual void visit (HIR::LiteralExpr &expr); diff --git a/gcc/rust/checks/errors/rust-const-checker.cc b/gcc/rust/checks/errors/rust-const-checker.cc index a2a6dc21f26..4b4350e881f 100644 --- a/gcc/rust/checks/errors/rust-const-checker.cc +++ b/gcc/rust/checks/errors/rust-const-checker.cc @@ -382,7 +382,7 @@ ConstChecker::visit (FieldAccessExpr &expr) } void -ConstChecker::visit (ClosureExprInner &expr) +ConstChecker::visit (ClosureExpr &expr) {} void @@ -395,10 +395,6 @@ ConstChecker::visit (BlockExpr &expr) expr.get_final_expr ()->accept_vis (*this); } -void -ConstChecker::visit (ClosureExprInnerTyped &expr) -{} - void ConstChecker::visit (ContinueExpr &expr) {} diff --git a/gcc/rust/checks/errors/rust-const-checker.h b/gcc/rust/checks/errors/rust-const-checker.h index 90b675b94b8..f0175df940d 100644 --- a/gcc/rust/checks/errors/rust-const-checker.h +++ b/gcc/rust/checks/errors/rust-const-checker.h @@ -111,9 +111,8 @@ private: virtual void visit (CallExpr &expr) override; virtual void visit (MethodCallExpr &expr) override; virtual void visit (FieldAccessExpr &expr) override; - virtual void visit (ClosureExprInner &expr) override; + virtual void visit (ClosureExpr &expr) override; virtual void visit (BlockExpr &expr) override; - virtual void visit (ClosureExprInnerTyped &expr) override; virtual void visit (ContinueExpr &expr) override; virtual void visit (BreakExpr &expr) override; virtual void visit (RangeFromToExpr &expr) override; diff --git a/gcc/rust/checks/errors/rust-unsafe-checker.cc b/gcc/rust/checks/errors/rust-unsafe-checker.cc index e3f32539562..8dff50b38f1 100644 --- a/gcc/rust/checks/errors/rust-unsafe-checker.cc +++ b/gcc/rust/checks/errors/rust-unsafe-checker.cc @@ -453,7 +453,7 @@ UnsafeChecker::visit (FieldAccessExpr &expr) } void -UnsafeChecker::visit (ClosureExprInner &expr) +UnsafeChecker::visit (ClosureExpr &expr) {} void @@ -466,10 +466,6 @@ UnsafeChecker::visit (BlockExpr &expr) expr.get_final_expr ()->accept_vis (*this); } -void -UnsafeChecker::visit (ClosureExprInnerTyped &expr) -{} - void UnsafeChecker::visit (ContinueExpr &expr) {} diff --git a/gcc/rust/checks/errors/rust-unsafe-checker.h b/gcc/rust/checks/errors/rust-unsafe-checker.h index ae1eb509d78..fe564a2088e 100644 --- a/gcc/rust/checks/errors/rust-unsafe-checker.h +++ b/gcc/rust/checks/errors/rust-unsafe-checker.h @@ -88,9 +88,8 @@ private: virtual void visit (CallExpr &expr) override; virtual void visit (MethodCallExpr &expr) override; virtual void visit (FieldAccessExpr &expr) override; - virtual void visit (ClosureExprInner &expr) override; + virtual void visit (ClosureExpr &expr) override; virtual void visit (BlockExpr &expr) override; - virtual void visit (ClosureExprInnerTyped &expr) override; virtual void visit (ContinueExpr &expr) override; virtual void visit (BreakExpr &expr) override; virtual void visit (RangeFromToExpr &expr) override; diff --git a/gcc/rust/hir/rust-ast-lower-base.h b/gcc/rust/hir/rust-ast-lower-base.h index 5479e639ddf..16fe13c8242 100644 --- a/gcc/rust/hir/rust-ast-lower-base.h +++ b/gcc/rust/hir/rust-ast-lower-base.h @@ -313,6 +313,8 @@ protected: HIR::Literal lower_literal (const AST::Literal &literal); HIR::ExternBlock *lower_extern_block (AST::ExternBlock &extern_block); + + HIR::ClosureParam lower_closure_param (AST::ClosureParam ¶m); }; } // namespace HIR diff --git a/gcc/rust/hir/rust-ast-lower-expr.cc b/gcc/rust/hir/rust-ast-lower-expr.cc index c148308d61e..df4ba9d2911 100644 --- a/gcc/rust/hir/rust-ast-lower-expr.cc +++ b/gcc/rust/hir/rust-ast-lower-expr.cc @@ -753,5 +753,58 @@ ASTLoweringExpr::visit (AST::RangeFromToInclExpr &expr) expr.get_locus ()); } +void +ASTLoweringExpr::visit (AST::ClosureExprInner &expr) +{ + HIR::Expr *closure_expr + = ASTLoweringExpr::translate (expr.get_definition_expr ().get ()); + + std::vector closure_params; + for (auto ¶m : expr.get_params ()) + { + HIR::ClosureParam p = lower_closure_param (param); + closure_params.push_back (std::move (p)); + } + + auto crate_num = mappings->get_current_crate (); + Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), + mappings->get_next_hir_id (crate_num), + mappings->get_next_localdef_id (crate_num)); + + translated + = new HIR::ClosureExpr (mapping, std::move (closure_params), + nullptr /* closure_return_type */, + std::unique_ptr (closure_expr), + expr.get_has_move (), expr.get_outer_attrs (), + expr.get_locus ()); +} + +void +ASTLoweringExpr::visit (AST::ClosureExprInnerTyped &expr) +{ + HIR::Type *closure_return_type = nullptr; + HIR::Expr *closure_expr + = ASTLoweringExpr::translate (expr.get_definition_block ().get ()); + + std::vector closure_params; + for (auto ¶m : expr.get_params ()) + { + HIR::ClosureParam p = lower_closure_param (param); + closure_params.push_back (std::move (p)); + } + + auto crate_num = mappings->get_current_crate (); + Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), + mappings->get_next_hir_id (crate_num), + mappings->get_next_localdef_id (crate_num)); + + translated + = new HIR::ClosureExpr (mapping, std::move (closure_params), + std::unique_ptr (closure_return_type), + std::unique_ptr (closure_expr), + expr.get_has_move (), expr.get_outer_attrs (), + expr.get_locus ()); +} + } // namespace HIR } // namespace Rust diff --git a/gcc/rust/hir/rust-ast-lower-expr.h b/gcc/rust/hir/rust-ast-lower-expr.h index 315bca34a1c..0963e40c5f0 100644 --- a/gcc/rust/hir/rust-ast-lower-expr.h +++ b/gcc/rust/hir/rust-ast-lower-expr.h @@ -116,6 +116,8 @@ public: void visit (AST::RangeToExpr &expr) override; void visit (AST::RangeFullExpr &expr) override; void visit (AST::RangeFromToInclExpr &expr) override; + void visit (AST::ClosureExprInner &expr) override; + void visit (AST::ClosureExprInnerTyped &expr) override; private: ASTLoweringExpr (); diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc index fa3a83db1db..52b7003a04a 100644 --- a/gcc/rust/hir/rust-ast-lower.cc +++ b/gcc/rust/hir/rust-ast-lower.cc @@ -22,9 +22,12 @@ #include "rust-ast-lower-expr.h" #include "rust-ast-lower-block.h" #include "rust-ast-lower-type.h" +#include "rust-ast-lower-pattern.h" +#include "rust-ast-lower-struct-field-expr.h" namespace Rust { namespace HIR { +using HIR::ClosureParam; Visibility translate_visibility (const AST::Visibility &vis) @@ -473,5 +476,25 @@ ASTLowerQualPathInExpression::visit (AST::QualifiedPathInExpression &expr) expr.get_locus (), expr.get_outer_attrs ()); } + +ClosureParam +ASTLoweringBase::lower_closure_param (AST::ClosureParam ¶m) +{ + HIR::Pattern *param_pattern + = ASTLoweringPattern::translate (param.get_pattern ().get ()); + + HIR::Type *param_type + = param.has_type_given () + ? ASTLoweringType::translate (param.get_type ().get ()) + : nullptr; + + return HIR::ClosureParam (std::unique_ptr (param_pattern), + param.get_locus (), + param.has_type_given () + ? std::unique_ptr (param_type) + : nullptr, + param.get_outer_attrs ()); +} + } // namespace HIR } // namespace Rust diff --git a/gcc/rust/hir/rust-hir-dump.cc b/gcc/rust/hir/rust-hir-dump.cc index bb139a7c1b7..11d4cd10527 100644 --- a/gcc/rust/hir/rust-hir-dump.cc +++ b/gcc/rust/hir/rust-hir-dump.cc @@ -197,7 +197,7 @@ void Dump::visit (FieldAccessExpr &) {} void -Dump::visit (ClosureExprInner &) +Dump::visit (ClosureExpr &) {} void Dump::visit (BlockExpr &block_expr) @@ -212,9 +212,7 @@ Dump::visit (BlockExpr &block_expr) stream << "]"; indent--; } -void -Dump::visit (ClosureExprInnerTyped &) -{} + void Dump::visit (ContinueExpr &) {} diff --git a/gcc/rust/hir/rust-hir-dump.h b/gcc/rust/hir/rust-hir-dump.h index 8b9e8939a28..1953efeffd6 100644 --- a/gcc/rust/hir/rust-hir-dump.h +++ b/gcc/rust/hir/rust-hir-dump.h @@ -78,9 +78,8 @@ private: virtual void visit (CallExpr &) override; virtual void visit (MethodCallExpr &) override; virtual void visit (FieldAccessExpr &) override; - virtual void visit (ClosureExprInner &) override; + virtual void visit (ClosureExpr &) override; virtual void visit (BlockExpr &) override; - virtual void visit (ClosureExprInnerTyped &) override; virtual void visit (ContinueExpr &) override; virtual void visit (BreakExpr &) override; virtual void visit (RangeFromToExpr &) override; diff --git a/gcc/rust/hir/tree/rust-hir-expr.h b/gcc/rust/hir/tree/rust-hir-expr.h index e173d376674..c3180d888cf 100644 --- a/gcc/rust/hir/tree/rust-hir-expr.h +++ b/gcc/rust/hir/tree/rust-hir-expr.h @@ -1985,21 +1985,22 @@ protected: struct ClosureParam { private: + std::vector outer_attrs; std::unique_ptr pattern; - - // bool has_type_given; std::unique_ptr type; - - // TODO: should this store location data? + Location locus; public: // Returns whether the type of the parameter has been given. bool has_type_given () const { return type != nullptr; } // Constructor for closure parameter - ClosureParam (std::unique_ptr param_pattern, - std::unique_ptr param_type = nullptr) - : pattern (std::move (param_pattern)), type (std::move (param_type)) + ClosureParam (std::unique_ptr param_pattern, Location locus, + std::unique_ptr param_type = nullptr, + std::vector outer_attrs = {}) + : outer_attrs (std::move (outer_attrs)), + pattern (std::move (param_pattern)), type (std::move (param_type)), + locus (locus) {} // Copy constructor required due to cloning as a result of unique_ptrs @@ -2007,6 +2008,8 @@ public: : pattern (other.pattern->clone_pattern ()) { // guard to protect from null pointer dereference + if (other.pattern != nullptr) + pattern = other.pattern->clone_pattern (); if (other.type != nullptr) type = other.type->clone_type (); } @@ -2016,8 +2019,17 @@ public: // Assignment operator must be overloaded to clone as well ClosureParam &operator= (ClosureParam const &other) { - pattern = other.pattern->clone_pattern (); - type = other.type->clone_type (); + outer_attrs = other.outer_attrs; + + // guard to protect from null pointer dereference + if (other.pattern != nullptr) + pattern = other.pattern->clone_pattern (); + else + pattern = nullptr; + if (other.type != nullptr) + type = other.type->clone_type (); + else + type = nullptr; return *this; } @@ -2026,31 +2038,79 @@ public: ClosureParam (ClosureParam &&other) = default; ClosureParam &operator= (ClosureParam &&other) = default; - // Returns whether closure parameter is in an error state. - bool is_error () const { return pattern == nullptr; } + std::string as_string () const; - // Creates an error state closure parameter. - static ClosureParam create_error () { return ClosureParam (nullptr); } + const std::vector &get_outer_attrs () const + { + return outer_attrs; + } + std::vector &get_outer_attrs () { return outer_attrs; } - std::string as_string () const; + std::unique_ptr &get_pattern () + { + rust_assert (pattern != nullptr); + return pattern; + } + + std::unique_ptr &get_type () + { + rust_assert (has_type_given ()); + return type; + } + + Location get_locus () const { return locus; } }; // Base closure definition expression HIR node - abstract class ClosureExpr : public ExprWithoutBlock { +private: bool has_move; std::vector params; Location locus; + std::unique_ptr return_type; + std::unique_ptr expr; -protected: +public: ClosureExpr (Analysis::NodeMapping mappings, - std::vector closure_params, bool has_move, + std::vector closure_params, + std::unique_ptr closure_return_type, + std::unique_ptr closure_expr, bool has_move, AST::AttrVec outer_attribs, Location locus) : ExprWithoutBlock (std::move (mappings), std::move (outer_attribs)), - has_move (has_move), params (std::move (closure_params)), locus (locus) + has_move (has_move), params (std::move (closure_params)), locus (locus), + return_type (std::move (closure_return_type)), + expr (std::move (closure_expr)) {} -public: + // Copy constructor requires cloning + ClosureExpr (ClosureExpr const &other) + : ExprWithoutBlock (other.get_mappings (), other.get_outer_attrs ()) + { + return_type + = other.has_return_type () ? other.return_type->clone_type () : nullptr; + expr = other.expr->clone_expr (); + params = other.params; + has_move = other.has_move; + } + + // Overload assignment operator to clone unique_ptrs + ClosureExpr &operator= (ClosureExpr const &other) + { + mappings = other.mappings; + return_type + = other.has_return_type () ? other.return_type->clone_type () : nullptr; + expr = other.expr->clone_expr (); + params = other.params; + has_move = other.has_move; + + return *this; + } + + // move constructors + ClosureExpr (ClosureExpr &&other) = default; + ClosureExpr &operator= (ClosureExpr &&other) = default; + std::string as_string () const override; Location get_locus () const override final { return locus; } @@ -2059,47 +2119,17 @@ public: { return ExprType::Closure; } -}; -// Represents a non-type-specified closure expression HIR node -class ClosureExprInner : public ClosureExpr -{ - std::unique_ptr closure_inner; + bool get_has_move () const { return has_move; } -public: - std::string as_string () const override; + bool has_return_type () const { return return_type != nullptr; } - // Constructor for a ClosureExprInner - ClosureExprInner (Analysis::NodeMapping mappings, - std::unique_ptr closure_inner_expr, - std::vector closure_params, Location locus, - bool is_move = false, - AST::AttrVec outer_attribs = AST::AttrVec ()) - : ClosureExpr (std::move (mappings), std::move (closure_params), is_move, - std::move (outer_attribs), locus), - closure_inner (std::move (closure_inner_expr)) - {} - - // Copy constructor must be defined to allow copying via cloning of unique_ptr - ClosureExprInner (ClosureExprInner const &other) - : ClosureExpr (other), closure_inner (other.closure_inner->clone_expr ()) - {} - - // Overload assignment operator to clone closure_inner - ClosureExprInner &operator= (ClosureExprInner const &other) + std::unique_ptr &get_return_type () { - ClosureExpr::operator= (other); - closure_inner = other.closure_inner->clone_expr (); - // params = other.params; - // has_move = other.has_move; - // outer_attrs = other.outer_attrs; - - return *this; - } - - // move constructors - ClosureExprInner (ClosureExprInner &&other) = default; - ClosureExprInner &operator= (ClosureExprInner &&other) = default; + rust_assert (has_return_type ()); + return return_type; + }; + std::unique_ptr &get_expr () { return expr; } void accept_vis (HIRFullVisitor &vis) override; void accept_vis (HIRExpressionVisitor &vis) override; @@ -2107,16 +2137,16 @@ public: protected: /* Use covariance to implement clone function as returning this object rather * than base */ - ClosureExprInner *clone_expr_impl () const override + ClosureExpr *clone_expr_impl () const override { - return new ClosureExprInner (*this); + return new ClosureExpr (*this); } /* Use covariance to implement clone function as returning this object rather * than base */ - ClosureExprInner *clone_expr_without_block_impl () const override + ClosureExpr *clone_expr_without_block_impl () const override { - return new ClosureExprInner (*this); + return new ClosureExpr (*this); } }; @@ -2239,71 +2269,6 @@ protected: } }; -// Represents a type-specified closure expression HIR node -class ClosureExprInnerTyped : public ClosureExpr -{ - std::unique_ptr return_type; - std::unique_ptr - expr; // only used because may be polymorphic in future - -public: - std::string as_string () const override; - - // Constructor potentially with a move - ClosureExprInnerTyped (Analysis::NodeMapping mappings, - std::unique_ptr closure_return_type, - std::unique_ptr closure_expr, - std::vector closure_params, - Location locus, bool is_move = false, - AST::AttrVec outer_attribs = AST::AttrVec ()) - : ClosureExpr (std::move (mappings), std::move (closure_params), is_move, - std::move (outer_attribs), locus), - return_type (std::move (closure_return_type)), - expr (std::move (closure_expr)) - {} - - // Copy constructor requires cloning - ClosureExprInnerTyped (ClosureExprInnerTyped const &other) - : ClosureExpr (other), return_type (other.return_type->clone_type ()), - expr (other.expr->clone_block_expr ()) - {} - - // Overload assignment operator to clone unique_ptrs - ClosureExprInnerTyped &operator= (ClosureExprInnerTyped const &other) - { - ClosureExpr::operator= (other); - return_type = other.return_type->clone_type (); - expr = other.expr->clone_block_expr (); - // params = other.params; - // has_move = other.has_move; - // outer_attrs = other.outer_attrs; - - return *this; - } - - // move constructors - ClosureExprInnerTyped (ClosureExprInnerTyped &&other) = default; - ClosureExprInnerTyped &operator= (ClosureExprInnerTyped &&other) = default; - - void accept_vis (HIRFullVisitor &vis) override; - void accept_vis (HIRExpressionVisitor &vis) override; - -protected: - /* Use covariance to implement clone function as returning this object rather - * than base */ - ClosureExprInnerTyped *clone_expr_impl () const override - { - return new ClosureExprInnerTyped (*this); - } - - /* Use covariance to implement clone function as returning this object rather - * than base */ - ClosureExprInnerTyped *clone_expr_without_block_impl () const override - { - return new ClosureExprInnerTyped (*this); - } -}; - // HIR node representing continue expression within loops class ContinueExpr : 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 2798ba9fd84..717facff687 100644 --- a/gcc/rust/hir/tree/rust-hir-full-decls.h +++ b/gcc/rust/hir/tree/rust-hir-full-decls.h @@ -94,9 +94,7 @@ class MethodCallExpr; class FieldAccessExpr; struct ClosureParam; class ClosureExpr; -class ClosureExprInner; class BlockExpr; -class ClosureExprInnerTyped; class ContinueExpr; class BreakExpr; class RangeExpr; diff --git a/gcc/rust/hir/tree/rust-hir-full-test.cc b/gcc/rust/hir/tree/rust-hir-full-test.cc index 4e255320e2d..7e5b49db1dc 100644 --- a/gcc/rust/hir/tree/rust-hir-full-test.cc +++ b/gcc/rust/hir/tree/rust-hir-full-test.cc @@ -1133,15 +1133,8 @@ ClosureExpr::as_string () const } } - return str; -} - -std::string -ClosureExprInnerTyped::as_string () const -{ - std::string str = ClosureExpr::as_string (); - - str += "\n Return type: " + return_type->as_string (); + str += "\n Return type: " + + (has_return_type () ? return_type->as_string () : "none"); str += "\n Body: " + expr->as_string (); @@ -1515,16 +1508,6 @@ UnsafeBlockExpr::as_string () const return str + "\n" + indent_spaces (out) + "}\n" + expr->as_string (); } -std::string -ClosureExprInner::as_string () const -{ - std::string str = ClosureExpr::as_string (); - - str += "\n Expression: " + closure_inner->as_string (); - - return str; -} - std::string IfExpr::as_string () const { @@ -4038,7 +4021,7 @@ FieldAccessExpr::accept_vis (HIRFullVisitor &vis) } void -ClosureExprInner::accept_vis (HIRFullVisitor &vis) +ClosureExpr::accept_vis (HIRFullVisitor &vis) { vis.visit (*this); } @@ -4049,12 +4032,6 @@ BlockExpr::accept_vis (HIRFullVisitor &vis) vis.visit (*this); } -void -ClosureExprInnerTyped::accept_vis (HIRFullVisitor &vis) -{ - vis.visit (*this); -} - void ContinueExpr::accept_vis (HIRFullVisitor &vis) { @@ -4986,7 +4963,7 @@ IfExpr::accept_vis (HIRExpressionVisitor &vis) } void -ClosureExprInner::accept_vis (HIRExpressionVisitor &vis) +ClosureExpr::accept_vis (HIRExpressionVisitor &vis) { vis.visit (*this); } @@ -5075,12 +5052,6 @@ QualifiedPathInExpression::accept_vis (HIRPatternVisitor &vis) vis.visit (*this); } -void -ClosureExprInnerTyped::accept_vis (HIRExpressionVisitor &vis) -{ - vis.visit (*this); -} - void ExprStmtWithBlock::accept_vis (HIRStmtVisitor &vis) { diff --git a/gcc/rust/hir/tree/rust-hir-visitor.h b/gcc/rust/hir/tree/rust-hir-visitor.h index b3c0b9359cc..a92279210fd 100644 --- a/gcc/rust/hir/tree/rust-hir-visitor.h +++ b/gcc/rust/hir/tree/rust-hir-visitor.h @@ -63,9 +63,8 @@ public: virtual void visit (CallExpr &expr) = 0; virtual void visit (MethodCallExpr &expr) = 0; virtual void visit (FieldAccessExpr &expr) = 0; - virtual void visit (ClosureExprInner &expr) = 0; virtual void visit (BlockExpr &expr) = 0; - virtual void visit (ClosureExprInnerTyped &expr) = 0; + virtual void visit (ClosureExpr &expr) = 0; virtual void visit (ContinueExpr &expr) = 0; virtual void visit (BreakExpr &expr) = 0; virtual void visit (RangeFromToExpr &expr) = 0; @@ -206,9 +205,8 @@ public: virtual void visit (CallExpr &) override {} virtual void visit (MethodCallExpr &) override {} virtual void visit (FieldAccessExpr &) override {} - virtual void visit (ClosureExprInner &) override {} + virtual void visit (ClosureExpr &) override {} virtual void visit (BlockExpr &) override {} - virtual void visit (ClosureExprInnerTyped &) override {} virtual void visit (ContinueExpr &) override {} virtual void visit (BreakExpr &) override {} virtual void visit (RangeFromToExpr &) override {} @@ -419,8 +417,7 @@ public: virtual void visit (HIR::QualifiedPathInExpression &expr) = 0; virtual void visit (HIR::PathInExpression &expr) = 0; - virtual void visit (ClosureExprInnerTyped &) = 0; - virtual void visit (ClosureExprInner &expr) = 0; + virtual void visit (ClosureExpr &) = 0; virtual void visit (StructExprStructFields &) = 0; virtual void visit (StructExprStruct &) = 0; virtual void visit (LiteralExpr &expr) = 0; diff --git a/gcc/rust/hir/tree/rust-hir.h b/gcc/rust/hir/tree/rust-hir.h index 26bf3028ac7..97c20c978fc 100644 --- a/gcc/rust/hir/tree/rust-hir.h +++ b/gcc/rust/hir/tree/rust-hir.h @@ -238,6 +238,7 @@ class ExprWithoutBlock; // Base expression HIR node - abstract class Expr : public Node { +protected: AST::AttrVec outer_attrs; Analysis::NodeMapping mappings; diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index 3411a2daccb..df4ddfab1dc 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -1418,6 +1418,12 @@ TypeCheckExpr::visit (HIR::MatchExpr &expr) } } +void +TypeCheckExpr::visit (HIR::ClosureExpr &expr) +{ + gcc_unreachable (); +} + bool TypeCheckExpr::resolve_operator_overload ( Analysis::RustLangItem::ItemType lang_item_type, HIR::OperatorExprMeta expr, diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h index 9e3db0060d3..bf36e19023a 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.h +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h @@ -69,10 +69,9 @@ public: void visit (HIR::RangeFullExpr &expr) override; void visit (HIR::RangeFromToInclExpr &expr) override; void visit (HIR::WhileLoopExpr &expr) override; + void visit (HIR::ClosureExpr &expr) override; // TODO - void visit (HIR::ClosureExprInnerTyped &) override {} - void visit (HIR::ClosureExprInner &expr) override {} void visit (HIR::ErrorPropagationExpr &expr) override {} void visit (HIR::RangeToInclExpr &expr) override {} void visit (HIR::WhileLetLoopExpr &expr) override {}