diff --git a/gcc/rust/ast/rust-ast-collector.cc b/gcc/rust/ast/rust-ast-collector.cc index 8f66742d119..804519835ce 100644 --- a/gcc/rust/ast/rust-ast-collector.cc +++ b/gcc/rust/ast/rust-ast-collector.cc @@ -21,6 +21,7 @@ #include "rust-expr.h" #include "rust-item.h" #include "rust-keyword-values.h" +#include "rust-path.h" #include "rust-system.h" #include "rust-token.h" @@ -100,6 +101,33 @@ TokenCollector::comment (std::string comment) tokens.push_back ({comment}); } +void +TokenCollector::begin_internal_comment (std::string comment) +{ + std::string symbol_begin ("("); + + tokens.push_back ({comment + symbol_begin, CollectItem::Comment::Internal}); +} + +void +TokenCollector::end_internal_comment (std::string comment) +{ + std::string symbol_end (")!"); + + tokens.push_back ({symbol_end + comment, CollectItem::Comment::Internal}); +} + +void +TokenCollector::internal_comment (std::string node_name, + std::function visitor) +{ + begin_internal_comment (node_name); + + visitor (); + + end_internal_comment (node_name); +} + void TokenCollector::visit (Visitable &v) { @@ -109,210 +137,233 @@ TokenCollector::visit (Visitable &v) void TokenCollector::visit (FunctionParam ¶m) { - visit_items_as_lines (param.get_outer_attrs ()); - if (!param.is_variadic ()) - { - visit (param.get_pattern ()); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (param.get_type ()); - } - else - { - if (param.has_name ()) - { - visit (param.get_pattern ()); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - } - push (Rust::Token::make (ELLIPSIS, UNDEF_LOCATION)); - } + internal_comment (std::string ("FunctionParam"), [this, ¶m] () { + visit_items_as_lines (param.get_outer_attrs ()); + if (!param.is_variadic ()) + { + visit (param.get_pattern ()); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit (param.get_type ()); + } + else + { + if (param.has_name ()) + { + visit (param.get_pattern ()); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + } + push (Rust::Token::make (ELLIPSIS, UNDEF_LOCATION)); + } + }); } void TokenCollector::visit (VariadicParam ¶m) { - if (param.has_pattern ()) - { - visit (param.get_pattern ()); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - } - push (Rust::Token::make (ELLIPSIS, UNDEF_LOCATION)); + internal_comment (std::string ("VariadicParam"), [this, ¶m] () { + if (param.has_pattern ()) + { + visit (param.get_pattern ()); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + } + push (Rust::Token::make (ELLIPSIS, UNDEF_LOCATION)); + }); } void TokenCollector::visit (Attribute &attrib) { - push (Rust::Token::make (HASH, attrib.get_locus ())); - if (attrib.is_inner_attribute ()) - push (Rust::Token::make (EXCLAM, UNDEF_LOCATION)); - push (Rust::Token::make (LEFT_SQUARE, UNDEF_LOCATION)); - visit (attrib.get_path ()); - - if (attrib.has_attr_input ()) - { - switch (attrib.get_attr_input ().get_attr_input_type ()) - { - case AST::AttrInput::AttrInputType::LITERAL: { - visit (static_cast (attrib.get_attr_input ())); - break; - } - case AST::AttrInput::AttrInputType::MACRO: { - visit (static_cast (attrib.get_attr_input ())); - break; - } - case AST::AttrInput::AttrInputType::META_ITEM: { - visit (static_cast ( - attrib.get_attr_input ())); - break; + internal_comment (std::string ("Attribute"), [this, &attrib] () { + push (Rust::Token::make (HASH, attrib.get_locus ())); + if (attrib.is_inner_attribute ()) + push (Rust::Token::make (EXCLAM, UNDEF_LOCATION)); + push (Rust::Token::make (LEFT_SQUARE, UNDEF_LOCATION)); + visit (attrib.get_path ()); + + if (attrib.has_attr_input ()) + { + switch (attrib.get_attr_input ().get_attr_input_type ()) + { + case AST::AttrInput::AttrInputType::LITERAL: { + visit ( + static_cast (attrib.get_attr_input ())); + break; + } + case AST::AttrInput::AttrInputType::MACRO: { + visit (static_cast (attrib.get_attr_input ())); + break; + } + case AST::AttrInput::AttrInputType::META_ITEM: { + visit (static_cast ( + attrib.get_attr_input ())); + break; + } + case AST::AttrInput::AttrInputType::TOKEN_TREE: { + visit (static_cast (attrib.get_attr_input ())); + break; + } + default: + rust_unreachable (); } - case AST::AttrInput::AttrInputType::TOKEN_TREE: { - visit (static_cast (attrib.get_attr_input ())); - break; - } - default: - rust_unreachable (); - } - } - push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + } + push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + }); } void TokenCollector::visit (SimplePath &path) { - if (path.has_opening_scope_resolution ()) - { - push (Rust::Token::make (SCOPE_RESOLUTION, path.get_locus ())); - } - visit_items_joined_by_separator (path.get_segments (), SCOPE_RESOLUTION); + internal_comment (std::string ("SimplePath"), [this, &path] () { + if (path.has_opening_scope_resolution ()) + { + push (Rust::Token::make (SCOPE_RESOLUTION, path.get_locus ())); + } + visit_items_joined_by_separator (path.get_segments (), SCOPE_RESOLUTION); + }); } void TokenCollector::visit (SimplePathSegment &segment) { - auto name = segment.get_segment_name (); - if (segment.is_crate_path_seg ()) - { - push (Rust::Token::make (CRATE, segment.get_locus ())); - } - else if (segment.is_super_path_seg ()) - { - push (Rust::Token::make (SUPER, segment.get_locus ())); - } - else if (segment.is_lower_self_seg ()) - { - push (Rust::Token::make (SELF, segment.get_locus ())); - } - else if (segment.is_big_self ()) - { - push (Rust::Token::make (SELF_ALIAS, segment.get_locus ())); - } - else - { - push ( - Rust::Token::make_identifier (segment.get_locus (), std::move (name))); - } + internal_comment (std::string ("SimplePathSegment"), [this, &segment] () { + auto name = segment.get_segment_name (); + if (segment.is_crate_path_seg ()) + { + push (Rust::Token::make (CRATE, segment.get_locus ())); + } + else if (segment.is_super_path_seg ()) + { + push (Rust::Token::make (SUPER, segment.get_locus ())); + } + else if (segment.is_lower_self_seg ()) + { + push (Rust::Token::make (SELF, segment.get_locus ())); + } + else if (segment.is_big_self ()) + { + push (Rust::Token::make (SELF_ALIAS, segment.get_locus ())); + } + else + { + push (Rust::Token::make_identifier (segment.get_locus (), + std::move (name))); + } + }); } void TokenCollector::visit (Visibility &vis) { - switch (vis.get_vis_type ()) - { - case Visibility::PUB: - push (Rust::Token::make (PUB, vis.get_locus ())); - break; - case Visibility::PUB_CRATE: - push (Rust::Token::make (PUB, vis.get_locus ())); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - push (Rust::Token::make (CRATE, UNDEF_LOCATION)); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); - break; - case Visibility::PUB_SELF: - push (Rust::Token::make (PUB, vis.get_locus ())); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - push (Rust::Token::make (SELF, UNDEF_LOCATION)); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); - break; - case Visibility::PUB_SUPER: - push (Rust::Token::make (PUB, vis.get_locus ())); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - push (Rust::Token::make (SUPER, UNDEF_LOCATION)); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); - break; - case Visibility::PUB_IN_PATH: - push (Rust::Token::make (PUB, vis.get_locus ())); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - push (Rust::Token::make (IN, UNDEF_LOCATION)); - visit (vis.get_path ()); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); - break; - case Visibility::PRIV: - break; - } + internal_comment (std::string ("Visibility"), [this, &vis] () { + switch (vis.get_vis_type ()) + { + case Visibility::PUB: + push (Rust::Token::make (PUB, vis.get_locus ())); + break; + case Visibility::PUB_CRATE: + push (Rust::Token::make (PUB, vis.get_locus ())); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (CRATE, UNDEF_LOCATION)); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + break; + case Visibility::PUB_SELF: + push (Rust::Token::make (PUB, vis.get_locus ())); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (SELF, UNDEF_LOCATION)); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + break; + case Visibility::PUB_SUPER: + push (Rust::Token::make (PUB, vis.get_locus ())); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (SUPER, UNDEF_LOCATION)); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + break; + case Visibility::PUB_IN_PATH: + push (Rust::Token::make (PUB, vis.get_locus ())); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (IN, UNDEF_LOCATION)); + visit (vis.get_path ()); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + break; + case Visibility::PRIV: + break; + } + }); } void TokenCollector::visit (NamedFunctionParam ¶m) { - auto name = param.get_name (); - if (!param.is_variadic ()) - { - push ( - Rust::Token::make_identifier (param.get_locus (), std::move (name))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (param.get_type ()); - } - else - { - if (name != "") - { - push (Rust::Token::make_identifier (param.get_locus (), - std::move (name))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - } - push (Rust::Token::make (ELLIPSIS, UNDEF_LOCATION)); - } + internal_comment (std::string ("NamedFunctionParam"), [this, ¶m] () { + auto name = param.get_name (); + if (!param.is_variadic ()) + { + push ( + Rust::Token::make_identifier (param.get_locus (), std::move (name))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit (param.get_type ()); + } + else + { + if (name != "") + { + push (Rust::Token::make_identifier (param.get_locus (), + std::move (name))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + } + push (Rust::Token::make (ELLIPSIS, UNDEF_LOCATION)); + } + }); } void TokenCollector::visit (std::vector> ¶ms) { - push (Rust::Token::make (LEFT_ANGLE, UNDEF_LOCATION)); - visit_items_joined_by_separator (params, COMMA); - push (Rust::Token::make (RIGHT_ANGLE, UNDEF_LOCATION)); + internal_comment (std::string ("GenericParam"), [this, ¶ms] () { + push (Rust::Token::make (LEFT_ANGLE, UNDEF_LOCATION)); + visit_items_joined_by_separator (params, COMMA); + push (Rust::Token::make (RIGHT_ANGLE, UNDEF_LOCATION)); + }); } void TokenCollector::visit (TupleField &field) { - for (auto attr : field.get_outer_attrs ()) - { - visit (attr); - } - visit (field.get_visibility ()); - visit (field.get_field_type ()); + internal_comment (std::string ("TupleField"), [this, &field] () { + for (auto attr : field.get_outer_attrs ()) + { + visit (attr); + } + visit (field.get_visibility ()); + visit (field.get_field_type ()); + }); } void TokenCollector::visit (StructField &field) { - for (auto attr : field.get_outer_attrs ()) - { - visit (attr); - } - visit (field.get_visibility ()); - auto name = field.get_field_name ().as_string (); - push (Rust::Token::make_identifier (field.get_locus (), std::move (name))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (field.get_field_type ()); + internal_comment (std::string ("StructField"), [this, &field] () { + for (auto attr : field.get_outer_attrs ()) + { + visit (attr); + } + visit (field.get_visibility ()); + auto name = field.get_field_name ().as_string (); + push (Rust::Token::make_identifier (field.get_locus (), std::move (name))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit (field.get_field_type ()); + }); } void TokenCollector::visit (std::vector &for_lifetimes) { - push (Rust::Token::make (FOR, UNDEF_LOCATION)); - push (Rust::Token::make (LEFT_ANGLE, UNDEF_LOCATION)); - visit_items_joined_by_separator (for_lifetimes, COMMA); - push (Rust::Token::make (RIGHT_ANGLE, UNDEF_LOCATION)); + internal_comment (std::string ("LifetimeParam"), [this, &for_lifetimes] () { + push (Rust::Token::make (FOR, UNDEF_LOCATION)); + push (Rust::Token::make (LEFT_ANGLE, UNDEF_LOCATION)); + visit_items_joined_by_separator (for_lifetimes, COMMA); + push (Rust::Token::make (RIGHT_ANGLE, UNDEF_LOCATION)); + }); } void @@ -321,22 +372,23 @@ TokenCollector::visit (FunctionQualifiers &qualifiers) // Syntax: // `const`? `async`? `unsafe`? (`extern` Abi?)? // unsafe? (extern Abi?)? - - if (qualifiers.is_async ()) - push (Rust::Token::make (ASYNC, qualifiers.get_locus ())); - if (qualifiers.is_const ()) - push (Rust::Token::make (CONST, qualifiers.get_locus ())); - if (qualifiers.is_unsafe ()) - push (Rust::Token::make (UNSAFE, qualifiers.get_locus ())); - if (qualifiers.is_extern ()) - { - push (Rust::Token::make (EXTERN_KW, qualifiers.get_locus ())); - if (qualifiers.has_abi ()) - { - push (Rust::Token::make_string (UNDEF_LOCATION, - qualifiers.get_extern_abi ())); - } - } + internal_comment (std::string ("FunctionQualifiers"), [this, &qualifiers] () { + if (qualifiers.is_async ()) + push (Rust::Token::make (ASYNC, qualifiers.get_locus ())); + if (qualifiers.is_const ()) + push (Rust::Token::make (CONST, qualifiers.get_locus ())); + if (qualifiers.is_unsafe ()) + push (Rust::Token::make (UNSAFE, qualifiers.get_locus ())); + if (qualifiers.is_extern ()) + { + push (Rust::Token::make (EXTERN_KW, qualifiers.get_locus ())); + if (qualifiers.has_abi ()) + { + push (Rust::Token::make_string (UNDEF_LOCATION, + qualifiers.get_extern_abi ())); + } + } + }); } void @@ -345,26 +397,28 @@ TokenCollector::visit (MaybeNamedParam ¶m) // Syntax: // OuterAttribute* ( ( IDENTIFIER | _ ) : )? Type - for (auto attr : param.get_outer_attrs ()) - { - visit (attr); - } - auto param_name = param.get_name ().as_string (); - switch (param.get_param_kind ()) - { - case MaybeNamedParam::UNNAMED: - break; - case MaybeNamedParam::IDENTIFIER: - push ( - Rust::Token::make_identifier (UNDEF_LOCATION, std::move (param_name))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - break; - case MaybeNamedParam::WILDCARD: - push (Rust::Token::make (UNDERSCORE, UNDEF_LOCATION)); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - break; - } - visit (param.get_type ()); + internal_comment (std::string ("MaybeNamedParam"), [this, ¶m] () { + for (auto attr : param.get_outer_attrs ()) + { + visit (attr); + } + auto param_name = param.get_name ().as_string (); + switch (param.get_param_kind ()) + { + case MaybeNamedParam::UNNAMED: + break; + case MaybeNamedParam::IDENTIFIER: + push (Rust::Token::make_identifier (UNDEF_LOCATION, + std::move (param_name))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + break; + case MaybeNamedParam::WILDCARD: + push (Rust::Token::make (UNDERSCORE, UNDEF_LOCATION)); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + break; + } + visit (param.get_type ()); + }); } void @@ -421,27 +475,34 @@ TokenCollector::visit (Token &tok) void TokenCollector::visit (DelimTokenTree &delim_tok_tree) { - for (auto &token : delim_tok_tree.to_token_stream ()) - { - visit (token); - } + internal_comment (std::string ("DelimTokenTree"), [this, &delim_tok_tree] () { + for (auto &token : delim_tok_tree.to_token_stream ()) + { + visit (token); + } + }); } void TokenCollector::visit (AttrInputMetaItemContainer &container) { - for (auto &item : container.get_items ()) - { - visit (item); - } + internal_comment (std::string ("AttrInputMetaItemContainer"), + [this, &container] () { + for (auto &item : container.get_items ()) + { + visit (item); + } + }); } void TokenCollector::visit (IdentifierExpr &ident_expr) { - auto ident = ident_expr.get_ident ().as_string (); - push ( - Rust::Token::make_identifier (ident_expr.get_locus (), std::move (ident))); + internal_comment (std::string ("IdentifierExpr"), [this, &ident_expr] () { + auto ident = ident_expr.get_ident ().as_string (); + push (Rust::Token::make_identifier (ident_expr.get_locus (), + std::move (ident))); + }); } void @@ -453,22 +514,24 @@ TokenCollector::visit (Lifetime &lifetime) // | 'static // | '_ - auto name = lifetime.get_lifetime_name (); - switch (lifetime.get_lifetime_type ()) - { - case Lifetime::LifetimeType::NAMED: - push ( - Rust::Token::make_lifetime (lifetime.get_locus (), std::move (name))); - break; - case Lifetime::LifetimeType::STATIC: - push (Rust::Token::make_lifetime (lifetime.get_locus (), - Values::Keywords::STATIC_KW)); - break; - case Lifetime::LifetimeType::WILDCARD: - push (Rust::Token::make_lifetime (lifetime.get_locus (), - Values::Keywords::UNDERSCORE)); - break; - } + internal_comment (std::string ("Lifetime"), [this, &lifetime] () { + auto name = lifetime.get_lifetime_name (); + switch (lifetime.get_lifetime_type ()) + { + case Lifetime::LifetimeType::NAMED: + push ( + Rust::Token::make_lifetime (lifetime.get_locus (), std::move (name))); + break; + case Lifetime::LifetimeType::STATIC: + push (Rust::Token::make_lifetime (lifetime.get_locus (), + Values::Keywords::STATIC_KW)); + break; + case Lifetime::LifetimeType::WILDCARD: + push (Rust::Token::make_lifetime (lifetime.get_locus (), + Values::Keywords::UNDERSCORE)); + break; + } + }); } void @@ -480,19 +543,20 @@ TokenCollector::visit (LifetimeParam &lifetime_param) // ( Lifetime + )* Lifetime? // TODO what to do with outer attr? They are not mentioned in the reference. - - visit_items_as_lines (lifetime_param.get_outer_attrs ()); - auto lifetime = lifetime_param.get_lifetime (); - visit (lifetime); - - if (lifetime_param.has_lifetime_bounds ()) - { - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - for (auto &bound : lifetime_param.get_lifetime_bounds ()) - { - visit (bound); - } - } + internal_comment (std::string ("LifetimeParam"), [this, &lifetime_param] () { + visit_items_as_lines (lifetime_param.get_outer_attrs ()); + auto lifetime = lifetime_param.get_lifetime (); + visit (lifetime); + + if (lifetime_param.has_lifetime_bounds ()) + { + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + for (auto &bound : lifetime_param.get_lifetime_bounds ()) + { + visit (bound); + } + } + }); } void @@ -500,65 +564,70 @@ TokenCollector::visit (ConstGenericParam ¶m) { // Syntax: // const IDENTIFIER : Type ( = Block | IDENTIFIER | -?LITERAL )? - - visit_items_as_lines (param.get_outer_attrs ()); - push (Rust::Token::make (CONST, param.get_locus ())); - auto id = param.get_name ().as_string (); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - if (param.has_type ()) - visit (param.get_type ()); - if (param.has_default_value ()) - { - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (param.get_default_value ()); - } + internal_comment (std::string ("ConstGenericParam"), [this, ¶m] () { + visit_items_as_lines (param.get_outer_attrs ()); + push (Rust::Token::make (CONST, param.get_locus ())); + auto id = param.get_name ().as_string (); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + if (param.has_type ()) + visit (param.get_type ()); + if (param.has_default_value ()) + { + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (param.get_default_value ()); + } + }); } void TokenCollector::visit (PathExprSegment &segment) { - visit (segment.get_ident_segment ()); - if (segment.has_generic_args ()) - { - auto generics = segment.get_generic_args (); - push (Rust::Token::make (SCOPE_RESOLUTION, segment.get_locus ())); - push (Rust::Token::make (LEFT_ANGLE, generics.get_locus ())); + internal_comment (std::string ("PathExprSegment"), [this, &segment] () { + visit (segment.get_ident_segment ()); + if (segment.has_generic_args ()) + { + auto generics = segment.get_generic_args (); + push (Rust::Token::make (SCOPE_RESOLUTION, segment.get_locus ())); + push (Rust::Token::make (LEFT_ANGLE, generics.get_locus ())); - auto &lifetime_args = generics.get_lifetime_args (); - auto &generic_args = generics.get_generic_args (); - auto &binding_args = generics.get_binding_args (); + auto &lifetime_args = generics.get_lifetime_args (); + auto &generic_args = generics.get_generic_args (); + auto &binding_args = generics.get_binding_args (); - visit_items_joined_by_separator (generic_args, COMMA); + visit_items_joined_by_separator (generic_args, COMMA); - if (!lifetime_args.empty () - && (!generic_args.empty () || !binding_args.empty ())) - { - push (Rust::Token::make (COMMA, UNDEF_LOCATION)); - } + if (!lifetime_args.empty () + && (!generic_args.empty () || !binding_args.empty ())) + { + push (Rust::Token::make (COMMA, UNDEF_LOCATION)); + } - visit_items_joined_by_separator (binding_args, COMMA); + visit_items_joined_by_separator (binding_args, COMMA); - if (!generic_args.empty () && !binding_args.empty ()) - { - push (Rust::Token::make (COMMA, UNDEF_LOCATION)); - } + if (!generic_args.empty () && !binding_args.empty ()) + { + push (Rust::Token::make (COMMA, UNDEF_LOCATION)); + } - visit_items_joined_by_separator (lifetime_args, COMMA); + visit_items_joined_by_separator (lifetime_args, COMMA); - push (Rust::Token::make (RIGHT_ANGLE, UNDEF_LOCATION)); - } + push (Rust::Token::make (RIGHT_ANGLE, UNDEF_LOCATION)); + } + }); } void TokenCollector::visit (PathInExpression &path) { - if (path.opening_scope_resolution ()) - { - push (Rust::Token::make (SCOPE_RESOLUTION, path.get_locus ())); - } + internal_comment (std::string ("PathInExpression"), [this, &path] () { + if (path.opening_scope_resolution ()) + { + push (Rust::Token::make (SCOPE_RESOLUTION, path.get_locus ())); + } - visit_items_joined_by_separator (path.get_segments (), SCOPE_RESOLUTION); + visit_items_joined_by_separator (path.get_segments (), SCOPE_RESOLUTION); + }); } void @@ -579,10 +648,12 @@ TokenCollector::visit (TypePathSegment &segment) { // Syntax: // PathIdentSegment - auto ident_segment = segment.get_ident_segment (); - auto id = ident_segment.as_string (); - push ( - Rust::Token::make_identifier (ident_segment.get_locus (), std::move (id))); + internal_comment (std::string ("TypePathSegment"), [this, &segment] () { + auto ident_segment = segment.get_ident_segment (); + auto id = ident_segment.as_string (); + push (Rust::Token::make_identifier (ident_segment.get_locus (), + std::move (id))); + }); } void @@ -593,33 +664,35 @@ TokenCollector::visit (TypePathSegmentGeneric &segment) // GenericArgs : // `<` `>` // | `<` ( GenericArg `,` )* GenericArg `,`? `>` + internal_comment (std::string ("TypePathSegmentGeneric"), [this, + &segment] () { + auto ident_segment = segment.get_ident_segment (); + auto id = ident_segment.as_string (); + push (Rust::Token::make_identifier (ident_segment.get_locus (), + std::move (id))); + + if (segment.get_separating_scope_resolution ()) + push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); - auto ident_segment = segment.get_ident_segment (); - auto id = ident_segment.as_string (); - push ( - Rust::Token::make_identifier (ident_segment.get_locus (), std::move (id))); - - if (segment.get_separating_scope_resolution ()) - push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); - - push (Rust::Token::make (LEFT_ANGLE, UNDEF_LOCATION)); + push (Rust::Token::make (LEFT_ANGLE, UNDEF_LOCATION)); - { - auto &lifetime_args = segment.get_generic_args ().get_lifetime_args (); - auto &generic_args = segment.get_generic_args ().get_generic_args (); - auto &binding_args = segment.get_generic_args ().get_binding_args (); + { + auto &lifetime_args = segment.get_generic_args ().get_lifetime_args (); + auto &generic_args = segment.get_generic_args ().get_generic_args (); + auto &binding_args = segment.get_generic_args ().get_binding_args (); - visit_items_joined_by_separator (lifetime_args, COMMA); - if (!lifetime_args.empty () - && (!generic_args.empty () || !binding_args.empty ())) - push (Rust::Token::make (COMMA, UNDEF_LOCATION)); - visit_items_joined_by_separator (generic_args, COMMA); - if (!generic_args.empty () && !binding_args.empty ()) - push (Rust::Token::make (COMMA, UNDEF_LOCATION)); - visit_items_joined_by_separator (binding_args, COMMA); - } + visit_items_joined_by_separator (lifetime_args, COMMA); + if (!lifetime_args.empty () + && (!generic_args.empty () || !binding_args.empty ())) + push (Rust::Token::make (COMMA, UNDEF_LOCATION)); + visit_items_joined_by_separator (generic_args, COMMA); + if (!generic_args.empty () && !binding_args.empty ()) + push (Rust::Token::make (COMMA, UNDEF_LOCATION)); + visit_items_joined_by_separator (binding_args, COMMA); + } - push (Rust::Token::make (RIGHT_ANGLE, UNDEF_LOCATION)); + push (Rust::Token::make (RIGHT_ANGLE, UNDEF_LOCATION)); + }); } void @@ -627,12 +700,14 @@ TokenCollector::visit (GenericArgsBinding &binding) { // Syntax: // IDENTIFIER `=` Type - auto identifier = binding.get_identifier ().as_string (); - push (Rust::Token::make_identifier (binding.get_locus (), - std::move (identifier))); + internal_comment (std::string ("GenericArgsBinding"), [this, &binding] () { + auto identifier = binding.get_identifier ().as_string (); + push (Rust::Token::make_identifier (binding.get_locus (), + std::move (identifier))); - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (binding.get_type ()); + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (binding.get_type ()); + }); } void @@ -640,22 +715,25 @@ TokenCollector::visit (GenericArg &arg) { // `GenericArg` implements `accept_vis` but it is not useful for this case as // it ignores unresolved cases (`Kind::Either`). - switch (arg.get_kind ()) - { - case GenericArg::Kind::Const: - visit (arg.get_expression ()); - break; - case GenericArg::Kind::Type: - visit (arg.get_type ()); - break; - case GenericArg::Kind::Either: { - auto path = arg.get_path (); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (path))); + internal_comment (std::string ("GenericArg"), [this, &arg] () { + switch (arg.get_kind ()) + { + case GenericArg::Kind::Const: + visit (arg.get_expression ()); + break; + case GenericArg::Kind::Type: + visit (arg.get_type ()); + break; + case GenericArg::Kind::Either: { + auto path = arg.get_path (); + push ( + Rust::Token::make_identifier (UNDEF_LOCATION, std::move (path))); + } + break; + case GenericArg::Kind::Error: + rust_unreachable (); } - break; - case GenericArg::Kind::Error: - rust_unreachable (); - } + }); } void @@ -663,17 +741,19 @@ TokenCollector::visit (TypePathSegmentFunction &segment) { // Syntax: // PathIdentSegment `::`? (TypePathFn)? + internal_comment (std::string ("TypePathSegmentFunction"), [this, + &segment] () { + auto ident_segment = segment.get_ident_segment (); + auto id = ident_segment.as_string (); + push (Rust::Token::make_identifier (ident_segment.get_locus (), + std::move (id))); + + if (segment.get_separating_scope_resolution ()) + push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); - auto ident_segment = segment.get_ident_segment (); - auto id = ident_segment.as_string (); - push ( - Rust::Token::make_identifier (ident_segment.get_locus (), std::move (id))); - - if (segment.get_separating_scope_resolution ()) - push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); - - if (!segment.is_ident_only ()) - visit (segment.get_type_path_function ()); + if (!segment.is_ident_only ()) + visit (segment.get_type_path_function ()); + }); } void @@ -683,17 +763,18 @@ TokenCollector::visit (TypePathFunction &type_path_fn) // `(` TypePathFnInputs? `)` (`->` Type)? // TypePathFnInputs : // Type (`,` Type)* `,`? - - push (Rust::Token::make (LEFT_PAREN, type_path_fn.get_locus ())); - if (type_path_fn.has_inputs ()) - visit_items_joined_by_separator (type_path_fn.get_params (), COMMA); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); - - if (type_path_fn.has_return_type ()) - { - push (Rust::Token::make (RETURN_TYPE, UNDEF_LOCATION)); - visit (type_path_fn.get_return_type ()); - } + internal_comment (std::string ("TypePathFunction"), [this, &type_path_fn] () { + push (Rust::Token::make (LEFT_PAREN, type_path_fn.get_locus ())); + if (type_path_fn.has_inputs ()) + visit_items_joined_by_separator (type_path_fn.get_params (), COMMA); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + + if (type_path_fn.has_return_type ()) + { + push (Rust::Token::make (RETURN_TYPE, UNDEF_LOCATION)); + visit (type_path_fn.get_return_type ()); + } + }); } void @@ -701,76 +782,86 @@ TokenCollector::visit (TypePath &path) { // Syntax: // `::`? TypePathSegment (`::` TypePathSegment)* + internal_comment (std::string ("TypePath"), [this, &path] () { + if (path.has_opening_scope_resolution_op ()) + push (Rust::Token::make (SCOPE_RESOLUTION, path.get_locus ())); - if (path.has_opening_scope_resolution_op ()) - push (Rust::Token::make (SCOPE_RESOLUTION, path.get_locus ())); - - visit_items_joined_by_separator (path.get_segments (), SCOPE_RESOLUTION); + visit_items_joined_by_separator (path.get_segments (), SCOPE_RESOLUTION); + }); } void TokenCollector::visit (PathIdentSegment &segment) { - if (segment.is_super_path_seg ()) - { - push (Rust::Token::make (SUPER, segment.get_locus ())); - } - else if (segment.is_crate_path_seg ()) - { - push (Rust::Token::make (CRATE, segment.get_locus ())); - } - else if (segment.is_lower_self_seg ()) - { - push (Rust::Token::make (SELF, segment.get_locus ())); - } - else if (segment.is_big_self_seg ()) - { - push (Rust::Token::make (SELF_ALIAS, segment.get_locus ())); - } - else - { - auto id = segment.as_string (); - push ( - Rust::Token::make_identifier (segment.get_locus (), std::move (id))); - } + internal_comment (std::string ("PathIdentSegment"), [this, &segment] () { + if (segment.is_super_path_seg ()) + { + push (Rust::Token::make (SUPER, segment.get_locus ())); + } + else if (segment.is_crate_path_seg ()) + { + push (Rust::Token::make (CRATE, segment.get_locus ())); + } + else if (segment.is_lower_self_seg ()) + { + push (Rust::Token::make (SELF, segment.get_locus ())); + } + else if (segment.is_big_self_seg ()) + { + push (Rust::Token::make (SELF_ALIAS, segment.get_locus ())); + } + else + { + auto id = segment.as_string (); + push ( + Rust::Token::make_identifier (segment.get_locus (), std::move (id))); + } + }); } void TokenCollector::visit (QualifiedPathInExpression &path) { - visit (path.get_qualified_path_type ()); - for (auto &segment : path.get_segments ()) - { - push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); - visit (segment); - } + internal_comment (std::string ("QualifiedPathInExpression"), [this, + &path] () { + visit (path.get_qualified_path_type ()); + for (auto &segment : path.get_segments ()) + { + push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); + visit (segment); + } + }); } void TokenCollector::visit (QualifiedPathType &path) { - push (Rust::Token::make (LEFT_ANGLE, path.get_locus ())); - visit (path.get_type ()); - if (path.has_as_clause ()) - { - push (Rust::Token::make (AS, UNDEF_LOCATION)); - visit (path.get_as_type_path ()); - } - push (Rust::Token::make (RIGHT_ANGLE, UNDEF_LOCATION)); + internal_comment (std::string ("QualifiedPathType"), [this, &path] () { + push (Rust::Token::make (LEFT_ANGLE, path.get_locus ())); + visit (path.get_type ()); + if (path.has_as_clause ()) + { + push (Rust::Token::make (AS, UNDEF_LOCATION)); + visit (path.get_as_type_path ()); + } + push (Rust::Token::make (RIGHT_ANGLE, UNDEF_LOCATION)); + }); } void TokenCollector::visit (QualifiedPathInType &path) { - visit (path.get_qualified_path_type ()); + internal_comment (std::string ("QualifiedPathInType"), [this, &path] () { + visit (path.get_qualified_path_type ()); - push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); - visit (path.get_associated_segment ()); - for (auto &segment : path.get_segments ()) - { - push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); - visit (segment); - } + push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); + visit (path.get_associated_segment ()); + for (auto &segment : path.get_segments ()) + { + push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); + visit (segment); + } + }); } void @@ -823,364 +914,422 @@ TokenCollector::visit (Literal &lit, location_t locus) void TokenCollector::visit (LiteralExpr &expr) { - auto lit = expr.get_literal (); - visit (lit, expr.get_locus ()); + internal_comment (std::string ("LiteralExpr"), [this, &expr] () { + auto lit = expr.get_literal (); + visit (lit, expr.get_locus ()); + }); } void TokenCollector::visit (AttrInputLiteral &literal) { - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (literal.get_literal ()); + internal_comment (std::string ("AttrInputLiteral"), [this, &literal] () { + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (literal.get_literal ()); + }); } void TokenCollector::visit (AttrInputMacro ¯o) { - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (macro.get_macro ()); + internal_comment (std::string ("AttrInputMacro"), [this, ¯o] () { + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (macro.get_macro ()); + }); } void TokenCollector::visit (MetaItemLitExpr &item) { - auto lit = item.get_literal (); - visit (lit); + internal_comment (std::string ("MetaItemLitExpr"), [this, &item] () { + auto lit = item.get_literal (); + visit (lit); + }); } void TokenCollector::visit (MetaItemPathLit &item) { - auto path = item.get_path (); - auto lit = item.get_literal (); - visit (path); - push (Rust::Token::make (COLON, item.get_locus ())); - visit (lit); + internal_comment (std::string ("MetaItemPathLit"), [this, &item] () { + auto path = item.get_path (); + auto lit = item.get_literal (); + visit (path); + push (Rust::Token::make (COLON, item.get_locus ())); + visit (lit); + }); } void TokenCollector::visit (BorrowExpr &expr) { - push (Rust::Token::make (AMP, expr.get_locus ())); - if (expr.get_is_double_borrow ()) - push (Rust::Token::make (AMP, UNDEF_LOCATION)); + internal_comment (std::string ("BorrowExpr"), [this, &expr] () { + push (Rust::Token::make (AMP, expr.get_locus ())); + if (expr.get_is_double_borrow ()) + push (Rust::Token::make (AMP, UNDEF_LOCATION)); - if (expr.is_raw_borrow ()) - { - push (Rust::Token::make_identifier (expr.get_locus (), - Values::WeakKeywords::RAW)); - if (expr.get_is_mut ()) - push (Rust::Token::make (MUT, UNDEF_LOCATION)); - else - push (Rust::Token::make (CONST, UNDEF_LOCATION)); - } - else - { - if (expr.get_is_mut ()) - push (Rust::Token::make (MUT, UNDEF_LOCATION)); - } + if (expr.is_raw_borrow ()) + { + push (Rust::Token::make_identifier (expr.get_locus (), + Values::WeakKeywords::RAW)); + if (expr.get_is_mut ()) + push (Rust::Token::make (MUT, UNDEF_LOCATION)); + else + push (Rust::Token::make (CONST, UNDEF_LOCATION)); + } + else + { + if (expr.get_is_mut ()) + push (Rust::Token::make (MUT, UNDEF_LOCATION)); + } - visit (expr.get_borrowed_expr ()); + visit (expr.get_borrowed_expr ()); + }); } void TokenCollector::visit (DereferenceExpr &expr) { - push (Rust::Token::make (ASTERISK, expr.get_locus ())); - visit (expr.get_dereferenced_expr ()); + internal_comment (std::string ("DereferenceExpr"), [this, &expr] () { + push (Rust::Token::make (ASTERISK, expr.get_locus ())); + visit (expr.get_dereferenced_expr ()); + }); } void TokenCollector::visit (ErrorPropagationExpr &expr) { - visit (expr.get_propagating_expr ()); - push (Rust::Token::make (QUESTION_MARK, expr.get_locus ())); + internal_comment (std::string ("ErrorPropagationExpr"), [this, &expr] () { + visit (expr.get_propagating_expr ()); + push (Rust::Token::make (QUESTION_MARK, expr.get_locus ())); + }); } void TokenCollector::visit (NegationExpr &expr) { - switch (expr.get_expr_type ()) - { - case NegationOperator::NEGATE: - push (Rust::Token::make (MINUS, expr.get_locus ())); - break; - case NegationOperator::NOT: - push (Rust::Token::make (EXCLAM, expr.get_locus ())); - break; - } - visit (expr.get_negated_expr ()); + internal_comment (std::string ("NegationExpr"), [this, &expr] () { + switch (expr.get_expr_type ()) + { + case NegationOperator::NEGATE: + push (Rust::Token::make (MINUS, expr.get_locus ())); + break; + case NegationOperator::NOT: + push (Rust::Token::make (EXCLAM, expr.get_locus ())); + break; + } + visit (expr.get_negated_expr ()); + }); } void TokenCollector::visit (ArithmeticOrLogicalExpr &expr) { - visit (expr.get_left_expr ()); - switch (expr.get_expr_type ()) - { - case ArithmeticOrLogicalOperator::ADD: - push (Rust::Token::make (PLUS, expr.get_locus ())); - break; + internal_comment (std::string ("ArithmeticOrLogicalExpr"), [this, &expr] () { + visit (expr.get_left_expr ()); + switch (expr.get_expr_type ()) + { + case ArithmeticOrLogicalOperator::ADD: + push (Rust::Token::make (PLUS, expr.get_locus ())); + break; - case ArithmeticOrLogicalOperator::SUBTRACT: - push (Rust::Token::make (MINUS, expr.get_locus ())); - break; + case ArithmeticOrLogicalOperator::SUBTRACT: + push (Rust::Token::make (MINUS, expr.get_locus ())); + break; - case ArithmeticOrLogicalOperator::MULTIPLY: - push (Rust::Token::make (ASTERISK, expr.get_locus ())); - break; + case ArithmeticOrLogicalOperator::MULTIPLY: + push (Rust::Token::make (ASTERISK, expr.get_locus ())); + break; - case ArithmeticOrLogicalOperator::DIVIDE: - push (Rust::Token::make (DIV, expr.get_locus ())); - break; + case ArithmeticOrLogicalOperator::DIVIDE: + push (Rust::Token::make (DIV, expr.get_locus ())); + break; - case ArithmeticOrLogicalOperator::MODULUS: - push (Rust::Token::make (PERCENT, expr.get_locus ())); - break; + case ArithmeticOrLogicalOperator::MODULUS: + push (Rust::Token::make (PERCENT, expr.get_locus ())); + break; - case ArithmeticOrLogicalOperator::BITWISE_AND: - push (Rust::Token::make (AMP, expr.get_locus ())); - break; + case ArithmeticOrLogicalOperator::BITWISE_AND: + push (Rust::Token::make (AMP, expr.get_locus ())); + break; - case ArithmeticOrLogicalOperator::BITWISE_OR: - push (Rust::Token::make (PIPE, expr.get_locus ())); - break; + case ArithmeticOrLogicalOperator::BITWISE_OR: + push (Rust::Token::make (PIPE, expr.get_locus ())); + break; - case ArithmeticOrLogicalOperator::BITWISE_XOR: - push (Rust::Token::make (CARET, expr.get_locus ())); - break; + case ArithmeticOrLogicalOperator::BITWISE_XOR: + push (Rust::Token::make (CARET, expr.get_locus ())); + break; - case ArithmeticOrLogicalOperator::LEFT_SHIFT: - push (Rust::Token::make (LEFT_SHIFT, expr.get_locus ())); - break; + case ArithmeticOrLogicalOperator::LEFT_SHIFT: + push (Rust::Token::make (LEFT_SHIFT, expr.get_locus ())); + break; - case ArithmeticOrLogicalOperator::RIGHT_SHIFT: - push (Rust::Token::make (RIGHT_SHIFT, expr.get_locus ())); - break; - } + case ArithmeticOrLogicalOperator::RIGHT_SHIFT: + push (Rust::Token::make (RIGHT_SHIFT, expr.get_locus ())); + break; + } - visit (expr.get_right_expr ()); + visit (expr.get_right_expr ()); + }); } void TokenCollector::visit (ComparisonExpr &expr) { - visit (expr.get_left_expr ()); + internal_comment (std::string ("ComparisonExpr"), [this, &expr] () { + visit (expr.get_left_expr ()); - switch (expr.get_expr_type ()) - { - case ComparisonOperator::EQUAL: - push (Rust::Token::make (EQUAL_EQUAL, expr.get_locus ())); - break; - case ComparisonOperator::NOT_EQUAL: - push (Rust::Token::make (NOT_EQUAL, expr.get_locus ())); - break; - case ComparisonOperator::GREATER_THAN: - push (Rust::Token::make (RIGHT_ANGLE, expr.get_locus ())); - break; - case ComparisonOperator::LESS_THAN: - push (Rust::Token::make (LEFT_ANGLE, expr.get_locus ())); - break; - case ComparisonOperator::GREATER_OR_EQUAL: - push (Rust::Token::make (GREATER_OR_EQUAL, expr.get_locus ())); - break; + switch (expr.get_expr_type ()) + { + case ComparisonOperator::EQUAL: + push (Rust::Token::make (EQUAL_EQUAL, expr.get_locus ())); + break; + case ComparisonOperator::NOT_EQUAL: + push (Rust::Token::make (NOT_EQUAL, expr.get_locus ())); + break; + case ComparisonOperator::GREATER_THAN: + push (Rust::Token::make (RIGHT_ANGLE, expr.get_locus ())); + break; + case ComparisonOperator::LESS_THAN: + push (Rust::Token::make (LEFT_ANGLE, expr.get_locus ())); + break; + case ComparisonOperator::GREATER_OR_EQUAL: + push (Rust::Token::make (GREATER_OR_EQUAL, expr.get_locus ())); + break; - case ComparisonOperator::LESS_OR_EQUAL: - push (Rust::Token::make (LESS_OR_EQUAL, expr.get_locus ())); - break; - } - visit (expr.get_right_expr ()); + case ComparisonOperator::LESS_OR_EQUAL: + push (Rust::Token::make (LESS_OR_EQUAL, expr.get_locus ())); + break; + } + visit (expr.get_right_expr ()); + }); } void TokenCollector::visit (LazyBooleanExpr &expr) { - visit (expr.get_left_expr ()); + internal_comment (std::string ("LazyBooleanExpr"), [this, &expr] () { + visit (expr.get_left_expr ()); - switch (expr.get_expr_type ()) - { - case LazyBooleanOperator::LOGICAL_AND: - push (Rust::Token::make (LOGICAL_AND, expr.get_locus ())); - break; - case LazyBooleanOperator::LOGICAL_OR: - push (Rust::Token::make (OR, expr.get_locus ())); - break; - } + switch (expr.get_expr_type ()) + { + case LazyBooleanOperator::LOGICAL_AND: + push (Rust::Token::make (LOGICAL_AND, expr.get_locus ())); + break; + case LazyBooleanOperator::LOGICAL_OR: + push (Rust::Token::make (OR, expr.get_locus ())); + break; + } - visit (expr.get_right_expr ()); + visit (expr.get_right_expr ()); + }); } void TokenCollector::visit (TypeCastExpr &expr) { - visit (expr.get_casted_expr ()); - push (Rust::Token::make (AS, expr.get_locus ())); - visit (expr.get_type_to_cast_to ()); + internal_comment (std::string ("TypeCastExpr"), [this, &expr] () { + visit (expr.get_casted_expr ()); + push (Rust::Token::make (AS, expr.get_locus ())); + visit (expr.get_type_to_cast_to ()); + }); } void TokenCollector::visit (AssignmentExpr &expr) { - expr.visit_lhs (*this); - push (Rust::Token::make (EQUAL, expr.get_locus ())); - expr.visit_rhs (*this); + internal_comment (std::string ("AssignementExpr"), [this, &expr] () { + expr.visit_lhs (*this); + push (Rust::Token::make (EQUAL, expr.get_locus ())); + expr.visit_rhs (*this); + }); } void TokenCollector::visit (CompoundAssignmentExpr &expr) { - visit (expr.get_left_expr ()); + internal_comment (std::string ("CompoundAssignmentExpr"), [this, &expr] () { + visit (expr.get_left_expr ()); - switch (expr.get_expr_type ()) - { - case CompoundAssignmentOperator::ADD: - push (Rust::Token::make (PLUS_EQ, expr.get_locus ())); - break; - case CompoundAssignmentOperator::SUBTRACT: - push (Rust::Token::make (MINUS_EQ, expr.get_locus ())); - break; - case CompoundAssignmentOperator::MULTIPLY: - push (Rust::Token::make (ASTERISK_EQ, expr.get_locus ())); - break; - case CompoundAssignmentOperator::DIVIDE: - push (Rust::Token::make (DIV_EQ, expr.get_locus ())); - break; - case CompoundAssignmentOperator::MODULUS: - push (Rust::Token::make (PERCENT_EQ, expr.get_locus ())); - break; - case CompoundAssignmentOperator::BITWISE_AND: - push (Rust::Token::make (AMP_EQ, expr.get_locus ())); - break; - case CompoundAssignmentOperator::BITWISE_OR: - push (Rust::Token::make (PIPE_EQ, expr.get_locus ())); - break; - case CompoundAssignmentOperator::BITWISE_XOR: - push (Rust::Token::make (CARET_EQ, expr.get_locus ())); - break; - case CompoundAssignmentOperator::LEFT_SHIFT: - push (Rust::Token::make (LEFT_SHIFT_EQ, expr.get_locus ())); - break; - case CompoundAssignmentOperator::RIGHT_SHIFT: - push (Rust::Token::make (RIGHT_SHIFT_EQ, expr.get_locus ())); - break; - } - visit (expr.get_right_expr ()); + switch (expr.get_expr_type ()) + { + case CompoundAssignmentOperator::ADD: + push (Rust::Token::make (PLUS_EQ, expr.get_locus ())); + break; + case CompoundAssignmentOperator::SUBTRACT: + push (Rust::Token::make (MINUS_EQ, expr.get_locus ())); + break; + case CompoundAssignmentOperator::MULTIPLY: + push (Rust::Token::make (ASTERISK_EQ, expr.get_locus ())); + break; + case CompoundAssignmentOperator::DIVIDE: + push (Rust::Token::make (DIV_EQ, expr.get_locus ())); + break; + case CompoundAssignmentOperator::MODULUS: + push (Rust::Token::make (PERCENT_EQ, expr.get_locus ())); + break; + case CompoundAssignmentOperator::BITWISE_AND: + push (Rust::Token::make (AMP_EQ, expr.get_locus ())); + break; + case CompoundAssignmentOperator::BITWISE_OR: + push (Rust::Token::make (PIPE_EQ, expr.get_locus ())); + break; + case CompoundAssignmentOperator::BITWISE_XOR: + push (Rust::Token::make (CARET_EQ, expr.get_locus ())); + break; + case CompoundAssignmentOperator::LEFT_SHIFT: + push (Rust::Token::make (LEFT_SHIFT_EQ, expr.get_locus ())); + break; + case CompoundAssignmentOperator::RIGHT_SHIFT: + push (Rust::Token::make (RIGHT_SHIFT_EQ, expr.get_locus ())); + break; + } + visit (expr.get_right_expr ()); + }); } void TokenCollector::visit (GroupedExpr &expr) { - push (Rust::Token::make (LEFT_PAREN, expr.get_locus ())); - visit (expr.get_expr_in_parens ()); - push (Rust::Token::make (RIGHT_PAREN, expr.get_locus ())); + internal_comment (std::string ("GroupedExpr"), [this, &expr] () { + push (Rust::Token::make (LEFT_PAREN, expr.get_locus ())); + visit (expr.get_expr_in_parens ()); + push (Rust::Token::make (RIGHT_PAREN, expr.get_locus ())); + }); } void TokenCollector::visit (ArrayElemsValues &elems) { - visit_items_joined_by_separator (elems.get_values (), COMMA); + internal_comment (std::string ("ArraysElemValues"), [this, &elems] () { + visit_items_joined_by_separator (elems.get_values (), COMMA); + }); } void TokenCollector::visit (ArrayElemsCopied &elems) { - visit (elems.get_elem_to_copy ()); - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); - visit (elems.get_num_copies ()); + internal_comment (std::string ("ArrayElemsCopied"), [this, &elems] () { + visit (elems.get_elem_to_copy ()); + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + visit (elems.get_num_copies ()); + }); } void TokenCollector::visit (ArrayExpr &expr) { - push (Rust::Token::make (LEFT_SQUARE, expr.get_locus ())); - visit (expr.get_array_elems ()); - push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + internal_comment (std::string ("ArrayExpr"), [this, &expr] () { + push (Rust::Token::make (LEFT_SQUARE, expr.get_locus ())); + visit (expr.get_array_elems ()); + push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + }); } void TokenCollector::visit (ArrayIndexExpr &expr) { - visit (expr.get_array_expr ()); - push (Rust::Token::make (LEFT_SQUARE, expr.get_locus ())); - visit (expr.get_index_expr ()); - push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + internal_comment (std::string ("ArrayIndexExpr"), [this, &expr] () { + visit (expr.get_array_expr ()); + push (Rust::Token::make (LEFT_SQUARE, expr.get_locus ())); + visit (expr.get_index_expr ()); + push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + }); } void TokenCollector::visit (TupleExpr &expr) { - visit_items_as_lines (expr.get_outer_attrs ()); - push (Rust::Token::make (LEFT_PAREN, expr.get_locus ())); - visit_items_joined_by_separator (expr.get_tuple_elems (), COMMA); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + internal_comment (std::string ("TupleExpr"), [this, &expr] () { + visit_items_as_lines (expr.get_outer_attrs ()); + push (Rust::Token::make (LEFT_PAREN, expr.get_locus ())); + visit_items_joined_by_separator (expr.get_tuple_elems (), COMMA); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } void TokenCollector::visit (TupleIndexExpr &expr) { - visit (expr.get_tuple_expr ()); - push (Rust::Token::make (DOT, expr.get_locus ())); - push (Rust::Token::make_int (UNDEF_LOCATION, - std::to_string (expr.get_tuple_index ()))); + internal_comment (std::string ("TupleIndexExpr"), [this, &expr] () { + visit (expr.get_tuple_expr ()); + push (Rust::Token::make (DOT, expr.get_locus ())); + push (Rust::Token::make_int (UNDEF_LOCATION, + std::to_string (expr.get_tuple_index ()))); + }); } void TokenCollector::visit (StructExprStruct &expr) { - visit (expr.get_struct_name ()); + internal_comment (std::string ("StructExprStruct"), + [this, &expr] () { visit (expr.get_struct_name ()); }); } void TokenCollector::visit (StructExprFieldIdentifier &expr) { - visit_items_as_lines (expr.get_outer_attrs ()); - auto id = expr.get_field_name ().as_string (); - push (Rust::Token::make_identifier (expr.get_locus (), std::move (id))); + internal_comment (std::string ("StructExprFieldIdentifier"), [this, + &expr] () { + visit_items_as_lines (expr.get_outer_attrs ()); + auto id = expr.get_field_name ().as_string (); + push (Rust::Token::make_identifier (expr.get_locus (), std::move (id))); + }); } void TokenCollector::visit (StructExprFieldIdentifierValue &expr) { - visit_items_as_lines (expr.get_outer_attrs ()); - auto id = expr.get_field_name (); - push (Rust::Token::make_identifier (expr.get_locus (), std::move (id))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (expr.get_value ()); + internal_comment (std::string ("StructExprFieldIdentifierValue"), [this, + &expr] () { + visit_items_as_lines (expr.get_outer_attrs ()); + auto id = expr.get_field_name (); + push (Rust::Token::make_identifier (expr.get_locus (), std::move (id))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit (expr.get_value ()); + }); } void TokenCollector::visit (StructExprFieldIndexValue &expr) { - visit_items_as_lines (expr.get_outer_attrs ()); - push (Rust::Token::make_int (expr.get_locus (), - std::to_string (expr.get_index ()))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (expr.get_value ()); + internal_comment (std::string ("StructExprFieldIndexValue"), [this, + &expr] () { + visit_items_as_lines (expr.get_outer_attrs ()); + push (Rust::Token::make_int (expr.get_locus (), + std::to_string (expr.get_index ()))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit (expr.get_value ()); + }); } void TokenCollector::visit (StructBase &base) { - push (Rust::Token::make (DOT_DOT, UNDEF_LOCATION)); - visit (base.get_base_struct ()); + internal_comment (std::string ("StructBase"), [this, &base] () { + push (Rust::Token::make (DOT_DOT, UNDEF_LOCATION)); + visit (base.get_base_struct ()); + }); } void TokenCollector::visit (StructExprStructFields &expr) { - visit (expr.get_struct_name ()); - push (Rust::Token::make (LEFT_CURLY, expr.get_locus ())); - visit_items_joined_by_separator (expr.get_fields (), COMMA); - if (expr.has_struct_base ()) - { - push (Rust::Token::make (COMMA, UNDEF_LOCATION)); - visit (expr.get_struct_base ()); - } - else - { - trailing_comma (); - } - push (Rust::Token::make (RIGHT_CURLY, expr.get_locus ())); + internal_comment (std::string ("StructExprStructFields"), [this, &expr] () { + visit (expr.get_struct_name ()); + push (Rust::Token::make (LEFT_CURLY, expr.get_locus ())); + visit_items_joined_by_separator (expr.get_fields (), COMMA); + if (expr.has_struct_base ()) + { + push (Rust::Token::make (COMMA, UNDEF_LOCATION)); + visit (expr.get_struct_base ()); + } + else + { + trailing_comma (); + } + push (Rust::Token::make (RIGHT_CURLY, expr.get_locus ())); + }); } void @@ -1193,343 +1342,413 @@ TokenCollector::visit (StructExprStructBase &) void TokenCollector::visit (CallExpr &expr) { - visit (expr.get_function_expr ()); + internal_comment (std::string ("CallExpr"), [this, &expr] () { + visit (expr.get_function_expr ()); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - visit_items_joined_by_separator (expr.get_params (), COMMA); + visit_items_joined_by_separator (expr.get_params (), COMMA); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } void TokenCollector::visit (MethodCallExpr &expr) { - visit (expr.get_receiver_expr ()); - push (Rust::Token::make (DOT, expr.get_locus ())); - visit (expr.get_method_name ()); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - visit_items_joined_by_separator (expr.get_params (), COMMA); - trailing_comma (); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + internal_comment (std::string ("MethodCallExpr"), [this, &expr] () { + visit (expr.get_receiver_expr ()); + push (Rust::Token::make (DOT, expr.get_locus ())); + visit (expr.get_method_name ()); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + visit_items_joined_by_separator (expr.get_params (), COMMA); + trailing_comma (); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } void TokenCollector::visit (FieldAccessExpr &expr) { - visit (expr.get_receiver_expr ()); - push (Rust::Token::make (DOT, expr.get_locus ())); - auto field_name = expr.get_field_name ().as_string (); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (field_name))); + internal_comment (std::string ("FieldAccessExpr"), [this, &expr] () { + visit (expr.get_receiver_expr ()); + push (Rust::Token::make (DOT, expr.get_locus ())); + auto field_name = expr.get_field_name ().as_string (); + push ( + Rust::Token::make_identifier (UNDEF_LOCATION, std::move (field_name))); + }); } void TokenCollector::visit (ClosureParam ¶m) { - visit_items_as_lines (param.get_outer_attrs ()); - visit (param.get_pattern ()); - if (param.has_type_given ()) - { - push (Rust::Token::make (COLON, param.get_locus ())); - visit (param.get_type ()); - } + internal_comment (std::string ("ClosureParam"), [this, ¶m] () { + visit_items_as_lines (param.get_outer_attrs ()); + visit (param.get_pattern ()); + if (param.has_type_given ()) + { + push (Rust::Token::make (COLON, param.get_locus ())); + visit (param.get_type ()); + } + }); } void TokenCollector::visit_closure_common (ClosureExpr &expr) { - if (expr.get_has_move ()) - { - push (Rust::Token::make (MOVE, expr.get_locus ())); - } - push (Rust::Token::make (PIPE, UNDEF_LOCATION)); - visit_items_joined_by_separator (expr.get_params (), COMMA); - push (Rust::Token::make (PIPE, UNDEF_LOCATION)); + internal_comment (std::string ("ClosureExpr"), [this, &expr] () { + if (expr.get_has_move ()) + { + push (Rust::Token::make (MOVE, expr.get_locus ())); + } + push (Rust::Token::make (PIPE, UNDEF_LOCATION)); + visit_items_joined_by_separator (expr.get_params (), COMMA); + push (Rust::Token::make (PIPE, UNDEF_LOCATION)); + }); } void TokenCollector::visit (ClosureExprInner &expr) { - visit_closure_common (expr); - visit (expr.get_definition_expr ()); + internal_comment (std::string ("ClosureExprInner"), [this, &expr] () { + visit_closure_common (expr); + visit (expr.get_definition_expr ()); + }); } void TokenCollector::visit (BlockExpr &expr) { - visit_items_as_lines (expr.get_outer_attrs ()); - push (Rust::Token::make (LEFT_CURLY, expr.get_locus ())); - newline (); - increment_indentation (); - visit_items_as_lines (expr.get_inner_attrs ()); + internal_comment (std::string ("BlockExpr"), [this, &expr] () { + visit_items_as_lines (expr.get_outer_attrs ()); + push (Rust::Token::make (LEFT_CURLY, expr.get_locus ())); + newline (); + increment_indentation (); + visit_items_as_lines (expr.get_inner_attrs ()); - visit_items_as_lines (expr.get_statements (), {}); + visit_items_as_lines (expr.get_statements (), {}); - if (expr.has_tail_expr ()) - { - indentation (); - visit (expr.get_tail_expr ()); - comment ("tail expr"); - newline (); - } + if (expr.has_tail_expr ()) + { + indentation (); + visit (expr.get_tail_expr ()); + newline (); + } - decrement_indentation (); - indentation (); - push (Rust::Token::make (RIGHT_CURLY, expr.get_locus ())); - newline (); + decrement_indentation (); + indentation (); + push (Rust::Token::make (RIGHT_CURLY, expr.get_locus ())); + newline (); + }); } void TokenCollector::visit (ClosureExprInnerTyped &expr) { - visit_closure_common (expr); - push (Rust::Token::make (RETURN_TYPE, expr.get_locus ())); - visit (expr.get_return_type ()); - visit (expr.get_definition_block ()); + internal_comment (std::string ("ClosureExprInnerTyped"), [this, &expr] () { + visit_closure_common (expr); + push (Rust::Token::make (RETURN_TYPE, expr.get_locus ())); + visit (expr.get_return_type ()); + visit (expr.get_definition_block ()); + }); } void TokenCollector::visit (ContinueExpr &expr) { - push (Rust::Token::make (CONTINUE, expr.get_locus ())); - if (expr.has_label ()) - visit (expr.get_label ()); + internal_comment (std::string ("ContinueExpr"), [this, &expr] () { + push (Rust::Token::make (CONTINUE, expr.get_locus ())); + if (expr.has_label ()) + visit (expr.get_label ()); + }); } void TokenCollector::visit (BreakExpr &expr) { - push (Rust::Token::make (BREAK, expr.get_locus ())); - if (expr.has_label ()) - visit (expr.get_label ()); - if (expr.has_break_expr ()) - visit (expr.get_break_expr ()); + internal_comment (std::string ("BreakExpr"), [this, &expr] () { + push (Rust::Token::make (BREAK, expr.get_locus ())); + if (expr.has_label ()) + visit (expr.get_label ()); + if (expr.has_break_expr ()) + visit (expr.get_break_expr ()); + }); } void TokenCollector::visit (RangeFromToExpr &expr) { - visit (expr.get_from_expr ()); - push (Rust::Token::make (DOT_DOT, expr.get_locus ())); - visit (expr.get_to_expr ()); + internal_comment (std::string ("RangeFromToExpr"), [this, &expr] () { + visit (expr.get_from_expr ()); + push (Rust::Token::make (DOT_DOT, expr.get_locus ())); + visit (expr.get_to_expr ()); + }); } void TokenCollector::visit (RangeFromExpr &expr) { - visit (expr.get_from_expr ()); - push (Rust::Token::make (DOT_DOT, expr.get_locus ())); + internal_comment (std::string ("RangeFromExpr"), [this, &expr] () { + visit (expr.get_from_expr ()); + push (Rust::Token::make (DOT_DOT, expr.get_locus ())); + }); } void TokenCollector::visit (RangeToExpr &expr) { - push (Rust::Token::make (DOT_DOT, expr.get_locus ())); - visit (expr.get_to_expr ()); + internal_comment (std::string ("RangeToExpr"), [this, &expr] () { + push (Rust::Token::make (DOT_DOT, expr.get_locus ())); + visit (expr.get_to_expr ()); + }); } void TokenCollector::visit (RangeFullExpr &expr) { - push (Rust::Token::make (DOT_DOT, expr.get_locus ())); + internal_comment (std::string ("RangeFullExpr"), [this, &expr] () { + push (Rust::Token::make (DOT_DOT, expr.get_locus ())); + }); } void TokenCollector::visit (RangeFromToInclExpr &expr) { - visit (expr.get_from_expr ()); - push (Rust::Token::make (DOT_DOT_EQ, expr.get_locus ())); - visit (expr.get_to_expr ()); + internal_comment (std::string ("RangeFromToInclExpr"), [this, &expr] () { + visit (expr.get_from_expr ()); + push (Rust::Token::make (DOT_DOT_EQ, expr.get_locus ())); + visit (expr.get_to_expr ()); + }); } void TokenCollector::visit (RangeToInclExpr &expr) { - push (Rust::Token::make (DOT_DOT_EQ, expr.get_locus ())); - visit (expr.get_to_expr ()); + internal_comment (std::string ("RangeToInclExpr"), [this, &expr] () { + push (Rust::Token::make (DOT_DOT_EQ, expr.get_locus ())); + visit (expr.get_to_expr ()); + }); } void TokenCollector::visit (BoxExpr &expr) { - push (Rust::Token::make (BOX, expr.get_locus ())); - visit (expr.get_boxed_expr ()); + internal_comment (std::string ("BoxExpr"), [this, &expr] () { + push (Rust::Token::make (BOX, expr.get_locus ())); + visit (expr.get_boxed_expr ()); + }); } void TokenCollector::visit (ReturnExpr &expr) { - push (Rust::Token::make (RETURN_KW, expr.get_locus ())); - if (expr.has_returned_expr ()) - visit (expr.get_returned_expr ()); + internal_comment (std::string ("ReturnExpr"), [this, &expr] () { + push (Rust::Token::make (RETURN_KW, expr.get_locus ())); + if (expr.has_returned_expr ()) + visit (expr.get_returned_expr ()); + }); } void TokenCollector::visit (UnsafeBlockExpr &expr) { - push (Rust::Token::make (UNSAFE, expr.get_locus ())); - visit (expr.get_block_expr ()); + internal_comment (std::string ("UnsafeBlockExpr"), [this, &expr] () { + push (Rust::Token::make (UNSAFE, expr.get_locus ())); + visit (expr.get_block_expr ()); + }); } void TokenCollector::visit (LoopLabel &label) { - visit (label.get_lifetime ()); - push (Rust::Token::make (COLON, label.get_locus ())); + internal_comment (std::string ("LoopLabel"), [this, &label] () { + visit (label.get_lifetime ()); + push (Rust::Token::make (COLON, label.get_locus ())); + }); } void TokenCollector::visit_loop_common (BaseLoopExpr &expr) { - if (expr.has_loop_label ()) - visit (expr.get_loop_label ()); + internal_comment (std::string ("BaseLoopExpr"), [this, &expr] () { + if (expr.has_loop_label ()) + visit (expr.get_loop_label ()); + }); } void TokenCollector::visit (LoopExpr &expr) { - visit_loop_common (expr); - push (Rust::Token::make (LOOP, expr.get_locus ())); - visit (expr.get_loop_block ()); + internal_comment (std::string ("LoopExpr"), [this, &expr] () { + visit_loop_common (expr); + push (Rust::Token::make (LOOP, expr.get_locus ())); + visit (expr.get_loop_block ()); + }); } void TokenCollector::visit (WhileLoopExpr &expr) { - visit_loop_common (expr); - push (Rust::Token::make (WHILE, expr.get_locus ())); - visit (expr.get_predicate_expr ()); - visit (expr.get_loop_block ()); + internal_comment (std::string ("WhileLoopExpr"), [this, &expr] () { + visit_loop_common (expr); + push (Rust::Token::make (WHILE, expr.get_locus ())); + visit (expr.get_predicate_expr ()); + visit (expr.get_loop_block ()); + }); } void TokenCollector::visit (WhileLetLoopExpr &expr) { - visit_loop_common (expr); - push (Rust::Token::make (WHILE, expr.get_locus ())); - push (Rust::Token::make (LET, UNDEF_LOCATION)); - // TODO: The reference mention only one Pattern - for (auto &item : expr.get_patterns ()) - { - visit (item); - } - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (expr.get_scrutinee_expr ()); - visit (expr.get_loop_block ()); + internal_comment (std::string ("WhileLetLoopExpr"), [this, &expr] () { + visit_loop_common (expr); + push (Rust::Token::make (WHILE, expr.get_locus ())); + push (Rust::Token::make (LET, UNDEF_LOCATION)); + // TODO: The reference mention only one Pattern + for (auto &item : expr.get_patterns ()) + { + visit (item); + } + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (expr.get_scrutinee_expr ()); + visit (expr.get_loop_block ()); + }); } void TokenCollector::visit (ForLoopExpr &expr) { - visit_loop_common (expr); - push (Rust::Token::make (FOR, expr.get_locus ())); - visit (expr.get_pattern ()); - push (Rust::Token::make (IN, UNDEF_LOCATION)); - visit (expr.get_iterator_expr ()); - visit (expr.get_loop_block ()); + internal_comment (std::string ("ForLoopExpr"), [this, &expr] () { + visit_loop_common (expr); + push (Rust::Token::make (FOR, expr.get_locus ())); + visit (expr.get_pattern ()); + push (Rust::Token::make (IN, UNDEF_LOCATION)); + visit (expr.get_iterator_expr ()); + visit (expr.get_loop_block ()); + }); } void TokenCollector::visit (IfExpr &expr) { - push (Rust::Token::make (IF, expr.get_locus ())); - visit (expr.get_condition_expr ()); - visit (expr.get_if_block ()); + internal_comment (std::string ("IfExpr"), [this, &expr] () { + push (Rust::Token::make (IF, expr.get_locus ())); + + visit (expr.get_condition_expr ()); + visit (expr.get_if_block ()); + }); } void TokenCollector::visit (IfExprConseqElse &expr) { - visit (static_cast (expr)); - indentation (); - push (Rust::Token::make (ELSE, expr.get_locus ())); - visit (expr.get_else_block ()); + internal_comment (std::string ("IfExprConseqElse"), [this, &expr] () { + visit (static_cast (expr)); + indentation (); + push (Rust::Token::make (ELSE, expr.get_locus ())); + visit (expr.get_else_block ()); + }); } void TokenCollector::visit (IfLetExpr &expr) { - push (Rust::Token::make (IF, expr.get_locus ())); - push (Rust::Token::make (LET, UNDEF_LOCATION)); - for (auto &pattern : expr.get_patterns ()) - { - visit (pattern); - } - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (expr.get_value_expr ()); - visit (expr.get_if_block ()); + internal_comment (std::string ("IfLetExpr"), [this, &expr] () { + push (Rust::Token::make (IF, expr.get_locus ())); + push (Rust::Token::make (LET, UNDEF_LOCATION)); + for (auto &pattern : expr.get_patterns ()) + { + visit (pattern); + } + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (expr.get_value_expr ()); + visit (expr.get_if_block ()); + }); } void TokenCollector::visit (IfLetExprConseqElse &expr) { - visit (static_cast (expr)); - indentation (); - push (Rust::Token::make (ELSE, expr.get_locus ())); - visit (expr.get_else_block ()); + internal_comment (std::string ("IfLetExprConseqElse"), [this, &expr] () { + visit (static_cast (expr)); + indentation (); + push (Rust::Token::make (ELSE, expr.get_locus ())); + visit (expr.get_else_block ()); + }); } void TokenCollector::visit (MatchArm &arm) { - visit_items_as_lines (arm.get_outer_attrs ()); - for (auto &pattern : arm.get_patterns ()) - { - visit (pattern); - } - if (arm.has_match_arm_guard ()) - { - push (Rust::Token::make (IF, UNDEF_LOCATION)); - visit (arm.get_guard_expr ()); - } + internal_comment (std::string ("MatchArm"), [this, &arm] () { + visit_items_as_lines (arm.get_outer_attrs ()); + for (auto &pattern : arm.get_patterns ()) + { + visit (pattern); + } + if (arm.has_match_arm_guard ()) + { + push (Rust::Token::make (IF, UNDEF_LOCATION)); + visit (arm.get_guard_expr ()); + } + }); } void TokenCollector::visit (MatchCase &match_case) { - indentation (); - visit (match_case.get_arm ()); - push (Rust::Token::make (MATCH_ARROW, UNDEF_LOCATION)); - visit (match_case.get_expr ()); - indentation (); - push (Rust::Token::make (COMMA, UNDEF_LOCATION)); - newline (); + internal_comment (std::string ("MatchCase"), [this, &match_case] () { + indentation (); + visit (match_case.get_arm ()); + push (Rust::Token::make (MATCH_ARROW, UNDEF_LOCATION)); + visit (match_case.get_expr ()); + indentation (); + push (Rust::Token::make (COMMA, UNDEF_LOCATION)); + newline (); + }); } void TokenCollector::visit (MatchExpr &expr) { - push (Rust::Token::make (MATCH_KW, expr.get_locus ())); - visit (expr.get_scrutinee_expr ()); - push (Rust::Token::make (LEFT_CURLY, UNDEF_LOCATION)); - newline (); - increment_indentation (); - visit_items_as_lines (expr.get_inner_attrs ()); - for (auto &arm : expr.get_match_cases ()) - { - visit (arm); - } - decrement_indentation (); - indentation (); - push (Rust::Token::make (RIGHT_CURLY, UNDEF_LOCATION)); + internal_comment (std::string ("MatchExpr"), [this, &expr] () { + push (Rust::Token::make (MATCH_KW, expr.get_locus ())); + visit (expr.get_scrutinee_expr ()); + push (Rust::Token::make (LEFT_CURLY, UNDEF_LOCATION)); + newline (); + increment_indentation (); + visit_items_as_lines (expr.get_inner_attrs ()); + for (auto &arm : expr.get_match_cases ()) + { + visit (arm); + } + decrement_indentation (); + indentation (); + push (Rust::Token::make (RIGHT_CURLY, UNDEF_LOCATION)); + }); } void TokenCollector::visit (AwaitExpr &expr) { - visit (expr.get_awaited_expr ()); - push (Rust::Token::make (DOT, expr.get_locus ())); - // TODO: Check status of await keyword (Context dependant ?) - push (Rust::Token::make_identifier (UNDEF_LOCATION, Values::Keywords::AWAIT)); + internal_comment (std::string ("AwaitExpr"), [this, &expr] () { + visit (expr.get_awaited_expr ()); + push (Rust::Token::make (DOT, expr.get_locus ())); + // TODO: Check status of await keyword (Context dependant ?) + push ( + Rust::Token::make_identifier (UNDEF_LOCATION, Values::Keywords::AWAIT)); + }); } void TokenCollector::visit (AsyncBlockExpr &expr) { - push (Rust::Token::make (ASYNC, expr.get_locus ())); - if (expr.get_has_move ()) - push (Rust::Token::make (MOVE, UNDEF_LOCATION)); - visit (expr.get_block_expr ()); + internal_comment (std::string ("AsyncBlockExpr"), [this, &expr] () { + push (Rust::Token::make (ASYNC, expr.get_locus ())); + if (expr.get_has_move ()) + push (Rust::Token::make (MOVE, UNDEF_LOCATION)); + visit (expr.get_block_expr ()); + }); } void @@ -1545,20 +1764,21 @@ TokenCollector::visit (TypeParam ¶m) // IDENTIFIER( : TypeParamBounds? )? ( = Type )? // TypeParamBounds : // TypeParamBound ( + TypeParamBound )* +? - - visit_items_as_lines (param.get_outer_attrs ()); - auto id = param.get_type_representation ().as_string (); - push (Rust::Token::make_identifier (param.get_locus (), std::move (id))); - if (param.has_type_param_bounds ()) - { - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit_items_joined_by_separator (param.get_type_param_bounds (), PLUS); - } - if (param.has_type ()) - { - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (param.get_type ()); - } + internal_comment (std::string ("TypeParam"), [this, ¶m] () { + visit_items_as_lines (param.get_outer_attrs ()); + auto id = param.get_type_representation ().as_string (); + push (Rust::Token::make_identifier (param.get_locus (), std::move (id))); + if (param.has_type_param_bounds ()) + { + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit_items_joined_by_separator (param.get_type_param_bounds (), PLUS); + } + if (param.has_type ()) + { + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (param.get_type ()); + } + }); } void @@ -1569,12 +1789,13 @@ TokenCollector::visit (WhereClause &rule) // WhereClauseItem : // LifetimeWhereClauseItem // | TypeBoundWhereClauseItem - - push (Rust::Token::make (WHERE, UNDEF_LOCATION)); - newline (); - increment_indentation (); - visit_items_joined_by_separator (rule.get_items (), COMMA); - decrement_indentation (); + internal_comment (std::string ("WhereClause"), [this, &rule] () { + push (Rust::Token::make (WHERE, UNDEF_LOCATION)); + newline (); + increment_indentation (); + visit_items_joined_by_separator (rule.get_items (), COMMA); + decrement_indentation (); + }); } void @@ -1585,9 +1806,11 @@ TokenCollector::visit (LifetimeWhereClauseItem &item) // LifetimeBounds : // ( Lifetime + )* Lifetime? - visit (item.get_lifetime ()); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit_items_joined_by_separator (item.get_lifetime_bounds (), PLUS); + internal_comment (std::string ("LifetimeWhereClauseItem"), [this, &item] () { + visit (item.get_lifetime ()); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit_items_joined_by_separator (item.get_lifetime_bounds (), PLUS); + }); } void @@ -1600,13 +1823,15 @@ TokenCollector::visit (TypeBoundWhereClauseItem &item) // TypeParamBound : // Lifetime | TraitBound - if (item.has_for_lifetimes ()) - visit (item.get_for_lifetimes ()); + internal_comment (std::string ("TypeBoundWhereClauseItem"), [this, &item] () { + if (item.has_for_lifetimes ()) + visit (item.get_for_lifetimes ()); - visit (item.get_type ()); + visit (item.get_type ()); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit_items_joined_by_separator (item.get_type_param_bounds (), PLUS); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit_items_joined_by_separator (item.get_type_param_bounds (), PLUS); + }); } void @@ -1618,130 +1843,141 @@ TokenCollector::visit (Module &module) // InnerAttribute* // Item* // } + internal_comment (std::string ("Module"), [this, &module] () { + visit_items_as_lines (module.get_outer_attrs ()); + visit (module.get_visibility ()); + auto name = module.get_name ().as_string (); + push (Rust::Token::make (MOD, module.get_locus ())); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (name))); + + if (module.get_kind () == Module::UNLOADED) + { + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + newline (); + } + else /* Module::LOADED */ + { + push (Rust::Token::make (LEFT_CURLY, UNDEF_LOCATION)); + newline (); + increment_indentation (); - visit_items_as_lines (module.get_outer_attrs ()); - visit (module.get_visibility ()); - auto name = module.get_name ().as_string (); - push (Rust::Token::make (MOD, module.get_locus ())); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (name))); - - if (module.get_kind () == Module::UNLOADED) - { - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); - newline (); - } - else /* Module::LOADED */ - { - push (Rust::Token::make (LEFT_CURLY, UNDEF_LOCATION)); - newline (); - increment_indentation (); - - visit_items_as_lines (module.get_inner_attrs ()); - visit_items_as_lines (module.get_items ()); + visit_items_as_lines (module.get_inner_attrs ()); + visit_items_as_lines (module.get_items ()); - decrement_indentation (); + decrement_indentation (); - push (Rust::Token::make (RIGHT_CURLY, UNDEF_LOCATION)); - newline (); - } + push (Rust::Token::make (RIGHT_CURLY, UNDEF_LOCATION)); + newline (); + } + }); } void TokenCollector::visit (ExternCrate &crate) { - visit_items_as_lines (crate.get_outer_attrs ()); - push (Rust::Token::make (EXTERN_KW, crate.get_locus ())); - push (Rust::Token::make (CRATE, UNDEF_LOCATION)); - auto ref = crate.get_referenced_crate (); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (ref))); - if (crate.has_as_clause ()) - { - auto as_clause = crate.get_as_clause (); - push (Rust::Token::make (AS, UNDEF_LOCATION)); - push ( - Rust::Token::make_identifier (UNDEF_LOCATION, std::move (as_clause))); - } - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); - newline (); + internal_comment (std::string ("ExternCrate"), [this, &crate] () { + visit_items_as_lines (crate.get_outer_attrs ()); + push (Rust::Token::make (EXTERN_KW, crate.get_locus ())); + push (Rust::Token::make (CRATE, UNDEF_LOCATION)); + auto ref = crate.get_referenced_crate (); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (ref))); + if (crate.has_as_clause ()) + { + auto as_clause = crate.get_as_clause (); + push (Rust::Token::make (AS, UNDEF_LOCATION)); + push ( + Rust::Token::make_identifier (UNDEF_LOCATION, std::move (as_clause))); + } + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + newline (); + }); } void TokenCollector::visit (UseTreeGlob &use_tree) { - switch (use_tree.get_glob_type ()) - { - case UseTreeGlob::PathType::PATH_PREFIXED: { - auto path = use_tree.get_path (); - visit (path); + internal_comment (std::string ("UseTreeGlob"), [this, &use_tree] () { + switch (use_tree.get_glob_type ()) + { + case UseTreeGlob::PathType::PATH_PREFIXED: { + auto path = use_tree.get_path (); + visit (path); + push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); + } + break; + case UseTreeGlob::PathType::NO_PATH: push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); + break; + case UseTreeGlob::PathType::GLOBAL: + break; } - break; - case UseTreeGlob::PathType::NO_PATH: - push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); - break; - case UseTreeGlob::PathType::GLOBAL: - break; - } - push (Rust::Token::make (ASTERISK, UNDEF_LOCATION)); + push (Rust::Token::make (ASTERISK, UNDEF_LOCATION)); + }); } void TokenCollector::visit (UseTreeList &use_tree) { - switch (use_tree.get_path_type ()) - { - case UseTreeList::PathType::PATH_PREFIXED: { - auto path = use_tree.get_path (); - visit (path); + internal_comment (std::string ("UseTreeList"), [this, &use_tree] () { + switch (use_tree.get_path_type ()) + { + case UseTreeList::PathType::PATH_PREFIXED: { + auto path = use_tree.get_path (); + visit (path); + push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); + } + break; + case UseTreeList::PathType::NO_PATH: push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); + break; + case UseTreeList::PathType::GLOBAL: + break; } - break; - case UseTreeList::PathType::NO_PATH: - push (Rust::Token::make (SCOPE_RESOLUTION, UNDEF_LOCATION)); - break; - case UseTreeList::PathType::GLOBAL: - break; - } - push (Rust::Token::make (LEFT_CURLY, UNDEF_LOCATION)); - if (use_tree.has_trees ()) - { - visit_items_joined_by_separator (use_tree.get_trees (), COMMA); - } - push (Rust::Token::make (RIGHT_CURLY, UNDEF_LOCATION)); + push (Rust::Token::make (LEFT_CURLY, UNDEF_LOCATION)); + if (use_tree.has_trees ()) + { + visit_items_joined_by_separator (use_tree.get_trees (), COMMA); + } + push (Rust::Token::make (RIGHT_CURLY, UNDEF_LOCATION)); + }); } void TokenCollector::visit (UseTreeRebind &use_tree) { - auto path = use_tree.get_path (); - visit (path); - switch (use_tree.get_new_bind_type ()) - { - case UseTreeRebind::NewBindType::IDENTIFIER: { + internal_comment (std::string ("UseTreeRebind"), [this, &use_tree] () { + auto path = use_tree.get_path (); + visit (path); + switch (use_tree.get_new_bind_type ()) + { + case UseTreeRebind::NewBindType::IDENTIFIER: { + push (Rust::Token::make (AS, UNDEF_LOCATION)); + auto id = use_tree.get_identifier ().as_string (); + push (Rust::Token::make_identifier (use_tree.get_locus (), + std::move (id))); + } + break; + case UseTreeRebind::NewBindType::WILDCARD: push (Rust::Token::make (AS, UNDEF_LOCATION)); - auto id = use_tree.get_identifier ().as_string (); - push ( - Rust::Token::make_identifier (use_tree.get_locus (), std::move (id))); + push (Rust::Token::make (UNDERSCORE, use_tree.get_locus ())); + break; + case UseTreeRebind::NewBindType::NONE: + break; } - break; - case UseTreeRebind::NewBindType::WILDCARD: - push (Rust::Token::make (AS, UNDEF_LOCATION)); - push (Rust::Token::make (UNDERSCORE, use_tree.get_locus ())); - break; - case UseTreeRebind::NewBindType::NONE: - break; - } + }); } void TokenCollector::visit (UseDeclaration &decl) { - visit_items_as_lines (decl.get_outer_attrs ()); - push (Rust::Token::make (USE, decl.get_locus ())); - visit (*decl.get_tree ()); - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); - newline (); + internal_comment (std::string ("UseDeclaration"), [this, &decl] () { + visit_items_as_lines (decl.get_outer_attrs ()); + push (Rust::Token::make (USE, decl.get_locus ())); + visit (*decl.get_tree ()); + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + newline (); + }); } void @@ -1752,37 +1988,39 @@ TokenCollector::visit (Function &function) // ( FunctionParameters? ) // FunctionReturnType? WhereClause? // ( BlockExpression | ; ) - visit_items_as_lines (function.get_outer_attrs ()); + internal_comment (std::string ("Function"), [this, &function] () { + visit_items_as_lines (function.get_outer_attrs ()); - visit (function.get_visibility ()); - auto qualifiers = function.get_qualifiers (); - visit (qualifiers); + visit (function.get_visibility ()); + auto qualifiers = function.get_qualifiers (); + visit (qualifiers); - push (Rust::Token::make (FN_KW, function.get_locus ())); - auto name = function.get_function_name ().as_string (); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (name))); - if (function.has_generics ()) - visit (function.get_generic_params ()); + push (Rust::Token::make (FN_KW, function.get_locus ())); + auto name = function.get_function_name ().as_string (); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (name))); + if (function.has_generics ()) + visit (function.get_generic_params ()); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - visit_items_joined_by_separator (function.get_function_params ()); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + visit_items_joined_by_separator (function.get_function_params ()); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); - if (function.has_return_type ()) - { - push (Rust::Token::make (RETURN_TYPE, UNDEF_LOCATION)); - visit (function.get_return_type ()); - } + if (function.has_return_type ()) + { + push (Rust::Token::make (RETURN_TYPE, UNDEF_LOCATION)); + visit (function.get_return_type ()); + } - if (function.has_where_clause ()) - visit (function.get_where_clause ()); + if (function.has_where_clause ()) + visit (function.get_where_clause ()); - if (function.has_body ()) - visit (*function.get_definition ()); - else - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); - newline (); + if (function.has_body ()) + visit (*function.get_definition ()); + else + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + newline (); + }); } void @@ -1792,186 +2030,210 @@ TokenCollector::visit (TypeAlias &type_alias) // Visibility? type IDENTIFIER GenericParams? WhereClause? = Type; // Note: Associated types are handled by `AST::TraitItemType`. - - visit_items_as_lines (type_alias.get_outer_attrs ()); - if (type_alias.has_visibility ()) - visit (type_alias.get_visibility ()); - auto alias_name = type_alias.get_new_type_name ().as_string (); - push (Rust::Token::make (TYPE, type_alias.get_locus ())); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (alias_name))); - - if (type_alias.has_generics ()) - visit (type_alias.get_generic_params ()); - - if (type_alias.has_where_clause ()) - visit (type_alias.get_where_clause ()); - - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (type_alias.get_type_aliased ()); - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + internal_comment (std::string ("TypeAlias"), [this, &type_alias] () { + visit_items_as_lines (type_alias.get_outer_attrs ()); + if (type_alias.has_visibility ()) + visit (type_alias.get_visibility ()); + auto alias_name = type_alias.get_new_type_name ().as_string (); + push (Rust::Token::make (TYPE, type_alias.get_locus ())); + push ( + Rust::Token::make_identifier (UNDEF_LOCATION, std::move (alias_name))); + + if (type_alias.has_generics ()) + visit (type_alias.get_generic_params ()); + + if (type_alias.has_where_clause ()) + visit (type_alias.get_where_clause ()); + + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (type_alias.get_type_aliased ()); + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + }); } void TokenCollector::visit (StructStruct &struct_item) { - visit_items_as_lines (struct_item.get_outer_attrs ()); - if (struct_item.has_visibility ()) - visit (struct_item.get_visibility ()); - auto struct_name = struct_item.get_identifier ().as_string (); - push (Rust::Token::make (STRUCT_KW, struct_item.get_locus ())); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (struct_name))); - - if (struct_item.has_generics ()) - visit (struct_item.get_generic_params ()); - if (struct_item.has_where_clause ()) - visit (struct_item.get_where_clause ()); - if (struct_item.is_unit_struct ()) - { - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); - newline (); - } - else - visit_items_as_block (struct_item.get_fields (), - {Rust::Token::make (COMMA, UNDEF_LOCATION)}); + internal_comment (std::string ("StructStruct"), [this, &struct_item] () { + visit_items_as_lines (struct_item.get_outer_attrs ()); + if (struct_item.has_visibility ()) + visit (struct_item.get_visibility ()); + auto struct_name = struct_item.get_identifier ().as_string (); + push (Rust::Token::make (STRUCT_KW, struct_item.get_locus ())); + push ( + Rust::Token::make_identifier (UNDEF_LOCATION, std::move (struct_name))); + + if (struct_item.has_generics ()) + visit (struct_item.get_generic_params ()); + if (struct_item.has_where_clause ()) + visit (struct_item.get_where_clause ()); + if (struct_item.is_unit_struct ()) + { + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + newline (); + } + else + visit_items_as_block (struct_item.get_fields (), + {Rust::Token::make (COMMA, UNDEF_LOCATION)}); + }); } void TokenCollector::visit (TupleStruct &tuple_struct) { - visit_items_as_lines (tuple_struct.get_outer_attrs ()); - auto struct_name = tuple_struct.get_identifier ().as_string (); - push (Rust::Token::make (STRUCT_KW, tuple_struct.get_locus ())); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (struct_name))); - if (tuple_struct.has_generics ()) - visit (tuple_struct.get_generic_params ()); - if (tuple_struct.has_where_clause ()) - visit (tuple_struct.get_where_clause ()); - - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - visit_items_joined_by_separator (tuple_struct.get_fields (), COMMA); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); - newline (); + internal_comment (std::string ("TupleStruct"), [this, &tuple_struct] () { + visit_items_as_lines (tuple_struct.get_outer_attrs ()); + auto struct_name = tuple_struct.get_identifier ().as_string (); + push (Rust::Token::make (STRUCT_KW, tuple_struct.get_locus ())); + push ( + Rust::Token::make_identifier (UNDEF_LOCATION, std::move (struct_name))); + if (tuple_struct.has_generics ()) + visit (tuple_struct.get_generic_params ()); + if (tuple_struct.has_where_clause ()) + visit (tuple_struct.get_where_clause ()); + + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + visit_items_joined_by_separator (tuple_struct.get_fields (), COMMA); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + newline (); + }); } void TokenCollector::visit (EnumItem &item) { - visit_items_as_lines (item.get_outer_attrs ()); - auto id = item.get_identifier ().as_string (); - push (Rust::Token::make_identifier (item.get_locus (), std::move (id))); + internal_comment (std::string ("EnumItem"), [this, &item] () { + visit_items_as_lines (item.get_outer_attrs ()); + auto id = item.get_identifier ().as_string (); + push (Rust::Token::make_identifier (item.get_locus (), std::move (id))); + }); } void TokenCollector::visit (EnumItemTuple &item) { - auto id = item.get_identifier ().as_string (); - push (Rust::Token::make_identifier (item.get_locus (), std::move (id))); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - visit_items_joined_by_separator (item.get_tuple_fields (), COMMA); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + internal_comment (std::string ("EnumItemTuple"), [this, &item] () { + auto id = item.get_identifier ().as_string (); + push (Rust::Token::make_identifier (item.get_locus (), std::move (id))); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + visit_items_joined_by_separator (item.get_tuple_fields (), COMMA); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } void TokenCollector::visit (EnumItemStruct &item) { - auto id = item.get_identifier ().as_string (); - push (Rust::Token::make_identifier (item.get_locus (), std::move (id))); - visit_items_as_block (item.get_struct_fields (), - {Rust::Token::make (COMMA, UNDEF_LOCATION)}); + internal_comment (std::string ("EnumItemStruct"), [this, &item] () { + auto id = item.get_identifier ().as_string (); + push (Rust::Token::make_identifier (item.get_locus (), std::move (id))); + visit_items_as_block (item.get_struct_fields (), + {Rust::Token::make (COMMA, UNDEF_LOCATION)}); + }); } void TokenCollector::visit (EnumItemDiscriminant &item) { - auto id = item.get_identifier ().as_string (); - push (Rust::Token::make_identifier (item.get_locus (), std::move (id))); - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (item.get_expr ()); + internal_comment (std::string ("EnumItemDiscriminant"), [this, &item] () { + auto id = item.get_identifier ().as_string (); + push (Rust::Token::make_identifier (item.get_locus (), std::move (id))); + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (item.get_expr ()); + }); } void TokenCollector::visit (Enum &enumeration) { - visit_items_as_lines (enumeration.get_outer_attrs ()); - if (enumeration.has_visibility ()) - visit (enumeration.get_visibility ()); - push (Rust::Token::make (ENUM_KW, enumeration.get_locus ())); - auto id = enumeration.get_identifier ().as_string (); - push ( - Rust::Token::make_identifier (enumeration.get_locus (), std::move (id))); - if (enumeration.has_generics ()) - visit (enumeration.get_generic_params ()); - if (enumeration.has_where_clause ()) - visit (enumeration.get_where_clause ()); - - visit_items_as_block (enumeration.get_variants (), - {Rust::Token::make (COMMA, UNDEF_LOCATION)}); + internal_comment (std::string ("Enum"), [this, &enumeration] () { + visit_items_as_lines (enumeration.get_outer_attrs ()); + if (enumeration.has_visibility ()) + visit (enumeration.get_visibility ()); + push (Rust::Token::make (ENUM_KW, enumeration.get_locus ())); + auto id = enumeration.get_identifier ().as_string (); + push ( + Rust::Token::make_identifier (enumeration.get_locus (), std::move (id))); + if (enumeration.has_generics ()) + visit (enumeration.get_generic_params ()); + if (enumeration.has_where_clause ()) + visit (enumeration.get_where_clause ()); + + visit_items_as_block (enumeration.get_variants (), + {Rust::Token::make (COMMA, UNDEF_LOCATION)}); + }); } void TokenCollector::visit (Union &union_item) { - visit_items_as_lines (union_item.get_outer_attrs ()); - auto id = union_item.get_identifier ().as_string (); - push (Rust::Token::make_identifier (union_item.get_locus (), - Values::WeakKeywords::UNION)); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + internal_comment (std::string ("Union"), [this, &union_item] () { + visit_items_as_lines (union_item.get_outer_attrs ()); + auto id = union_item.get_identifier ().as_string (); + push (Rust::Token::make_identifier (union_item.get_locus (), + Values::WeakKeywords::UNION)); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - if (union_item.has_generics ()) - visit (union_item.get_generic_params ()); + if (union_item.has_generics ()) + visit (union_item.get_generic_params ()); - if (union_item.has_where_clause ()) - visit (union_item.get_where_clause ()); + if (union_item.has_where_clause ()) + visit (union_item.get_where_clause ()); - visit_items_as_block (union_item.get_variants (), - {Rust::Token::make (COMMA, UNDEF_LOCATION)}); + visit_items_as_block (union_item.get_variants (), + {Rust::Token::make (COMMA, UNDEF_LOCATION)}); + }); } void TokenCollector::visit (ConstantItem &item) { - visit_items_as_lines (item.get_outer_attrs ()); - push (Rust::Token::make (CONST, item.get_locus ())); - if (item.is_unnamed ()) - { - push (Rust::Token::make (UNDERSCORE, UNDEF_LOCATION)); - } - else - { - auto id = item.get_identifier (); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - } - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (item.get_type ()); - if (item.has_expr ()) - { - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (item.get_expr ()); - } - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + internal_comment (std::string ("ConstantItem"), [this, &item] () { + visit_items_as_lines (item.get_outer_attrs ()); + push (Rust::Token::make (CONST, item.get_locus ())); + if (item.is_unnamed ()) + { + push (Rust::Token::make (UNDERSCORE, UNDEF_LOCATION)); + } + else + { + auto id = item.get_identifier (); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + } + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit (item.get_type ()); + if (item.has_expr ()) + { + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (item.get_expr ()); + } + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + }); } void TokenCollector::visit (StaticItem &item) { - visit_items_as_lines (item.get_outer_attrs ()); - push (Rust::Token::make (STATIC_KW, item.get_locus ())); - if (item.is_mutable ()) - push (Rust::Token::make (MUT, UNDEF_LOCATION)); + internal_comment (std::string ("StaticItem"), [this, &item] () { + visit_items_as_lines (item.get_outer_attrs ()); + push (Rust::Token::make (STATIC_KW, item.get_locus ())); + if (item.is_mutable ()) + push (Rust::Token::make (MUT, UNDEF_LOCATION)); - auto id = item.get_identifier ().as_string (); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); + auto id = item.get_identifier ().as_string (); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (item.get_type ()); + visit (item.get_type ()); - if (item.has_expr ()) - { - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (item.get_expr ()); - } - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + if (item.has_expr ()) + { + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (item.get_expr ()); + } + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + }); } void @@ -1999,150 +2261,167 @@ TokenCollector::visit_function_common (std::unique_ptr &return_type, void TokenCollector::visit (SelfParam ¶m) { - if (param.get_has_ref ()) - { - push (Rust::Token::make (AMP, UNDEF_LOCATION)); - if (param.has_lifetime ()) - { - auto lifetime = param.get_lifetime (); - visit (lifetime); - } - if (param.get_is_mut ()) - push (Rust::Token::make (MUT, UNDEF_LOCATION)); - } - push (Rust::Token::make (SELF, UNDEF_LOCATION)); - if (param.has_type ()) - { - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (param.get_type ()); - } + internal_comment (std::string ("SelfParam"), [this, ¶m] () { + if (param.get_has_ref ()) + { + push (Rust::Token::make (AMP, UNDEF_LOCATION)); + if (param.has_lifetime ()) + { + auto lifetime = param.get_lifetime (); + visit (lifetime); + } + if (param.get_is_mut ()) + push (Rust::Token::make (MUT, UNDEF_LOCATION)); + } + push (Rust::Token::make (SELF, UNDEF_LOCATION)); + if (param.has_type ()) + { + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit (param.get_type ()); + } + }); } void TokenCollector::visit (TraitItemConst &item) { - auto id = item.get_identifier ().as_string (); - indentation (); - push (Rust::Token::make (CONST, item.get_locus ())); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (item.get_type ()); - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); - newline (); + internal_comment (std::string ("TraitItemConst"), [this, &item] () { + auto id = item.get_identifier ().as_string (); + indentation (); + push (Rust::Token::make (CONST, item.get_locus ())); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit (item.get_type ()); + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + newline (); + }); } void TokenCollector::visit (TraitItemType &item) { - visit_items_as_lines (item.get_outer_attrs ()); - auto id = item.get_identifier ().as_string (); - indentation (); + internal_comment (std::string ("TraitItemType"), [this, &item] () { + visit_items_as_lines (item.get_outer_attrs ()); + auto id = item.get_identifier ().as_string (); + indentation (); - push (Rust::Token::make (TYPE, item.get_locus ())); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); - newline (); + push (Rust::Token::make (TYPE, item.get_locus ())); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + newline (); + }); } void TokenCollector::visit (Trait &trait) { - for (auto &attr : trait.get_outer_attrs ()) - { - visit (attr); - newline (); - indentation (); - } + internal_comment (std::string ("Trait"), [this, &trait] () { + for (auto &attr : trait.get_outer_attrs ()) + { + visit (attr); + newline (); + indentation (); + } - visit (trait.get_visibility ()); + visit (trait.get_visibility ()); - auto id = trait.get_identifier ().as_string (); - push (Rust::Token::make (TRAIT, trait.get_locus ())); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + auto id = trait.get_identifier ().as_string (); + push (Rust::Token::make (TRAIT, trait.get_locus ())); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - visit (trait.get_generic_params ()); + visit (trait.get_generic_params ()); - visit_items_as_block (trait.get_trait_items (), {}); + visit_items_as_block (trait.get_trait_items (), {}); + }); } void TokenCollector::visit (InherentImpl &impl) { - visit_items_as_lines (impl.get_outer_attrs ()); - push (Rust::Token::make (IMPL, impl.get_locus ())); - visit (impl.get_generic_params ()); + internal_comment (std::string ("InherentImpl"), [this, &impl] () { + visit_items_as_lines (impl.get_outer_attrs ()); + push (Rust::Token::make (IMPL, impl.get_locus ())); + visit (impl.get_generic_params ()); - visit (impl.get_type ()); + visit (impl.get_type ()); - if (impl.has_where_clause ()) - visit (impl.get_where_clause ()); + if (impl.has_where_clause ()) + visit (impl.get_where_clause ()); - // FIXME: Handle inner attributes + // FIXME: Handle inner attributes - visit_items_as_block (impl.get_impl_items (), {}); + visit_items_as_block (impl.get_impl_items (), {}); + }); } void TokenCollector::visit (TraitImpl &impl) { - visit_items_as_lines (impl.get_outer_attrs ()); - push (Rust::Token::make (IMPL, impl.get_locus ())); - visit (impl.get_generic_params ()); - if (impl.is_exclam ()) - push (Rust::Token::make (EXCLAM, UNDEF_LOCATION)); - visit (impl.get_trait_path ()); - push (Rust::Token::make (FOR, UNDEF_LOCATION)); - visit (impl.get_type ()); - - if (impl.has_where_clause ()) - visit (impl.get_where_clause ()); - + internal_comment (std::string ("TraitImpl"), [this, &impl] () { + visit_items_as_lines (impl.get_outer_attrs ()); + push (Rust::Token::make (IMPL, impl.get_locus ())); + visit (impl.get_generic_params ()); + if (impl.is_exclam ()) + push (Rust::Token::make (EXCLAM, UNDEF_LOCATION)); + visit (impl.get_trait_path ()); + push (Rust::Token::make (FOR, UNDEF_LOCATION)); + visit (impl.get_type ()); + + if (impl.has_where_clause ()) + visit (impl.get_where_clause ()); + }); visit_items_as_block (impl.get_impl_items ()); } void TokenCollector::visit (ExternalTypeItem &type) { - visit (type.get_visibility ()); + internal_comment (std::string ("ExternalTypeItem"), [this, &type] () { + visit (type.get_visibility ()); - auto id = type.get_identifier ().as_string (); + auto id = type.get_identifier ().as_string (); - push (Rust::Token::make (TYPE, UNDEF_LOCATION)); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + push (Rust::Token::make (TYPE, UNDEF_LOCATION)); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + }); } void TokenCollector::visit (ExternalStaticItem &item) { - auto id = item.get_identifier ().as_string (); - visit_items_as_lines (item.get_outer_attrs ()); - if (item.has_visibility ()) - visit (item.get_visibility ()); - push (Rust::Token::make (STATIC_KW, item.get_locus ())); - if (item.is_mut ()) - push (Rust::Token::make (MUT, UNDEF_LOCATION)); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (item.get_type ()); - // TODO: No expr ? The "(= Expression)?" part from the reference seems missing - // in the ast. - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + internal_comment (std::string ("ExternalStaticItem"), [this, &item] () { + auto id = item.get_identifier ().as_string (); + visit_items_as_lines (item.get_outer_attrs ()); + if (item.has_visibility ()) + visit (item.get_visibility ()); + push (Rust::Token::make (STATIC_KW, item.get_locus ())); + if (item.is_mut ()) + push (Rust::Token::make (MUT, UNDEF_LOCATION)); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit (item.get_type ()); + // TODO: No expr ? The "(= Expression)?" part from the reference seems + // missing in the ast. + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + }); } void TokenCollector::visit (ExternBlock &block) { - visit_items_as_lines (block.get_outer_attrs ()); - push (Rust::Token::make (EXTERN_KW, block.get_locus ())); + internal_comment (std::string ("ExternBlock"), [this, &block] () { + visit_items_as_lines (block.get_outer_attrs ()); + push (Rust::Token::make (EXTERN_KW, block.get_locus ())); - if (block.has_abi ()) - { - auto abi = block.get_abi (); - push (Rust::Token::make_string (UNDEF_LOCATION, std::move (abi))); - } + if (block.has_abi ()) + { + auto abi = block.get_abi (); + push (Rust::Token::make_string (UNDEF_LOCATION, std::move (abi))); + } - visit_items_as_block (block.get_extern_items (), {}); + visit_items_as_block (block.get_extern_items (), {}); + }); } static std::pair @@ -2164,204 +2443,238 @@ get_delimiters (DelimType delim) void TokenCollector::visit (MacroMatchFragment &match) { - auto id = match.get_ident ().as_string (); - auto frag_spec = match.get_frag_spec ().as_string (); - push (Rust::Token::make (DOLLAR_SIGN, UNDEF_LOCATION)); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (frag_spec))); + internal_comment (std::string ("MacroMatchFragment"), [this, &match] () { + auto id = match.get_ident ().as_string (); + auto frag_spec = match.get_frag_spec ().as_string (); + push (Rust::Token::make (DOLLAR_SIGN, UNDEF_LOCATION)); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (frag_spec))); + }); } void TokenCollector::visit (MacroMatchRepetition &repetition) { - push (Rust::Token::make (DOLLAR_SIGN, UNDEF_LOCATION)); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + internal_comment (std::string ("MacroMatchRepetition"), [this, + &repetition] () { + push (Rust::Token::make (DOLLAR_SIGN, UNDEF_LOCATION)); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - for (auto &match : repetition.get_matches ()) - { - visit (match); - } + for (auto &match : repetition.get_matches ()) + { + visit (match); + } - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); - if (repetition.has_sep ()) - { - push (Rust::Token::make (repetition.get_sep ()->get_id (), - repetition.get_sep ()->get_locus ())); - } - switch (repetition.get_op ()) - { - case MacroMatchRepetition::ANY: - push (Rust::Token::make (ASTERISK, UNDEF_LOCATION)); - break; - case MacroMatchRepetition::ONE_OR_MORE: - push (Rust::Token::make (PLUS, UNDEF_LOCATION)); - break; - case MacroMatchRepetition::ZERO_OR_ONE: - push (Rust::Token::make (QUESTION_MARK, UNDEF_LOCATION)); - break; - case MacroMatchRepetition::NONE: - break; - } + if (repetition.has_sep ()) + { + push (Rust::Token::make (repetition.get_sep ()->get_id (), + repetition.get_sep ()->get_locus ())); + } + switch (repetition.get_op ()) + { + case MacroMatchRepetition::ANY: + push (Rust::Token::make (ASTERISK, UNDEF_LOCATION)); + break; + case MacroMatchRepetition::ONE_OR_MORE: + push (Rust::Token::make (PLUS, UNDEF_LOCATION)); + break; + case MacroMatchRepetition::ZERO_OR_ONE: + push (Rust::Token::make (QUESTION_MARK, UNDEF_LOCATION)); + break; + case MacroMatchRepetition::NONE: + break; + } + }); } void TokenCollector::visit (MacroMatcher &matcher) { - auto delimiters = get_delimiters (matcher.get_delim_type ()); + internal_comment (std::string ("MacroMatcher"), [this, &matcher] () { + auto delimiters = get_delimiters (matcher.get_delim_type ()); - push (Rust::Token::make (delimiters.first, UNDEF_LOCATION)); + push (Rust::Token::make (delimiters.first, UNDEF_LOCATION)); - for (auto &item : matcher.get_matches ()) - { - visit (item); - } + for (auto &item : matcher.get_matches ()) + { + visit (item); + } - push (Rust::Token::make (delimiters.second, UNDEF_LOCATION)); + push (Rust::Token::make (delimiters.second, UNDEF_LOCATION)); + }); } void TokenCollector::visit (MacroRule &rule) { - visit (rule.get_matcher ()); - push (Rust::Token::make (MATCH_ARROW, rule.get_locus ())); - visit (rule.get_transcriber ().get_token_tree ()); + internal_comment (std::string ("MacroRule"), [this, &rule] () { + visit (rule.get_matcher ()); + push (Rust::Token::make (MATCH_ARROW, rule.get_locus ())); + visit (rule.get_transcriber ().get_token_tree ()); + }); } void TokenCollector::visit (MacroRulesDefinition &rules_def) { - for (auto &outer_attr : rules_def.get_outer_attrs ()) - visit (outer_attr); + internal_comment (std::string ("MacroRulesDefinition"), [this, + &rules_def] () { + for (auto &outer_attr : rules_def.get_outer_attrs ()) + visit (outer_attr); - auto rule_name = rules_def.get_rule_name ().as_string (); + auto rule_name = rules_def.get_rule_name ().as_string (); - push (Rust::Token::make_identifier (rules_def.get_locus (), - Values::WeakKeywords::MACRO_RULES)); - push (Rust::Token::make (EXCLAM, UNDEF_LOCATION)); + push (Rust::Token::make_identifier (rules_def.get_locus (), + Values::WeakKeywords::MACRO_RULES)); + push (Rust::Token::make (EXCLAM, UNDEF_LOCATION)); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (rule_name))); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (rule_name))); - visit_items_as_block (rules_def.get_rules (), - {Rust::Token::make (SEMICOLON, UNDEF_LOCATION)}); + visit_items_as_block (rules_def.get_rules (), + {Rust::Token::make (SEMICOLON, UNDEF_LOCATION)}); + }); } void TokenCollector::visit (MacroInvocation &invocation) { - auto data = invocation.get_invoc_data (); - visit (data.get_path ()); - push (Rust::Token::make (EXCLAM, UNDEF_LOCATION)); - visit (data.get_delim_tok_tree ()); - if (invocation.has_semicolon ()) - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + internal_comment (std::string ("MacroInvocation"), [this, &invocation] () { + auto data = invocation.get_invoc_data (); + visit (data.get_path ()); + push (Rust::Token::make (EXCLAM, UNDEF_LOCATION)); + visit (data.get_delim_tok_tree ()); + if (invocation.has_semicolon ()) + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + }); } void TokenCollector::visit (MetaItemPath &item) { - auto path = item.to_path_item (); - visit (path); + internal_comment (std::string ("MetaItemPath"), [this, &item] () { + auto path = item.to_path_item (); + visit (path); + }); } void TokenCollector::visit (MetaItemSeq &item) { - visit (item.get_path ()); - // TODO: Double check this, there is probably a mistake. - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - visit_items_joined_by_separator (item.get_seq (), COMMA); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + internal_comment (std::string ("MetaItemSeq"), [this, &item] () { + visit (item.get_path ()); + // TODO: Double check this, there is probably a mistake. + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + visit_items_joined_by_separator (item.get_seq (), COMMA); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } void TokenCollector::visit (MetaWord &word) { - auto id = word.get_ident ().as_string (); + internal_comment (std::string ("MetaWord"), [this, &word] () { + auto id = word.get_ident ().as_string (); - push (Rust::Token::make_identifier (word.get_locus (), std::move (id))); + push (Rust::Token::make_identifier (word.get_locus (), std::move (id))); + }); } void TokenCollector::visit (MetaNameValueStr &name) { - auto pair = name.get_name_value_pair (); - auto id = std::get<0> (pair).as_string (); - auto value = std::get<1> (pair); + internal_comment (std::string ("MetaNameValueStr"), [this, &name] () { + auto pair = name.get_name_value_pair (); + auto id = std::get<0> (pair).as_string (); + auto value = std::get<1> (pair); - push (Rust::Token::make_identifier (name.get_locus (), std::move (id))); - push (Rust::Token::make (EQUAL, name.get_locus ())); - push (Rust::Token::make (DOUBLE_QUOTE, UNDEF_LOCATION)); - push (Rust::Token::make_identifier (name.get_locus (), std::move (value))); - push (Rust::Token::make (DOUBLE_QUOTE, UNDEF_LOCATION)); + push (Rust::Token::make_identifier (name.get_locus (), std::move (id))); + push (Rust::Token::make (EQUAL, name.get_locus ())); + push (Rust::Token::make (DOUBLE_QUOTE, UNDEF_LOCATION)); + push (Rust::Token::make_identifier (name.get_locus (), std::move (value))); + push (Rust::Token::make (DOUBLE_QUOTE, UNDEF_LOCATION)); + }); } void TokenCollector::visit (MetaListPaths &list) { - auto id = list.get_ident ().as_string (); + internal_comment (std::string ("MetaListPath"), [this, &list] () { + auto id = list.get_ident ().as_string (); - push (Rust::Token::make_identifier (list.get_locus (), std::move (id))); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make_identifier (list.get_locus (), std::move (id))); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - visit_items_joined_by_separator (list.get_paths (), COMMA); + visit_items_joined_by_separator (list.get_paths (), COMMA); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } void TokenCollector::visit (MetaListNameValueStr &list) { - auto id = list.get_ident ().as_string (); + internal_comment (std::string ("MetaListNameValueStr"), [this, &list] () { + auto id = list.get_ident ().as_string (); - push (Rust::Token::make_identifier (list.get_locus (), std::move (id))); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make_identifier (list.get_locus (), std::move (id))); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - visit_items_joined_by_separator (list.get_values (), COMMA); + visit_items_joined_by_separator (list.get_values (), COMMA); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } // rust-pattern.h void TokenCollector::visit (LiteralPattern &pattern) { - visit (pattern.get_literal (), pattern.get_locus ()); + internal_comment (std::string ("LiteralPattern"), [this, &pattern] () { + visit (pattern.get_literal (), pattern.get_locus ()); + }); } void TokenCollector::visit (IdentifierPattern &pattern) { - if (pattern.get_is_ref ()) - { - push (Rust::Token::make (REF, pattern.get_locus ())); - } - if (pattern.get_is_mut ()) - { - push (Rust::Token::make (MUT, UNDEF_LOCATION)); - } + internal_comment (std::string ("IdentifierPattern"), [this, &pattern] () { + if (pattern.get_is_ref ()) + { + push (Rust::Token::make (REF, pattern.get_locus ())); + } + if (pattern.get_is_mut ()) + { + push (Rust::Token::make (MUT, UNDEF_LOCATION)); + } - auto id = pattern.get_ident ().as_string (); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + auto id = pattern.get_ident ().as_string (); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - if (pattern.has_pattern_to_bind ()) - { - push (Rust::Token::make (PATTERN_BIND, UNDEF_LOCATION)); - visit (pattern.get_pattern_to_bind ()); - } + if (pattern.has_pattern_to_bind ()) + { + push (Rust::Token::make (PATTERN_BIND, UNDEF_LOCATION)); + visit (pattern.get_pattern_to_bind ()); + } + }); } void TokenCollector::visit (WildcardPattern &pattern) { - push (Rust::Token::make (UNDERSCORE, pattern.get_locus ())); + internal_comment (std::string ("WildcardPattern"), [this, &pattern] () { + push (Rust::Token::make (UNDERSCORE, pattern.get_locus ())); + }); } void TokenCollector::visit (RestPattern &pattern) { - push (Rust::Token::make (DOT_DOT, pattern.get_locus ())); + internal_comment (std::string ("RestPattern"), [this, &pattern] () { + push (Rust::Token::make (DOT_DOT, pattern.get_locus ())); + }); } // void TokenCollector::visit(RangePatternBound& ){} @@ -2369,68 +2682,80 @@ TokenCollector::visit (RestPattern &pattern) void TokenCollector::visit (RangePatternBoundLiteral &pattern) { - if (pattern.get_has_minus ()) - { - push (Rust::Token::make (MINUS, pattern.get_locus ())); - } - auto literal = pattern.get_literal (); - visit (literal); + internal_comment (std::string ("RangePatternBoundLiteral"), [this, + &pattern] () { + if (pattern.get_has_minus ()) + { + push (Rust::Token::make (MINUS, pattern.get_locus ())); + } + auto literal = pattern.get_literal (); + visit (literal); + }); } void TokenCollector::visit (RangePatternBoundPath &pattern) { - visit (pattern.get_path ()); + internal_comment (std::string ("RangePatternBoundPath"), + [this, &pattern] () { visit (pattern.get_path ()); }); } void TokenCollector::visit (RangePatternBoundQualPath &pattern) { - visit (pattern.get_qualified_path ()); + internal_comment (std::string ("RangePatternBoundQualPath"), + [this, &pattern] () { + visit (pattern.get_qualified_path ()); + }); } void TokenCollector::visit (RangePattern &pattern) { - if (pattern.get_has_lower_bound () && pattern.get_has_upper_bound ()) - { - visit (pattern.get_lower_bound ()); - if (pattern.get_has_ellipsis_syntax ()) - push (Rust::Token::make (ELLIPSIS, pattern.get_locus ())); - else + internal_comment (std::string ("RangePattern"), [this, &pattern] () { + if (pattern.get_has_lower_bound () && pattern.get_has_upper_bound ()) + { + visit (pattern.get_lower_bound ()); + if (pattern.get_has_ellipsis_syntax ()) + push (Rust::Token::make (ELLIPSIS, pattern.get_locus ())); + else + push (Rust::Token::make (DOT_DOT_EQ, pattern.get_locus ())); + visit (pattern.get_upper_bound ()); + } + else if (pattern.get_has_lower_bound ()) + { + visit (pattern.get_lower_bound ()); + push (Rust::Token::make (DOT_DOT, pattern.get_locus ())); + } + else + { push (Rust::Token::make (DOT_DOT_EQ, pattern.get_locus ())); - visit (pattern.get_upper_bound ()); - } - else if (pattern.get_has_lower_bound ()) - { - visit (pattern.get_lower_bound ()); - push (Rust::Token::make (DOT_DOT, pattern.get_locus ())); - } - else - { - push (Rust::Token::make (DOT_DOT_EQ, pattern.get_locus ())); - visit (pattern.get_upper_bound ()); - } + visit (pattern.get_upper_bound ()); + } + }); } void TokenCollector::visit (ReferencePattern &pattern) + { - if (pattern.is_double_reference ()) - { - push (Rust::Token::make (LOGICAL_AND, pattern.get_locus ())); - } - else - { - push (Rust::Token::make (AMP, pattern.get_locus ())); - } + internal_comment (std::string ("ReferencePattern"), [this, &pattern] () { + if (pattern.is_double_reference ()) + { + push (Rust::Token::make (LOGICAL_AND, pattern.get_locus ())); + } + else + { + push (Rust::Token::make (AMP, pattern.get_locus ())); + } - if (pattern.get_is_mut ()) - { - push (Rust::Token::make (MUT, UNDEF_LOCATION)); - } + if (pattern.get_is_mut ()) + { + push (Rust::Token::make (MUT, UNDEF_LOCATION)); + } - visit (pattern.get_referenced_pattern ()); + visit (pattern.get_referenced_pattern ()); + }); } // void TokenCollector::visit(StructPatternField& ){} @@ -2438,60 +2763,71 @@ TokenCollector::visit (ReferencePattern &pattern) void TokenCollector::visit (StructPatternFieldTuplePat &pattern) { - visit_items_as_lines (pattern.get_outer_attrs ()); - push (Rust::Token::make_int (pattern.get_locus (), - std::to_string (pattern.get_index ()))); - push (Rust::Token::make (COLON, pattern.get_locus ())); - visit (pattern.get_index_pattern ()); + internal_comment (std::string ("StructPatternFieldTuplePat"), [this, + &pattern] () { + visit_items_as_lines (pattern.get_outer_attrs ()); + push (Rust::Token::make_int (pattern.get_locus (), + std::to_string (pattern.get_index ()))); + push (Rust::Token::make (COLON, pattern.get_locus ())); + visit (pattern.get_index_pattern ()); + }); } void TokenCollector::visit (StructPatternFieldIdentPat &pattern) { - visit_items_as_lines (pattern.get_outer_attrs ()); + internal_comment (std::string ("StructPatternFieldIdentPat"), [this, + &pattern] () { + visit_items_as_lines (pattern.get_outer_attrs ()); - auto id = pattern.get_identifier ().as_string (); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + auto id = pattern.get_identifier ().as_string (); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); - push (Rust::Token::make (COLON, pattern.get_locus ())); + push (Rust::Token::make (COLON, pattern.get_locus ())); - visit (pattern.get_ident_pattern ()); + visit (pattern.get_ident_pattern ()); + }); } void TokenCollector::visit (StructPatternFieldIdent &pattern) { - visit_items_as_lines (pattern.get_outer_attrs ()); - if (pattern.is_ref ()) - push (Rust::Token::make (REF, UNDEF_LOCATION)); - if (pattern.is_mut ()) - push (Rust::Token::make (MUT, UNDEF_LOCATION)); + internal_comment (std::string ("StructPatternFieldIdent"), [this, + &pattern] () { + visit_items_as_lines (pattern.get_outer_attrs ()); + if (pattern.is_ref ()) + push (Rust::Token::make (REF, UNDEF_LOCATION)); + if (pattern.is_mut ()) + push (Rust::Token::make (MUT, UNDEF_LOCATION)); - auto id = pattern.get_identifier ().as_string (); - push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + auto id = pattern.get_identifier ().as_string (); + push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id))); + }); } void TokenCollector::visit (StructPattern &pattern) { - visit (pattern.get_path ()); - push (Rust::Token::make (LEFT_CURLY, pattern.get_locus ())); - auto elems = pattern.get_struct_pattern_elems (); - if (elems.has_struct_pattern_fields ()) - { - visit_items_joined_by_separator (elems.get_struct_pattern_fields ()); - if (elems.has_etc ()) - { - push (Rust::Token::make (COMMA, UNDEF_LOCATION)); - visit_items_as_lines (elems.get_etc_outer_attrs ()); - } - } - else - { - visit_items_as_lines (elems.get_etc_outer_attrs ()); - } + internal_comment (std::string ("StructPattern"), [this, &pattern] () { + visit (pattern.get_path ()); + push (Rust::Token::make (LEFT_CURLY, pattern.get_locus ())); + auto elems = pattern.get_struct_pattern_elems (); + if (elems.has_struct_pattern_fields ()) + { + visit_items_joined_by_separator (elems.get_struct_pattern_fields ()); + if (elems.has_etc ()) + { + push (Rust::Token::make (COMMA, UNDEF_LOCATION)); + visit_items_as_lines (elems.get_etc_outer_attrs ()); + } + } + else + { + visit_items_as_lines (elems.get_etc_outer_attrs ()); + } - push (Rust::Token::make (RIGHT_CURLY, UNDEF_LOCATION)); + push (Rust::Token::make (RIGHT_CURLY, UNDEF_LOCATION)); + }); } // void TokenCollector::visit(TupleStructItems& ){} @@ -2499,33 +2835,40 @@ TokenCollector::visit (StructPattern &pattern) void TokenCollector::visit (TupleStructItemsNoRange &pattern) { - for (auto &pat : pattern.get_patterns ()) - { - visit (pat); - } + internal_comment (std::string ("TupleStructItemsNoRange"), + [this, &pattern] () { + for (auto &pat : pattern.get_patterns ()) + { + visit (pat); + } + }); } void TokenCollector::visit (TupleStructItemsRange &pattern) { - for (auto &lower : pattern.get_lower_patterns ()) - { - visit (lower); - } - push (Rust::Token::make (DOT_DOT, UNDEF_LOCATION)); - for (auto &upper : pattern.get_lower_patterns ()) - { - visit (upper); - } + internal_comment (std::string ("TupleStructItemsRange"), [this, &pattern] () { + for (auto &lower : pattern.get_lower_patterns ()) + { + visit (lower); + } + push (Rust::Token::make (DOT_DOT, UNDEF_LOCATION)); + for (auto &upper : pattern.get_lower_patterns ()) + { + visit (upper); + } + }); } void TokenCollector::visit (TupleStructPattern &pattern) { - visit (pattern.get_path ()); - push (Rust::Token::make (LEFT_PAREN, pattern.get_locus ())); - visit (pattern.get_items ()); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + internal_comment (std::string ("TupleStructPattern"), [this, &pattern] () { + visit (pattern.get_path ()); + push (Rust::Token::make (LEFT_PAREN, pattern.get_locus ())); + visit (pattern.get_items ()); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } // void @@ -2535,51 +2878,65 @@ TokenCollector::visit (TupleStructPattern &pattern) void TokenCollector::visit (TuplePatternItemsMultiple &pattern) { - visit_items_joined_by_separator (pattern.get_patterns (), COMMA); + internal_comment (std::string ("TuplePatternItemsMultiple"), [this, + &pattern] () { + visit_items_joined_by_separator (pattern.get_patterns (), COMMA); + }); } void TokenCollector::visit (TuplePatternItemsRanged &pattern) { - for (auto &lower : pattern.get_lower_patterns ()) - { - visit (lower); - } - push (Rust::Token::make (DOT_DOT, UNDEF_LOCATION)); - for (auto &upper : pattern.get_lower_patterns ()) - { - visit (upper); - } + internal_comment (std::string ("TuplePatternItemsRanged"), + [this, &pattern] () { + for (auto &lower : pattern.get_lower_patterns ()) + { + visit (lower); + } + push (Rust::Token::make (DOT_DOT, UNDEF_LOCATION)); + for (auto &upper : pattern.get_lower_patterns ()) + { + visit (upper); + } + }); } void TokenCollector::visit (TuplePattern &pattern) { - push (Rust::Token::make (LEFT_PAREN, pattern.get_locus ())); - visit (pattern.get_items ()); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + internal_comment (std::string ("TuplePattern"), [this, &pattern] () { + push (Rust::Token::make (LEFT_PAREN, pattern.get_locus ())); + visit (pattern.get_items ()); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } void TokenCollector::visit (GroupedPattern &pattern) { - push (Rust::Token::make (LEFT_PAREN, pattern.get_locus ())); - visit (pattern.get_pattern_in_parens ()); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + internal_comment (std::string ("GroupedPattern"), [this, &pattern] () { + push (Rust::Token::make (LEFT_PAREN, pattern.get_locus ())); + visit (pattern.get_pattern_in_parens ()); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } void TokenCollector::visit (SlicePattern &pattern) { - push (Rust::Token::make (LEFT_SQUARE, pattern.get_locus ())); - visit_items_joined_by_separator (pattern.get_items (), COMMA); - push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + internal_comment (std::string ("SlicePattern"), [this, &pattern] () { + push (Rust::Token::make (LEFT_SQUARE, pattern.get_locus ())); + visit_items_joined_by_separator (pattern.get_items (), COMMA); + push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + }); } void TokenCollector::visit (AltPattern &pattern) { - visit_items_joined_by_separator (pattern.get_alts (), PIPE); + internal_comment (std::string ("AltPattern"), [this, &pattern] () { + visit_items_joined_by_separator (pattern.get_alts (), PIPE); + }); } // rust-stmt.h @@ -2590,30 +2947,35 @@ TokenCollector::visit (EmptyStmt &) void TokenCollector::visit (LetStmt &stmt) { - push (Rust::Token::make (LET, stmt.get_locus ())); - auto &pattern = stmt.get_pattern (); - visit (pattern); + internal_comment (std::string ("LetStmt"), [this, &stmt] () { + push (Rust::Token::make (LET, stmt.get_locus ())); + auto &pattern = stmt.get_pattern (); + visit (pattern); - if (stmt.has_type ()) - { - push (Rust::Token::make (COLON, UNDEF_LOCATION)); - visit (stmt.get_type ()); - } + if (stmt.has_type ()) + { + push (Rust::Token::make (COLON, UNDEF_LOCATION)); + visit (stmt.get_type ()); + } - if (stmt.has_init_expr ()) - { - push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); - visit (stmt.get_init_expr ()); - } - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + if (stmt.has_init_expr ()) + { + push (Rust::Token::make (EQUAL, UNDEF_LOCATION)); + visit (stmt.get_init_expr ()); + } + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + }); } void TokenCollector::visit (ExprStmt &stmt) { - visit (stmt.get_expr ()); - if (stmt.is_semicolon_followed ()) - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + internal_comment (std::string ("ExprStmt"), [this, &stmt] () { + visit (stmt.get_expr ()); + + if (stmt.is_semicolon_followed ()) + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + }); } // rust-type.h @@ -2623,14 +2985,15 @@ TokenCollector::visit (TraitBound &bound) // Syntax: // ?? ForLifetimes? TypePath // | ( ?? ForLifetimes? TypePath ) + internal_comment (std::string ("TraitBound"), [this, &bound] () { + if (bound.has_opening_question_mark ()) + push (Rust::Token::make (QUESTION_MARK, bound.get_locus ())); - if (bound.has_opening_question_mark ()) - push (Rust::Token::make (QUESTION_MARK, bound.get_locus ())); - - if (bound.has_for_lifetimes ()) - visit (bound.get_for_lifetimes ()); + if (bound.has_for_lifetimes ()) + visit (bound.get_for_lifetimes ()); - visit (bound.get_type_path ()); + visit (bound.get_type_path ()); + }); } void @@ -2640,9 +3003,10 @@ TokenCollector::visit (ImplTraitType &type) // impl TypeParamBounds // TypeParamBounds : // TypeParamBound ( + TypeParamBound )* +? - - push (Rust::Token::make (IMPL, type.get_locus ())); - visit_items_joined_by_separator (type.get_type_param_bounds (), PLUS); + internal_comment (std::string ("ImplTraitType"), [this, &type] () { + push (Rust::Token::make (IMPL, type.get_locus ())); + visit_items_joined_by_separator (type.get_type_param_bounds (), PLUS); + }); } void @@ -2652,10 +3016,11 @@ TokenCollector::visit (TraitObjectType &type) // dyn? TypeParamBounds // TypeParamBounds : // TypeParamBound ( + TypeParamBound )* +? - - if (type.is_dyn ()) - push (Rust::Token::make (DYN, type.get_locus ())); - visit_items_joined_by_separator (type.get_type_param_bounds (), PLUS); + internal_comment (std::string ("TraiObjectType"), [this, &type] () { + if (type.is_dyn ()) + push (Rust::Token::make (DYN, type.get_locus ())); + visit_items_joined_by_separator (type.get_type_param_bounds (), PLUS); + }); } void @@ -2663,10 +3028,11 @@ TokenCollector::visit (ParenthesisedType &type) { // Syntax: // ( Type ) - - push (Rust::Token::make (LEFT_PAREN, type.get_locus ())); - visit (type.get_type_in_parens ()); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + internal_comment (std::string ("ParenthesisedType"), [this, &type] () { + push (Rust::Token::make (LEFT_PAREN, type.get_locus ())); + visit (type.get_type_in_parens ()); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } void @@ -2675,8 +3041,10 @@ TokenCollector::visit (ImplTraitTypeOneBound &type) // Syntax: // impl TraitBound - push (Rust::Token::make (IMPL, type.get_locus ())); - visit (type.get_trait_bound ()); + internal_comment (std::string ("ImplTraitTypeOneBound"), [this, &type] () { + push (Rust::Token::make (IMPL, type.get_locus ())); + visit (type.get_trait_bound ()); + }); } void @@ -2684,10 +3052,11 @@ TokenCollector::visit (TraitObjectTypeOneBound &type) { // Syntax: // dyn? TraitBound - - if (type.is_dyn ()) - push (Rust::Token::make (DYN, type.get_locus ())); - visit (type.get_trait_bound ()); + internal_comment (std::string ("TraitObjectTypeOneBound"), [this, &type] () { + if (type.is_dyn ()) + push (Rust::Token::make (DYN, type.get_locus ())); + visit (type.get_trait_bound ()); + }); } void @@ -2697,9 +3066,11 @@ TokenCollector::visit (TupleType &type) // ( ) // | ( ( Type , )+ Type? ) - push (Rust::Token::make (LEFT_PAREN, type.get_locus ())); - visit_items_joined_by_separator (type.get_elems (), COMMA); - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + internal_comment (std::string ("TupleType"), [this, &type] () { + push (Rust::Token::make (LEFT_PAREN, type.get_locus ())); + visit_items_joined_by_separator (type.get_elems (), COMMA); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + }); } void @@ -2708,7 +3079,9 @@ TokenCollector::visit (NeverType &type) // Syntax: // ! - push (Rust::Token::make (EXCLAM, type.get_locus ())); + internal_comment (std::string ("NeverType"), [this, &type] () { + push (Rust::Token::make (EXCLAM, type.get_locus ())); + }); } void @@ -2716,14 +3089,15 @@ TokenCollector::visit (RawPointerType &type) { // Syntax: // * ( mut | const ) TypeNoBounds + internal_comment (std::string ("RawPointerType"), [this, &type] () { + push (Rust::Token::make (ASTERISK, type.get_locus ())); + if (type.get_pointer_type () == RawPointerType::MUT) + push (Rust::Token::make (MUT, UNDEF_LOCATION)); + else /* RawPointerType::CONST */ + push (Rust::Token::make (CONST, UNDEF_LOCATION)); - push (Rust::Token::make (ASTERISK, type.get_locus ())); - if (type.get_pointer_type () == RawPointerType::MUT) - push (Rust::Token::make (MUT, UNDEF_LOCATION)); - else /* RawPointerType::CONST */ - push (Rust::Token::make (CONST, UNDEF_LOCATION)); - - visit (type.get_type_pointed_to ()); + visit (type.get_type_pointed_to ()); + }); } void @@ -2731,42 +3105,46 @@ TokenCollector::visit (ReferenceType &type) { // Syntax: // & Lifetime? mut? TypeNoBounds + internal_comment (std::string ("ReferenceType"), [this, &type] () { + push (Rust::Token::make (AMP, type.get_locus ())); - push (Rust::Token::make (AMP, type.get_locus ())); - - if (type.has_lifetime ()) - { - visit (type.get_lifetime ()); - } + if (type.has_lifetime ()) + { + visit (type.get_lifetime ()); + } - if (type.get_has_mut ()) - push (Rust::Token::make (MUT, UNDEF_LOCATION)); + if (type.get_has_mut ()) + push (Rust::Token::make (MUT, UNDEF_LOCATION)); - visit (type.get_type_referenced ()); + visit (type.get_type_referenced ()); + }); } void TokenCollector::visit (ArrayType &type) { // Syntax: - // [ Type ; Expression ] - - push (Rust::Token::make (LEFT_SQUARE, type.get_locus ())); - visit (type.get_elem_type ()); - push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); - visit (type.get_size_expr ()); - push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + // [type Type ; Expression ] + internal_comment (std::string ("ArrayType"), [this, &type] () { + push (Rust::Token::make (LEFT_SQUARE, type.get_locus ())); + visit (type.get_elem_type ()); + push (Rust::Token::make (SEMICOLON, UNDEF_LOCATION)); + visit (type.get_size_expr ()); + push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + }); } void TokenCollector::visit (SliceType &type) { // Syntax: - // [ Type ] + // [type Type ] - push (Rust::Token::make (LEFT_SQUARE, type.get_locus ())); - visit (type.get_elem_type ()); - push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + internal_comment (std::string ("SliceType"), [this, &type] () { + push (Rust::Token::make (LEFT_SQUARE, type.get_locus ())); + visit (type.get_elem_type ()); + push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION)); + }); } void @@ -2774,8 +3152,9 @@ TokenCollector::visit (InferredType &type) { // Syntax: // _ - - push (Rust::Token::make (UNDERSCORE, type.get_locus ())); + internal_comment (std::string ("InferredType"), [this, &type] () { + push (Rust::Token::make (UNDERSCORE, type.get_locus ())); + }); } void @@ -2796,34 +3175,35 @@ TokenCollector::visit (BareFunctionType &type) // // MaybeNamedFunctionParametersVariadic : // ( MaybeNamedParam , )* MaybeNamedParam , OuterAttribute* ... + internal_comment (std::string ("BareFunctionType"), [this, &type] () { + if (type.has_for_lifetimes ()) + visit (type.get_for_lifetimes ()); - if (type.has_for_lifetimes ()) - visit (type.get_for_lifetimes ()); + visit (type.get_function_qualifiers ()); - visit (type.get_function_qualifiers ()); + push (Rust::Token::make (FN_KW, type.get_locus ())); + push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); - push (Rust::Token::make (FN_KW, type.get_locus ())); - push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION)); + visit_items_joined_by_separator (type.get_function_params (), COMMA); - visit_items_joined_by_separator (type.get_function_params (), COMMA); - - if (type.is_variadic ()) - { - push (Rust::Token::make (COMMA, UNDEF_LOCATION)); - for (auto &item : type.get_variadic_attr ()) - { - visit (item); - } - push (Rust::Token::make (ELLIPSIS, UNDEF_LOCATION)); - } + if (type.is_variadic ()) + { + push (Rust::Token::make (COMMA, UNDEF_LOCATION)); + for (auto &item : type.get_variadic_attr ()) + { + visit (item); + } + push (Rust::Token::make (ELLIPSIS, UNDEF_LOCATION)); + } - push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); + push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION)); - if (type.has_return_type ()) - { - push (Rust::Token::make (RETURN_TYPE, UNDEF_LOCATION)); - visit (type.get_return_type ()); - } + if (type.has_return_type ()) + { + push (Rust::Token::make (RETURN_TYPE, UNDEF_LOCATION)); + visit (type.get_return_type ()); + } + }); } void diff --git a/gcc/rust/ast/rust-ast-collector.h b/gcc/rust/ast/rust-ast-collector.h index ceb161ccc13..60b784abd7d 100644 --- a/gcc/rust/ast/rust-ast-collector.h +++ b/gcc/rust/ast/rust-ast-collector.h @@ -23,6 +23,8 @@ #include "rust-ast-visitor.h" #include "rust-ast.h" #include "rust-ast-full.h" +#include "rust-system.h" +#include namespace Rust { namespace AST { @@ -33,13 +35,23 @@ class CollectItem enum class Kind { Comment, + InternalComment, Newline, Indentation, Token, }; + enum class Comment + { + Regular, + Internal, + }; + CollectItem (TokenPtr token) : token (token), kind (Kind::Token) {} - CollectItem (std::string comment) : comment (comment), kind (Kind::Comment) {} + CollectItem (std::string comment, Comment type = Comment::Regular) + : comment (comment), + kind (type == Comment::Internal ? Kind::InternalComment : Kind::Comment) + {} CollectItem (Kind kind) : kind (kind) { rust_assert (kind != Kind::Token); } CollectItem (size_t level) : indent_level (level), kind (Kind::Indentation) {} @@ -63,11 +75,20 @@ class CollectItem return indent_level; } + std::string get_internal_comment () + { + rust_assert (kind == Kind::InternalComment); + return comment; + } + + bool is_debug () { return debug; } + private: TokenPtr token; std::string comment; size_t indent_level; Kind kind; + bool debug = false; }; class TokenCollector : public ASTVisitor @@ -164,12 +185,16 @@ class TokenCollector : public ASTVisitor } } + void internal_comment (std::string node_name, std::function visitor); + void trailing_comma (); void newline (); void indentation (); void increment_indentation (); void decrement_indentation (); void comment (std::string comment); + void begin_internal_comment (std::string internalcomment); + void end_internal_comment (std::string internalcomment); /** * Visit common items of functions: Parameters, return type, block */ diff --git a/gcc/rust/ast/rust-ast-dump.cc b/gcc/rust/ast/rust-ast-dump.cc index 2612c27e772..0148c752f40 100644 --- a/gcc/rust/ast/rust-ast-dump.cc +++ b/gcc/rust/ast/rust-ast-dump.cc @@ -18,11 +18,21 @@ #include "rust-ast-dump.h" #include "rust-expr.h" +#include namespace Rust { namespace AST { -Dump::Dump (std::ostream &stream) : stream (stream), indentation (Indent ()) {} +Dump::Dump (std::ostream &stream) + : stream (stream), indentation (Indent ()), print_internal (false) +{} + +Dump::Dump (std::ostream &stream, bool print_internal, + std::set excluded_node) + : stream (stream), indentation (Indent ()), print_internal (print_internal) +{ + excluded_node = excluded_node; +} bool Dump::require_spacing (TokenPtr previous, TokenPtr current) diff --git a/gcc/rust/ast/rust-ast-dump.h b/gcc/rust/ast/rust-ast-dump.h index b76cbbf825d..3c1a0016166 100644 --- a/gcc/rust/ast/rust-ast-dump.h +++ b/gcc/rust/ast/rust-ast-dump.h @@ -22,6 +22,7 @@ #include "rust-ast.h" #include "rust-ast-full.h" #include "rust-dump.h" +#include "rust-system.h" #include "rust-ast-collector.h" @@ -32,6 +33,8 @@ class Dump { public: Dump (std::ostream &stream); + Dump (std::ostream &stream, bool print_internal, + std::set excluded_node); /** * Run the visitor on an entire crate and its items @@ -70,6 +73,23 @@ class Dump stream << "\n"; previous = nullptr; break; + case AST::CollectItem::Kind::InternalComment: + if (print_internal) + { + bool is_excluded = false; + std::string comment = item.get_internal_comment (); + for (auto &node : excluded_node) + { + if (comment.find (node) != std::string::npos) + { + is_excluded = true; + break; + } + } + if (!is_excluded) + stream << " /* " << comment << " */ "; + } + break; default: rust_unreachable (); } @@ -82,6 +102,8 @@ class Dump private: std::ostream &stream; Indent indentation; + bool print_internal; + std::set excluded_node; static bool require_spacing (TokenPtr previous, TokenPtr current); }; diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index 561ba95d14e..0ac14a75dd7 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -1,4 +1,4 @@ -// Copyright (C) 2020-2024 Free Software Foundation, Inc. +// Copyright (C) 2020 - 2024 Free Software Foundation, Inc. // This file is part of GCC. @@ -21,6 +21,7 @@ #include "rust-diagnostics.h" #include "rust-hir-pattern-analysis.h" #include "rust-immutable-name-resolution-context.h" +#include "rust-location.h" #include "rust-unsafe-checker.h" #include "rust-lex.h" #include "rust-parse.h" @@ -58,6 +59,7 @@ #include "selftest.h" #include "tm.h" #include "rust-target.h" +#include "rust-system.h" extern bool saw_errors (void); @@ -70,6 +72,7 @@ namespace Rust { const char *kLexDumpFile = "gccrs.lex.dump"; const char *kASTDumpFile = "gccrs.ast.dump"; const char *kASTPrettyDumpFile = "gccrs.ast-pretty.dump"; +const char *kASTPrettyInternalDumpFile = "gccrs.ast-pretty-internal.dump"; const char *kASTPrettyDumpFileExpanded = "gccrs.ast-pretty-expanded.dump"; const char *kASTExpandedDumpFile = "gccrs.ast-expanded.dump"; const char *kASTmacroResolutionDumpFile = "gccrs.ast-macro-resolution.dump"; @@ -373,6 +376,27 @@ Session::enable_dump (std::string arg) { options.enable_dump_option (CompileOptions::BIR_DUMP); } + else if (!arg.compare (0, 8, "internal")) + { + if (arg.size () == 8) + { + options.enable_dump_option (CompileOptions::INTERNAL_DUMP); + } + else + { + if (arg[8] != ':') + { + rust_error_at (UNDEF_LOCATION, + "%qs malformated to specify Node to ignore when " + "dumping internal comment put a " + "%qs then all the Nodes separated by comma", + arg.c_str (), ":"); + return false; + } + handle_excluded_node (arg); + options.enable_dump_option (CompileOptions::INTERNAL_DUMP); + } + } else { rust_error_at ( @@ -387,6 +411,22 @@ Session::enable_dump (std::string arg) return true; } +/* Helper function to parse a string when dump internal to get node to blacklist + */ + +void +Session::handle_excluded_node (std::string arg) +{ + const int size_node_string = 50; + std::istringstream blist_str ( + arg.substr (arg.find (":") + 1, size_node_string)); + std::string token; + while (std::getline (blist_str, token, ',')) + { + options.add_excluded (token); + } +} + /* Actual main entry point for front-end. Called from langhook to parse files. */ void @@ -543,6 +583,10 @@ Session::compile_crate (const char *filename) { dump_ast_pretty (*ast_crate.get ()); } + if (options.dump_option_enabled (CompileOptions::INTERNAL_DUMP)) + { + dump_ast_pretty_internal (*ast_crate.get ()); + } if (options.dump_option_enabled (CompileOptions::TARGET_OPTION_DUMP)) { options.target_data.dump_target_options (); @@ -1002,6 +1046,26 @@ Session::dump_ast_pretty (AST::Crate &crate, bool expanded) const out.close (); } +void +Session::dump_ast_pretty_internal (AST::Crate &crate) const +{ + std::ofstream out; + out.open (kASTPrettyInternalDumpFile); + + if (out.fail ()) + { + rust_error_at (UNKNOWN_LOCATION, "cannot open %s:%m; ignored", + kASTDumpFile); + return; + } + + std::set str_tmp = options.get_excluded (); + + AST::Dump (out, true, str_tmp).go (crate); + + out.close (); +} + void Session::dump_name_resolution (Resolver2_0::NameResolutionContext &ctx) const { diff --git a/gcc/rust/rust-session-manager.h b/gcc/rust/rust-session-manager.h index 17b52bae4b1..a6aa780941f 100644 --- a/gcc/rust/rust-session-manager.h +++ b/gcc/rust/rust-session-manager.h @@ -223,10 +223,15 @@ struct CompileOptions HIR_DUMP, HIR_DUMP_PRETTY, BIR_DUMP, + INTERNAL_DUMP, }; std::set dump_options; + /* List of node that is not print during the dump of the ast with internal + * comment */ + std::set excluded_node; + /* configuration options - actually useful for conditional compilation and * whatever data related to target arch, features, os, family, env, endian, * pointer width, vendor */ @@ -283,8 +288,17 @@ struct CompileOptions enable_dump_option (DumpOption::HIR_DUMP); enable_dump_option (DumpOption::HIR_DUMP_PRETTY); enable_dump_option (DumpOption::BIR_DUMP); + enable_dump_option (DumpOption::INTERNAL_DUMP); + } + + void add_excluded (std::string node) + { + rust_assert (!node.empty ()); + excluded_node.insert (node); } + const std::set get_excluded () const { return excluded_node; } + void set_crate_name (std::string name) { rust_assert (!name.empty ()); @@ -396,10 +410,13 @@ struct Session void dump_lex (Parser &parser) const; void dump_ast_pretty (AST::Crate &crate, bool expanded = false) const; + void dump_ast_pretty_internal (AST::Crate &crate) const; void dump_name_resolution (Resolver2_0::NameResolutionContext &ctx) const; void dump_hir (HIR::Crate &crate) const; void dump_hir_pretty (HIR::Crate &crate) const; + void handle_excluded_node (std::string arg); + // pipeline stages - TODO maybe move? /* Register plugins pipeline stage. TODO maybe move to another object? * Currently dummy stage. In future will handle attribute injection