rust/rust-compile-resolve-path.o \
rust/rust-macro-expand.o \
rust/rust-attribute-visitor.o \
+ rust/rust-expand-visitor.o \
rust/rust-macro-invoc-lexer.o \
rust/rust-macro-substitute-ctx.o \
rust/rust-macro-builtins.o \
crate.strip_crate ();
// TODO: maybe create warning here? probably not desired behaviour
}
+
+ auto &items = crate.items;
+
+ for (auto it = items.begin (); it != items.end ();)
+ {
+ auto &item = *it;
+ item->accept_vis (*this);
+
+ if (item->is_marked_for_strip ())
+ it = items.erase (it);
+ else
+ it++;
+ }
+
// expand module attributes?
}
continue;
}
- expander.push_context (MacroExpander::ContextType::TYPE);
-
// expand sub-types of type, but can't strip type itself
auto &type = field.get_field_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (),
"cannot strip type in this position");
- expander.pop_context ();
-
// if nothing else happens, increment
++it;
}
void
AttrVisitor::expand_function_params (std::vector<AST::FunctionParam> ¶ms)
{
- expander.push_context (MacroExpander::ContextType::TYPE);
-
for (auto it = params.begin (); it != params.end ();)
{
auto ¶m = *it;
auto &type = param.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (),
"cannot strip type in this position");
// increment
++it;
}
-
- expander.pop_context ();
}
void
// lifetime args can't be expanded
// FIXME: Can we have macro invocations for lifetimes?
- expander.push_context (MacroExpander::ContextType::TYPE);
-
// expand type args - strip sub-types only
for (auto &arg : args.get_generic_args ())
{
case AST::GenericArg::Kind::Type: {
auto &type = arg.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (),
case AST::GenericArg::Kind::Const: {
auto &expr = arg.get_expression ();
expr->accept_vis (*this);
- maybe_expand_expr (expr);
if (expr->is_marked_for_strip ())
rust_error_at (expr->get_locus (),
}
}
- expander.pop_context ();
-
// FIXME: Can we have macro invocations in generic type bindings?
// expand binding args - strip sub-types only
for (auto &binding : args.get_binding_args ())
void
AttrVisitor::expand_qualified_path_type (AST::QualifiedPathType &path_type)
{
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &type = path_type.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
- expander.pop_context ();
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (), "cannot strip type in this position");
if (param.has_type_given ())
{
- expander.push_context (MacroExpander::ContextType::TYPE);
auto &type = param.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (),
"cannot strip type in this position");
-
- expander.pop_context ();
}
// increment if found nothing else so far
{
if (self_param.has_type ())
{
- expander.push_context (MacroExpander::ContextType::TYPE);
auto &type = self_param.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (),
"cannot strip type in this position");
-
- expander.pop_context ();
}
/* TODO: maybe check for invariants being violated - e.g. both type and
* lifetime? */
if (decl.has_return_type ())
{
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &return_type = decl.get_return_type ();
return_type->accept_vis (*this);
- maybe_expand_type (return_type);
-
if (return_type->is_marked_for_strip ())
rust_error_at (return_type->get_locus (),
"cannot strip type in this position");
-
- expander.pop_context ();
}
if (decl.has_where_clause ())
if (decl.has_return_type ())
{
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &return_type = decl.get_return_type ();
return_type->accept_vis (*this);
- maybe_expand_type (return_type);
-
if (return_type->is_marked_for_strip ())
rust_error_at (return_type->get_locus (),
"cannot strip type in this position");
-
- expander.pop_context ();
}
if (decl.has_where_clause ())
// I don't think any macro token trees can be stripped in any way
// TODO: maybe have cfg! macro stripping behaviour here?
- expander.expand_invoc (macro_invoc, macro_invoc.has_semicolon ());
}
void
if (type_path_function.has_return_type ())
{
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &return_type = type_path_function.get_return_type ();
return_type->accept_vis (*this);
- maybe_expand_type (return_type);
-
if (return_type->is_marked_for_strip ())
rust_error_at (return_type->get_locus (),
"cannot strip type in this position");
-
- expander.pop_context ();
}
}
void
* with outer expr */
auto &l_expr = expr.get_left_expr ();
l_expr->accept_vis (*this);
- maybe_expand_expr (l_expr);
/* should syntactically not have outer attributes, though this may
* not have worked in practice */
auto &r_expr = expr.get_right_expr ();
r_expr->accept_vis (*this);
- maybe_expand_expr (r_expr);
// ensure that they are not marked for strip
if (expr.get_left_expr ()->is_marked_for_strip ())
* with outer expr */
auto &l_expr = expr.get_left_expr ();
l_expr->accept_vis (*this);
- maybe_expand_expr (l_expr);
/* should syntactically not have outer attributes, though this may
* not have worked in practice */
auto &r_expr = expr.get_right_expr ();
r_expr->accept_vis (*this);
- maybe_expand_expr (r_expr);
// ensure that they are not marked for strip
if (expr.get_left_expr ()->is_marked_for_strip ())
* with outer expr */
auto &l_expr = expr.get_left_expr ();
l_expr->accept_vis (*this);
- maybe_expand_expr (l_expr);
/* should syntactically not have outer attributes, though this may
* not have worked in practice */
auto &r_expr = expr.get_right_expr ();
r_expr->accept_vis (*this);
- maybe_expand_expr (r_expr);
// ensure that they are not marked for strip
if (expr.get_left_expr ()->is_marked_for_strip ())
* with outer expr */
auto &l_expr = expr.get_left_expr ();
l_expr->accept_vis (*this);
- maybe_expand_expr (l_expr);
/* should syntactically not have outer attributes, though this may
* not have worked in practice */
auto &r_expr = expr.get_right_expr ();
r_expr->accept_vis (*this);
- maybe_expand_expr (r_expr);
// ensure that they are not marked for strip
if (expr.get_left_expr ()->is_marked_for_strip ())
* with outer expr */
auto &l_expr = expr.get_left_expr ();
l_expr->accept_vis (*this);
- maybe_expand_expr (l_expr);
/* should syntactically not have outer attributes, though this may
* not have worked in practice */
auto &r_expr = expr.get_right_expr ();
r_expr->accept_vis (*this);
- maybe_expand_expr (r_expr);
// ensure that they are not marked for strip
if (expr.get_left_expr ()->is_marked_for_strip ())
// FIXME: Arthur: Figure out how to refactor this - This is similar to
// expanding items in the crate or stmts in blocks
expand_pointer_allow_strip (expr.get_params ());
- auto ¶ms = expr.get_params ();
- for (auto it = params.begin (); it != params.end ();)
- {
- auto &stmt = *it;
-
- stmt->accept_vis (*this);
-
- auto final_fragment = expander.take_expanded_fragment ();
- if (final_fragment.should_expand ())
- {
- // Remove the current expanded invocation
- it = params.erase (it);
- for (auto &node : final_fragment.get_nodes ())
- {
- it = params.insert (it, node.take_expr ());
- it++;
- }
- }
- else if (stmt->is_marked_for_strip ())
- it = params.erase (it);
- else
- it++;
- }
}
void
AttrVisitor::visit (AST::MethodCallExpr &expr)
return;
}
- std::function<std::unique_ptr<AST::Stmt> (AST::SingleASTNode)> extractor
- = [] (AST::SingleASTNode node) { return node.take_stmt (); };
-
- expand_macro_children (MacroExpander::ContextType::BLOCK,
- expr.get_statements (), extractor);
-
- expander.push_context (MacroExpander::ContextType::BLOCK);
+ expand_pointer_allow_strip (expr.get_statements ());
// strip tail expression if exists - can actually fully remove it
if (expr.has_tail_expr ())
auto &tail_expr = expr.get_tail_expr ();
tail_expr->accept_vis (*this);
- maybe_expand_expr (tail_expr);
if (tail_expr->is_marked_for_strip ())
expr.strip_tail_expr ();
}
- expander.pop_context ();
}
void
* allowed by spec */
expand_closure_params (expr.get_params ());
- expander.push_context (MacroExpander::ContextType::TYPE);
-
// can't strip return type, but can strip sub-types
auto &type = expr.get_return_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (), "cannot strip type in this position");
- expander.pop_context ();
-
// can't strip expression itself, but can strip sub-expressions
auto &definition_block = expr.get_definition_block ();
definition_block->accept_vis (*this);
// can't strip condition expr itself, but can strip sub-expressions
auto &condition_expr = expr.get_condition_expr ();
condition_expr->accept_vis (*this);
- maybe_expand_expr (condition_expr);
if (condition_expr->is_marked_for_strip ())
rust_error_at (condition_expr->get_locus (),
"cannot strip expression in this position - outer "
// can't strip condition expr itself, but can strip sub-expressions
auto &condition_expr = expr.get_condition_expr ();
condition_expr->accept_vis (*this);
- maybe_expand_expr (condition_expr);
if (condition_expr->is_marked_for_strip ())
rust_error_at (condition_expr->get_locus (),
"cannot strip expression in this position - outer "
// can't strip condition expr itself, but can strip sub-expressions
auto &condition_expr = expr.get_condition_expr ();
condition_expr->accept_vis (*this);
- maybe_expand_expr (condition_expr);
if (condition_expr->is_marked_for_strip ())
rust_error_at (condition_expr->get_locus (),
"cannot strip expression in this position - outer "
// can't strip condition expr itself, but can strip sub-expressions
auto &condition_expr = expr.get_condition_expr ();
condition_expr->accept_vis (*this);
- maybe_expand_expr (condition_expr);
if (condition_expr->is_marked_for_strip ())
rust_error_at (condition_expr->get_locus (),
"cannot strip expression in this position - outer "
if (param.has_type ())
{
- expander.push_context (MacroExpander::ContextType::TYPE);
auto &type = param.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (),
"cannot strip type in this position");
-
- expander.pop_context ();
}
}
void
{
// for lifetimes shouldn't require
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &type = item.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (), "cannot strip type in this position");
- expander.pop_context ();
-
// don't strip directly, only components of bounds
for (auto &bound : item.get_type_param_bounds ())
bound->accept_vis (*this);
if (method.has_return_type ())
{
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &return_type = method.get_return_type ();
return_type->accept_vis (*this);
- maybe_expand_type (return_type);
-
if (return_type->is_marked_for_strip ())
rust_error_at (return_type->get_locus (),
"cannot strip type in this position");
-
- expander.pop_context ();
}
if (method.has_where_clause ())
if (function.has_return_type ())
{
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &return_type = function.get_return_type ();
return_type->accept_vis (*this);
- maybe_expand_type (return_type);
-
if (return_type->is_marked_for_strip ())
rust_error_at (return_type->get_locus (),
"cannot strip type in this position");
-
- expander.pop_context ();
}
if (function.has_where_clause ())
if (struct_item.has_where_clause ())
expand_where_clause (struct_item.get_where_clause ());
-
- /* strip struct fields if required - this is presumably
- * allowed by spec */
- expand_struct_fields (struct_item.get_fields ());
}
void
AttrVisitor::visit (AST::TupleStruct &tuple_struct)
return;
}
- expander.push_context (MacroExpander::ContextType::TYPE);
-
// strip any sub-types
auto &type = const_item.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (), "cannot strip type in this position");
- expander.pop_context ();
-
/* strip any internal sub-expressions - expression itself isn't
* allowed to have external attributes in this position so can't be
* stripped. */
return;
}
- expander.push_context (MacroExpander::ContextType::TYPE);
-
// strip any sub-types
auto &type = static_item.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (), "cannot strip type in this position");
- expander.pop_context ();
-
/* strip any internal sub-expressions - expression itself isn't
* allowed to have external attributes in this position so can't be
* stripped. */
return;
}
- expander.push_context (MacroExpander::ContextType::TYPE);
-
// strip any sub-types
auto &type = item.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (), "cannot strip type in this position");
- expander.pop_context ();
-
/* strip any internal sub-expressions - expression itself isn't
* allowed to have external attributes in this position so can't be
* stripped */
if (trait.has_where_clause ())
expand_where_clause (trait.get_where_clause ());
- std::function<std::unique_ptr<AST::TraitItem> (AST::SingleASTNode)> extractor
- = [] (AST::SingleASTNode node) { return node.take_trait_item (); };
-
- expand_macro_children (MacroExpander::ContextType::TRAIT,
- trait.get_trait_items (), extractor);
+ expand_pointer_allow_strip (trait.get_trait_items ());
}
void
AttrVisitor::visit (AST::InherentImpl &impl)
for (auto ¶m : impl.get_generic_params ())
param->accept_vis (*this);
- expander.push_context (MacroExpander::ContextType::ITEM);
-
auto &type = impl.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (), "cannot strip type in this position");
- expander.pop_context ();
-
if (impl.has_where_clause ())
expand_where_clause (impl.get_where_clause ());
- std::function<std::unique_ptr<AST::InherentImplItem> (AST::SingleASTNode)>
- extractor = [] (AST::SingleASTNode node) { return node.take_impl_item (); };
-
- expand_macro_children (MacroExpander::ContextType::IMPL,
- impl.get_impl_items (), extractor);
+ expand_pointer_allow_strip (impl.get_impl_items ());
}
void
AttrVisitor::visit (AST::TraitImpl &impl)
for (auto ¶m : impl.get_generic_params ())
param->accept_vis (*this);
- expander.push_context (MacroExpander::ContextType::ITEM);
-
auto &type = impl.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (), "cannot strip type in this position");
- expander.pop_context ();
-
auto &trait_path = impl.get_trait_path ();
visit (trait_path);
if (trait_path.is_marked_for_strip ())
if (impl.has_where_clause ())
expand_where_clause (impl.get_where_clause ());
- std::function<std::unique_ptr<AST::TraitImplItem> (AST::SingleASTNode)>
- extractor
- = [] (AST::SingleASTNode node) { return node.take_trait_impl_item (); };
-
- expand_macro_children (MacroExpander::ContextType::TRAIT_IMPL,
- impl.get_impl_items (), extractor);
+ expand_pointer_allow_strip (impl.get_impl_items ());
}
void
return;
}
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &type = item.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (), "cannot strip type in this position");
-
- expander.pop_context ();
}
void
continue;
}
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &type = param.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (),
"cannot strip type in this position");
- expander.pop_context ();
-
// increment if nothing else happens
++it;
}
if (item.has_return_type ())
{
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &return_type = item.get_return_type ();
return_type->accept_vis (*this);
- maybe_expand_type (return_type);
-
if (return_type->is_marked_for_strip ())
rust_error_at (return_type->get_locus (),
"cannot strip type in this position");
-
- expander.pop_context ();
}
if (item.has_where_clause ())
return;
}
- std::function<std::unique_ptr<AST::ExternalItem> (AST::SingleASTNode)>
- extractor
- = [] (AST::SingleASTNode node) { return node.take_external_item (); };
-
- expand_macro_children (MacroExpander::ContextType::EXTERN,
- block.get_extern_items (), extractor);
+ expand_pointer_allow_strip (block.get_extern_items ());
}
// I don't think it would be possible to strip macros without expansion
// similar for type
if (stmt.has_type ())
{
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &type = stmt.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (),
"cannot strip type in this position");
-
- expander.pop_context ();
}
/* strip any internal sub-expressions - expression itself isn't
rust_error_at (init_expr->get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
-
- maybe_expand_expr (init_expr);
}
}
void
continue;
}
- expander.push_context (MacroExpander::ContextType::TYPE);
-
auto &type = param.get_type ();
type->accept_vis (*this);
- maybe_expand_type (type);
-
if (type->is_marked_for_strip ())
rust_error_at (type->get_locus (),
"cannot strip type in this position");
- expander.pop_context ();
-
// increment if nothing else happens
++it;
}
// no where clause, apparently
}
-void
-AttrVisitor::maybe_expand_expr (std::unique_ptr<AST::Expr> &expr)
-{
- auto final_fragment = expander.take_expanded_fragment ();
- if (final_fragment.should_expand ()
- && final_fragment.is_expression_fragment ())
- expr = final_fragment.take_expression_fragment ();
-}
-
-void
-AttrVisitor::maybe_expand_type (std::unique_ptr<AST::Type> &type)
-{
- auto final_fragment = expander.take_expanded_fragment ();
- if (final_fragment.should_expand () && final_fragment.is_type_fragment ())
- type = final_fragment.take_type_fragment ();
-}
-
} // namespace Rust
class AttrVisitor : public AST::ASTVisitor
{
private:
- MacroExpander &expander;
- void maybe_expand_expr (std::unique_ptr<AST::Expr> &expr);
- void maybe_expand_type (std::unique_ptr<AST::Type> &expr);
-
public:
- AttrVisitor (MacroExpander &expander) : expander (expander) {}
+ AttrVisitor () {}
/* Run the AttrVisitor on an entire crate */
void go (AST::Crate &crate);
void expand_trait_method_decl (AST::TraitMethodDecl &decl);
/**
- * Expand a set of values, erasing them if they are marked for strip, and
- * replacing them with expanded macro nodes if necessary.
- * This function is slightly different from `expand_pointer_allow_strip` as
- * it can only be called in certain expansion contexts - where macro
- * invocations are allowed.
+ * Expand a set of values, erasing them if they are marked for strip.
*
- * @param ctx Context to use for macro expansion
* @param values Iterable reference over values to replace or erase
- * @param extractor Function to call when replacing values with the content
- * of an expanded AST node
*/
- template <typename T, typename U>
- void expand_macro_children (MacroExpander::ContextType ctx, T &values,
- std::function<U (AST::SingleASTNode)> extractor)
- {
- expander.push_context (ctx);
-
- for (auto it = values.begin (); it != values.end ();)
- {
- auto &value = *it;
-
- // mark for stripping if required
- value->accept_vis (*this);
-
- auto final_fragment = expander.take_expanded_fragment ();
-
- if (final_fragment.should_expand ())
- {
- it = values.erase (it);
- for (auto &node : final_fragment.get_nodes ())
- {
- auto new_node = extractor (node);
- if (new_node != nullptr && !new_node->is_marked_for_strip ())
- {
- it = values.insert (it, std::move (new_node));
- it++;
- }
- }
- }
- else if (value->is_marked_for_strip ())
- {
- it = values.erase (it);
- }
- else
- {
- ++it;
- }
- }
-
- expander.pop_context ();
- }
-
template <typename T> void expand_pointer_allow_strip (T &values)
{
for (auto it = values.begin (); it != values.end ();)
// mark for stripping if required
value->accept_vis (*this);
if (value->is_marked_for_strip ())
- {
- it = values.erase (it);
- }
+ it = values.erase (it);
else
- {
- ++it;
- }
+ ++it;
}
}
--- /dev/null
+// Copyright (C) 2020-2023 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-expand-visitor.h"
+
+namespace Rust {
+
+/* Expand all of the macro invocations currently contained in a crate */
+void
+ExpandVisitor::go (AST::Crate &crate)
+{
+ expander.push_context (MacroExpander::ContextType::ITEM);
+
+ // expand attributes recursively and strip items if required
+ // AttrVisitor attr_visitor (*this);
+ auto &items = crate.items;
+ for (auto it = items.begin (); it != items.end ();)
+ {
+ auto &item = *it;
+ item->accept_vis (*this);
+
+ auto fragment = expander.take_expanded_fragment ();
+ if (fragment.should_expand ())
+ {
+ // Remove the current expanded invocation
+ it = items.erase (it);
+ for (auto &node : fragment.get_nodes ())
+ {
+ it = items.insert (it, node.take_item ());
+ it++;
+ }
+ }
+ else
+ it++;
+ }
+
+ expander.pop_context ();
+}
+
+void
+ExpandVisitor::maybe_expand_expr (std::unique_ptr<AST::Expr> &expr)
+{
+ // FIXME: ARTHUR: Why isn't there a ContextType::EXPR? We can only
+ // reach `parse_expr` once in MacroExpander::transcribe_rule(), but it
+ // would make things clearer wouldn't it?
+ expr->accept_vis (*this);
+
+ auto final_fragment = expander.take_expanded_fragment ();
+ if (final_fragment.should_expand ()
+ && final_fragment.is_expression_fragment ())
+ expr = final_fragment.take_expression_fragment ();
+}
+
+void
+ExpandVisitor::maybe_expand_type (std::unique_ptr<AST::Type> &type)
+{
+ expander.push_context (MacroExpander::ContextType::TYPE);
+
+ type->accept_vis (*this);
+ auto final_fragment = expander.take_expanded_fragment ();
+ if (final_fragment.should_expand () && final_fragment.is_type_fragment ())
+ type = final_fragment.take_type_fragment ();
+
+ expander.pop_context ();
+}
+
+// FIXME: Can this be refactored into a `scoped` method? Which takes a
+// ContextType as parameter and a lambda? And maybe just an std::vector<T>&?
+void
+ExpandVisitor::expand_struct_fields (std::vector<AST::StructField> &fields)
+{
+ for (auto &field : fields)
+ maybe_expand_type (field.get_field_type ());
+}
+
+void
+ExpandVisitor::expand_tuple_fields (std::vector<AST::TupleField> &fields)
+{
+ for (auto &field : fields)
+ maybe_expand_type (field.get_field_type ());
+}
+
+// FIXME: This can definitely be refactored with the method above
+void
+ExpandVisitor::expand_function_params (std::vector<AST::FunctionParam> ¶ms)
+{
+ for (auto ¶m : params)
+ maybe_expand_type (param.get_type ());
+}
+
+void
+ExpandVisitor::expand_generic_args (AST::GenericArgs &args)
+{
+ for (auto &arg : args.get_generic_args ())
+ {
+ switch (arg.get_kind ())
+ {
+ case AST::GenericArg::Kind::Type:
+ maybe_expand_type (arg.get_type ());
+ break;
+ case AST::GenericArg::Kind::Const:
+ maybe_expand_expr (arg.get_expression ());
+ break;
+ default:
+ break;
+ // FIXME: Figure out what to do here if there is ambiguity. Since the
+ // resolver comes after the expansion, we need to figure out a way to
+ // strip ambiguous values here
+ // TODO: ARTHUR: Probably add a `mark_as_strip` method to `GenericArg`
+ // or something. This would clean up this whole thing
+ }
+ }
+
+ // FIXME: Can we have macro invocations in generic type bindings?
+ // expand binding args - strip sub-types only
+ // FIXME: ARTHUR: This needs a test! Foo<Item = macro!()>
+ for (auto &binding : args.get_binding_args ())
+ maybe_expand_type (binding.get_type ());
+}
+
+void
+ExpandVisitor::expand_qualified_path_type (AST::QualifiedPathType &path_type)
+{
+ maybe_expand_type (path_type.get_type ());
+
+ // FIXME: ARTHUR: Can we do macro expansion in there? Needs a test!
+ if (path_type.has_as_clause ())
+ path_type.get_as_type_path ().accept_vis (*this);
+}
+
+void
+ExpandVisitor::expand_closure_params (std::vector<AST::ClosureParam> ¶ms)
+{
+ for (auto ¶m : params)
+ if (param.has_type_given ())
+ maybe_expand_type (param.get_type ());
+}
+
+void
+ExpandVisitor::expand_self_param (AST::SelfParam &self_param)
+{
+ if (self_param.has_type ())
+ maybe_expand_type (self_param.get_type ());
+
+ /* TODO: maybe check for invariants being violated - e.g. both type and
+ * lifetime? */
+}
+
+void
+ExpandVisitor::expand_where_clause (AST::WhereClause &where_clause)
+{
+ for (auto &item : where_clause.get_items ())
+ visit (item);
+}
+
+void
+ExpandVisitor::expand_trait_function_decl (AST::TraitFunctionDecl &decl)
+{
+ // just expand sub-stuff - can't actually strip generic params themselves
+ for (auto ¶m : decl.get_generic_params ())
+ visit (param);
+
+ /* strip function parameters if required - this is specifically
+ * allowed by spec */
+ expand_function_params (decl.get_function_params ());
+
+ if (decl.has_return_type ())
+ maybe_expand_type (decl.get_return_type ());
+
+ if (decl.has_where_clause ())
+ expand_where_clause (decl.get_where_clause ());
+}
+
+void
+ExpandVisitor::expand_trait_method_decl (AST::TraitMethodDecl &decl)
+{
+ for (auto ¶m : decl.get_generic_params ())
+ visit (param);
+
+ /* assuming you can't strip self param - wouldn't be a method
+ * anymore. spec allows outer attrs on self param, but doesn't
+ * specify whether cfg is used. */
+ expand_self_param (decl.get_self_param ());
+
+ /* strip function parameters if required - this is specifically
+ * allowed by spec */
+ expand_function_params (decl.get_function_params ());
+
+ if (decl.has_return_type ())
+
+ maybe_expand_type (decl.get_return_type ());
+
+ if (decl.has_where_clause ())
+ expand_where_clause (decl.get_where_clause ());
+}
+
+void
+ExpandVisitor::visit (AST::Token &)
+{}
+
+void
+ExpandVisitor::visit (AST::DelimTokenTree &)
+{}
+
+void
+ExpandVisitor::visit (AST::AttrInputMetaItemContainer &)
+{}
+
+void
+ExpandVisitor::visit (AST::IdentifierExpr &ident_expr)
+{}
+
+void
+ExpandVisitor::visit (AST::Lifetime &)
+{}
+
+void
+ExpandVisitor::visit (AST::LifetimeParam &)
+{}
+
+void
+ExpandVisitor::visit (AST::ConstGenericParam &)
+{}
+
+void
+ExpandVisitor::visit (AST::MacroInvocation ¯o_invoc)
+{
+ // TODO: Can we do the AST fragment replacing here? Probably not, right?
+ expander.expand_invoc (macro_invoc, macro_invoc.has_semicolon ());
+}
+
+void
+ExpandVisitor::visit (AST::PathInExpression &path)
+{
+ for (auto &segment : path.get_segments ())
+ if (segment.has_generic_args ())
+ expand_generic_args (segment.get_generic_args ());
+}
+
+void
+ExpandVisitor::visit (AST::TypePathSegment &)
+{}
+
+void
+ExpandVisitor::visit (AST::TypePathSegmentGeneric &segment)
+{}
+
+void
+ExpandVisitor::visit (AST::TypePathSegmentFunction &segment)
+{
+ auto &type_path_function = segment.get_type_path_function ();
+
+ for (auto &type : type_path_function.get_params ())
+ visit (type);
+
+ if (type_path_function.has_return_type ())
+ maybe_expand_type (type_path_function.get_return_type ());
+}
+
+void
+ExpandVisitor::visit (AST::TypePath &path)
+{
+ for (auto &segment : path.get_segments ())
+ visit (segment);
+}
+
+void
+ExpandVisitor::visit (AST::QualifiedPathInExpression &path)
+{
+ expand_qualified_path_type (path.get_qualified_path_type ());
+
+ for (auto &segment : path.get_segments ())
+ if (segment.has_generic_args ())
+ expand_generic_args (segment.get_generic_args ());
+}
+
+void
+ExpandVisitor::visit (AST::QualifiedPathInType &path)
+{
+ expand_qualified_path_type (path.get_qualified_path_type ());
+
+ // this shouldn't strip any segments, but can strip inside them
+ for (auto &segment : path.get_segments ())
+ visit (segment);
+}
+
+void
+ExpandVisitor::visit (AST::LiteralExpr &expr)
+{}
+
+void
+ExpandVisitor::visit (AST::AttrInputLiteral &)
+{}
+
+void
+ExpandVisitor::visit (AST::MetaItemLitExpr &)
+{}
+
+void
+ExpandVisitor::visit (AST::MetaItemPathLit &)
+{}
+
+void
+ExpandVisitor::visit (AST::BorrowExpr &expr)
+{
+ visit (expr.get_borrowed_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::DereferenceExpr &expr)
+{
+ visit (expr.get_dereferenced_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::ErrorPropagationExpr &expr)
+{
+ visit (expr.get_propagating_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::NegationExpr &expr)
+{
+ visit (expr.get_negated_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
+{
+ maybe_expand_expr (expr.get_left_expr ());
+ maybe_expand_expr (expr.get_right_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::ComparisonExpr &expr)
+{
+ maybe_expand_expr (expr.get_left_expr ());
+ maybe_expand_expr (expr.get_right_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::LazyBooleanExpr &expr)
+{
+ maybe_expand_expr (expr.get_left_expr ());
+ maybe_expand_expr (expr.get_right_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::TypeCastExpr &expr)
+{
+ visit (expr.get_casted_expr ());
+
+ visit (expr.get_type_to_cast_to ());
+}
+
+void
+ExpandVisitor::visit (AST::AssignmentExpr &expr)
+{
+ maybe_expand_expr (expr.get_left_expr ());
+ maybe_expand_expr (expr.get_right_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::CompoundAssignmentExpr &expr)
+{
+ maybe_expand_expr (expr.get_left_expr ());
+ maybe_expand_expr (expr.get_right_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::GroupedExpr &expr)
+{
+ visit (expr.get_expr_in_parens ());
+}
+
+void
+ExpandVisitor::visit (AST::ArrayElemsValues &elems)
+{
+ for (auto &elem : elems.get_values ())
+ visit (elem);
+}
+
+void
+ExpandVisitor::visit (AST::ArrayElemsCopied &elems)
+{
+ visit (elems.get_elem_to_copy ());
+ visit (elems.get_num_copies ());
+}
+
+void
+ExpandVisitor::visit (AST::ArrayExpr &expr)
+{
+ visit (expr.get_array_elems ());
+}
+
+void
+ExpandVisitor::visit (AST::ArrayIndexExpr &expr)
+{
+ visit (expr.get_array_expr ());
+ visit (expr.get_index_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::TupleExpr &expr)
+{
+ for (auto &element : expr.get_tuple_elems ())
+ visit (element);
+}
+
+void
+ExpandVisitor::visit (AST::TupleIndexExpr &expr)
+{
+ visit (expr.get_tuple_expr ());
+
+ // We can't have macro invocations for tuple indexes, right? Need a test!
+}
+
+void
+ExpandVisitor::visit (AST::StructExprStruct &expr)
+{}
+
+void
+ExpandVisitor::visit (AST::StructExprFieldIdentifier &)
+{}
+
+void
+ExpandVisitor::visit (AST::StructExprFieldIdentifierValue &field)
+{
+ visit (field.get_value ());
+}
+
+void
+ExpandVisitor::visit (AST::StructExprFieldIndexValue &field)
+{
+ visit (field.get_value ());
+}
+
+void
+ExpandVisitor::visit (AST::StructExprStructFields &expr)
+{
+ for (auto &field : expr.get_fields ())
+ visit (field);
+
+ if (expr.has_struct_base ())
+ visit (expr.get_struct_base ().get_base_struct ());
+}
+
+void
+ExpandVisitor::visit (AST::StructExprStructBase &expr)
+{
+ visit (expr.get_struct_base ().get_base_struct ());
+}
+
+void
+ExpandVisitor::visit (AST::CallExpr &expr)
+{
+ visit (expr.get_function_expr ());
+
+ for (auto ¶m : expr.get_params ())
+ maybe_expand_expr (param);
+}
+
+void
+ExpandVisitor::visit (AST::MethodCallExpr &expr)
+{
+ visit (expr.get_receiver_expr ());
+
+ for (auto ¶m : expr.get_params ())
+ maybe_expand_expr (param);
+}
+
+void
+ExpandVisitor::visit (AST::FieldAccessExpr &expr)
+{
+ visit (expr.get_receiver_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::ClosureExprInner &expr)
+{
+ expand_closure_params (expr.get_params ());
+
+ visit (expr.get_definition_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::BlockExpr &expr)
+{
+ std::function<std::unique_ptr<AST::Stmt> (AST::SingleASTNode)> extractor
+ = [] (AST::SingleASTNode node) { return node.take_stmt (); };
+
+ expand_macro_children (MacroExpander::ContextType::BLOCK,
+ expr.get_statements (), extractor);
+
+ expander.push_context (MacroExpander::ContextType::BLOCK);
+
+ if (expr.has_tail_expr ())
+ maybe_expand_expr (expr.get_tail_expr ());
+
+ expander.pop_context ();
+}
+
+void
+ExpandVisitor::visit (AST::ClosureExprInnerTyped &expr)
+{
+ expand_closure_params (expr.get_params ());
+
+ maybe_expand_type (expr.get_return_type ());
+
+ visit (expr.get_definition_block ());
+}
+
+void
+ExpandVisitor::visit (AST::ContinueExpr &expr)
+{}
+
+void
+ExpandVisitor::visit (AST::BreakExpr &expr)
+{
+ if (expr.has_break_expr ())
+ visit (expr.get_break_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::RangeFromToExpr &expr)
+{
+ visit (expr.get_from_expr ());
+ visit (expr.get_to_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::RangeFromExpr &expr)
+{
+ visit (expr.get_from_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::RangeToExpr &expr)
+{
+ visit (expr.get_to_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::RangeFullExpr &)
+{}
+
+void
+ExpandVisitor::visit (AST::RangeFromToInclExpr &expr)
+{
+ visit (expr.get_from_expr ());
+ visit (expr.get_to_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::RangeToInclExpr &expr)
+{
+ visit (expr.get_to_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::ReturnExpr &expr)
+{
+ if (expr.has_returned_expr ())
+ visit (expr.get_returned_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::UnsafeBlockExpr &expr)
+{
+ visit (expr.get_block_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::LoopExpr &expr)
+{
+ visit (expr.get_loop_block ());
+}
+
+void
+ExpandVisitor::visit (AST::WhileLoopExpr &expr)
+{
+ visit (expr.get_predicate_expr ());
+ visit (expr.get_loop_block ());
+}
+
+void
+ExpandVisitor::visit (AST::WhileLetLoopExpr &expr)
+{
+ for (auto &pattern : expr.get_patterns ())
+ visit (pattern);
+
+ visit (expr.get_scrutinee_expr ());
+ visit (expr.get_loop_block ());
+}
+
+void
+ExpandVisitor::visit (AST::ForLoopExpr &expr)
+{
+ visit (expr.get_pattern ());
+ visit (expr.get_iterator_expr ());
+ visit (expr.get_loop_block ());
+}
+
+void
+ExpandVisitor::visit (AST::IfExpr &expr)
+{
+ maybe_expand_expr (expr.get_condition_expr ());
+
+ visit (expr.get_if_block ());
+}
+
+void
+ExpandVisitor::visit (AST::IfExprConseqElse &expr)
+{
+ maybe_expand_expr (expr.get_condition_expr ());
+
+ visit (expr.get_if_block ());
+ visit (expr.get_else_block ());
+}
+
+void
+ExpandVisitor::visit (AST::IfExprConseqIf &expr)
+{
+ maybe_expand_expr (expr.get_condition_expr ());
+
+ visit (expr.get_if_block ());
+ visit (expr.get_conseq_if_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::IfExprConseqIfLet &expr)
+{
+ maybe_expand_expr (expr.get_condition_expr ());
+
+ visit (expr.get_if_block ());
+ visit (expr.get_conseq_if_let_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::IfLetExpr &expr)
+{
+ maybe_expand_expr (expr.get_value_expr ());
+
+ visit (expr.get_if_block ());
+}
+
+void
+ExpandVisitor::visit (AST::IfLetExprConseqElse &expr)
+{
+ maybe_expand_expr (expr.get_value_expr ());
+
+ visit (expr.get_if_block ());
+ visit (expr.get_else_block ());
+}
+
+void
+ExpandVisitor::visit (AST::IfLetExprConseqIf &expr)
+{
+ maybe_expand_expr (expr.get_value_expr ());
+
+ visit (expr.get_if_block ());
+ visit (expr.get_conseq_if_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::IfLetExprConseqIfLet &expr)
+{
+ maybe_expand_expr (expr.get_value_expr ());
+
+ visit (expr.get_if_block ());
+ visit (expr.get_conseq_if_let_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::MatchExpr &expr)
+{
+ visit (expr.get_scrutinee_expr ());
+
+ for (auto &match_case : expr.get_match_cases ())
+ {
+ auto &arm = match_case.get_arm ();
+
+ for (auto &pattern : arm.get_patterns ())
+ visit (pattern);
+
+ if (arm.has_match_arm_guard ())
+ visit (arm.get_guard_expr ());
+
+ visit (match_case.get_expr ());
+ }
+}
+
+void
+ExpandVisitor::visit (AST::AwaitExpr &expr)
+{
+ visit (expr.get_awaited_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::AsyncBlockExpr &expr)
+{
+ visit (expr.get_block_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::TypeParam ¶m)
+{
+ for (auto &bound : param.get_type_param_bounds ())
+ visit (bound);
+
+ if (param.has_type ())
+ maybe_expand_type (param.get_type ());
+}
+
+void
+ExpandVisitor::visit (AST::LifetimeWhereClauseItem &)
+{}
+
+void
+ExpandVisitor::visit (AST::TypeBoundWhereClauseItem &item)
+{
+ maybe_expand_type (item.get_type ());
+
+ for (auto &bound : item.get_type_param_bounds ())
+ visit (bound);
+}
+
+void
+ExpandVisitor::visit (AST::Method &method)
+{
+ for (auto ¶m : method.get_generic_params ())
+ visit (param);
+
+ expand_self_param (method.get_self_param ());
+ expand_function_params (method.get_function_params ());
+
+ if (method.has_return_type ())
+ visit (method.get_return_type ());
+
+ if (method.has_where_clause ())
+ expand_where_clause (method.get_where_clause ());
+
+ visit (method.get_definition ());
+}
+
+void
+ExpandVisitor::visit (AST::Module &module)
+{
+ if (module.get_kind () == AST::Module::ModuleKind::LOADED)
+ for (auto &item : module.get_items ())
+ visit (item);
+}
+
+void
+ExpandVisitor::visit (AST::ExternCrate &crate)
+{}
+
+void
+ExpandVisitor::visit (AST::UseTreeGlob &)
+{}
+
+void
+ExpandVisitor::visit (AST::UseTreeList &)
+{}
+
+void
+ExpandVisitor::visit (AST::UseTreeRebind &)
+{}
+
+void
+ExpandVisitor::visit (AST::UseDeclaration &use_decl)
+{}
+
+void
+ExpandVisitor::visit (AST::Function &function)
+{
+ for (auto ¶m : function.get_generic_params ())
+ visit (param);
+
+ expand_function_params (function.get_function_params ());
+
+ if (function.has_return_type ())
+ maybe_expand_type (function.get_return_type ());
+
+ if (function.has_where_clause ())
+ expand_where_clause (function.get_where_clause ());
+
+ visit (function.get_definition ());
+}
+
+void
+ExpandVisitor::visit (AST::TypeAlias &type_alias)
+{
+ visit (type_alias.get_type_aliased ());
+}
+
+void
+ExpandVisitor::visit (AST::StructStruct &struct_item)
+{
+ for (auto &generic : struct_item.get_generic_params ())
+ visit (generic);
+
+ if (struct_item.has_where_clause ())
+ expand_where_clause (struct_item.get_where_clause ());
+
+ expand_struct_fields (struct_item.get_fields ());
+}
+
+void
+ExpandVisitor::visit (AST::TupleStruct &tuple_struct)
+{
+ for (auto &generic : tuple_struct.get_generic_params ())
+ visit (generic);
+
+ if (tuple_struct.has_where_clause ())
+ expand_where_clause (tuple_struct.get_where_clause ());
+
+ expand_tuple_fields (tuple_struct.get_fields ());
+}
+
+void
+ExpandVisitor::visit (AST::EnumItem &item)
+{}
+
+void
+ExpandVisitor::visit (AST::EnumItemTuple &item)
+{
+ expand_tuple_fields (item.get_tuple_fields ());
+}
+
+void
+ExpandVisitor::visit (AST::EnumItemStruct &item)
+{
+ expand_struct_fields (item.get_struct_fields ());
+}
+
+void
+ExpandVisitor::visit (AST::EnumItemDiscriminant &item)
+{
+ visit (item.get_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::Enum &enum_item)
+{
+ for (auto &generic : enum_item.get_generic_params ())
+ visit (generic);
+
+ for (auto &variant : enum_item.get_variants ())
+ visit (variant);
+}
+
+void
+ExpandVisitor::visit (AST::Union &union_item)
+{
+ for (auto &generic : union_item.get_generic_params ())
+ visit (generic);
+
+ expand_struct_fields (union_item.get_variants ());
+}
+
+void
+ExpandVisitor::visit (AST::ConstantItem &const_item)
+{
+ maybe_expand_type (const_item.get_type ());
+
+ visit (const_item.get_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::StaticItem &static_item)
+{
+ maybe_expand_type (static_item.get_type ());
+
+ visit (static_item.get_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::TraitItemFunc &item)
+{
+ expand_trait_function_decl (item.get_trait_function_decl ());
+
+ if (item.has_definition ())
+ visit (item.get_definition ());
+}
+
+void
+ExpandVisitor::visit (AST::TraitItemMethod &item)
+{
+ expand_trait_method_decl (item.get_trait_method_decl ());
+
+ if (item.has_definition ())
+ visit (item.get_definition ());
+}
+
+void
+ExpandVisitor::visit (AST::TraitItemConst &const_item)
+{
+ maybe_expand_type (const_item.get_type ());
+
+ if (const_item.has_expr ())
+ visit (const_item.get_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::TraitItemType &item)
+{
+ for (auto &type : item.get_type_param_bounds ())
+ visit (type);
+}
+
+void
+ExpandVisitor::visit (AST::Trait &trait)
+{
+ for (auto &generic : trait.get_generic_params ())
+ visit (generic);
+
+ for (auto &bound : trait.get_type_param_bounds ())
+ visit (bound);
+
+ if (trait.has_where_clause ())
+ expand_where_clause (trait.get_where_clause ());
+
+ expander.push_context (MacroExpander::ContextType::TRAIT);
+
+ std::function<std::unique_ptr<AST::TraitItem> (AST::SingleASTNode)> extractor
+ = [] (AST::SingleASTNode node) { return node.take_trait_item (); };
+
+ expand_macro_children (MacroExpander::ContextType::TRAIT,
+ trait.get_trait_items (), extractor);
+
+ expander.pop_context ();
+}
+
+void
+ExpandVisitor::visit (AST::InherentImpl &impl)
+{
+ // just expand sub-stuff - can't actually strip generic params themselves
+ for (auto &generic : impl.get_generic_params ())
+ visit (generic);
+
+ // FIXME: Is that correct? How do we test that?
+ expander.push_context (MacroExpander::ContextType::ITEM);
+
+ maybe_expand_type (impl.get_type ());
+
+ expander.pop_context ();
+
+ if (impl.has_where_clause ())
+ expand_where_clause (impl.get_where_clause ());
+
+ std::function<std::unique_ptr<AST::InherentImplItem> (AST::SingleASTNode)>
+ extractor = [] (AST::SingleASTNode node) { return node.take_impl_item (); };
+
+ expand_macro_children (MacroExpander::ContextType::IMPL,
+ impl.get_impl_items (), extractor);
+}
+
+void
+ExpandVisitor::visit (AST::TraitImpl &impl)
+{
+ // just expand sub-stuff - can't actually strip generic params themselves
+ for (auto ¶m : impl.get_generic_params ())
+ visit (param);
+
+ // FIXME: Is that correct? How do we test that?
+ expander.push_context (MacroExpander::ContextType::ITEM);
+
+ maybe_expand_type (impl.get_type ());
+
+ expander.pop_context ();
+
+ visit (impl.get_trait_path ());
+
+ if (impl.has_where_clause ())
+ expand_where_clause (impl.get_where_clause ());
+
+ std::function<std::unique_ptr<AST::TraitImplItem> (AST::SingleASTNode)>
+ extractor
+ = [] (AST::SingleASTNode node) { return node.take_trait_impl_item (); };
+
+ expand_macro_children (MacroExpander::ContextType::TRAIT_IMPL,
+ impl.get_impl_items (), extractor);
+}
+
+void
+ExpandVisitor::visit (AST::ExternalTypeItem &item)
+{}
+
+void
+ExpandVisitor::visit (AST::ExternalStaticItem &static_item)
+{
+ maybe_expand_type (static_item.get_type ());
+}
+
+void
+ExpandVisitor::visit (AST::ExternalFunctionItem &item)
+{
+ for (auto ¶m : item.get_generic_params ())
+ visit (param);
+
+ // FIXME: Should this work? What is the difference between NamedFunctionParam
+ // and FunctionParam?
+ // expand_function_params (item.get_function_params ());
+
+ for (auto ¶m : item.get_function_params ())
+ maybe_expand_type (param.get_type ());
+
+ if (item.has_return_type ())
+ maybe_expand_type (item.get_return_type ());
+
+ if (item.has_where_clause ())
+ expand_where_clause (item.get_where_clause ());
+}
+
+void
+ExpandVisitor::visit (AST::ExternBlock &block)
+{
+ std::function<std::unique_ptr<AST::ExternalItem> (AST::SingleASTNode)>
+ extractor
+ = [] (AST::SingleASTNode node) { return node.take_external_item (); };
+
+ expand_macro_children (MacroExpander::ContextType::EXTERN,
+ block.get_extern_items (), extractor);
+}
+
+// I don't think it would be possible to strip macros without expansion
+void
+ExpandVisitor::visit (AST::MacroMatchFragment &)
+{}
+
+void
+ExpandVisitor::visit (AST::MacroMatchRepetition &)
+{}
+
+void
+ExpandVisitor::visit (AST::MacroMatcher &)
+{}
+
+void
+ExpandVisitor::visit (AST::MacroRulesDefinition &rules_def)
+{}
+
+void
+ExpandVisitor::visit (AST::MetaItemPath &)
+{}
+
+void
+ExpandVisitor::visit (AST::MetaItemSeq &)
+{}
+
+void
+ExpandVisitor::visit (AST::MetaWord &)
+{}
+
+void
+ExpandVisitor::visit (AST::MetaNameValueStr &)
+{}
+
+void
+ExpandVisitor::visit (AST::MetaListPaths &)
+{}
+
+void
+ExpandVisitor::visit (AST::MetaListNameValueStr &)
+{}
+
+void
+ExpandVisitor::visit (AST::LiteralPattern &)
+{}
+
+void
+ExpandVisitor::visit (AST::IdentifierPattern &pattern)
+{
+ if (pattern.has_pattern_to_bind ())
+ visit (pattern.get_pattern_to_bind ());
+}
+
+void
+ExpandVisitor::visit (AST::WildcardPattern &)
+{}
+
+void
+ExpandVisitor::visit (AST::RestPattern &)
+{}
+
+void
+ExpandVisitor::visit (AST::RangePatternBoundLiteral &)
+{}
+
+void
+ExpandVisitor::visit (AST::RangePatternBoundPath &bound)
+{
+ visit (bound.get_path ());
+}
+
+void
+ExpandVisitor::visit (AST::RangePatternBoundQualPath &bound)
+{
+ visit (bound.get_qualified_path ());
+}
+
+void
+ExpandVisitor::visit (AST::RangePattern &pattern)
+{
+ visit (pattern.get_lower_bound ());
+ visit (pattern.get_upper_bound ());
+}
+
+void
+ExpandVisitor::visit (AST::ReferencePattern &pattern)
+{
+ visit (pattern.get_referenced_pattern ());
+}
+
+void
+ExpandVisitor::visit (AST::StructPatternFieldTuplePat &field)
+{
+ visit (field.get_index_pattern ());
+}
+
+void
+ExpandVisitor::visit (AST::StructPatternFieldIdentPat &field)
+{
+ visit (field.get_ident_pattern ());
+}
+
+void
+ExpandVisitor::visit (AST::StructPatternFieldIdent &field)
+{}
+
+void
+ExpandVisitor::visit (AST::StructPattern &pattern)
+{
+ visit (pattern.get_path ());
+
+ for (auto &inner :
+ pattern.get_struct_pattern_elems ().get_struct_pattern_fields ())
+ visit (inner);
+}
+
+void
+ExpandVisitor::visit (AST::TupleStructItemsNoRange &tuple_items)
+{
+ for (auto &pattern : tuple_items.get_patterns ())
+ visit (pattern);
+}
+
+void
+ExpandVisitor::visit (AST::TupleStructItemsRange &tuple_items)
+{
+ for (auto &lower_pattern : tuple_items.get_lower_patterns ())
+ visit (lower_pattern);
+ for (auto &upper_pattern : tuple_items.get_upper_patterns ())
+ visit (upper_pattern);
+}
+
+void
+ExpandVisitor::visit (AST::TupleStructPattern &pattern)
+{
+ visit (pattern.get_path ());
+
+ if (pattern.has_items ())
+ visit (pattern.get_items ());
+}
+
+void
+ExpandVisitor::visit (AST::TuplePatternItemsMultiple &tuple_items)
+{
+ for (auto &pattern : tuple_items.get_patterns ())
+ visit (pattern);
+}
+
+void
+ExpandVisitor::visit (AST::TuplePatternItemsRanged &tuple_items)
+{
+ for (auto &pattern : tuple_items.get_lower_patterns ())
+ visit (pattern);
+ for (auto &pattern : tuple_items.get_upper_patterns ())
+ visit (pattern);
+}
+
+void
+ExpandVisitor::visit (AST::TuplePattern &pattern)
+{
+ if (pattern.has_tuple_pattern_items ())
+ visit (pattern.get_items ());
+}
+
+void
+ExpandVisitor::visit (AST::GroupedPattern &pattern)
+{
+ visit (pattern.get_pattern_in_parens ());
+}
+
+void
+ExpandVisitor::visit (AST::SlicePattern &pattern)
+{
+ for (auto &item : pattern.get_items ())
+ visit (item);
+}
+
+void
+ExpandVisitor::visit (AST::AltPattern &pattern)
+{
+ for (auto &alt : pattern.get_alts ())
+ visit (alt);
+}
+
+void
+ExpandVisitor::visit (AST::EmptyStmt &)
+{}
+
+void
+ExpandVisitor::visit (AST::LetStmt &stmt)
+{
+ visit (stmt.get_pattern ());
+
+ if (stmt.has_type ())
+ maybe_expand_type (stmt.get_type ());
+
+ if (stmt.has_init_expr ())
+ maybe_expand_expr (stmt.get_init_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::ExprStmtWithoutBlock &stmt)
+{
+ visit (stmt.get_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::ExprStmtWithBlock &stmt)
+{
+ visit (stmt.get_expr ());
+}
+
+void
+ExpandVisitor::visit (AST::TraitBound &bound)
+{
+ visit (bound.get_type_path ());
+}
+
+void
+ExpandVisitor::visit (AST::ImplTraitType &type)
+{
+ for (auto &bound : type.get_type_param_bounds ())
+ visit (bound);
+}
+
+void
+ExpandVisitor::visit (AST::TraitObjectType &type)
+{
+ for (auto &bound : type.get_type_param_bounds ())
+ visit (bound);
+}
+
+void
+ExpandVisitor::visit (AST::ParenthesisedType &type)
+{
+ visit (type.get_type_in_parens ());
+}
+
+void
+ExpandVisitor::visit (AST::ImplTraitTypeOneBound &type)
+{
+ visit (type.get_trait_bound ());
+}
+
+void
+ExpandVisitor::visit (AST::TraitObjectTypeOneBound &type)
+{
+ visit (type.get_trait_bound ());
+}
+
+void
+ExpandVisitor::visit (AST::TupleType &type)
+{
+ for (auto &elem : type.get_elems ())
+ visit (elem);
+}
+
+void
+ExpandVisitor::visit (AST::NeverType &)
+{}
+
+void
+ExpandVisitor::visit (AST::RawPointerType &type)
+{
+ visit (type.get_type_pointed_to ());
+}
+
+void
+ExpandVisitor::visit (AST::ReferenceType &type)
+{
+ visit (type.get_type_referenced ());
+}
+
+void
+ExpandVisitor::visit (AST::ArrayType &type)
+{
+ visit (type.get_elem_type ());
+}
+
+void
+ExpandVisitor::visit (AST::SliceType &type)
+{
+ visit (type.get_elem_type ());
+}
+
+void
+ExpandVisitor::visit (AST::InferredType &)
+{}
+
+void
+ExpandVisitor::visit (AST::BareFunctionType &type)
+{
+ for (auto ¶m : type.get_function_params ())
+ maybe_expand_type (param.get_type ());
+
+ if (type.has_return_type ())
+ visit (type.get_return_type ());
+}
+
+} // namespace Rust
--- /dev/null
+// Copyright (C) 2020-2023 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-ast-visitor.h"
+#include "rust-macro-expand.h"
+
+namespace Rust {
+
+class ExpandVisitor : public AST::ASTVisitor
+{
+public:
+ ExpandVisitor (MacroExpander &expander) : expander (expander) {}
+
+ /* Expand all of the macro invocations currently contained in a crate */
+ void go (AST::Crate &crate);
+
+ /* Maybe expand a macro invocation in lieu of an expression */
+ void maybe_expand_expr (std::unique_ptr<AST::Expr> &expr);
+
+ /* Maybe expand a macro invocation in lieu of a type */
+ void maybe_expand_type (std::unique_ptr<AST::Type> &type);
+
+ /**
+ * Expand all macro invocations in lieu of types within a vector of struct
+ * fields
+ */
+ void expand_struct_fields (std::vector<AST::StructField> &fields);
+
+ /**
+ * Expand all macro invocations in lieu of types within a vector of tuple
+ * fields
+ */
+ void expand_tuple_fields (std::vector<AST::TupleField> &fields);
+
+ /**
+ * Expand all macro invocations in lieu of types within a list of function
+ * parameters
+ */
+ void expand_function_params (std::vector<AST::FunctionParam> ¶ms);
+
+ /**
+ * Expand all macro invocations in lieu of types within a list of generic
+ * arguments
+ */
+ void expand_generic_args (AST::GenericArgs &args);
+
+ /**
+ * Expand a macro invocation in lieu of a qualified path type
+ */
+ void expand_qualified_path_type (AST::QualifiedPathType &path_type);
+
+ void expand_closure_params (std::vector<AST::ClosureParam> ¶ms);
+ void expand_self_param (AST::SelfParam &self_param);
+ void expand_where_clause (AST::WhereClause &where_clause);
+ void expand_trait_function_decl (AST::TraitFunctionDecl &decl);
+ void expand_trait_method_decl (AST::TraitMethodDecl &decl);
+
+ /**
+ * Expand a set of values, erasing them if they are marked for strip, and
+ * replacing them with expanded macro nodes if necessary.
+ * This function is slightly different from `expand_pointer_allow_strip` as
+ * it can only be called in certain expansion contexts - where macro
+ * invocations are allowed.
+ *
+ * @param ctx Context to use for macro expansion
+ * @param values Iterable reference over values to replace or erase
+ * @param extractor Function to call when replacing values with the content
+ * of an expanded AST node
+ */
+ template <typename T, typename U>
+ void expand_macro_children (MacroExpander::ContextType ctx, T &values,
+ std::function<U (AST::SingleASTNode)> extractor)
+ {
+ expander.push_context (ctx);
+
+ for (auto it = values.begin (); it != values.end ();)
+ {
+ auto &value = *it;
+
+ // Perform expansion
+ value->accept_vis (*this);
+
+ auto final_fragment = expander.take_expanded_fragment ();
+
+ // FIXME: Is that correct? It seems *extremely* dodgy
+ if (final_fragment.should_expand ())
+ {
+ it = values.erase (it);
+ for (auto &node : final_fragment.get_nodes ())
+ {
+ auto new_node = extractor (node);
+ if (new_node != nullptr)
+ {
+ it = values.insert (it, std::move (new_node));
+ it++;
+ }
+ }
+ }
+ else
+ {
+ ++it;
+ }
+ }
+
+ expander.pop_context ();
+ }
+
+ // TODO: See if possible to make more specialization for Impl items, Block
+ // stmts etc? This could allow us to remove expand_macro_children or at least
+ // its extractor parameter
+ /**
+ * These functions allow to easily visit `std::unique_ptr`s as well as
+ * _replace_ them when necessary, e.g when expanding macro invocations in a
+ * list of expressions or types. The most generic version of the function will
+ * simply call the visitor again on the pointer, but there are two
+ * specializations for `std::unique_ptr<Expr>` and `std::unique_ptr<Type>` to
+ * enable replacing as well.
+ */
+ template <typename T> void visit (std::unique_ptr<T> &value)
+ {
+ value->accept_vis (*this);
+ }
+
+ template <typename T> void visit (std::unique_ptr<AST::Expr> &expr)
+ {
+ maybe_expand_expr (expr);
+ }
+
+ template <typename T> void visit (std::unique_ptr<AST::Type> &type)
+ {
+ maybe_expand_type (type);
+ }
+
+ void visit (AST::Token &) override;
+ void visit (AST::DelimTokenTree &) override;
+ void visit (AST::AttrInputMetaItemContainer &) override;
+ void visit (AST::IdentifierExpr &ident_expr) override;
+ void visit (AST::Lifetime &) override;
+ void visit (AST::LifetimeParam &) override;
+ void visit (AST::ConstGenericParam &) override;
+
+ void visit (AST::MacroInvocation ¯o_invoc) override;
+
+ void visit (AST::PathInExpression &path) override;
+ void visit (AST::TypePathSegment &) override;
+ void visit (AST::TypePathSegmentGeneric &segment) override;
+ void visit (AST::TypePathSegmentFunction &segment) override;
+ void visit (AST::TypePath &path) override;
+ void visit (AST::QualifiedPathInExpression &path) override;
+ void visit (AST::QualifiedPathInType &path) override;
+
+ void visit (AST::LiteralExpr &expr) override;
+ void visit (AST::AttrInputLiteral &) override;
+ void visit (AST::MetaItemLitExpr &) override;
+ void visit (AST::MetaItemPathLit &) override;
+ void visit (AST::BorrowExpr &expr) override;
+ void visit (AST::DereferenceExpr &expr) override;
+ void visit (AST::ErrorPropagationExpr &expr) override;
+ void visit (AST::NegationExpr &expr) override;
+ void visit (AST::ArithmeticOrLogicalExpr &expr) override;
+ void visit (AST::ComparisonExpr &expr) override;
+ void visit (AST::LazyBooleanExpr &expr) override;
+ void visit (AST::TypeCastExpr &expr) override;
+ void visit (AST::AssignmentExpr &expr) override;
+ void visit (AST::CompoundAssignmentExpr &expr) override;
+ void visit (AST::GroupedExpr &expr) override;
+ void visit (AST::ArrayElemsValues &elems) override;
+ void visit (AST::ArrayElemsCopied &elems) override;
+ void visit (AST::ArrayExpr &expr) override;
+ void visit (AST::ArrayIndexExpr &expr) override;
+ void visit (AST::TupleExpr &expr) override;
+ void visit (AST::TupleIndexExpr &expr) override;
+ void visit (AST::StructExprStruct &expr) override;
+ void visit (AST::StructExprFieldIdentifier &) override;
+ void visit (AST::StructExprFieldIdentifierValue &field) override;
+
+ void visit (AST::StructExprFieldIndexValue &field) override;
+ void visit (AST::StructExprStructFields &expr) override;
+ void visit (AST::StructExprStructBase &expr) override;
+ void visit (AST::CallExpr &expr) override;
+ void visit (AST::MethodCallExpr &expr) override;
+ void visit (AST::FieldAccessExpr &expr) override;
+ void visit (AST::ClosureExprInner &expr) override;
+
+ void visit (AST::BlockExpr &expr) override;
+
+ void visit (AST::ClosureExprInnerTyped &expr) override;
+ void visit (AST::ContinueExpr &expr) override;
+ void visit (AST::BreakExpr &expr) override;
+ void visit (AST::RangeFromToExpr &expr) override;
+ void visit (AST::RangeFromExpr &expr) override;
+ void visit (AST::RangeToExpr &expr) override;
+ void visit (AST::RangeFullExpr &) override;
+ void visit (AST::RangeFromToInclExpr &expr) override;
+ void visit (AST::RangeToInclExpr &expr) override;
+ void visit (AST::ReturnExpr &expr) override;
+ void visit (AST::UnsafeBlockExpr &expr) override;
+ void visit (AST::LoopExpr &expr) override;
+ void visit (AST::WhileLoopExpr &expr) override;
+ void visit (AST::WhileLetLoopExpr &expr) override;
+ void visit (AST::ForLoopExpr &expr) override;
+ void visit (AST::IfExpr &expr) override;
+ void visit (AST::IfExprConseqElse &expr) override;
+ void visit (AST::IfExprConseqIf &expr) override;
+ void visit (AST::IfExprConseqIfLet &expr) override;
+ void visit (AST::IfLetExpr &expr) override;
+ void visit (AST::IfLetExprConseqElse &expr) override;
+ void visit (AST::IfLetExprConseqIf &expr) override;
+ void visit (AST::IfLetExprConseqIfLet &expr) override;
+ void visit (AST::MatchExpr &expr) override;
+ void visit (AST::AwaitExpr &expr) override;
+ void visit (AST::AsyncBlockExpr &expr) override;
+ void visit (AST::TypeParam ¶m) override;
+ void visit (AST::LifetimeWhereClauseItem &) override;
+ void visit (AST::TypeBoundWhereClauseItem &item) override;
+ void visit (AST::Method &method) override;
+ void visit (AST::Module &module) override;
+ void visit (AST::ExternCrate &crate) override;
+ void visit (AST::UseTreeGlob &) override;
+ void visit (AST::UseTreeList &) override;
+ void visit (AST::UseTreeRebind &) override;
+ void visit (AST::UseDeclaration &use_decl) override;
+ void visit (AST::Function &function) override;
+ void visit (AST::TypeAlias &type_alias) override;
+ void visit (AST::StructStruct &struct_item) override;
+ void visit (AST::TupleStruct &tuple_struct) override;
+ void visit (AST::EnumItem &item) override;
+ void visit (AST::EnumItemTuple &item) override;
+ void visit (AST::EnumItemStruct &item) override;
+ void visit (AST::EnumItemDiscriminant &item) override;
+ void visit (AST::Enum &enum_item) override;
+ void visit (AST::Union &union_item) override;
+ void visit (AST::ConstantItem &const_item) override;
+ void visit (AST::StaticItem &static_item) override;
+ void visit (AST::TraitItemFunc &item) override;
+ void visit (AST::TraitItemMethod &item) override;
+ void visit (AST::TraitItemConst &item) override;
+ void visit (AST::TraitItemType &item) override;
+ void visit (AST::Trait &trait) override;
+ void visit (AST::InherentImpl &impl) override;
+ void visit (AST::TraitImpl &impl) override;
+ void visit (AST::ExternalTypeItem &item) override;
+ void visit (AST::ExternalStaticItem &item) override;
+ void visit (AST::ExternalFunctionItem &item) override;
+ void visit (AST::ExternBlock &block) override;
+
+ // I don't think it would be possible to strip macros without expansion
+ void visit (AST::MacroMatchFragment &) override;
+ void visit (AST::MacroMatchRepetition &) override;
+ void visit (AST::MacroMatcher &) override;
+ void visit (AST::MacroRulesDefinition &rules_def) override;
+ void visit (AST::MetaItemPath &) override;
+ void visit (AST::MetaItemSeq &) override;
+ void visit (AST::MetaWord &) override;
+ void visit (AST::MetaNameValueStr &) override;
+ void visit (AST::MetaListPaths &) override;
+ void visit (AST::MetaListNameValueStr &) override;
+ void visit (AST::LiteralPattern &) override;
+ void visit (AST::IdentifierPattern &pattern) override;
+ void visit (AST::WildcardPattern &) override;
+ void visit (AST::RestPattern &) override;
+ void visit (AST::RangePatternBoundLiteral &) override;
+ void visit (AST::RangePatternBoundPath &bound) override;
+ void visit (AST::RangePatternBoundQualPath &bound) override;
+ void visit (AST::RangePattern &pattern) override;
+ void visit (AST::ReferencePattern &pattern) override;
+ void visit (AST::StructPatternFieldTuplePat &field) override;
+ void visit (AST::StructPatternFieldIdentPat &field) override;
+ void visit (AST::StructPatternFieldIdent &field) override;
+ void visit (AST::StructPattern &pattern) override;
+ void visit (AST::TupleStructItemsNoRange &tuple_items) override;
+ void visit (AST::TupleStructItemsRange &tuple_items) override;
+ void visit (AST::TupleStructPattern &pattern) override;
+ void visit (AST::TuplePatternItemsMultiple &tuple_items) override;
+ void visit (AST::TuplePatternItemsRanged &tuple_items) override;
+ void visit (AST::TuplePattern &pattern) override;
+ void visit (AST::GroupedPattern &pattern) override;
+ void visit (AST::SlicePattern &pattern) override;
+ void visit (AST::AltPattern &pattern) override;
+
+ void visit (AST::EmptyStmt &) override;
+ void visit (AST::LetStmt &stmt) override;
+ void visit (AST::ExprStmtWithoutBlock &stmt) override;
+ void visit (AST::ExprStmtWithBlock &stmt) override;
+
+ void visit (AST::TraitBound &bound) override;
+ void visit (AST::ImplTraitType &type) override;
+ void visit (AST::TraitObjectType &type) override;
+ void visit (AST::ParenthesisedType &type) override;
+ void visit (AST::ImplTraitTypeOneBound &type) override;
+ void visit (AST::TraitObjectTypeOneBound &type) override;
+ void visit (AST::TupleType &type) override;
+ void visit (AST::NeverType &) override;
+ void visit (AST::RawPointerType &type) override;
+ void visit (AST::ReferenceType &type) override;
+ void visit (AST::ArrayType &type) override;
+ void visit (AST::SliceType &type) override;
+ void visit (AST::InferredType &) override;
+ void visit (AST::BareFunctionType &type) override;
+
+private:
+ MacroExpander &expander;
+};
+
+} // namespace Rust
#include "rust-early-name-resolver.h"
namespace Rust {
+
AST::Fragment
MacroExpander::expand_decl_macro (Location invoc_locus,
AST::MacroInvocData &invoc,
// TODO: does cfg apply for inner attributes? research.
// the apparent answer (from playground test) is yes
- push_context (ITEM);
+ push_context (ContextType::ITEM);
// expand attributes recursively and strip items if required
- AttrVisitor attr_visitor (*this);
+ // AttrVisitor attr_visitor (*this);
auto &items = crate.items;
for (auto it = items.begin (); it != items.end ();)
{
auto &item = *it;
- // mark for stripping if required
- item->accept_vis (attr_visitor);
-
auto fragment = take_expanded_fragment ();
if (fragment.should_expand ())
{
// Object used to store shared data (between functions) for macro expansion.
struct MacroExpander
{
- enum ContextType
+ enum class ContextType
{
ITEM,
BLOCK,
#include "rust-extern-crate.h"
#include "rust-attributes.h"
#include "rust-early-name-resolver.h"
+#include "rust-attribute-visitor.h"
+#include "rust-expand-visitor.h"
#include "diagnostic.h"
#include "input.h"
while (!fixed_point_reached && iterations < cfg.recursion_limit)
{
- /* We need to name resolve macros and imports here */
+ AttrVisitor ().go (crate);
Resolver::EarlyNameResolver ().go (crate);
-
- expander.expand_crate ();
+ ExpandVisitor (expander).go (crate);
fixed_point_reached = !expander.has_changed ();
expander.reset_changed_state ();
--- /dev/null
+macro_rules! closure {
+ () => {{
+ 14 + 15
+ }};
+}
+
+fn main() {
+ let _ = || closure!();
+}
--- /dev/null
+macro_rules! foo {
+ () => {
+ u32
+ };
+}
+
+fn main() {
+ let _a = 15i32;
+ let _b = _a as foo!();
+}
projects / thirdparty / gcc.git / commitdiff
