aboutsummaryrefslogtreecommitdiff
path: root/gcc/rust/hir
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/rust/hir')
-rw-r--r--gcc/rust/hir/rust-ast-lower-base.cc119
-rw-r--r--gcc/rust/hir/rust-ast-lower-base.h19
-rw-r--r--gcc/rust/hir/rust-ast-lower-enumitem.h9
-rw-r--r--gcc/rust/hir/rust-ast-lower-expr.cc88
-rw-r--r--gcc/rust/hir/rust-ast-lower-extern.h5
-rw-r--r--gcc/rust/hir/rust-ast-lower-implitem.cc20
-rw-r--r--gcc/rust/hir/rust-ast-lower-implitem.h2
-rw-r--r--gcc/rust/hir/rust-ast-lower-item.cc175
-rw-r--r--gcc/rust/hir/rust-ast-lower-pattern.cc102
-rw-r--r--gcc/rust/hir/rust-ast-lower.cc52
-rw-r--r--gcc/rust/hir/rust-hir-dump.cc43
-rw-r--r--gcc/rust/hir/rust-hir-dump.h12
-rw-r--r--gcc/rust/hir/tree/rust-hir-full-decls.h10
-rw-r--r--gcc/rust/hir/tree/rust-hir-item.h1
-rw-r--r--gcc/rust/hir/tree/rust-hir-pattern.h324
-rw-r--r--gcc/rust/hir/tree/rust-hir-visitor.cc27
-rw-r--r--gcc/rust/hir/tree/rust-hir-visitor.h41
-rw-r--r--gcc/rust/hir/tree/rust-hir.cc104
18 files changed, 759 insertions, 394 deletions
diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc
index b723f59..1c8e5b6 100644
--- a/gcc/rust/hir/rust-ast-lower-base.cc
+++ b/gcc/rust/hir/rust-ast-lower-base.cc
@@ -372,9 +372,6 @@ void
ASTLoweringBase::visit (AST::StaticItem &)
{}
void
-ASTLoweringBase::visit (AST::TraitItemConst &)
-{}
-void
ASTLoweringBase::visit (AST::TraitItemType &)
{}
void
@@ -473,20 +470,20 @@ ASTLoweringBase::visit (AST::StructPattern &)
{}
// void ASTLoweringBase::visit(TupleStructItemstuple_items) {}
void
-ASTLoweringBase::visit (AST::TupleStructItemsNoRange &)
+ASTLoweringBase::visit (AST::TupleStructItemsNoRest &)
{}
void
-ASTLoweringBase::visit (AST::TupleStructItemsRange &)
+ASTLoweringBase::visit (AST::TupleStructItemsHasRest &)
{}
void
ASTLoweringBase::visit (AST::TupleStructPattern &)
{}
// void ASTLoweringBase::visit(TuplePatternItemstuple_items) {}
void
-ASTLoweringBase::visit (AST::TuplePatternItemsMultiple &)
+ASTLoweringBase::visit (AST::TuplePatternItemsNoRest &)
{}
void
-ASTLoweringBase::visit (AST::TuplePatternItemsRanged &)
+ASTLoweringBase::visit (AST::TuplePatternItemsHasRest &)
{}
void
ASTLoweringBase::visit (AST::TuplePattern &)
@@ -622,11 +619,10 @@ ASTLoweringBase::lower_generic_params (
std::vector<std::unique_ptr<AST::GenericParam>> &params)
{
std::vector<std::unique_ptr<HIR::GenericParam>> lowered;
+ lowered.reserve (params.size ());
+
for (auto &ast_param : params)
- {
- auto hir_param = ASTLowerGenericParam::translate (*ast_param);
- lowered.push_back (std::unique_ptr<HIR::GenericParam> (hir_param));
- }
+ lowered.emplace_back (ASTLowerGenericParam::translate (*ast_param));
return lowered;
}
@@ -659,18 +655,16 @@ HIR::GenericArgs
ASTLoweringBase::lower_generic_args (AST::GenericArgs &args)
{
std::vector<HIR::GenericArgsBinding> binding_args;
+ binding_args.reserve (args.get_binding_args ().size ());
+
for (auto &binding : args.get_binding_args ())
- {
- HIR::GenericArgsBinding b = lower_binding (binding);
- binding_args.push_back (std::move (b));
- }
+ binding_args.emplace_back (lower_binding (binding));
std::vector<HIR::Lifetime> lifetime_args;
+ lifetime_args.reserve (args.get_lifetime_args ().size ());
+
for (auto &lifetime : args.get_lifetime_args ())
- {
- HIR::Lifetime l = lower_lifetime (lifetime);
- lifetime_args.push_back (std::move (l));
- }
+ lifetime_args.emplace_back (lower_lifetime (lifetime));
std::vector<std::unique_ptr<HIR::Type>> type_args;
std::vector<HIR::ConstGenericArg> const_args;
@@ -681,16 +675,15 @@ ASTLoweringBase::lower_generic_args (AST::GenericArgs &args)
{
case AST::GenericArg::Kind::Type:
{
- auto type = ASTLoweringType::translate (arg.get_type ());
- type_args.emplace_back (std::unique_ptr<HIR::Type> (type));
+ type_args.emplace_back (
+ ASTLoweringType::translate (arg.get_type ()));
break;
}
case AST::GenericArg::Kind::Const:
{
auto expr = ASTLoweringExpr::translate (arg.get_expression ());
- const_args.emplace_back (
- HIR::ConstGenericArg (std::unique_ptr<HIR::Expr> (expr),
- expr->get_locus ()));
+ const_args.emplace_back (std::unique_ptr<HIR::Expr> (expr),
+ expr->get_locus ());
break;
}
default:
@@ -850,9 +843,10 @@ void
ASTLoweringBase::handle_lang_item_attribute (const ItemWrapper &item,
const AST::Attribute &attr)
{
- auto &literal = static_cast<AST::AttrInputLiteral &> (attr.get_attr_input ());
- const auto &lang_item_type_str = literal.get_literal ().as_string ();
- auto lang_item_type = LangItem::Parse (lang_item_type_str);
+ auto lang_item_type_str = Analysis::Attributes::extract_string_literal (attr);
+ rust_assert (lang_item_type_str.has_value ());
+
+ auto lang_item_type = LangItem::Parse (*lang_item_type_str);
if (lang_item_type)
mappings.insert_lang_item (*lang_item_type,
@@ -877,41 +871,71 @@ ASTLoweringBase::attribute_handled_in_another_pass (
std::unique_ptr<HIR::TuplePatternItems>
ASTLoweringBase::lower_tuple_pattern_multiple (
- AST::TuplePatternItemsMultiple &pattern)
+ AST::TuplePatternItemsNoRest &pattern)
{
std::vector<std::unique_ptr<HIR::Pattern>> patterns;
+ patterns.reserve (pattern.get_patterns ().size ());
+
for (auto &p : pattern.get_patterns ())
- {
- HIR::Pattern *translated = ASTLoweringPattern::translate (*p);
- patterns.push_back (std::unique_ptr<HIR::Pattern> (translated));
- }
+ patterns.emplace_back (ASTLoweringPattern::translate (*p));
return std::unique_ptr<HIR::TuplePatternItems> (
- new HIR::TuplePatternItemsMultiple (std::move (patterns)));
+ new HIR::TuplePatternItemsNoRest (std::move (patterns)));
}
std::unique_ptr<TuplePatternItems>
ASTLoweringBase::lower_tuple_pattern_ranged (
- AST::TuplePatternItemsRanged &pattern)
+ AST::TuplePatternItemsHasRest &pattern)
{
std::vector<std::unique_ptr<HIR::Pattern>> lower_patterns;
+ lower_patterns.reserve (pattern.get_lower_patterns ().size ());
std::vector<std::unique_ptr<HIR::Pattern>> upper_patterns;
+ upper_patterns.reserve (pattern.get_upper_patterns ().size ());
for (auto &p : pattern.get_lower_patterns ())
- {
- HIR::Pattern *translated = ASTLoweringPattern::translate (*p);
- lower_patterns.push_back (std::unique_ptr<HIR::Pattern> (translated));
- }
+ lower_patterns.emplace_back (ASTLoweringPattern::translate (*p));
for (auto &p : pattern.get_upper_patterns ())
- {
- HIR::Pattern *translated = ASTLoweringPattern::translate (*p);
- upper_patterns.push_back (std::unique_ptr<HIR::Pattern> (translated));
- }
+ upper_patterns.emplace_back (ASTLoweringPattern::translate (*p));
return std::unique_ptr<HIR::TuplePatternItems> (
- new HIR::TuplePatternItemsRanged (std::move (lower_patterns),
- std::move (upper_patterns)));
+ new HIR::TuplePatternItemsHasRest (std::move (lower_patterns),
+ std::move (upper_patterns)));
+}
+
+std::unique_ptr<HIR::SlicePatternItems>
+ASTLoweringBase::lower_slice_pattern_no_rest (
+ AST::SlicePatternItemsNoRest &pattern)
+{
+ std::vector<std::unique_ptr<HIR::Pattern>> patterns;
+ patterns.reserve (pattern.get_patterns ().size ());
+ for (auto &p : pattern.get_patterns ())
+ patterns.emplace_back (ASTLoweringPattern::translate (*p));
+
+ return std::unique_ptr<HIR::SlicePatternItems> (
+ new HIR::SlicePatternItemsNoRest (std::move (patterns)));
+}
+
+std::unique_ptr<HIR::SlicePatternItems>
+ASTLoweringBase::lower_slice_pattern_has_rest (
+ AST::SlicePatternItemsHasRest &pattern)
+{
+ std::vector<std::unique_ptr<HIR::Pattern>> lower_patterns;
+ lower_patterns.reserve (pattern.get_lower_patterns ().size ());
+ std::vector<std::unique_ptr<HIR::Pattern>> upper_patterns;
+ upper_patterns.reserve (pattern.get_upper_patterns ().size ());
+
+ for (auto &p : pattern.get_lower_patterns ())
+ lower_patterns.emplace_back (
+ std::unique_ptr<HIR::Pattern> (ASTLoweringPattern::translate (*p)));
+
+ for (auto &p : pattern.get_upper_patterns ())
+ upper_patterns.emplace_back (
+ std::unique_ptr<HIR::Pattern> (ASTLoweringPattern::translate (*p)));
+
+ return std::unique_ptr<HIR::SlicePatternItems> (
+ new HIR::SlicePatternItemsHasRest (std::move (lower_patterns),
+ std::move (upper_patterns)));
}
std::unique_ptr<HIR::RangePatternBound>
@@ -1008,14 +1032,15 @@ ASTLoweringBase::lower_extern_block (AST::ExternBlock &extern_block)
mappings.get_next_localdef_id (crate_num));
std::vector<std::unique_ptr<HIR::ExternalItem>> extern_items;
+ extern_items.reserve (extern_block.get_extern_items ().size ());
+
for (auto &item : extern_block.get_extern_items ())
{
if (item->is_marked_for_strip ())
continue;
- HIR::ExternalItem *lowered
- = ASTLoweringExternItem::translate (item.get (), mapping.get_hirid ());
- extern_items.push_back (std::unique_ptr<HIR::ExternalItem> (lowered));
+ extern_items.emplace_back (
+ ASTLoweringExternItem::translate (item.get (), mapping.get_hirid ()));
}
ABI abi = ABI::C;
diff --git a/gcc/rust/hir/rust-ast-lower-base.h b/gcc/rust/hir/rust-ast-lower-base.h
index e86aacb..933f77b 100644
--- a/gcc/rust/hir/rust-ast-lower-base.h
+++ b/gcc/rust/hir/rust-ast-lower-base.h
@@ -189,7 +189,6 @@ public:
virtual void visit (AST::Union &union_item) override;
virtual void visit (AST::ConstantItem &const_item) override;
virtual void visit (AST::StaticItem &static_item) override;
- virtual void visit (AST::TraitItemConst &item) override;
virtual void visit (AST::TraitItemType &item) override;
virtual void visit (AST::Trait &trait) override;
virtual void visit (AST::InherentImpl &impl) override;
@@ -228,12 +227,12 @@ public:
virtual void visit (AST::StructPatternFieldIdent &field) override;
virtual void visit (AST::StructPattern &pattern) override;
// virtual void visit(TupleStructItems& tuple_items) override;
- virtual void visit (AST::TupleStructItemsNoRange &tuple_items) override;
- virtual void visit (AST::TupleStructItemsRange &tuple_items) override;
+ virtual void visit (AST::TupleStructItemsNoRest &tuple_items) override;
+ virtual void visit (AST::TupleStructItemsHasRest &tuple_items) override;
virtual void visit (AST::TupleStructPattern &pattern) override;
// virtual void visit(TuplePatternItems& tuple_items) override;
- virtual void visit (AST::TuplePatternItemsMultiple &tuple_items) override;
- virtual void visit (AST::TuplePatternItemsRanged &tuple_items) override;
+ virtual void visit (AST::TuplePatternItemsNoRest &tuple_items) override;
+ virtual void visit (AST::TuplePatternItemsHasRest &tuple_items) override;
virtual void visit (AST::TuplePattern &pattern) override;
virtual void visit (AST::GroupedPattern &pattern) override;
virtual void visit (AST::SlicePatternItemsNoRest &items) override;
@@ -317,10 +316,16 @@ protected:
attribute_handled_in_another_pass (const std::string &attribute_path) const;
std::unique_ptr<TuplePatternItems>
- lower_tuple_pattern_multiple (AST::TuplePatternItemsMultiple &pattern);
+ lower_tuple_pattern_multiple (AST::TuplePatternItemsNoRest &pattern);
std::unique_ptr<TuplePatternItems>
- lower_tuple_pattern_ranged (AST::TuplePatternItemsRanged &pattern);
+ lower_tuple_pattern_ranged (AST::TuplePatternItemsHasRest &pattern);
+
+ std::unique_ptr<SlicePatternItems>
+ lower_slice_pattern_no_rest (AST::SlicePatternItemsNoRest &pattern);
+
+ std::unique_ptr<SlicePatternItems>
+ lower_slice_pattern_has_rest (AST::SlicePatternItemsHasRest &pattern);
std::unique_ptr<HIR::RangePatternBound>
lower_range_pattern_bound (AST::RangePatternBound &bound);
diff --git a/gcc/rust/hir/rust-ast-lower-enumitem.h b/gcc/rust/hir/rust-ast-lower-enumitem.h
index 1b95345..8e28c08 100644
--- a/gcc/rust/hir/rust-ast-lower-enumitem.h
+++ b/gcc/rust/hir/rust-ast-lower-enumitem.h
@@ -80,6 +80,8 @@ public:
item.get_visibility ().as_string ().c_str ());
std::vector<HIR::TupleField> fields;
+ fields.reserve (item.get_tuple_fields ().size ());
+
for (auto &field : item.get_tuple_fields ())
{
HIR::Visibility vis = translate_visibility (field.get_visibility ());
@@ -90,11 +92,8 @@ public:
crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num),
mappings.get_next_localdef_id (crate_num));
- HIR::TupleField translated_field (field_mapping,
- std::unique_ptr<HIR::Type> (type),
- vis, field.get_locus (),
- field.get_outer_attrs ());
- fields.push_back (std::move (translated_field));
+ fields.emplace_back (field_mapping, std::unique_ptr<HIR::Type> (type),
+ vis, field.get_locus (), field.get_outer_attrs ());
}
translated
diff --git a/gcc/rust/hir/rust-ast-lower-expr.cc b/gcc/rust/hir/rust-ast-lower-expr.cc
index 4ed51d9..a1e24ee 100644
--- a/gcc/rust/hir/rust-ast-lower-expr.cc
+++ b/gcc/rust/hir/rust-ast-lower-expr.cc
@@ -81,11 +81,10 @@ void
ASTLoweringExpr::visit (AST::TupleExpr &expr)
{
std::vector<std::unique_ptr<HIR::Expr>> tuple_elements;
+ tuple_elements.reserve (expr.get_tuple_elems ().size ());
+
for (auto &e : expr.get_tuple_elems ())
- {
- HIR::Expr *t = ASTLoweringExpr::translate (*e);
- tuple_elements.push_back (std::unique_ptr<HIR::Expr> (t));
- }
+ tuple_elements.emplace_back (ASTLoweringExpr::translate (*e));
auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
@@ -221,12 +220,12 @@ ASTLoweringExpr::visit (AST::CallExpr &expr)
HIR::Expr *func = ASTLoweringExpr::translate (expr.get_function_expr ());
auto const &in_params = expr.get_params ();
+
std::vector<std::unique_ptr<HIR::Expr>> params;
+ params.reserve (in_params.size ());
+
for (auto &param : in_params)
- {
- auto trans = ASTLoweringExpr::translate (*param);
- params.push_back (std::unique_ptr<HIR::Expr> (trans));
- }
+ params.emplace_back (ASTLoweringExpr::translate (*param));
auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (
@@ -248,11 +247,10 @@ ASTLoweringExpr::visit (AST::MethodCallExpr &expr)
auto const &in_params = expr.get_params ();
std::vector<std::unique_ptr<HIR::Expr>> params;
+ params.reserve (in_params.size ());
+
for (auto &param : in_params)
- {
- auto trans = ASTLoweringExpr::translate (*param);
- params.push_back (std::unique_ptr<HIR::Expr> (trans));
- }
+ params.emplace_back (ASTLoweringExpr::translate (*param));
auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
@@ -338,11 +336,10 @@ void
ASTLoweringExpr::visit (AST::ArrayElemsValues &elems)
{
std::vector<std::unique_ptr<HIR::Expr>> elements;
+ elements.reserve (elems.get_values ().size ());
+
for (auto &elem : elems.get_values ())
- {
- HIR::Expr *translated_elem = ASTLoweringExpr::translate (*elem);
- elements.push_back (std::unique_ptr<HIR::Expr> (translated_elem));
- }
+ elements.emplace_back (ASTLoweringExpr::translate (*elem));
auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (mappings.get_current_crate (),
@@ -569,13 +566,12 @@ ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr)
}
auto const &in_fields = struct_expr.get_fields ();
+
std::vector<std::unique_ptr<HIR::StructExprField>> fields;
+ fields.reserve (in_fields.size ());
+
for (auto &field : in_fields)
- {
- HIR::StructExprField *translated
- = ASTLowerStructExprField::translate (*field);
- fields.push_back (std::unique_ptr<HIR::StructExprField> (translated));
- }
+ fields.emplace_back (ASTLowerStructExprField::translate (*field));
auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
@@ -814,11 +810,10 @@ ASTLoweringExpr::visit (AST::ClosureExprInner &expr)
= ASTLoweringExpr::translate (expr.get_definition_expr ());
std::vector<HIR::ClosureParam> closure_params;
+ closure_params.reserve (expr.get_params ().size ());
+
for (auto &param : expr.get_params ())
- {
- HIR::ClosureParam p = lower_closure_param (param);
- closure_params.push_back (std::move (p));
- }
+ closure_params.emplace_back (lower_closure_param (param));
auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
@@ -841,11 +836,10 @@ ASTLoweringExpr::visit (AST::ClosureExprInnerTyped &expr)
= ASTLoweringExpr::translate (expr.get_definition_expr ());
std::vector<HIR::ClosureParam> closure_params;
+ closure_params.reserve (expr.get_params ().size ());
+
for (auto &param : expr.get_params ())
- {
- HIR::ClosureParam p = lower_closure_param (param);
- closure_params.push_back (std::move (p));
- }
+ closure_params.emplace_back (lower_closure_param (param));
auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
@@ -1000,6 +994,23 @@ ASTLoweringExpr::visit (AST::InlineAsm &expr)
expr.get_options (), mapping);
}
+namespace {
+// We're not really supporting llvm_asm, only the bare minimum for libcore's
+// blackbox
+// llvm_asm!("" : : "r"(&mut dummy) : "memory" : "volatile");
+bool
+check_llvm_asm_support (const std::vector<LlvmOperand> &inputs,
+ const std::vector<LlvmOperand> &outputs,
+ const AST::LlvmInlineAsm &expr)
+{
+ return outputs.size () == 0 && inputs.size () <= 1
+ && expr.get_clobbers ().size () <= 1
+ && expr.get_templates ().size () == 1
+ && expr.get_templates ()[0].symbol == "";
+}
+
+} // namespace
+
void
ASTLoweringExpr::visit (AST::LlvmInlineAsm &expr)
{
@@ -1009,7 +1020,10 @@ ASTLoweringExpr::visit (AST::LlvmInlineAsm &expr)
mappings.get_next_localdef_id (crate_num));
std::vector<LlvmOperand> inputs;
+ inputs.reserve (expr.get_inputs ().size ());
+
std::vector<LlvmOperand> outputs;
+ outputs.reserve (expr.get_outputs ().size ());
for (auto i : expr.get_inputs ())
{
@@ -1029,13 +1043,15 @@ ASTLoweringExpr::visit (AST::LlvmInlineAsm &expr)
expr.is_stack_aligned (),
expr.get_dialect ()};
- // We're not really supporting llvm_asm, only the bare minimum
- // we're quite conservative here as the current code support more usecase.
- rust_assert (outputs.size () == 0);
- rust_assert (inputs.size () <= 1);
- rust_assert (expr.get_clobbers ().size () <= 1);
- rust_assert (expr.get_templates ().size () == 1);
- rust_assert (expr.get_templates ()[0].symbol == "");
+ if (!check_llvm_asm_support (inputs, outputs, expr))
+ {
+ rust_error_at (expr.get_locus (), "unsupported %qs construct",
+ "llvm_asm");
+ rust_inform (
+ expr.get_locus (),
+ "%<llvm_asm%> has been replaced with %<asm%>, gccrs only supports a "
+ "subset of %<llvm_asm%> to compile libcore");
+ }
translated
= new HIR::LlvmInlineAsm (expr.get_locus (), inputs, outputs,
diff --git a/gcc/rust/hir/rust-ast-lower-extern.h b/gcc/rust/hir/rust-ast-lower-extern.h
index 3dca1b6..1f3ceda 100644
--- a/gcc/rust/hir/rust-ast-lower-extern.h
+++ b/gcc/rust/hir/rust-ast-lower-extern.h
@@ -109,9 +109,8 @@ public:
mappings.get_next_localdef_id (
crate_num));
- function_params.push_back (
- HIR::NamedFunctionParam (mapping, param_name,
- std::unique_ptr<HIR::Type> (param_type)));
+ function_params.emplace_back (mapping, param_name,
+ std::unique_ptr<HIR::Type> (param_type));
}
auto crate_num = mappings.get_current_crate ();
diff --git a/gcc/rust/hir/rust-ast-lower-implitem.cc b/gcc/rust/hir/rust-ast-lower-implitem.cc
index 5db11cb..8fd9d16 100644
--- a/gcc/rust/hir/rust-ast-lower-implitem.cc
+++ b/gcc/rust/hir/rust-ast-lower-implitem.cc
@@ -115,7 +115,7 @@ ASTLowerImplItem::visit (AST::Function &function)
{
HIR::WhereClauseItem *i
= ASTLowerWhereClauseItem::translate (*item.get ());
- where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
+ where_clause_items.emplace_back (i);
}
HIR::WhereClause where_clause (std::move (where_clause_items));
@@ -162,10 +162,9 @@ ASTLowerImplItem::visit (AST::Function &function)
mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- auto hir_param
- = HIR::FunctionParam (mapping, std::move (translated_pattern),
- std::move (translated_type), param.get_locus ());
- function_params.push_back (std::move (hir_param));
+ function_params.emplace_back (mapping, std::move (translated_pattern),
+ std::move (translated_type),
+ param.get_locus ());
}
bool terminated = false;
@@ -272,10 +271,9 @@ ASTLowerTraitItem::visit (AST::Function &func)
mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- auto hir_param
- = HIR::FunctionParam (mapping, std::move (translated_pattern),
- std::move (translated_type), param.get_locus ());
- function_params.push_back (std::move (hir_param));
+ function_params.emplace_back (mapping, std::move (translated_pattern),
+ std::move (translated_type),
+ param.get_locus ());
}
if (func.has_self_param ())
@@ -320,10 +318,10 @@ ASTLowerTraitItem::visit (AST::Function &func)
}
void
-ASTLowerTraitItem::visit (AST::TraitItemConst &constant)
+ASTLowerTraitItem::visit (AST::ConstantItem &constant)
{
HIR::Type *type = ASTLoweringType::translate (constant.get_type ());
- HIR::Expr *expr = constant.has_expression ()
+ HIR::Expr *expr = constant.has_expr ()
? ASTLoweringExpr::translate (constant.get_expr ())
: nullptr;
diff --git a/gcc/rust/hir/rust-ast-lower-implitem.h b/gcc/rust/hir/rust-ast-lower-implitem.h
index 8331bba..dfcf567 100644
--- a/gcc/rust/hir/rust-ast-lower-implitem.h
+++ b/gcc/rust/hir/rust-ast-lower-implitem.h
@@ -49,7 +49,7 @@ class ASTLowerTraitItem : public ASTLoweringBase
public:
static HIR::TraitItem *translate (AST::AssociatedItem &item);
void visit (AST::Function &func) override;
- void visit (AST::TraitItemConst &constant) override;
+ void visit (AST::ConstantItem &constant) override;
void visit (AST::TraitItemType &type) override;
private:
diff --git a/gcc/rust/hir/rust-ast-lower-item.cc b/gcc/rust/hir/rust-ast-lower-item.cc
index 4e5a747..81815ff 100644
--- a/gcc/rust/hir/rust-ast-lower-item.cc
+++ b/gcc/rust/hir/rust-ast-lower-item.cc
@@ -72,7 +72,7 @@ ASTLoweringItem::visit (AST::Module &module)
// The item may be null if it doesn't need to live in the HIR - for
// example, macro rules definitions
if (transitem)
- items.push_back (std::unique_ptr<Item> (transitem));
+ items.emplace_back (transitem);
}
// should be lowered/copied from module.get_in/outer_attrs()
@@ -90,12 +90,11 @@ void
ASTLoweringItem::visit (AST::TypeAlias &alias)
{
std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
+ where_clause_items.reserve (alias.get_where_clause ().get_items ().size ());
+
for (auto &item : alias.get_where_clause ().get_items ())
- {
- HIR::WhereClauseItem *i
- = ASTLowerWhereClauseItem::translate (*item.get ());
- where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
- }
+ where_clause_items.emplace_back (
+ ASTLowerWhereClauseItem::translate (*item.get ()));
HIR::WhereClause where_clause (std::move (where_clause_items));
HIR::Visibility vis = translate_visibility (alias.get_visibility ());
@@ -130,17 +129,19 @@ ASTLoweringItem::visit (AST::TupleStruct &struct_decl)
}
std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
+ where_clause_items.reserve (
+ struct_decl.get_where_clause ().get_items ().size ());
+
for (auto &item : struct_decl.get_where_clause ().get_items ())
- {
- HIR::WhereClauseItem *i
- = ASTLowerWhereClauseItem::translate (*item.get ());
- where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
- }
+ where_clause_items.emplace_back (
+ ASTLowerWhereClauseItem::translate (*item.get ()));
HIR::WhereClause where_clause (std::move (where_clause_items));
HIR::Visibility vis = translate_visibility (struct_decl.get_visibility ());
std::vector<HIR::TupleField> fields;
+ fields.reserve (struct_decl.get_fields ().size ());
+
for (AST::TupleField &field : struct_decl.get_fields ())
{
if (field.get_field_type ().is_marked_for_strip ())
@@ -155,11 +156,8 @@ ASTLoweringItem::visit (AST::TupleStruct &struct_decl)
mappings.get_next_hir_id (crate_num),
mappings.get_next_localdef_id (crate_num));
- HIR::TupleField translated_field (mapping,
- std::unique_ptr<HIR::Type> (type), vis,
- field.get_locus (),
- field.get_outer_attrs ());
- fields.push_back (std::move (translated_field));
+ fields.emplace_back (mapping, std::unique_ptr<HIR::Type> (type), vis,
+ field.get_locus (), field.get_outer_attrs ());
}
auto crate_num = mappings.get_current_crate ();
@@ -185,12 +183,12 @@ ASTLoweringItem::visit (AST::StructStruct &struct_decl)
}
std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
+ where_clause_items.reserve (
+ struct_decl.get_where_clause ().get_items ().size ());
+
for (auto &item : struct_decl.get_where_clause ().get_items ())
- {
- HIR::WhereClauseItem *i
- = ASTLowerWhereClauseItem::translate (*item.get ());
- where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
- }
+ where_clause_items.emplace_back (
+ ASTLowerWhereClauseItem::translate (*item.get ()));
HIR::WhereClause where_clause (std::move (where_clause_items));
@@ -245,25 +243,26 @@ ASTLoweringItem::visit (AST::Enum &enum_decl)
}
std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
+ where_clause_items.reserve (
+ enum_decl.get_where_clause ().get_items ().size ());
+
for (auto &item : enum_decl.get_where_clause ().get_items ())
- {
- HIR::WhereClauseItem *i
- = ASTLowerWhereClauseItem::translate (*item.get ());
- where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
- }
+ where_clause_items.emplace_back (
+ ASTLowerWhereClauseItem::translate (*item.get ()));
HIR::WhereClause where_clause (std::move (where_clause_items));
HIR::Visibility vis = translate_visibility (enum_decl.get_visibility ());
// bool is_unit = enum_decl.is_zero_variant ();
std::vector<std::unique_ptr<HIR::EnumItem>> items;
+ items.reserve (enum_decl.get_variants ().size ());
+
for (auto &variant : enum_decl.get_variants ())
{
if (variant->is_marked_for_strip ())
continue;
- HIR::EnumItem *hir_item = ASTLoweringEnumItem::translate (variant.get ());
- items.push_back (std::unique_ptr<HIR::EnumItem> (hir_item));
+ items.emplace_back (ASTLoweringEnumItem::translate (variant.get ()));
}
auto crate_num = mappings.get_current_crate ();
@@ -288,17 +287,16 @@ ASTLoweringItem::visit (AST::Union &union_decl)
{
std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
if (union_decl.has_generics ())
- {
- generic_params = lower_generic_params (union_decl.get_generic_params ());
- }
+ generic_params = lower_generic_params (union_decl.get_generic_params ());
std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
+ where_clause_items.reserve (
+ union_decl.get_where_clause ().get_items ().size ());
+
for (auto &item : union_decl.get_where_clause ().get_items ())
- {
- HIR::WhereClauseItem *i
- = ASTLowerWhereClauseItem::translate (*item.get ());
- where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
- }
+ where_clause_items.emplace_back (
+ ASTLowerWhereClauseItem::translate (*item.get ()));
+
HIR::WhereClause where_clause (std::move (where_clause_items));
HIR::Visibility vis = translate_visibility (union_decl.get_visibility ());
@@ -390,12 +388,12 @@ ASTLoweringItem::visit (AST::Function &function)
return;
std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
+ where_clause_items.reserve (
+ function.get_where_clause ().get_items ().size ());
+
for (auto &item : function.get_where_clause ().get_items ())
- {
- HIR::WhereClauseItem *i
- = ASTLowerWhereClauseItem::translate (*item.get ());
- where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
- }
+ where_clause_items.emplace_back (
+ ASTLowerWhereClauseItem::translate (*item.get ()));
HIR::WhereClause where_clause (std::move (where_clause_items));
HIR::FunctionQualifiers qualifiers
@@ -418,10 +416,41 @@ ASTLoweringItem::visit (AST::Function &function)
: nullptr;
std::vector<HIR::FunctionParam> function_params;
+ function_params.reserve (function.get_function_params ().size ());
+
+ auto crate_num = mappings.get_current_crate ();
for (auto &p : function.get_function_params ())
{
- if (p->is_variadic () || p->is_self ())
+ if (p->is_variadic ())
continue;
+ if (p->is_self ())
+ {
+ rich_location r (line_table, p->get_locus ());
+ r.add_range (function.get_locus ());
+ rust_error_at (
+ r, "%<self%> parameter is only allowed in associated functions");
+
+ // rustc creates a synthetic regular fn-param here pointing to a
+ // generic Self as far as i can see but that seems over the top for
+ // now.
+ //
+ // see this example (invalid code):
+ //
+ // pub trait X {
+ // fn x() {
+ // fn f(&mut self) {}
+ // f();
+ // }
+ // }
+ //
+ // without a synthetic param we wont get the number of args error as
+ // well but i think this is fine for now.
+ //
+ // problem is what we make the param type to become...
+
+ continue;
+ }
+
auto param = static_cast<AST::FunctionParam &> (*p);
auto translated_pattern = std::unique_ptr<HIR::Pattern> (
@@ -434,10 +463,9 @@ ASTLoweringItem::visit (AST::Function &function)
mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- auto hir_param
- = HIR::FunctionParam (mapping, std::move (translated_pattern),
- std::move (translated_type), param.get_locus ());
- function_params.push_back (std::move (hir_param));
+ function_params.emplace_back (mapping, std::move (translated_pattern),
+ std::move (translated_type),
+ param.get_locus ());
}
bool terminated = false;
@@ -446,7 +474,6 @@ ASTLoweringItem::visit (AST::Function &function)
ASTLoweringBlock::translate (*function.get_definition ().value (),
&terminated));
- auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, function.get_node_id (),
mappings.get_next_hir_id (crate_num),
mappings.get_next_localdef_id (crate_num));
@@ -479,11 +506,12 @@ void
ASTLoweringItem::visit (AST::InherentImpl &impl_block)
{
std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
+ where_clause_items.reserve (
+ impl_block.get_where_clause ().get_items ().size ());
+
for (auto &item : impl_block.get_where_clause ().get_items ())
- {
- HIR::WhereClauseItem *i = ASTLowerWhereClauseItem::translate (*item);
- where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
- }
+ where_clause_items.emplace_back (
+ ASTLowerWhereClauseItem::translate (*item));
HIR::WhereClause where_clause (std::move (where_clause_items));
HIR::Visibility vis = translate_visibility (impl_block.get_visibility ());
@@ -540,7 +568,7 @@ ASTLoweringItem::visit (AST::InherentImpl &impl_block)
HIR::ImplItem *lowered
= ASTLowerImplItem::translate (*impl_item, mapping.get_hirid ());
rust_assert (lowered != nullptr);
- impl_items.push_back (std::unique_ptr<HIR::ImplItem> (lowered));
+ impl_items.emplace_back (lowered);
impl_item_ids.push_back (lowered->get_impl_mappings ().get_hirid ());
}
@@ -563,12 +591,12 @@ void
ASTLoweringItem::visit (AST::Trait &trait)
{
std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
+ where_clause_items.reserve (trait.get_where_clause ().get_items ().size ());
+
for (auto &item : trait.get_where_clause ().get_items ())
- {
- HIR::WhereClauseItem *i
- = ASTLowerWhereClauseItem::translate (*item.get ());
- where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
- }
+ where_clause_items.emplace_back (
+ ASTLowerWhereClauseItem::translate (*item.get ()));
+
HIR::WhereClause where_clause (std::move (where_clause_items));
HIR::Visibility vis = translate_visibility (trait.get_visibility ());
@@ -589,23 +617,24 @@ ASTLoweringItem::visit (AST::Trait &trait)
if (trait.has_type_param_bounds ())
{
for (auto &bound : trait.get_type_param_bounds ())
- {
- HIR::TypeParamBound *b = lower_bound (*bound);
- type_param_bounds.push_back (
- std::unique_ptr<HIR::TypeParamBound> (b));
- }
+ type_param_bounds.emplace_back (lower_bound (*bound));
}
+ auto trait_item_size = trait.get_trait_items ().size ();
+
std::vector<std::unique_ptr<HIR::TraitItem>> trait_items;
+ trait_items.reserve (trait_item_size);
std::vector<HirId> trait_item_ids;
+ trait_item_ids.reserve (trait_item_size);
+
for (auto &item : trait.get_trait_items ())
{
if (item->is_marked_for_strip ())
continue;
HIR::TraitItem *lowered = ASTLowerTraitItem::translate (*item);
- trait_items.push_back (std::unique_ptr<HIR::TraitItem> (lowered));
trait_item_ids.push_back (lowered->get_mappings ().get_hirid ());
+ trait_items.emplace_back (lowered);
}
auto crate_num = mappings.get_current_crate ();
@@ -636,13 +665,16 @@ ASTLoweringItem::visit (AST::Trait &trait)
void
ASTLoweringItem::visit (AST::TraitImpl &impl_block)
{
- std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
bool unsafe = impl_block.is_unsafe ();
+
+ std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
+ where_clause_items.reserve (
+ impl_block.get_where_clause ().get_items ().size ());
+
for (auto &item : impl_block.get_where_clause ().get_items ())
- {
- HIR::WhereClauseItem *i = ASTLowerWhereClauseItem::translate (*item);
- where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
- }
+ where_clause_items.emplace_back (
+ ASTLowerWhereClauseItem::translate (*item));
+
HIR::WhereClause where_clause (std::move (where_clause_items));
HIR::Visibility vis = translate_visibility (impl_block.get_visibility ());
@@ -690,8 +722,13 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block)
mappings.get_next_hir_id (crate_num),
mappings.get_next_localdef_id (crate_num));
+ auto impl_items_size = impl_block.get_impl_items ().size ();
+
std::vector<std::unique_ptr<HIR::ImplItem>> impl_items;
+ impl_items.reserve (impl_items_size);
std::vector<HirId> impl_item_ids;
+ impl_item_ids.reserve (impl_items_size);
+
for (auto &impl_item : impl_block.get_impl_items ())
{
if (impl_item->is_marked_for_strip ())
@@ -700,8 +737,8 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block)
HIR::ImplItem *lowered
= ASTLowerImplItem::translate (*impl_item, mapping.get_hirid ());
rust_assert (lowered != nullptr);
- impl_items.push_back (std::unique_ptr<HIR::ImplItem> (lowered));
impl_item_ids.push_back (lowered->get_impl_mappings ().get_hirid ());
+ impl_items.emplace_back (lowered);
}
BoundPolarity polarity = impl_block.is_exclam ()
diff --git a/gcc/rust/hir/rust-ast-lower-pattern.cc b/gcc/rust/hir/rust-ast-lower-pattern.cc
index 8aabcd8..4250adb 100644
--- a/gcc/rust/hir/rust-ast-lower-pattern.cc
+++ b/gcc/rust/hir/rust-ast-lower-pattern.cc
@@ -81,26 +81,45 @@ ASTLoweringPattern::visit (AST::TupleStructPattern &pattern)
auto &items = pattern.get_items ();
switch (items.get_item_type ())
{
- case AST::TupleStructItems::RANGE:
+ case AST::TupleStructItems::HAS_REST:
{
- // TODO
- rust_unreachable ();
+ AST::TupleStructItemsHasRest &items_has_rest
+ = static_cast<AST::TupleStructItemsHasRest &> (items);
+
+ std::vector<std::unique_ptr<HIR::Pattern>> lower_patterns;
+ lower_patterns.reserve (items_has_rest.get_lower_patterns ().size ());
+ for (auto &pattern_member : items_has_rest.get_lower_patterns ())
+ {
+ lower_patterns.emplace_back (
+ ASTLoweringPattern::translate (*pattern_member));
+ }
+
+ std::vector<std::unique_ptr<HIR::Pattern>> upper_patterns;
+ upper_patterns.reserve (items_has_rest.get_upper_patterns ().size ());
+ for (auto &pattern_member : items_has_rest.get_upper_patterns ())
+ {
+ upper_patterns.emplace_back (
+ ASTLoweringPattern::translate (*pattern_member));
+ }
+
+ lowered = new HIR::TupleStructItemsHasRest (std::move (lower_patterns),
+ std::move (upper_patterns));
}
break;
- case AST::TupleStructItems::NO_RANGE:
+ case AST::TupleStructItems::NO_REST:
{
- AST::TupleStructItemsNoRange &items_no_range
- = static_cast<AST::TupleStructItemsNoRange &> (items);
+ AST::TupleStructItemsNoRest &items_no_rest
+ = static_cast<AST::TupleStructItemsNoRest &> (items);
std::vector<std::unique_ptr<HIR::Pattern>> patterns;
- for (auto &inner_pattern : items_no_range.get_patterns ())
- {
- HIR::Pattern *p = ASTLoweringPattern::translate (*inner_pattern);
- patterns.push_back (std::unique_ptr<HIR::Pattern> (p));
- }
+ patterns.reserve (items_no_rest.get_patterns ().size ());
+
+ for (auto &inner_pattern : items_no_rest.get_patterns ())
+ patterns.emplace_back (
+ ASTLoweringPattern::translate (*inner_pattern));
- lowered = new HIR::TupleStructItemsNoRange (std::move (patterns));
+ lowered = new HIR::TupleStructItemsNoRest (std::move (patterns));
}
break;
}
@@ -121,7 +140,6 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern)
= ASTLowerPathInExpression::translate (pattern.get_path ());
auto &raw_elems = pattern.get_struct_pattern_elems ();
- rust_assert (!raw_elems.has_etc ());
std::vector<std::unique_ptr<HIR::StructPatternField>> fields;
for (auto &field : raw_elems.get_struct_pattern_fields ())
@@ -196,7 +214,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern)
mappings.insert_node_to_hir (field_node_id, field_id);
// add it to the lowered fields list
- fields.push_back (std::unique_ptr<HIR::StructPatternField> (f));
+ fields.emplace_back (f);
}
auto crate_num = mappings.get_current_crate ();
@@ -204,7 +222,8 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern)
mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- HIR::StructPatternElements elems (std::move (fields));
+ HIR::StructPatternElements elems (
+ std::move (fields), pattern.get_struct_pattern_elems ().has_rest ());
translated = new HIR::StructPattern (mapping, *path, std::move (elems));
}
@@ -223,21 +242,20 @@ void
ASTLoweringPattern::visit (AST::TuplePattern &pattern)
{
std::unique_ptr<HIR::TuplePatternItems> items;
- switch (pattern.get_items ().get_pattern_type ())
+ switch (pattern.get_items ().get_item_type ())
{
- case AST::TuplePatternItems::TuplePatternItemType::MULTIPLE:
+ case AST::TuplePatternItems::ItemType::NO_REST:
{
- AST::TuplePatternItemsMultiple &ref
- = static_cast<AST::TuplePatternItemsMultiple &> (
- pattern.get_items ());
+ AST::TuplePatternItemsNoRest &ref
+ = static_cast<AST::TuplePatternItemsNoRest &> (pattern.get_items ());
items = lower_tuple_pattern_multiple (ref);
}
break;
- case AST::TuplePatternItems::TuplePatternItemType::RANGED:
+ case AST::TuplePatternItems::ItemType::HAS_REST:
{
- AST::TuplePatternItemsRanged &ref
- = static_cast<AST::TuplePatternItemsRanged &> (pattern.get_items ());
+ AST::TuplePatternItemsHasRest &ref
+ = static_cast<AST::TuplePatternItemsHasRest &> (pattern.get_items ());
items = lower_tuple_pattern_ranged (ref);
}
break;
@@ -268,8 +286,6 @@ ASTLoweringPattern::visit (AST::LiteralPattern &pattern)
void
ASTLoweringPattern::visit (AST::RangePattern &pattern)
{
- if (pattern.get_range_kind () == AST::RangeKind::EXCLUDED)
- rust_unreachable (); // Not supported yet
auto upper_bound = lower_range_pattern_bound (pattern.get_upper_bound ());
auto lower_bound = lower_range_pattern_bound (pattern.get_lower_bound ());
@@ -278,9 +294,11 @@ ASTLoweringPattern::visit (AST::RangePattern &pattern)
mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- translated
- = new HIR::RangePattern (mapping, std::move (lower_bound),
- std::move (upper_bound), pattern.get_locus ());
+ bool is_inclusive = (pattern.get_range_kind () == AST::RangeKind::INCLUDED);
+
+ translated = new HIR::RangePattern (mapping, std::move (lower_bound),
+ std::move (upper_bound),
+ pattern.get_locus (), is_inclusive);
}
void
@@ -322,26 +340,22 @@ ASTLoweringPattern::visit (AST::ReferencePattern &pattern)
void
ASTLoweringPattern::visit (AST::SlicePattern &pattern)
{
- std::vector<std::unique_ptr<HIR::Pattern>> items;
+ std::unique_ptr<HIR::SlicePatternItems> items;
- switch (pattern.get_items ().get_pattern_type ())
+ switch (pattern.get_items ().get_item_type ())
{
- case AST::SlicePatternItems::SlicePatternItemType::NO_REST:
+ case AST::SlicePatternItems::ItemType::NO_REST:
{
- AST::SlicePatternItemsNoRest &ref
+ auto &ref
= static_cast<AST::SlicePatternItemsNoRest &> (pattern.get_items ());
- for (auto &p : ref.get_patterns ())
- {
- HIR::Pattern *item = ASTLoweringPattern::translate (*p);
- items.push_back (std::unique_ptr<HIR::Pattern> (item));
- }
+ items = ASTLoweringBase::lower_slice_pattern_no_rest (ref);
}
break;
- case AST::SlicePatternItems::SlicePatternItemType::HAS_REST:
+ case AST::SlicePatternItems::ItemType::HAS_REST:
{
- rust_error_at (pattern.get_locus (),
- "lowering of slice patterns with rest elements are not "
- "supported yet");
+ auto &ref
+ = static_cast<AST::SlicePatternItemsHasRest &> (pattern.get_items ());
+ items = ASTLoweringBase::lower_slice_pattern_has_rest (ref);
}
break;
}
@@ -364,12 +378,10 @@ ASTLoweringPattern::visit (AST::AltPattern &pattern)
UNKNOWN_LOCAL_DEFID);
std::vector<std::unique_ptr<HIR::Pattern>> alts;
+ alts.reserve (pattern.get_alts ().size ());
for (auto &alt : pattern.get_alts ())
- {
- alts.push_back (
- std::unique_ptr<HIR::Pattern> (ASTLoweringPattern::translate (*alt)));
- }
+ alts.emplace_back (ASTLoweringPattern::translate (*alt));
translated
= new HIR::AltPattern (mapping, std::move (alts), pattern.get_locus ());
diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc
index e6e327f..5b8e7c5 100644
--- a/gcc/rust/hir/rust-ast-lower.cc
+++ b/gcc/rust/hir/rust-ast-lower.cc
@@ -80,7 +80,7 @@ ASTLowering::go ()
{
auto translated = ASTLoweringItem::translate (*item);
if (translated != nullptr)
- items.push_back (std::unique_ptr<HIR::Item> (translated));
+ items.emplace_back (translated);
}
auto &mappings = Analysis::Mappings::get ();
@@ -127,7 +127,7 @@ ASTLoweringBlock::visit (AST::BlockExpr &expr)
block_did_terminate |= terminated;
if (translated_stmt)
- block_stmts.push_back (std::unique_ptr<HIR::Stmt> (translated_stmt));
+ block_stmts.emplace_back (translated_stmt);
}
if (expr.has_tail_expr () && block_did_terminate)
@@ -231,6 +231,7 @@ ASTLoweringIfLetBlock::desugar_iflet (AST::IfLetExpr &expr,
{
HIR::Expr *kase_expr;
std::vector<std::unique_ptr<HIR::Pattern>> match_arm_patterns;
+ match_arm_patterns.reserve (expr.get_patterns ().size ());
*branch_value = ASTLoweringExpr::translate (expr.get_value_expr ());
kase_expr = ASTLoweringExpr::translate (expr.get_if_block ());
@@ -241,10 +242,7 @@ ASTLoweringIfLetBlock::desugar_iflet (AST::IfLetExpr &expr,
rust_assert (expr.get_patterns ().size () == 1);
for (auto &pattern : expr.get_patterns ())
- {
- HIR::Pattern *ptrn = ASTLoweringPattern::translate (*pattern);
- match_arm_patterns.push_back (std::unique_ptr<HIR::Pattern> (ptrn));
- }
+ match_arm_patterns.emplace_back (ASTLoweringPattern::translate (*pattern));
// The match arm corresponding to the if let pattern when it matches.
HIR::MatchArm arm (std::move (match_arm_patterns), expr.get_locus (), nullptr,
@@ -255,9 +253,8 @@ ASTLoweringIfLetBlock::desugar_iflet (AST::IfLetExpr &expr,
mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- HIR::MatchCase kase (std::move (mapping), std::move (arm),
- std::unique_ptr<HIR::Expr> (kase_expr));
- match_arms.push_back (std::move (kase));
+ match_arms.emplace_back (std::move (mapping), std::move (arm),
+ std::unique_ptr<HIR::Expr> (kase_expr));
// The default match arm when the if let pattern does not match
std::vector<std::unique_ptr<HIR::Pattern>> match_arm_patterns_wildcard;
@@ -265,19 +262,14 @@ ASTLoweringIfLetBlock::desugar_iflet (AST::IfLetExpr &expr,
mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- std::unique_ptr<HIR::WildcardPattern> wc
- = std::unique_ptr<HIR::WildcardPattern> (
- new HIR::WildcardPattern (mapping_default, expr.get_locus ()));
-
- match_arm_patterns_wildcard.push_back (std::move (wc));
+ match_arm_patterns_wildcard.emplace_back (
+ new HIR::WildcardPattern (mapping_default, expr.get_locus ()));
HIR::MatchArm arm_default (std::move (match_arm_patterns_wildcard),
expr.get_locus (), nullptr, {});
- HIR::MatchCase kase_else (std::move (mapping_default),
- std::move (arm_default),
- std::unique_ptr<HIR::Expr> (kase_else_expr));
- match_arms.push_back (std::move (kase_else));
+ match_arms.emplace_back (std::move (mapping_default), std::move (arm_default),
+ std::unique_ptr<HIR::Expr> (kase_else_expr));
}
void
@@ -442,11 +434,12 @@ ASTLoweringExprWithBlock::visit (AST::MatchExpr &expr)
}
std::vector<std::unique_ptr<HIR::Pattern>> match_arm_patterns;
+ match_arm_patterns.reserve (
+ match_case.get_arm ().get_patterns ().size ());
+
for (auto &pattern : match_case.get_arm ().get_patterns ())
- {
- HIR::Pattern *ptrn = ASTLoweringPattern::translate (*pattern);
- match_arm_patterns.push_back (std::unique_ptr<HIR::Pattern> (ptrn));
- }
+ match_arm_patterns.emplace_back (
+ ASTLoweringPattern::translate (*pattern));
HIR::MatchArm arm (std::move (match_arm_patterns), expr.get_locus (),
std::unique_ptr<HIR::Expr> (kase_guard_expr),
@@ -457,9 +450,8 @@ ASTLoweringExprWithBlock::visit (AST::MatchExpr &expr)
mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- HIR::MatchCase kase (std::move (mapping), std::move (arm),
- std::unique_ptr<HIR::Expr> (kase_expr));
- match_arms.push_back (std::move (kase));
+ match_arms.emplace_back (std::move (mapping), std::move (arm),
+ std::unique_ptr<HIR::Expr> (kase_expr));
}
auto crate_num = mappings.get_current_crate ();
@@ -490,8 +482,11 @@ ASTLowerPathInExpression::visit (AST::PathInExpression &expr)
return;
}
- std::vector<HIR::PathExprSegment> path_segments;
auto &segments = expr.get_segments ();
+
+ std::vector<HIR::PathExprSegment> path_segments;
+ path_segments.reserve (segments.size ());
+
for (auto &s : segments)
{
path_segments.push_back (lower_path_expr_seg ((s)));
@@ -531,8 +526,11 @@ ASTLowerQualPathInExpression::visit (AST::QualifiedPathInExpression &expr)
HIR::QualifiedPathType qual_path_type
= lower_qual_path_type (expr.get_qualified_path_type ());
- std::vector<HIR::PathExprSegment> path_segments;
auto &segments = expr.get_segments ();
+
+ std::vector<HIR::PathExprSegment> path_segments;
+ path_segments.reserve (segments.size ());
+
for (auto &s : segments)
{
path_segments.push_back (lower_path_expr_seg ((s)));
diff --git a/gcc/rust/hir/rust-hir-dump.cc b/gcc/rust/hir/rust-hir-dump.cc
index a0cdcb2..49ce143 100644
--- a/gcc/rust/hir/rust-hir-dump.cc
+++ b/gcc/rust/hir/rust-hir-dump.cc
@@ -2307,20 +2307,20 @@ Dump::visit (StructPattern &e)
}
void
-Dump::visit (TupleStructItemsNoRange &e)
+Dump::visit (TupleStructItemsNoRest &e)
{
- begin ("TupleStructItemsNoRange");
+ begin ("TupleStructItemsNoRest");
visit_collection ("patterns", e.get_patterns ());
- end ("TupleStructItemsNoRange");
+ end ("TupleStructItemsNoRest");
}
void
-Dump::visit (TupleStructItemsRange &e)
+Dump::visit (TupleStructItemsHasRest &e)
{
- begin ("TupleStructItemsRange");
+ begin ("TupleStructItemsHasRest");
visit_collection ("lower_patterns", e.get_lower_patterns ());
visit_collection ("upper_patterns", e.get_upper_patterns ());
- end ("TupleStructItemsRange");
+ end ("TupleStructItemsHasRest");
}
void
@@ -2337,20 +2337,20 @@ Dump::visit (TupleStructPattern &e)
}
void
-Dump::visit (TuplePatternItemsMultiple &e)
+Dump::visit (TuplePatternItemsNoRest &e)
{
- begin ("TuplePatternItemsMultiple");
+ begin ("TuplePatternItemsNoRest");
visit_collection ("patterns", e.get_patterns ());
- end ("TuplePatternItemsMultiple");
+ end ("TuplePatternItemsNoRest");
}
void
-Dump::visit (TuplePatternItemsRanged &e)
+Dump::visit (TuplePatternItemsHasRest &e)
{
- begin ("TuplePatternItemsRanged");
+ begin ("TuplePatternItemsHasRest");
visit_collection ("lower_patterns", e.get_lower_patterns ());
visit_collection ("upper_patterns", e.get_upper_patterns ());
- end ("TuplePatternItemsRanged");
+ end ("TuplePatternItemsHasRest");
}
void
@@ -2363,11 +2363,28 @@ Dump::visit (TuplePattern &e)
}
void
+Dump::visit (SlicePatternItemsNoRest &e)
+{
+ begin ("SlicePatternItemsNoRest");
+ visit_collection ("patterns", e.get_patterns ());
+ end ("SlicePatternItemsNoRest");
+}
+
+void
+Dump::visit (SlicePatternItemsHasRest &e)
+{
+ begin ("SlicePatternItemsHasRest");
+ visit_collection ("lower_patterns", e.get_lower_patterns ());
+ visit_collection ("upper_patterns", e.get_upper_patterns ());
+ end ("SlicePatternItemsHasRest");
+}
+
+void
Dump::visit (SlicePattern &e)
{
begin ("SlicePattern");
do_mappings (e.get_mappings ());
- visit_collection ("items", e.get_items ());
+ visit_field ("items", e.get_items ());
end ("SlicePattern");
}
diff --git a/gcc/rust/hir/rust-hir-dump.h b/gcc/rust/hir/rust-hir-dump.h
index 3e6ae30..4dfc885 100644
--- a/gcc/rust/hir/rust-hir-dump.h
+++ b/gcc/rust/hir/rust-hir-dump.h
@@ -223,14 +223,18 @@ private:
virtual void visit (StructPatternFieldIdent &) override;
virtual void visit (StructPattern &) override;
- virtual void visit (TupleStructItemsNoRange &) override;
- virtual void visit (TupleStructItemsRange &) override;
+ virtual void visit (TupleStructItemsNoRest &) override;
+ virtual void visit (TupleStructItemsHasRest &) override;
virtual void visit (TupleStructPattern &) override;
- virtual void visit (TuplePatternItemsMultiple &) override;
- virtual void visit (TuplePatternItemsRanged &) override;
+ virtual void visit (TuplePatternItemsNoRest &) override;
+ virtual void visit (TuplePatternItemsHasRest &) override;
virtual void visit (TuplePattern &) override;
+
+ virtual void visit (SlicePatternItemsNoRest &) override;
+ virtual void visit (SlicePatternItemsHasRest &) override;
virtual void visit (SlicePattern &) override;
+
virtual void visit (AltPattern &) override;
virtual void visit (EmptyStmt &) override;
diff --git a/gcc/rust/hir/tree/rust-hir-full-decls.h b/gcc/rust/hir/tree/rust-hir-full-decls.h
index 57b3a4d..aec2f36 100644
--- a/gcc/rust/hir/tree/rust-hir-full-decls.h
+++ b/gcc/rust/hir/tree/rust-hir-full-decls.h
@@ -199,13 +199,15 @@ class StructPatternFieldIdentPat;
class StructPatternFieldIdent;
class StructPattern;
class TupleStructItems;
-class TupleStructItemsNoRange;
-class TupleStructItemsRange;
+class TupleStructItemsNoRest;
+class TupleStructItemsHasRest;
class TupleStructPattern;
class TuplePatternItems;
-class TuplePatternItemsMultiple;
-class TuplePatternItemsRanged;
+class TuplePatternItemsNoRest;
+class TuplePatternItemsHasRest;
class TuplePattern;
+class SlicePatternItemsNoRest;
+class SlicePatternItemsHasRest;
class SlicePattern;
class AltPattern;
diff --git a/gcc/rust/hir/tree/rust-hir-item.h b/gcc/rust/hir/tree/rust-hir-item.h
index d9df602..eb9cec7 100644
--- a/gcc/rust/hir/tree/rust-hir-item.h
+++ b/gcc/rust/hir/tree/rust-hir-item.h
@@ -452,6 +452,7 @@ public:
bool is_unsafe () const { return unsafety == Unsafety::Unsafe; }
bool is_async () const { return async_status == Async::Yes; }
+ Unsafety get_unsafety () const { return unsafety; }
ABI get_abi () const { return abi; }
};
diff --git a/gcc/rust/hir/tree/rust-hir-pattern.h b/gcc/rust/hir/tree/rust-hir-pattern.h
index 9c636ca..89b9cc6 100644
--- a/gcc/rust/hir/tree/rust-hir-pattern.h
+++ b/gcc/rust/hir/tree/rust-hir-pattern.h
@@ -350,6 +350,7 @@ class RangePattern : public Pattern
/* location only stored to avoid a dereference - lower pattern should give
* correct location so maybe change in future */
location_t locus;
+ bool is_inclusive;
Analysis::NodeMapping mappings;
public:
@@ -359,10 +360,10 @@ public:
RangePattern (Analysis::NodeMapping mappings,
std::unique_ptr<RangePatternBound> lower,
std::unique_ptr<RangePatternBound> upper, location_t locus,
- bool has_ellipsis_syntax = false)
+ bool is_inclusive, bool has_ellipsis_syntax = false)
: lower (std::move (lower)), upper (std::move (upper)),
has_ellipsis_syntax (has_ellipsis_syntax), locus (locus),
- mappings (mappings)
+ is_inclusive (is_inclusive), mappings (mappings)
{}
// Copy constructor with clone
@@ -370,7 +371,7 @@ public:
: lower (other.lower->clone_range_pattern_bound ()),
upper (other.upper->clone_range_pattern_bound ()),
has_ellipsis_syntax (other.has_ellipsis_syntax), locus (other.locus),
- mappings (other.mappings)
+ is_inclusive (other.is_inclusive), mappings (other.mappings)
{}
// Overloaded assignment operator to clone
@@ -380,6 +381,7 @@ public:
upper = other.upper->clone_range_pattern_bound ();
has_ellipsis_syntax = other.has_ellipsis_syntax;
locus = other.locus;
+ is_inclusive = other.is_inclusive;
mappings = other.mappings;
return *this;
@@ -395,6 +397,7 @@ public:
void accept_vis (HIRPatternVisitor &vis) override;
bool get_has_ellipsis_syntax () { return has_ellipsis_syntax; };
+ bool is_inclusive_range () const { return is_inclusive; }
const Analysis::NodeMapping &get_mappings () const override final
{
@@ -680,6 +683,7 @@ protected:
class StructPatternElements
{
std::vector<std::unique_ptr<StructPatternField>> fields;
+ bool has_rest_pattern;
public:
// Returns whether there are any struct pattern fields
@@ -689,10 +693,18 @@ public:
* no etc). */
bool is_empty () const { return !has_struct_pattern_fields (); }
+ bool has_rest () const { return has_rest_pattern; }
+
// Constructor for StructPatternElements with both (potentially)
StructPatternElements (
std::vector<std::unique_ptr<StructPatternField>> fields)
- : fields (std::move (fields))
+ : fields (std::move (fields)), has_rest_pattern (false)
+ {}
+
+ StructPatternElements (
+ std::vector<std::unique_ptr<StructPatternField>> fields,
+ bool has_rest_pattern)
+ : fields (std::move (fields)), has_rest_pattern (has_rest_pattern)
{}
// Copy constructor with vector clone
@@ -700,7 +712,8 @@ public:
{
fields.reserve (other.fields.size ());
for (const auto &e : other.fields)
- fields.push_back (e->clone_struct_pattern_field ());
+ fields.emplace_back (e->clone_struct_pattern_field ());
+ has_rest_pattern = other.has_rest_pattern;
}
// Overloaded assignment operator with vector clone
@@ -709,8 +722,8 @@ public:
fields.clear ();
fields.reserve (other.fields.size ());
for (const auto &e : other.fields)
- fields.push_back (e->clone_struct_pattern_field ());
-
+ fields.emplace_back (e->clone_struct_pattern_field ());
+ has_rest_pattern = other.has_rest_pattern;
return *this;
}
@@ -778,24 +791,25 @@ protected:
}
};
-// Base abstract class for TupleStructItems and TuplePatternItems
-class TupleItems : public FullVisitable
+// Base abstract class for TupleStructItems, TuplePatternItems &
+// SlicePatternItems
+class PatternItems : public FullVisitable
{
public:
enum ItemType
{
- MULTIPLE,
- RANGED,
+ NO_REST,
+ HAS_REST,
};
- virtual ~TupleItems () {}
+ virtual ~PatternItems () {}
// TODO: should this store location data?
// Unique pointer custom clone function
- std::unique_ptr<TupleItems> clone_tuple_items () const
+ std::unique_ptr<PatternItems> clone_pattern_items () const
{
- return std::unique_ptr<TupleItems> (clone_tuple_items_impl ());
+ return std::unique_ptr<PatternItems> (clone_pattern_items_impl ());
}
virtual ItemType get_item_type () const = 0;
@@ -804,36 +818,36 @@ public:
protected:
// pure virtual clone implementation
- virtual TupleItems *clone_tuple_items_impl () const = 0;
+ virtual PatternItems *clone_pattern_items_impl () const = 0;
};
// Base abstract class for patterns used in TupleStructPattern
-class TupleStructItems : public TupleItems
+class TupleStructItems : public PatternItems
{
public:
// Unique pointer custom clone function
std::unique_ptr<TupleStructItems> clone_tuple_struct_items () const
{
- return std::unique_ptr<TupleStructItems> (clone_tuple_items_impl ());
+ return std::unique_ptr<TupleStructItems> (clone_pattern_items_impl ());
}
protected:
// pure virtual clone implementation
- virtual TupleStructItems *clone_tuple_items_impl () const override = 0;
+ virtual TupleStructItems *clone_pattern_items_impl () const override = 0;
};
-// Class for non-ranged tuple struct pattern patterns
-class TupleStructItemsNoRange : public TupleStructItems
+// Class for patterns within a tuple struct pattern, without a rest pattern
+class TupleStructItemsNoRest : public TupleStructItems
{
std::vector<std::unique_ptr<Pattern>> patterns;
public:
- TupleStructItemsNoRange (std::vector<std::unique_ptr<Pattern>> patterns)
+ TupleStructItemsNoRest (std::vector<std::unique_ptr<Pattern>> patterns)
: patterns (std::move (patterns))
{}
// Copy constructor with vector clone
- TupleStructItemsNoRange (TupleStructItemsNoRange const &other)
+ TupleStructItemsNoRest (TupleStructItemsNoRest const &other)
{
patterns.reserve (other.patterns.size ());
for (const auto &e : other.patterns)
@@ -841,7 +855,7 @@ public:
}
// Overloaded assignment operator with vector clone
- TupleStructItemsNoRange &operator= (TupleStructItemsNoRange const &other)
+ TupleStructItemsNoRest &operator= (TupleStructItemsNoRest const &other)
{
patterns.clear ();
patterns.reserve (other.patterns.size ());
@@ -852,9 +866,8 @@ public:
}
// move constructors
- TupleStructItemsNoRange (TupleStructItemsNoRange &&other) = default;
- TupleStructItemsNoRange &operator= (TupleStructItemsNoRange &&other)
- = default;
+ TupleStructItemsNoRest (TupleStructItemsNoRest &&other) = default;
+ TupleStructItemsNoRest &operator= (TupleStructItemsNoRest &&other) = default;
std::string as_string () const override;
@@ -866,32 +879,33 @@ public:
return patterns;
}
- ItemType get_item_type () const override final { return ItemType::MULTIPLE; }
+ ItemType get_item_type () const override final { return ItemType::NO_REST; }
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
- TupleStructItemsNoRange *clone_tuple_items_impl () const override
+ TupleStructItemsNoRest *clone_pattern_items_impl () const override
{
- return new TupleStructItemsNoRange (*this);
+ return new TupleStructItemsNoRest (*this);
}
};
-// Class for ranged tuple struct pattern patterns
-class TupleStructItemsRange : public TupleStructItems
+// Class for patterns within a tuple struct pattern, with a rest pattern
+// included
+class TupleStructItemsHasRest : public TupleStructItems
{
std::vector<std::unique_ptr<Pattern>> lower_patterns;
std::vector<std::unique_ptr<Pattern>> upper_patterns;
public:
- TupleStructItemsRange (std::vector<std::unique_ptr<Pattern>> lower_patterns,
- std::vector<std::unique_ptr<Pattern>> upper_patterns)
+ TupleStructItemsHasRest (std::vector<std::unique_ptr<Pattern>> lower_patterns,
+ std::vector<std::unique_ptr<Pattern>> upper_patterns)
: lower_patterns (std::move (lower_patterns)),
upper_patterns (std::move (upper_patterns))
{}
// Copy constructor with vector clone
- TupleStructItemsRange (TupleStructItemsRange const &other)
+ TupleStructItemsHasRest (TupleStructItemsHasRest const &other)
{
lower_patterns.reserve (other.lower_patterns.size ());
for (const auto &e : other.lower_patterns)
@@ -903,7 +917,7 @@ public:
}
// Overloaded assignment operator to clone
- TupleStructItemsRange &operator= (TupleStructItemsRange const &other)
+ TupleStructItemsHasRest &operator= (TupleStructItemsHasRest const &other)
{
lower_patterns.clear ();
lower_patterns.reserve (other.lower_patterns.size ());
@@ -919,8 +933,9 @@ public:
}
// move constructors
- TupleStructItemsRange (TupleStructItemsRange &&other) = default;
- TupleStructItemsRange &operator= (TupleStructItemsRange &&other) = default;
+ TupleStructItemsHasRest (TupleStructItemsHasRest &&other) = default;
+ TupleStructItemsHasRest &operator= (TupleStructItemsHasRest &&other)
+ = default;
std::string as_string () const override;
@@ -945,14 +960,14 @@ public:
return upper_patterns;
}
- ItemType get_item_type () const override final { return ItemType::RANGED; }
+ ItemType get_item_type () const override final { return ItemType::HAS_REST; }
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
- TupleStructItemsRange *clone_tuple_items_impl () const override
+ TupleStructItemsHasRest *clone_pattern_items_impl () const override
{
- return new TupleStructItemsRange (*this);
+ return new TupleStructItemsHasRest (*this);
}
};
@@ -1025,32 +1040,32 @@ protected:
};
// Base abstract class representing TuplePattern patterns
-class TuplePatternItems : public TupleItems
+class TuplePatternItems : public PatternItems
{
public:
// Unique pointer custom clone function
std::unique_ptr<TuplePatternItems> clone_tuple_pattern_items () const
{
- return std::unique_ptr<TuplePatternItems> (clone_tuple_items_impl ());
+ return std::unique_ptr<TuplePatternItems> (clone_pattern_items_impl ());
}
protected:
// pure virtual clone implementation
- virtual TuplePatternItems *clone_tuple_items_impl () const override = 0;
+ virtual TuplePatternItems *clone_pattern_items_impl () const override = 0;
};
-// Class representing TuplePattern patterns where there are multiple patterns
-class TuplePatternItemsMultiple : public TuplePatternItems
+// Class representing patterns within a TuplePattern, without a rest pattern
+class TuplePatternItemsNoRest : public TuplePatternItems
{
std::vector<std::unique_ptr<Pattern>> patterns;
public:
- TuplePatternItemsMultiple (std::vector<std::unique_ptr<Pattern>> patterns)
+ TuplePatternItemsNoRest (std::vector<std::unique_ptr<Pattern>> patterns)
: patterns (std::move (patterns))
{}
// Copy constructor with vector clone
- TuplePatternItemsMultiple (TuplePatternItemsMultiple const &other)
+ TuplePatternItemsNoRest (TuplePatternItemsNoRest const &other)
{
patterns.reserve (other.patterns.size ());
for (const auto &e : other.patterns)
@@ -1058,7 +1073,7 @@ public:
}
// Overloaded assignment operator to vector clone
- TuplePatternItemsMultiple &operator= (TuplePatternItemsMultiple const &other)
+ TuplePatternItemsNoRest &operator= (TuplePatternItemsNoRest const &other)
{
patterns.clear ();
patterns.reserve (other.patterns.size ());
@@ -1069,15 +1084,15 @@ public:
}
// move constructors
- TuplePatternItemsMultiple (TuplePatternItemsMultiple &&other) = default;
- TuplePatternItemsMultiple &operator= (TuplePatternItemsMultiple &&other)
+ TuplePatternItemsNoRest (TuplePatternItemsNoRest &&other) = default;
+ TuplePatternItemsNoRest &operator= (TuplePatternItemsNoRest &&other)
= default;
std::string as_string () const override;
void accept_vis (HIRFullVisitor &vis) override;
- ItemType get_item_type () const override { return ItemType::MULTIPLE; }
+ ItemType get_item_type () const override { return ItemType::NO_REST; }
std::vector<std::unique_ptr<Pattern>> &get_patterns () { return patterns; }
const std::vector<std::unique_ptr<Pattern>> &get_patterns () const
@@ -1088,27 +1103,29 @@ public:
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
- TuplePatternItemsMultiple *clone_tuple_items_impl () const override
+ TuplePatternItemsNoRest *clone_pattern_items_impl () const override
{
- return new TuplePatternItemsMultiple (*this);
+ return new TuplePatternItemsNoRest (*this);
}
};
-// Class representing TuplePattern patterns where there are a range of patterns
-class TuplePatternItemsRanged : public TuplePatternItems
+// Class representing patterns within a TuplePattern, with a rest pattern
+// included
+class TuplePatternItemsHasRest : public TuplePatternItems
{
std::vector<std::unique_ptr<Pattern>> lower_patterns;
std::vector<std::unique_ptr<Pattern>> upper_patterns;
public:
- TuplePatternItemsRanged (std::vector<std::unique_ptr<Pattern>> lower_patterns,
- std::vector<std::unique_ptr<Pattern>> upper_patterns)
+ TuplePatternItemsHasRest (
+ std::vector<std::unique_ptr<Pattern>> lower_patterns,
+ std::vector<std::unique_ptr<Pattern>> upper_patterns)
: lower_patterns (std::move (lower_patterns)),
upper_patterns (std::move (upper_patterns))
{}
// Copy constructor with vector clone
- TuplePatternItemsRanged (TuplePatternItemsRanged const &other)
+ TuplePatternItemsHasRest (TuplePatternItemsHasRest const &other)
{
lower_patterns.reserve (other.lower_patterns.size ());
for (const auto &e : other.lower_patterns)
@@ -1120,7 +1137,7 @@ public:
}
// Overloaded assignment operator to clone
- TuplePatternItemsRanged &operator= (TuplePatternItemsRanged const &other)
+ TuplePatternItemsHasRest &operator= (TuplePatternItemsHasRest const &other)
{
lower_patterns.clear ();
lower_patterns.reserve (other.lower_patterns.size ());
@@ -1136,15 +1153,15 @@ public:
}
// move constructors
- TuplePatternItemsRanged (TuplePatternItemsRanged &&other) = default;
- TuplePatternItemsRanged &operator= (TuplePatternItemsRanged &&other)
+ TuplePatternItemsHasRest (TuplePatternItemsHasRest &&other) = default;
+ TuplePatternItemsHasRest &operator= (TuplePatternItemsHasRest &&other)
= default;
std::string as_string () const override;
void accept_vis (HIRFullVisitor &vis) override;
- ItemType get_item_type () const override { return ItemType::RANGED; }
+ ItemType get_item_type () const override { return ItemType::HAS_REST; }
std::vector<std::unique_ptr<Pattern>> &get_lower_patterns ()
{
@@ -1167,9 +1184,9 @@ public:
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
- TuplePatternItemsRanged *clone_tuple_items_impl () const override
+ TuplePatternItemsHasRest *clone_pattern_items_impl () const override
{
- return new TuplePatternItemsRanged (*this);
+ return new TuplePatternItemsHasRest (*this);
}
};
@@ -1234,10 +1251,161 @@ protected:
}
};
+// Base abstract class representing SlicePattern patterns
+class SlicePatternItems : public PatternItems
+{
+public:
+ // Unique pointer custom clone function
+ std::unique_ptr<SlicePatternItems> clone_slice_pattern_items () const
+ {
+ return std::unique_ptr<SlicePatternItems> (clone_pattern_items_impl ());
+ }
+
+protected:
+ // pure virtual clone implementation
+ virtual SlicePatternItems *clone_pattern_items_impl () const override = 0;
+};
+
+// Class representing patterns within a SlicePattern, without a rest pattern
+class SlicePatternItemsNoRest : public SlicePatternItems
+{
+ std::vector<std::unique_ptr<Pattern>> patterns;
+
+public:
+ SlicePatternItemsNoRest (std::vector<std::unique_ptr<Pattern>> patterns)
+ : patterns (std::move (patterns))
+ {}
+
+ // Copy constructor with vector clone
+ SlicePatternItemsNoRest (SlicePatternItemsNoRest const &other)
+ {
+ patterns.reserve (other.patterns.size ());
+ for (const auto &e : other.patterns)
+ patterns.push_back (e->clone_pattern ());
+ }
+
+ // Overloaded assignment operator to vector clone
+ SlicePatternItemsNoRest &operator= (SlicePatternItemsNoRest const &other)
+ {
+ patterns.clear ();
+ patterns.reserve (other.patterns.size ());
+ for (const auto &e : other.patterns)
+ patterns.push_back (e->clone_pattern ());
+
+ return *this;
+ }
+
+ // move constructors
+ SlicePatternItemsNoRest (SlicePatternItemsNoRest &&other) = default;
+ SlicePatternItemsNoRest &operator= (SlicePatternItemsNoRest &&other)
+ = default;
+
+ std::string as_string () const override;
+
+ void accept_vis (HIRFullVisitor &vis) override;
+
+ ItemType get_item_type () const override { return ItemType::NO_REST; }
+
+ std::vector<std::unique_ptr<Pattern>> &get_patterns () { return patterns; }
+ const std::vector<std::unique_ptr<Pattern>> &get_patterns () const
+ {
+ return patterns;
+ }
+
+protected:
+ /* Use covariance to implement clone function as returning this object rather
+ * than base */
+ SlicePatternItemsNoRest *clone_pattern_items_impl () const override
+ {
+ return new SlicePatternItemsNoRest (*this);
+ }
+};
+
+// Class representing patterns within a SlicePattern, with a rest pattern
+// included
+class SlicePatternItemsHasRest : public SlicePatternItems
+{
+ std::vector<std::unique_ptr<Pattern>> lower_patterns;
+ std::vector<std::unique_ptr<Pattern>> upper_patterns;
+
+public:
+ SlicePatternItemsHasRest (
+ std::vector<std::unique_ptr<Pattern>> lower_patterns,
+ std::vector<std::unique_ptr<Pattern>> upper_patterns)
+ : lower_patterns (std::move (lower_patterns)),
+ upper_patterns (std::move (upper_patterns))
+ {}
+
+ // Copy constructor with vector clone
+ SlicePatternItemsHasRest (SlicePatternItemsHasRest const &other)
+ {
+ lower_patterns.reserve (other.lower_patterns.size ());
+ for (const auto &e : other.lower_patterns)
+ lower_patterns.push_back (e->clone_pattern ());
+
+ upper_patterns.reserve (other.upper_patterns.size ());
+ for (const auto &e : other.upper_patterns)
+ upper_patterns.push_back (e->clone_pattern ());
+ }
+
+ // Overloaded assignment operator to clone
+ SlicePatternItemsHasRest &operator= (SlicePatternItemsHasRest const &other)
+ {
+ lower_patterns.clear ();
+ lower_patterns.reserve (other.lower_patterns.size ());
+ for (const auto &e : other.lower_patterns)
+ lower_patterns.push_back (e->clone_pattern ());
+
+ lower_patterns.clear ();
+ upper_patterns.reserve (other.upper_patterns.size ());
+ for (const auto &e : other.upper_patterns)
+ upper_patterns.push_back (e->clone_pattern ());
+
+ return *this;
+ }
+
+ // move constructors
+ SlicePatternItemsHasRest (SlicePatternItemsHasRest &&other) = default;
+ SlicePatternItemsHasRest &operator= (SlicePatternItemsHasRest &&other)
+ = default;
+
+ std::string as_string () const override;
+
+ void accept_vis (HIRFullVisitor &vis) override;
+
+ ItemType get_item_type () const override { return ItemType::HAS_REST; }
+
+ std::vector<std::unique_ptr<Pattern>> &get_lower_patterns ()
+ {
+ return lower_patterns;
+ }
+ const std::vector<std::unique_ptr<Pattern>> &get_lower_patterns () const
+ {
+ return lower_patterns;
+ }
+
+ std::vector<std::unique_ptr<Pattern>> &get_upper_patterns ()
+ {
+ return upper_patterns;
+ }
+ const std::vector<std::unique_ptr<Pattern>> &get_upper_patterns () const
+ {
+ return upper_patterns;
+ }
+
+protected:
+ /* Use covariance to implement clone function as returning this object rather
+ * than base */
+ SlicePatternItemsHasRest *clone_pattern_items_impl () const override
+ {
+ return new SlicePatternItemsHasRest (*this);
+ }
+};
+
// HIR node representing patterns that can match slices and arrays
class SlicePattern : public Pattern
{
- std::vector<std::unique_ptr<Pattern>> items;
+ std::unique_ptr<SlicePatternItems> items;
location_t locus;
Analysis::NodeMapping mappings;
@@ -1245,30 +1413,23 @@ public:
std::string as_string () const override;
SlicePattern (Analysis::NodeMapping mappings,
- std::vector<std::unique_ptr<Pattern>> items, location_t locus)
+ std::unique_ptr<SlicePatternItems> items, location_t locus)
: items (std::move (items)), locus (locus), mappings (mappings)
{}
- // Copy constructor with vector clone
+ // Copy constructor requires clone
SlicePattern (SlicePattern const &other)
- : locus (other.locus), mappings (other.mappings)
- {
- items.reserve (other.items.size ());
- for (const auto &e : other.items)
- items.push_back (e->clone_pattern ());
- }
+ : items (other.items->clone_slice_pattern_items ()), locus (other.locus),
+ mappings (other.mappings)
+ {}
// Overloaded assignment operator to vector clone
SlicePattern &operator= (SlicePattern const &other)
{
+ items = other.items->clone_slice_pattern_items ();
locus = other.locus;
mappings = other.mappings;
- items.clear ();
- items.reserve (other.items.size ());
- for (const auto &e : other.items)
- items.push_back (e->clone_pattern ());
-
return *this;
}
@@ -1276,11 +1437,8 @@ public:
SlicePattern (SlicePattern &&other) = default;
SlicePattern &operator= (SlicePattern &&other) = default;
- std::vector<std::unique_ptr<Pattern>> &get_items () { return items; }
- const std::vector<std::unique_ptr<Pattern>> &get_items () const
- {
- return items;
- }
+ SlicePatternItems &get_items () { return *items; }
+ const SlicePatternItems &get_items () const { return *items; }
location_t get_locus () const override { return locus; }
diff --git a/gcc/rust/hir/tree/rust-hir-visitor.cc b/gcc/rust/hir/tree/rust-hir-visitor.cc
index 58c1e1a..1e201a5 100644
--- a/gcc/rust/hir/tree/rust-hir-visitor.cc
+++ b/gcc/rust/hir/tree/rust-hir-visitor.cc
@@ -1023,14 +1023,14 @@ DefaultHIRVisitor::walk (StructPattern &pattern)
}
void
-DefaultHIRVisitor::walk (TupleStructItemsNoRange &tuple_items)
+DefaultHIRVisitor::walk (TupleStructItemsNoRest &tuple_items)
{
for (auto &item : tuple_items.get_patterns ())
item->accept_vis (*this);
}
void
-DefaultHIRVisitor::walk (TupleStructItemsRange &tuple_items)
+DefaultHIRVisitor::walk (TupleStructItemsHasRest &tuple_items)
{
for (auto &lower : tuple_items.get_lower_patterns ())
lower->accept_vis (*this);
@@ -1046,14 +1046,14 @@ DefaultHIRVisitor::walk (TupleStructPattern &pattern)
}
void
-DefaultHIRVisitor::walk (TuplePatternItemsMultiple &tuple_items)
+DefaultHIRVisitor::walk (TuplePatternItemsNoRest &tuple_items)
{
for (auto &pattern : tuple_items.get_patterns ())
pattern->accept_vis (*this);
}
void
-DefaultHIRVisitor::walk (TuplePatternItemsRanged &tuple_items)
+DefaultHIRVisitor::walk (TuplePatternItemsHasRest &tuple_items)
{
for (auto &lower : tuple_items.get_lower_patterns ())
lower->accept_vis (*this);
@@ -1068,10 +1068,25 @@ DefaultHIRVisitor::walk (TuplePattern &pattern)
}
void
+DefaultHIRVisitor::walk (SlicePatternItemsNoRest &items)
+{
+ for (auto &pattern : items.get_patterns ())
+ pattern->accept_vis (*this);
+}
+
+void
+DefaultHIRVisitor::walk (SlicePatternItemsHasRest &items)
+{
+ for (auto &lower : items.get_lower_patterns ())
+ lower->accept_vis (*this);
+ for (auto &upper : items.get_upper_patterns ())
+ upper->accept_vis (*this);
+}
+
+void
DefaultHIRVisitor::walk (SlicePattern &pattern)
{
- for (auto &item : pattern.get_items ())
- item->accept_vis (*this);
+ pattern.get_items ().accept_vis (*this);
}
void
diff --git a/gcc/rust/hir/tree/rust-hir-visitor.h b/gcc/rust/hir/tree/rust-hir-visitor.h
index 7996260..77760b0 100644
--- a/gcc/rust/hir/tree/rust-hir-visitor.h
+++ b/gcc/rust/hir/tree/rust-hir-visitor.h
@@ -132,12 +132,14 @@ public:
virtual void visit (StructPatternFieldIdentPat &field) = 0;
virtual void visit (StructPatternFieldIdent &field) = 0;
virtual void visit (StructPattern &pattern) = 0;
- virtual void visit (TupleStructItemsNoRange &tuple_items) = 0;
- virtual void visit (TupleStructItemsRange &tuple_items) = 0;
+ virtual void visit (TupleStructItemsNoRest &tuple_items) = 0;
+ virtual void visit (TupleStructItemsHasRest &tuple_items) = 0;
virtual void visit (TupleStructPattern &pattern) = 0;
- virtual void visit (TuplePatternItemsMultiple &tuple_items) = 0;
- virtual void visit (TuplePatternItemsRanged &tuple_items) = 0;
+ virtual void visit (TuplePatternItemsNoRest &tuple_items) = 0;
+ virtual void visit (TuplePatternItemsHasRest &tuple_items) = 0;
virtual void visit (TuplePattern &pattern) = 0;
+ virtual void visit (SlicePatternItemsNoRest &items) = 0;
+ virtual void visit (SlicePatternItemsHasRest &items) = 0;
virtual void visit (SlicePattern &pattern) = 0;
virtual void visit (AltPattern &pattern) = 0;
virtual void visit (EmptyStmt &stmt) = 0;
@@ -305,12 +307,14 @@ public:
}
virtual void visit (StructPatternFieldIdent &node) override { walk (node); }
virtual void visit (StructPattern &node) override { walk (node); }
- virtual void visit (TupleStructItemsNoRange &node) override { walk (node); }
- virtual void visit (TupleStructItemsRange &node) override { walk (node); }
+ virtual void visit (TupleStructItemsNoRest &node) override { walk (node); }
+ virtual void visit (TupleStructItemsHasRest &node) override { walk (node); }
virtual void visit (TupleStructPattern &node) override { walk (node); }
- virtual void visit (TuplePatternItemsMultiple &node) override { walk (node); }
- virtual void visit (TuplePatternItemsRanged &node) override { walk (node); }
+ virtual void visit (TuplePatternItemsNoRest &node) override { walk (node); }
+ virtual void visit (TuplePatternItemsHasRest &node) override { walk (node); }
virtual void visit (TuplePattern &node) override { walk (node); }
+ virtual void visit (SlicePatternItemsNoRest &node) override { walk (node); }
+ virtual void visit (SlicePatternItemsHasRest &node) override { walk (node); }
virtual void visit (SlicePattern &node) override { walk (node); }
virtual void visit (AltPattern &node) override { walk (node); }
virtual void visit (EmptyStmt &node) override { walk (node); }
@@ -438,12 +442,14 @@ protected:
virtual void walk (StructPatternFieldIdentPat &) final;
virtual void walk (StructPatternFieldIdent &) final;
virtual void walk (StructPattern &) final;
- virtual void walk (TupleStructItemsNoRange &) final;
- virtual void walk (TupleStructItemsRange &) final;
+ virtual void walk (TupleStructItemsNoRest &) final;
+ virtual void walk (TupleStructItemsHasRest &) final;
virtual void walk (TupleStructPattern &) final;
- virtual void walk (TuplePatternItemsMultiple &) final;
- virtual void walk (TuplePatternItemsRanged &) final;
+ virtual void walk (TuplePatternItemsNoRest &) final;
+ virtual void walk (TuplePatternItemsHasRest &) final;
virtual void walk (TuplePattern &) final;
+ virtual void walk (SlicePatternItemsNoRest &) final;
+ virtual void walk (SlicePatternItemsHasRest &) final;
virtual void walk (SlicePattern &) final;
virtual void walk (AltPattern &) final;
virtual void walk (EmptyStmt &) final;
@@ -586,13 +592,16 @@ public:
virtual void visit (StructPatternFieldIdent &) override {}
virtual void visit (StructPattern &) override {}
- virtual void visit (TupleStructItemsNoRange &) override {}
- virtual void visit (TupleStructItemsRange &) override {}
+ virtual void visit (TupleStructItemsNoRest &) override {}
+ virtual void visit (TupleStructItemsHasRest &) override {}
virtual void visit (TupleStructPattern &) override {}
- virtual void visit (TuplePatternItemsMultiple &) override {}
- virtual void visit (TuplePatternItemsRanged &) override {}
+ virtual void visit (TuplePatternItemsNoRest &) override {}
+ virtual void visit (TuplePatternItemsHasRest &) override {}
virtual void visit (TuplePattern &) override {}
+
+ virtual void visit (SlicePatternItemsNoRest &) override {}
+ virtual void visit (SlicePatternItemsHasRest &) override {}
virtual void visit (SlicePattern &) override {}
virtual void visit (AltPattern &) override {}
diff --git a/gcc/rust/hir/tree/rust-hir.cc b/gcc/rust/hir/tree/rust-hir.cc
index a802e8c..ce10b02 100644
--- a/gcc/rust/hir/tree/rust-hir.cc
+++ b/gcc/rust/hir/tree/rust-hir.cc
@@ -2239,8 +2239,8 @@ PathPattern::convert_to_simple_path (bool with_opening_scope_resolution) const
// create segment and add to vector
std::string segment_str = segment.as_string ();
- simple_segments.push_back (
- AST::SimplePathSegment (std::move (segment_str), segment.get_locus ()));
+ simple_segments.emplace_back (std::move (segment_str),
+ segment.get_locus ());
}
// kind of a HACK to get locus depending on opening scope resolution
@@ -2281,9 +2281,8 @@ TypePath::as_simple_path () const
// create segment and add to vector
std::string segment_str = segment->as_string ();
- simple_segments.push_back (
- AST::SimplePathSegment (std::move (segment_str),
- segment->get_locus ()));
+ simple_segments.emplace_back (std::move (segment_str),
+ segment->get_locus ());
}
return AST::SimplePath (std::move (simple_segments),
@@ -2387,11 +2386,11 @@ RangePatternBoundLiteral::as_string () const
}
std::string
-SlicePattern::as_string () const
+SlicePatternItemsNoRest::as_string () const
{
- std::string str ("SlicePattern: ");
+ std::string str;
- for (const auto &pattern : items)
+ for (const auto &pattern : patterns)
{
str += "\n " + pattern->as_string ();
}
@@ -2400,6 +2399,46 @@ SlicePattern::as_string () const
}
std::string
+SlicePatternItemsHasRest::as_string () const
+{
+ std::string str;
+
+ str += "\n Lower patterns: ";
+ if (lower_patterns.empty ())
+ {
+ str += "none";
+ }
+ else
+ {
+ for (const auto &lower : lower_patterns)
+ {
+ str += "\n " + lower->as_string ();
+ }
+ }
+
+ str += "\n Upper patterns: ";
+ if (upper_patterns.empty ())
+ {
+ str += "none";
+ }
+ else
+ {
+ for (const auto &upper : upper_patterns)
+ {
+ str += "\n " + upper->as_string ();
+ }
+ }
+
+ return str;
+}
+
+std::string
+SlicePattern::as_string () const
+{
+ return "SlicePattern: " + items->as_string ();
+}
+
+std::string
AltPattern::as_string () const
{
std::string str ("AltPattern: ");
@@ -2413,7 +2452,7 @@ AltPattern::as_string () const
}
std::string
-TuplePatternItemsMultiple::as_string () const
+TuplePatternItemsNoRest::as_string () const
{
std::string str;
@@ -2426,7 +2465,7 @@ TuplePatternItemsMultiple::as_string () const
}
std::string
-TuplePatternItemsRanged::as_string () const
+TuplePatternItemsHasRest::as_string () const
{
std::string str;
@@ -2480,10 +2519,29 @@ StructPatternField::as_string () const
* just the body */
for (const auto &attr : outer_attrs)
{
- str += "\n " + attr.as_string ();
+ str += "\n " + attr.as_string ();
}
}
+ str += "\n item type: ";
+ switch (get_item_type ())
+ {
+ case ItemType::TUPLE_PAT:
+ str += "TUPLE_PAT";
+ break;
+ case ItemType::IDENT_PAT:
+ str += "IDENT_PAT";
+ break;
+ case ItemType::IDENT:
+ str += "IDENT";
+ break;
+ default:
+ str += "UNKNOWN";
+ break;
+ }
+
+ str += "\n mapping: " + mappings.as_string ();
+
return str;
}
@@ -2620,7 +2678,7 @@ IdentifierPattern::as_string () const
}
std::string
-TupleStructItemsNoRange::as_string () const
+TupleStructItemsNoRest::as_string () const
{
std::string str;
@@ -2633,7 +2691,7 @@ TupleStructItemsNoRange::as_string () const
}
std::string
-TupleStructItemsRange::as_string () const
+TupleStructItemsHasRest::as_string () const
{
std::string str ("\n Lower patterns: ");
@@ -4471,13 +4529,13 @@ StructPattern::accept_vis (HIRFullVisitor &vis)
}
void
-TupleStructItemsNoRange::accept_vis (HIRFullVisitor &vis)
+TupleStructItemsNoRest::accept_vis (HIRFullVisitor &vis)
{
vis.visit (*this);
}
void
-TupleStructItemsRange::accept_vis (HIRFullVisitor &vis)
+TupleStructItemsHasRest::accept_vis (HIRFullVisitor &vis)
{
vis.visit (*this);
}
@@ -4489,13 +4547,13 @@ TupleStructPattern::accept_vis (HIRFullVisitor &vis)
}
void
-TuplePatternItemsMultiple::accept_vis (HIRFullVisitor &vis)
+TuplePatternItemsNoRest::accept_vis (HIRFullVisitor &vis)
{
vis.visit (*this);
}
void
-TuplePatternItemsRanged::accept_vis (HIRFullVisitor &vis)
+TuplePatternItemsHasRest::accept_vis (HIRFullVisitor &vis)
{
vis.visit (*this);
}
@@ -4507,6 +4565,18 @@ TuplePattern::accept_vis (HIRFullVisitor &vis)
}
void
+SlicePatternItemsNoRest::accept_vis (HIRFullVisitor &vis)
+{
+ vis.visit (*this);
+}
+
+void
+SlicePatternItemsHasRest::accept_vis (HIRFullVisitor &vis)
+{
+ vis.visit (*this);
+}
+
+void
SlicePattern::accept_vis (HIRFullVisitor &vis)
{
vis.visit (*this);
generated by cgit v1.1 at 2025-11-02 19:28:42 +0000