public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc/devel/rust/master] Add hir lowering of closure expressions
@ 2022-10-22 10:47 Thomas Schwinge
0 siblings, 0 replies; only message in thread
From: Thomas Schwinge @ 2022-10-22 10:47 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:5f25f457eca1e04e577aae8e60fe640bb32d36fc
commit 5f25f457eca1e04e577aae8e60fe640bb32d36fc
Author: Philip Herron <philip.herron@embecosm.com>
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<Attribute> outer_attrs;
std::unique_ptr<Pattern> pattern;
-
- // bool has_type_given;
std::unique_ptr<Type> type;
Location locus;
@@ -2202,19 +2200,19 @@ public:
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
std::vector<Attribute> &get_outer_attrs () { return outer_attrs; }
- // TODO: is this better? Or is a "vis_block" better?
std::unique_ptr<Pattern> &get_pattern ()
{
rust_assert (pattern != nullptr);
return pattern;
}
- // TODO: is this better? Or is a "vis_block" better?
std::unique_ptr<Type> &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<Expr> &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<HIR::ClosureParam> 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<HIR::Expr> (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<HIR::ClosureParam> 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<HIR::Type> (closure_return_type),
+ std::unique_ptr<HIR::Expr> (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<HIR::Pattern> (param_pattern),
+ param.get_locus (),
+ param.has_type_given ()
+ ? std::unique_ptr<HIR::Type> (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<AST::Attribute> outer_attrs;
std::unique_ptr<Pattern> pattern;
-
- // bool has_type_given;
std::unique_ptr<Type> 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<Pattern> param_pattern,
- std::unique_ptr<Type> param_type = nullptr)
- : pattern (std::move (param_pattern)), type (std::move (param_type))
+ ClosureParam (std::unique_ptr<Pattern> param_pattern, Location locus,
+ std::unique_ptr<Type> param_type = nullptr,
+ std::vector<AST::Attribute> 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<AST::Attribute> &get_outer_attrs () const
+ {
+ return outer_attrs;
+ }
+ std::vector<AST::Attribute> &get_outer_attrs () { return outer_attrs; }
- std::string as_string () const;
+ std::unique_ptr<Pattern> &get_pattern ()
+ {
+ rust_assert (pattern != nullptr);
+ return pattern;
+ }
+
+ std::unique_ptr<Type> &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<ClosureParam> params;
Location locus;
+ std::unique_ptr<Type> return_type;
+ std::unique_ptr<Expr> expr;
-protected:
+public:
ClosureExpr (Analysis::NodeMapping mappings,
- std::vector<ClosureParam> closure_params, bool has_move,
+ std::vector<ClosureParam> closure_params,
+ std::unique_ptr<Type> closure_return_type,
+ std::unique_ptr<Expr> 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<Expr> 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<Expr> closure_inner_expr,
- std::vector<ClosureParam> 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<Type> &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<Expr> &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<Type> return_type;
- std::unique_ptr<BlockExpr>
- 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<Type> closure_return_type,
- std::unique_ptr<BlockExpr> closure_expr,
- std::vector<ClosureParam> 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 {}
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-10-22 10:47 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-10-22 10:47 [gcc/devel/rust/master] Add hir lowering of closure expressions Thomas Schwinge
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).