namespace Rust {
namespace AST {
-TokenStream::TokenStream (std::vector<TokenPtr> &container) : tokens (container)
+TokenCollector::TokenCollector (std::vector<TokenPtr> &container)
+ : tokens (container)
{}
std::vector<TokenPtr>
-TokenStream::collect_tokens () const
+TokenCollector::collect_tokens () const
{
return tokens;
}
}
ProcMacro::TokenStream
-TokenStream::collect () const
+TokenCollector::collect () const
{
std::vector<ProcMacro::TokenStream> trees;
trees.push_back (ProcMacro::TokenStream::make_tokenstream ());
}
void
-TokenStream::visit (AST::Crate &crate)
+TokenCollector::visit (AST::Crate &crate)
{
visit_items_as_lines (crate.inner_attrs);
visit_items_as_lines (crate.items);
}
void
-TokenStream::visit (AST::Item &item)
+TokenCollector::visit (AST::Item &item)
{
item.accept_vis (*this);
}
template <typename T>
void
-TokenStream::visit (std::unique_ptr<T> &node)
+TokenCollector::visit (std::unique_ptr<T> &node)
{
node->accept_vis (*this);
}
template <typename T>
void
-TokenStream::visit (T &node)
+TokenCollector::visit (T &node)
{
node.accept_vis (*this);
}
template <typename T>
void
-TokenStream::visit_items_joined_by_separator (T &collection, TokenId separator,
- size_t start_offset,
- size_t end_offset)
+TokenCollector::visit_items_joined_by_separator (T &collection,
+ TokenId separator,
+ size_t start_offset,
+ size_t end_offset)
{
if (collection.size () > start_offset)
{
template <typename T>
void
-TokenStream::visit_as_line (T &item, std::vector<TokenPtr> trailing)
+TokenCollector::visit_as_line (T &item, std::vector<TokenPtr> trailing)
{
indentation ();
visit (item);
template <typename T>
void
-TokenStream::visit_items_as_lines (T &collection,
- std::vector<TokenPtr> trailing)
+TokenCollector::visit_items_as_lines (T &collection,
+ std::vector<TokenPtr> trailing)
{
for (auto &item : collection)
visit_as_line (item, trailing);
template <typename T>
void
-TokenStream::visit_items_as_block (T &collection,
- std::vector<TokenPtr> trailing,
- TokenId left_brace, TokenId right_brace)
+TokenCollector::visit_items_as_block (T &collection,
+ std::vector<TokenPtr> trailing,
+ TokenId left_brace, TokenId right_brace)
{
tokens.push_back (Rust::Token::make (left_brace, Location ()));
if (collection.empty ())
}
void
-TokenStream::trailing_comma ()
+TokenCollector::trailing_comma ()
{
if (output_trailing_commas)
{
}
void
-TokenStream::newline ()
+TokenCollector::newline ()
{}
void
-TokenStream::indentation ()
+TokenCollector::indentation ()
{}
void
-TokenStream::increment_indentation ()
+TokenCollector::increment_indentation ()
{}
void
-TokenStream::decrement_indentation ()
+TokenCollector::decrement_indentation ()
{}
void
-TokenStream::visit (FunctionParam ¶m)
+TokenCollector::visit (FunctionParam ¶m)
{
visit (param.get_pattern ());
tokens.push_back (Rust::Token::make (COLON, Location ()));
}
void
-TokenStream::visit (Attribute &attrib)
+TokenCollector::visit (Attribute &attrib)
{
tokens.push_back (Rust::Token::make (HASH, attrib.get_locus ()));
if (attrib.is_inner_attribute ())
}
void
-TokenStream::visit (SimplePath &path)
+TokenCollector::visit (SimplePath &path)
{
if (path.has_opening_scope_resolution ())
{
}
void
-TokenStream::visit (SimplePathSegment &segment)
+TokenCollector::visit (SimplePathSegment &segment)
{
auto name = segment.get_segment_name ();
if (segment.is_crate_path_seg ())
}
void
-TokenStream::visit (Visibility &vis)
+TokenCollector::visit (Visibility &vis)
{
switch (vis.get_vis_type ())
{
}
void
-TokenStream::visit (NamedFunctionParam ¶m)
+TokenCollector::visit (NamedFunctionParam ¶m)
{
auto name = param.get_name ();
tokens.push_back (
}
void
-TokenStream::visit (std::vector<std::unique_ptr<GenericParam>> ¶ms)
+TokenCollector::visit (std::vector<std::unique_ptr<GenericParam>> ¶ms)
{
tokens.push_back (Rust::Token::make (LEFT_ANGLE, Location ()));
visit_items_joined_by_separator (params, COMMA);
}
void
-TokenStream::visit (TupleField &field)
+TokenCollector::visit (TupleField &field)
{
for (auto attr : field.get_outer_attrs ())
{
}
void
-TokenStream::visit (StructField &field)
+TokenCollector::visit (StructField &field)
{
for (auto attr : field.get_outer_attrs ())
{
}
void
-TokenStream::visit (std::vector<LifetimeParam> &for_lifetimes)
+TokenCollector::visit (std::vector<LifetimeParam> &for_lifetimes)
{
tokens.push_back (Rust::Token::make (FOR, Location ()));
tokens.push_back (Rust::Token::make (LEFT_ANGLE, Location ()));
}
void
-TokenStream::visit (FunctionQualifiers &qualifiers)
+TokenCollector::visit (FunctionQualifiers &qualifiers)
{
// Syntax:
// `const`? `async`? `unsafe`? (`extern` Abi?)?
}
void
-TokenStream::visit (MaybeNamedParam ¶m)
+TokenCollector::visit (MaybeNamedParam ¶m)
{
// Syntax:
// OuterAttribute* ( ( IDENTIFIER | _ ) : )? Type
}
void
-TokenStream::visit (Token &tok)
+TokenCollector::visit (Token &tok)
{
std::string data = tok.get_tok_ptr ()->has_str () ? tok.get_str () : "";
switch (tok.get_id ())
}
void
-TokenStream::visit (DelimTokenTree &delim_tok_tree)
+TokenCollector::visit (DelimTokenTree &delim_tok_tree)
{
increment_indentation ();
newline ();
}
void
-TokenStream::visit (AttrInputMetaItemContainer &container)
+TokenCollector::visit (AttrInputMetaItemContainer &container)
{
for (auto &item : container.get_items ())
{
}
void
-TokenStream::visit (IdentifierExpr &ident_expr)
+TokenCollector::visit (IdentifierExpr &ident_expr)
{
auto ident = ident_expr.get_ident ();
tokens.push_back (
}
void
-TokenStream::visit (Lifetime &lifetime)
+TokenCollector::visit (Lifetime &lifetime)
{
// Syntax:
// Lifetime :
}
void
-TokenStream::visit (LifetimeParam &lifetime_param)
+TokenCollector::visit (LifetimeParam &lifetime_param)
{
// Syntax:
// LIFETIME_OR_LABEL ( : LifetimeBounds )?
}
void
-TokenStream::visit (ConstGenericParam ¶m)
+TokenCollector::visit (ConstGenericParam ¶m)
{
// Syntax:
// const IDENTIFIER : Type ( = Block | IDENTIFIER | -?LITERAL )?
}
void
-TokenStream::visit (PathExprSegment &segment)
+TokenCollector::visit (PathExprSegment &segment)
{
visit (segment.get_ident_segment ());
if (segment.has_generic_args ())
}
void
-TokenStream::visit (PathInExpression &path)
+TokenCollector::visit (PathInExpression &path)
{
if (path.opening_scope_resolution ())
{
}
void
-TokenStream::visit (TypePathSegment &segment)
+TokenCollector::visit (TypePathSegment &segment)
{
// Syntax:
// PathIdentSegment
}
void
-TokenStream::visit (TypePathSegmentGeneric &segment)
+TokenCollector::visit (TypePathSegmentGeneric &segment)
{
// Syntax:
// PathIdentSegment `::`? (GenericArgs)?
}
void
-TokenStream::visit (GenericArgsBinding &binding)
+TokenCollector::visit (GenericArgsBinding &binding)
{
// Syntax:
// IDENTIFIER `=` Type
}
void
-TokenStream::visit (GenericArg &arg)
+TokenCollector::visit (GenericArg &arg)
{
// `GenericArg` implements `accept_vis` but it is not useful for this case as
// it ignores unresolved cases (`Kind::Either`).
}
void
-TokenStream::visit (TypePathSegmentFunction &segment)
+TokenCollector::visit (TypePathSegmentFunction &segment)
{
// Syntax:
// PathIdentSegment `::`? (TypePathFn)?
}
void
-TokenStream::visit (TypePathFunction &type_path_fn)
+TokenCollector::visit (TypePathFunction &type_path_fn)
{
// Syntax:
// `(` TypePathFnInputs? `)` (`->` Type)?
}
void
-TokenStream::visit (TypePath &path)
+TokenCollector::visit (TypePath &path)
{
// Syntax:
// `::`? TypePathSegment (`::` TypePathSegment)*
}
void
-TokenStream::visit (PathIdentSegment &segment)
+TokenCollector::visit (PathIdentSegment &segment)
{
if (segment.is_super_segment ())
{
}
void
-TokenStream::visit (QualifiedPathInExpression &path)
+TokenCollector::visit (QualifiedPathInExpression &path)
{
visit (path.get_qualified_path_type ());
for (auto &segment : path.get_segments ())
}
void
-TokenStream::visit (QualifiedPathType &path)
+TokenCollector::visit (QualifiedPathType &path)
{
tokens.push_back (Rust::Token::make (LEFT_ANGLE, path.get_locus ()));
visit (path.get_type ());
}
void
-TokenStream::visit (QualifiedPathInType &path)
+TokenCollector::visit (QualifiedPathInType &path)
{
visit (path.get_qualified_path_type ());
}
void
-TokenStream::visit (Literal &lit, Location locus)
+TokenCollector::visit (Literal &lit, Location locus)
{
auto value = lit.as_string ();
switch (lit.get_lit_type ())
}
void
-TokenStream::visit (LiteralExpr &expr)
+TokenCollector::visit (LiteralExpr &expr)
{
auto lit = expr.get_literal ();
visit (lit, expr.get_locus ());
}
void
-TokenStream::visit (AttrInputLiteral &literal)
+TokenCollector::visit (AttrInputLiteral &literal)
{
tokens.push_back (Rust::Token::make (EQUAL, Location ()));
visit (literal.get_literal ());
}
void
-TokenStream::visit (MetaItemLitExpr &item)
+TokenCollector::visit (MetaItemLitExpr &item)
{
auto lit = item.get_literal ();
visit (lit);
}
void
-TokenStream::visit (MetaItemPathLit &item)
+TokenCollector::visit (MetaItemPathLit &item)
{
auto path = item.get_path ();
auto lit = item.get_literal ();
}
void
-TokenStream::visit (BorrowExpr &expr)
+TokenCollector::visit (BorrowExpr &expr)
{
tokens.push_back (Rust::Token::make (AMP, expr.get_locus ()));
if (expr.get_is_double_borrow ())
}
void
-TokenStream::visit (DereferenceExpr &expr)
+TokenCollector::visit (DereferenceExpr &expr)
{
tokens.push_back (Rust::Token::make (ASTERISK, expr.get_locus ()));
visit (expr.get_dereferenced_expr ());
}
void
-TokenStream::visit (ErrorPropagationExpr &expr)
+TokenCollector::visit (ErrorPropagationExpr &expr)
{
visit (expr.get_propagating_expr ());
tokens.push_back (Rust::Token::make (QUESTION_MARK, expr.get_locus ()));
}
void
-TokenStream::visit (NegationExpr &expr)
+TokenCollector::visit (NegationExpr &expr)
{
switch (expr.get_expr_type ())
{
}
void
-TokenStream::visit (ArithmeticOrLogicalExpr &expr)
+TokenCollector::visit (ArithmeticOrLogicalExpr &expr)
{
visit (expr.get_left_expr ());
switch (expr.get_expr_type ())
}
void
-TokenStream::visit (ComparisonExpr &expr)
+TokenCollector::visit (ComparisonExpr &expr)
{
visit (expr.get_left_expr ());
}
void
-TokenStream::visit (LazyBooleanExpr &expr)
+TokenCollector::visit (LazyBooleanExpr &expr)
{
visit (expr.get_left_expr ());
}
void
-TokenStream::visit (TypeCastExpr &expr)
+TokenCollector::visit (TypeCastExpr &expr)
{
visit (expr.get_casted_expr ());
tokens.push_back (Rust::Token::make (AS, expr.get_locus ()));
}
void
-TokenStream::visit (AssignmentExpr &expr)
+TokenCollector::visit (AssignmentExpr &expr)
{
expr.visit_lhs (*this);
tokens.push_back (Rust::Token::make (EQUAL, expr.get_locus ()));
}
void
-TokenStream::visit (CompoundAssignmentExpr &expr)
+TokenCollector::visit (CompoundAssignmentExpr &expr)
{
visit (expr.get_left_expr ());
}
void
-TokenStream::visit (GroupedExpr &expr)
+TokenCollector::visit (GroupedExpr &expr)
{
tokens.push_back (Rust::Token::make (LEFT_PAREN, expr.get_locus ()));
visit (expr.get_expr_in_parens ());
}
void
-TokenStream::visit (ArrayElemsValues &elems)
+TokenCollector::visit (ArrayElemsValues &elems)
{
visit_items_joined_by_separator (elems.get_values (), COMMA);
}
void
-TokenStream::visit (ArrayElemsCopied &elems)
+TokenCollector::visit (ArrayElemsCopied &elems)
{
visit (elems.get_elem_to_copy ());
tokens.push_back (Rust::Token::make (SEMICOLON, Location ()));
}
void
-TokenStream::visit (ArrayExpr &expr)
+TokenCollector::visit (ArrayExpr &expr)
{
tokens.push_back (Rust::Token::make (LEFT_SQUARE, expr.get_locus ()));
visit (expr.get_array_elems ());
}
void
-TokenStream::visit (ArrayIndexExpr &expr)
+TokenCollector::visit (ArrayIndexExpr &expr)
{
visit (expr.get_array_expr ());
tokens.push_back (Rust::Token::make (LEFT_SQUARE, expr.get_locus ()));
}
void
-TokenStream::visit (TupleExpr &expr)
+TokenCollector::visit (TupleExpr &expr)
{
visit_items_as_lines (expr.get_outer_attrs ());
tokens.push_back (Rust::Token::make (LEFT_PAREN, expr.get_locus ()));
}
void
-TokenStream::visit (TupleIndexExpr &expr)
+TokenCollector::visit (TupleIndexExpr &expr)
{
visit (expr.get_tuple_expr ());
tokens.push_back (Rust::Token::make (DOT, expr.get_locus ()));
}
void
-TokenStream::visit (StructExprStruct &expr)
+TokenCollector::visit (StructExprStruct &expr)
{
visit (expr.get_struct_name ());
}
void
-TokenStream::visit (StructExprFieldIdentifier &expr)
+TokenCollector::visit (StructExprFieldIdentifier &expr)
{
// TODO: Add attributes
// visit_items_as_lines (expr.get_attrs ());
}
void
-TokenStream::visit (StructExprFieldIdentifierValue &expr)
+TokenCollector::visit (StructExprFieldIdentifierValue &expr)
{
// TODO: Add attributes
// visit_items_as_lines (expr.get_attrs ());
}
void
-TokenStream::visit (StructExprFieldIndexValue &expr)
+TokenCollector::visit (StructExprFieldIndexValue &expr)
{
// TODO: Add attributes
// visit_items_as_lines (expr.get_attrs ());
}
void
-TokenStream::visit (StructBase &base)
+TokenCollector::visit (StructBase &base)
{
tokens.push_back (Rust::Token::make (DOT_DOT, Location ()));
visit (base.get_base_struct ());
}
void
-TokenStream::visit (StructExprStructFields &expr)
+TokenCollector::visit (StructExprStructFields &expr)
{
visit (expr.get_struct_name ());
tokens.push_back (Rust::Token::make (LEFT_CURLY, expr.get_locus ()));
}
void
-TokenStream::visit (StructExprStructBase &)
+TokenCollector::visit (StructExprStructBase &)
{
// FIXME: Implement this node
gcc_unreachable ();
}
void
-TokenStream::visit (CallExpr &expr)
+TokenCollector::visit (CallExpr &expr)
{
visit (expr.get_function_expr ());
}
void
-TokenStream::visit (MethodCallExpr &expr)
+TokenCollector::visit (MethodCallExpr &expr)
{
visit (expr.get_receiver_expr ());
tokens.push_back (Rust::Token::make (DOT, expr.get_locus ()));
}
void
-TokenStream::visit (FieldAccessExpr &expr)
+TokenCollector::visit (FieldAccessExpr &expr)
{
visit (expr.get_receiver_expr ());
tokens.push_back (Rust::Token::make (DOT, expr.get_locus ()));
}
void
-TokenStream::visit (ClosureParam ¶m)
+TokenCollector::visit (ClosureParam ¶m)
{
visit_items_as_lines (param.get_outer_attrs ());
visit (param.get_pattern ());
}
void
-TokenStream::visit_closure_common (ClosureExpr &expr)
+TokenCollector::visit_closure_common (ClosureExpr &expr)
{
if (expr.get_has_move ())
{
}
void
-TokenStream::visit (ClosureExprInner &expr)
+TokenCollector::visit (ClosureExprInner &expr)
{
visit_closure_common (expr);
visit (expr.get_definition_expr ());
}
void
-TokenStream::visit (BlockExpr &expr)
+TokenCollector::visit (BlockExpr &expr)
{
tokens.push_back (Rust::Token::make (LEFT_CURLY, expr.get_locus ()));
newline ();
}
void
-TokenStream::visit (ClosureExprInnerTyped &expr)
+TokenCollector::visit (ClosureExprInnerTyped &expr)
{
visit_closure_common (expr);
tokens.push_back (Rust::Token::make (RETURN_TYPE, expr.get_locus ()));
}
void
-TokenStream::visit (ContinueExpr &expr)
+TokenCollector::visit (ContinueExpr &expr)
{
tokens.push_back (Rust::Token::make (CONTINUE, expr.get_locus ()));
if (expr.has_label ())
}
void
-TokenStream::visit (BreakExpr &expr)
+TokenCollector::visit (BreakExpr &expr)
{
tokens.push_back (Rust::Token::make (BREAK, expr.get_locus ()));
if (expr.has_label ())
}
void
-TokenStream::visit (RangeFromToExpr &expr)
+TokenCollector::visit (RangeFromToExpr &expr)
{
visit (expr.get_from_expr ());
tokens.push_back (Rust::Token::make (DOT_DOT, expr.get_locus ()));
}
void
-TokenStream::visit (RangeFromExpr &expr)
+TokenCollector::visit (RangeFromExpr &expr)
{
visit (expr.get_from_expr ());
tokens.push_back (Rust::Token::make (DOT_DOT, expr.get_locus ()));
}
void
-TokenStream::visit (RangeToExpr &expr)
+TokenCollector::visit (RangeToExpr &expr)
{
tokens.push_back (Rust::Token::make (DOT_DOT, expr.get_locus ()));
visit (expr.get_to_expr ());
}
void
-TokenStream::visit (RangeFullExpr &expr)
+TokenCollector::visit (RangeFullExpr &expr)
{
tokens.push_back (Rust::Token::make (DOT_DOT, expr.get_locus ()));
}
void
-TokenStream::visit (RangeFromToInclExpr &expr)
+TokenCollector::visit (RangeFromToInclExpr &expr)
{
visit (expr.get_from_expr ());
tokens.push_back (Rust::Token::make (DOT_DOT_EQ, expr.get_locus ()));
}
void
-TokenStream::visit (RangeToInclExpr &expr)
+TokenCollector::visit (RangeToInclExpr &expr)
{
tokens.push_back (Rust::Token::make (DOT_DOT_EQ, expr.get_locus ()));
visit (expr.get_to_expr ());
}
void
-TokenStream::visit (ReturnExpr &expr)
+TokenCollector::visit (ReturnExpr &expr)
{
tokens.push_back (Rust::Token::make (RETURN_TOK, expr.get_locus ()));
if (expr.has_returned_expr ())
}
void
-TokenStream::visit (UnsafeBlockExpr &expr)
+TokenCollector::visit (UnsafeBlockExpr &expr)
{
tokens.push_back (Rust::Token::make (UNSAFE, expr.get_locus ()));
visit (expr.get_block_expr ());
}
void
-TokenStream::visit (LoopLabel &label)
+TokenCollector::visit (LoopLabel &label)
{
visit (label.get_lifetime ());
tokens.push_back (Rust::Token::make (COLON, label.get_locus ()));
}
void
-TokenStream::visit_loop_common (BaseLoopExpr &expr)
+TokenCollector::visit_loop_common (BaseLoopExpr &expr)
{
if (expr.has_loop_label ())
visit (expr.get_loop_label ());
}
void
-TokenStream::visit (LoopExpr &expr)
+TokenCollector::visit (LoopExpr &expr)
{
visit_loop_common (expr);
tokens.push_back (Rust::Token::make (LOOP, expr.get_locus ()));
}
void
-TokenStream::visit (WhileLoopExpr &expr)
+TokenCollector::visit (WhileLoopExpr &expr)
{
visit_loop_common (expr);
tokens.push_back (Rust::Token::make (WHILE, expr.get_locus ()));
}
void
-TokenStream::visit (WhileLetLoopExpr &expr)
+TokenCollector::visit (WhileLetLoopExpr &expr)
{
visit_loop_common (expr);
tokens.push_back (Rust::Token::make (WHILE, expr.get_locus ()));
}
void
-TokenStream::visit (ForLoopExpr &expr)
+TokenCollector::visit (ForLoopExpr &expr)
{
visit_loop_common (expr);
tokens.push_back (Rust::Token::make (FOR, expr.get_locus ()));
}
void
-TokenStream::visit (IfExpr &expr)
+TokenCollector::visit (IfExpr &expr)
{
tokens.push_back (Rust::Token::make (IF, expr.get_locus ()));
visit (expr.get_condition_expr ());
}
void
-TokenStream::visit (IfExprConseqElse &expr)
+TokenCollector::visit (IfExprConseqElse &expr)
{
visit (static_cast<IfExpr &> (expr));
indentation ();
}
void
-TokenStream::visit (IfLetExpr &expr)
+TokenCollector::visit (IfLetExpr &expr)
{
tokens.push_back (Rust::Token::make (IF, expr.get_locus ()));
tokens.push_back (Rust::Token::make (LET, Location ()));
}
void
-TokenStream::visit (IfLetExprConseqElse &expr)
+TokenCollector::visit (IfLetExprConseqElse &expr)
{
visit (static_cast<IfLetExpr &> (expr));
indentation ();
}
void
-TokenStream::visit (MatchArm &arm)
+TokenCollector::visit (MatchArm &arm)
{
visit_items_as_lines (arm.get_outer_attrs ());
for (auto &pattern : arm.get_patterns ())
}
void
-TokenStream::visit (MatchCase &match_case)
+TokenCollector::visit (MatchCase &match_case)
{
visit (match_case.get_arm ());
tokens.push_back (Rust::Token::make (MATCH_ARROW, Location ()));
}
void
-TokenStream::visit (MatchExpr &expr)
+TokenCollector::visit (MatchExpr &expr)
{
tokens.push_back (Rust::Token::make (MATCH_TOK, expr.get_locus ()));
visit (expr.get_scrutinee_expr ());
}
void
-TokenStream::visit (AwaitExpr &expr)
+TokenCollector::visit (AwaitExpr &expr)
{
visit (expr.get_awaited_expr ());
tokens.push_back (Rust::Token::make (DOT, expr.get_locus ()));
}
void
-TokenStream::visit (AsyncBlockExpr &expr)
+TokenCollector::visit (AsyncBlockExpr &expr)
{
tokens.push_back (Rust::Token::make (ASYNC, expr.get_locus ()));
if (expr.get_has_move ())
// rust-item.h
void
-TokenStream::visit (TypeParam ¶m)
+TokenCollector::visit (TypeParam ¶m)
{
// Syntax:
// IDENTIFIER( : TypeParamBounds? )? ( = Type )?
}
void
-TokenStream::visit (WhereClause &rule)
+TokenCollector::visit (WhereClause &rule)
{
// Syntax:
// where ( WhereClauseItem , )* WhereClauseItem ?
}
void
-TokenStream::visit (LifetimeWhereClauseItem &item)
+TokenCollector::visit (LifetimeWhereClauseItem &item)
{
// Syntax:
// Lifetime : LifetimeBounds
}
void
-TokenStream::visit (TypeBoundWhereClauseItem &item)
+TokenCollector::visit (TypeBoundWhereClauseItem &item)
{
// Syntax:
// ForLifetimes? Type : TypeParamBounds?
}
void
-TokenStream::visit (Method &method)
+TokenCollector::visit (Method &method)
{
visit (method.get_visibility ());
auto method_name = method.get_method_name ();
}
void
-TokenStream::visit (Module &module)
+TokenCollector::visit (Module &module)
{
// Syntax:
// mod IDENTIFIER ;
}
void
-TokenStream::visit (ExternCrate &crate)
+TokenCollector::visit (ExternCrate &crate)
{
tokens.push_back (Rust::Token::make (EXTERN_TOK, crate.get_locus ()));
tokens.push_back (Rust::Token::make (CRATE, Location ()));
}
void
-TokenStream::visit (UseTreeGlob &use_tree)
+TokenCollector::visit (UseTreeGlob &use_tree)
{
switch (use_tree.get_glob_type ())
{
}
void
-TokenStream::visit (UseTreeList &use_tree)
+TokenCollector::visit (UseTreeList &use_tree)
{
switch (use_tree.get_path_type ())
{
}
void
-TokenStream::visit (UseTreeRebind &use_tree)
+TokenCollector::visit (UseTreeRebind &use_tree)
{
auto path = use_tree.get_path ();
visit (path);
}
void
-TokenStream::visit (UseDeclaration &decl)
+TokenCollector::visit (UseDeclaration &decl)
{
tokens.push_back (Rust::Token::make (USE, decl.get_locus ()));
visit (*decl.get_tree ());
}
void
-TokenStream::visit (Function &function)
+TokenCollector::visit (Function &function)
{
// Syntax:
// FunctionQualifiers fn IDENTIFIER GenericParams?
}
void
-TokenStream::visit (TypeAlias &type_alias)
+TokenCollector::visit (TypeAlias &type_alias)
{
// Syntax:
// Visibility? type IDENTIFIER GenericParams? WhereClause? = Type;
}
void
-TokenStream::visit (StructStruct &struct_item)
+TokenCollector::visit (StructStruct &struct_item)
{
if (struct_item.has_visibility ())
visit (struct_item.get_visibility ());
}
void
-TokenStream::visit (TupleStruct &tuple_struct)
+TokenCollector::visit (TupleStruct &tuple_struct)
{
auto struct_name = tuple_struct.get_identifier ();
tokens.push_back (Rust::Token::make (STRUCT_TOK, tuple_struct.get_locus ()));
}
void
-TokenStream::visit (EnumItem &item)
+TokenCollector::visit (EnumItem &item)
{
auto id = item.get_identifier ();
tokens.push_back (
}
void
-TokenStream::visit (EnumItemTuple &item)
+TokenCollector::visit (EnumItemTuple &item)
{
auto id = item.get_identifier ();
tokens.push_back (
}
void
-TokenStream::visit (EnumItemStruct &item)
+TokenCollector::visit (EnumItemStruct &item)
{
auto id = item.get_identifier ();
tokens.push_back (
}
void
-TokenStream::visit (EnumItemDiscriminant &item)
+TokenCollector::visit (EnumItemDiscriminant &item)
{
auto id = item.get_identifier ();
tokens.push_back (
}
void
-TokenStream::visit (Enum &enumeration)
+TokenCollector::visit (Enum &enumeration)
{
if (enumeration.has_visibility ())
visit (enumeration.get_visibility ());
}
void
-TokenStream::visit (Union &union_item)
+TokenCollector::visit (Union &union_item)
{
visit_items_as_lines (union_item.get_outer_attrs ());
auto id = union_item.get_identifier ();
}
void
-TokenStream::visit (ConstantItem &item)
+TokenCollector::visit (ConstantItem &item)
{
tokens.push_back (Rust::Token::make (CONST, item.get_locus ()));
if (item.is_unnamed ())
}
void
-TokenStream::visit (StaticItem &item)
+TokenCollector::visit (StaticItem &item)
{
tokens.push_back (Rust::Token::make (STATIC_TOK, item.get_locus ()));
if (item.is_mutable ())
}
void
-TokenStream::visit_function_common (std::unique_ptr<Type> &return_type,
- std::unique_ptr<BlockExpr> &block)
+TokenCollector::visit_function_common (std::unique_ptr<Type> &return_type,
+ std::unique_ptr<BlockExpr> &block)
{
// FIXME: This should format the `<vis> fn <name> ( [args] )` as well
if (return_type)
}
void
-TokenStream::visit (TraitItemFunc &item)
+TokenCollector::visit (TraitItemFunc &item)
{
auto func = item.get_trait_function_decl ();
auto id = func.get_identifier ();
}
void
-TokenStream::visit (SelfParam ¶m)
+TokenCollector::visit (SelfParam ¶m)
{
if (param.get_has_ref ())
{
}
void
-TokenStream::visit (TraitItemMethod &item)
+TokenCollector::visit (TraitItemMethod &item)
{
auto method = item.get_trait_method_decl ();
auto id = method.get_identifier ();
}
void
-TokenStream::visit (TraitItemConst &item)
+TokenCollector::visit (TraitItemConst &item)
{
auto id = item.get_identifier ();
indentation ();
}
void
-TokenStream::visit (TraitItemType &item)
+TokenCollector::visit (TraitItemType &item)
{
auto id = item.get_identifier ();
indentation ();
}
void
-TokenStream::visit (Trait &trait)
+TokenCollector::visit (Trait &trait)
{
for (auto &attr : trait.get_outer_attrs ())
{
}
void
-TokenStream::visit (InherentImpl &impl)
+TokenCollector::visit (InherentImpl &impl)
{
tokens.push_back (Rust::Token::make (IMPL, impl.get_locus ()));
// FIXME: Handle generics
}
void
-TokenStream::visit (TraitImpl &impl)
+TokenCollector::visit (TraitImpl &impl)
{
tokens.push_back (Rust::Token::make (IMPL, impl.get_locus ()));
visit (impl.get_trait_path ());
}
void
-TokenStream::visit (ExternalTypeItem &type)
+TokenCollector::visit (ExternalTypeItem &type)
{
visit (type.get_visibility ());
}
void
-TokenStream::visit (ExternalStaticItem &item)
+TokenCollector::visit (ExternalStaticItem &item)
{
auto id = item.get_identifier ();
visit_items_as_lines (item.get_outer_attrs ());
}
void
-TokenStream::visit (ExternalFunctionItem &function)
+TokenCollector::visit (ExternalFunctionItem &function)
{
visit (function.get_visibility ());
}
void
-TokenStream::visit (ExternBlock &block)
+TokenCollector::visit (ExternBlock &block)
{
tokens.push_back (Rust::Token::make (EXTERN_TOK, block.get_locus ()));
}
void
-TokenStream::visit (MacroMatchFragment &match)
+TokenCollector::visit (MacroMatchFragment &match)
{
auto id = match.get_ident ();
auto frag_spec = match.get_frag_spec ().as_string ();
}
void
-TokenStream::visit (MacroMatchRepetition &repetition)
+TokenCollector::visit (MacroMatchRepetition &repetition)
{
tokens.push_back (Rust::Token::make (DOLLAR_SIGN, Location ()));
tokens.push_back (Rust::Token::make (LEFT_PAREN, Location ()));
}
void
-TokenStream::visit (MacroMatcher &matcher)
+TokenCollector::visit (MacroMatcher &matcher)
{
auto delimiters = get_delimiters (matcher.get_delim_type ());
}
void
-TokenStream::visit (MacroRule &rule)
+TokenCollector::visit (MacroRule &rule)
{
visit (rule.get_matcher ());
tokens.push_back (Rust::Token::make (MATCH_ARROW, rule.get_locus ()));
}
void
-TokenStream::visit (MacroRulesDefinition &rules_def)
+TokenCollector::visit (MacroRulesDefinition &rules_def)
{
for (auto &outer_attr : rules_def.get_outer_attrs ())
visit (outer_attr);
}
void
-TokenStream::visit (MacroInvocation &invocation)
+TokenCollector::visit (MacroInvocation &invocation)
{
auto data = invocation.get_invoc_data ();
visit (data.get_path ());
}
void
-TokenStream::visit (MetaItemPath &item)
+TokenCollector::visit (MetaItemPath &item)
{
auto path = item.to_path_item ();
visit (path);
}
void
-TokenStream::visit (MetaItemSeq &item)
+TokenCollector::visit (MetaItemSeq &item)
{
visit (item.get_path ());
// TODO: Double check this, there is probably a mistake.
}
void
-TokenStream::visit (MetaWord &word)
+TokenCollector::visit (MetaWord &word)
{
auto id = word.get_ident ();
tokens.push_back (
}
void
-TokenStream::visit (MetaNameValueStr &name)
+TokenCollector::visit (MetaNameValueStr &name)
{
auto pair = name.get_name_value_pair ();
auto id = std::get<0> (pair);
}
void
-TokenStream::visit (MetaListPaths &list)
+TokenCollector::visit (MetaListPaths &list)
{
auto id = list.get_ident ();
tokens.push_back (
}
void
-TokenStream::visit (MetaListNameValueStr &list)
+TokenCollector::visit (MetaListNameValueStr &list)
{
auto id = list.get_ident ();
tokens.push_back (
// rust-pattern.h
void
-TokenStream::visit (LiteralPattern &pattern)
+TokenCollector::visit (LiteralPattern &pattern)
{
visit (pattern.get_literal (), pattern.get_locus ());
}
void
-TokenStream::visit (IdentifierPattern &pattern)
+TokenCollector::visit (IdentifierPattern &pattern)
{
if (pattern.get_is_ref ())
{
}
void
-TokenStream::visit (WildcardPattern &pattern)
+TokenCollector::visit (WildcardPattern &pattern)
{
tokens.push_back (Rust::Token::make (UNDERSCORE, pattern.get_locus ()));
}
void
-TokenStream::visit (RestPattern &pattern)
+TokenCollector::visit (RestPattern &pattern)
{
tokens.push_back (Rust::Token::make (DOT_DOT, pattern.get_locus ()));
}
-// void TokenStream::visit(RangePatternBound& ){}
+// void TokenCollector::visit(RangePatternBound& ){}
void
-TokenStream::visit (RangePatternBoundLiteral &pattern)
+TokenCollector::visit (RangePatternBoundLiteral &pattern)
{
if (pattern.get_has_minus ())
{
}
void
-TokenStream::visit (RangePatternBoundPath &pattern)
+TokenCollector::visit (RangePatternBoundPath &pattern)
{
visit (pattern.get_path ());
}
void
-TokenStream::visit (RangePatternBoundQualPath &pattern)
+TokenCollector::visit (RangePatternBoundQualPath &pattern)
{
visit (pattern.get_qualified_path ());
}
void
-TokenStream::visit (RangePattern &pattern)
+TokenCollector::visit (RangePattern &pattern)
{
if (pattern.get_has_lower_bound () && pattern.get_has_upper_bound ())
{
}
void
-TokenStream::visit (ReferencePattern &pattern)
+TokenCollector::visit (ReferencePattern &pattern)
{
if (pattern.is_double_reference ())
{
visit (pattern.get_referenced_pattern ());
}
-// void TokenStream::visit(StructPatternField& ){}
+// void TokenCollector::visit(StructPatternField& ){}
void
-TokenStream::visit (StructPatternFieldTuplePat &pattern)
+TokenCollector::visit (StructPatternFieldTuplePat &pattern)
{
visit_items_as_lines (pattern.get_outer_attrs ());
tokens.push_back (
}
void
-TokenStream::visit (StructPatternFieldIdentPat &pattern)
+TokenCollector::visit (StructPatternFieldIdentPat &pattern)
{
visit_items_as_lines (pattern.get_outer_attrs ());
auto id = pattern.get_identifier ();
}
void
-TokenStream::visit (StructPatternFieldIdent &pattern)
+TokenCollector::visit (StructPatternFieldIdent &pattern)
{
visit_items_as_lines (pattern.get_outer_attrs ());
if (pattern.is_ref ())
}
void
-TokenStream::visit (StructPattern &pattern)
+TokenCollector::visit (StructPattern &pattern)
{
visit (pattern.get_path ());
tokens.push_back (Rust::Token::make (LEFT_CURLY, pattern.get_locus ()));
tokens.push_back (Rust::Token::make (RIGHT_CURLY, Location ()));
}
-// void TokenStream::visit(TupleStructItems& ){}
+// void TokenCollector::visit(TupleStructItems& ){}
void
-TokenStream::visit (TupleStructItemsNoRange &pattern)
+TokenCollector::visit (TupleStructItemsNoRange &pattern)
{
for (auto &pat : pattern.get_patterns ())
{
}
void
-TokenStream::visit (TupleStructItemsRange &pattern)
+TokenCollector::visit (TupleStructItemsRange &pattern)
{
for (auto &lower : pattern.get_lower_patterns ())
{
}
void
-TokenStream::visit (TupleStructPattern &pattern)
+TokenCollector::visit (TupleStructPattern &pattern)
{
visit (pattern.get_path ());
tokens.push_back (Rust::Token::make (LEFT_PAREN, pattern.get_locus ()));
}
// void
-// TokenStream::visit (TuplePatternItems &)
+// TokenCollector::visit (TuplePatternItems &)
// {}
void
-TokenStream::visit (TuplePatternItemsMultiple &pattern)
+TokenCollector::visit (TuplePatternItemsMultiple &pattern)
{
visit_items_joined_by_separator (pattern.get_patterns (), COMMA);
}
void
-TokenStream::visit (TuplePatternItemsRanged &pattern)
+TokenCollector::visit (TuplePatternItemsRanged &pattern)
{
for (auto &lower : pattern.get_lower_patterns ())
{
}
void
-TokenStream::visit (TuplePattern &pattern)
+TokenCollector::visit (TuplePattern &pattern)
{
tokens.push_back (Rust::Token::make (LEFT_PAREN, pattern.get_locus ()));
visit (pattern.get_items ());
}
void
-TokenStream::visit (GroupedPattern &pattern)
+TokenCollector::visit (GroupedPattern &pattern)
{
tokens.push_back (Rust::Token::make (LEFT_PAREN, pattern.get_locus ()));
visit (pattern.get_pattern_in_parens ());
}
void
-TokenStream::visit (SlicePattern &pattern)
+TokenCollector::visit (SlicePattern &pattern)
{
tokens.push_back (Rust::Token::make (LEFT_SQUARE, pattern.get_locus ()));
visit_items_joined_by_separator (pattern.get_items (), COMMA);
}
void
-TokenStream::visit (AltPattern &pattern)
+TokenCollector::visit (AltPattern &pattern)
{
visit_items_joined_by_separator (pattern.get_alts (), PIPE);
}
// rust-stmt.h
void
-TokenStream::visit (EmptyStmt &)
+TokenCollector::visit (EmptyStmt &)
{}
void
-TokenStream::visit (LetStmt &stmt)
+TokenCollector::visit (LetStmt &stmt)
{
tokens.push_back (Rust::Token::make (LET, stmt.get_locus ()));
auto &pattern = stmt.get_pattern ();
}
void
-TokenStream::visit (ExprStmtWithoutBlock &stmt)
+TokenCollector::visit (ExprStmtWithoutBlock &stmt)
{
visit (stmt.get_expr ());
}
void
-TokenStream::visit (ExprStmtWithBlock &stmt)
+TokenCollector::visit (ExprStmtWithBlock &stmt)
{
visit (stmt.get_expr ());
}
// rust-type.h
void
-TokenStream::visit (TraitBound &bound)
+TokenCollector::visit (TraitBound &bound)
{
// Syntax:
// ?? ForLifetimes? TypePath
}
void
-TokenStream::visit (ImplTraitType &type)
+TokenCollector::visit (ImplTraitType &type)
{
// Syntax:
// impl TypeParamBounds
}
void
-TokenStream::visit (TraitObjectType &type)
+TokenCollector::visit (TraitObjectType &type)
{
// Syntax:
// dyn? TypeParamBounds
}
void
-TokenStream::visit (ParenthesisedType &type)
+TokenCollector::visit (ParenthesisedType &type)
{
// Syntax:
// ( Type )
}
void
-TokenStream::visit (ImplTraitTypeOneBound &type)
+TokenCollector::visit (ImplTraitTypeOneBound &type)
{
// Syntax:
// impl TraitBound
}
void
-TokenStream::visit (TraitObjectTypeOneBound &type)
+TokenCollector::visit (TraitObjectTypeOneBound &type)
{
// Syntax:
// dyn? TraitBound
}
void
-TokenStream::visit (TupleType &type)
+TokenCollector::visit (TupleType &type)
{
// Syntax:
// ( )
}
void
-TokenStream::visit (NeverType &type)
+TokenCollector::visit (NeverType &type)
{
// Syntax:
// !
}
void
-TokenStream::visit (RawPointerType &type)
+TokenCollector::visit (RawPointerType &type)
{
// Syntax:
// * ( mut | const ) TypeNoBounds
}
void
-TokenStream::visit (ReferenceType &type)
+TokenCollector::visit (ReferenceType &type)
{
// Syntax:
// & Lifetime? mut? TypeNoBounds
}
void
-TokenStream::visit (ArrayType &type)
+TokenCollector::visit (ArrayType &type)
{
// Syntax:
// [ Type ; Expression ]
}
void
-TokenStream::visit (SliceType &type)
+TokenCollector::visit (SliceType &type)
{
// Syntax:
// [ Type ]
}
void
-TokenStream::visit (InferredType &type)
+TokenCollector::visit (InferredType &type)
{
// Syntax:
// _
}
void
-TokenStream::visit (BareFunctionType &type)
+TokenCollector::visit (BareFunctionType &type)
{
// Syntax:
// ForLifetimes? FunctionTypeQualifiers fn
projects / thirdparty / gcc.git / commitdiff
