Converted Parser to template in preparation for macro expansion

1 files changed, 336 insertions, 331 deletions

diff --git a/gcc/rust/parse/rust-parse.h b/gcc/rust/parse/rust-parse.h
index 5bbfefc..2cf503a 100644
--- a/gcc/rust/parse/rust-parse.h
+++ b/gcc/rust/parse/rust-parse.h
@@ -10,34 +10,34 @@ namespace Rust {
  * probably take up the same amount of space. */
 struct ExprOrStmt
 {
-  ::std::unique_ptr<AST::ExprWithoutBlock> expr;
-  ::std::unique_ptr<AST::Stmt> stmt;
+  std::unique_ptr<AST::ExprWithoutBlock> expr;
+  std::unique_ptr<AST::Stmt> stmt;
 
   /* I was going to resist the urge to make this a real class and make it POD,
    * but construction in steps is too difficult. So it'll just also have a
    * constructor. */
 
   // expression constructor
-  ExprOrStmt (::std::unique_ptr<AST::ExprWithoutBlock> expr)
-    : expr (::std::move (expr))
+  ExprOrStmt (std::unique_ptr<AST::ExprWithoutBlock> expr)
+    : expr (std::move (expr))
   {}
 
   // statement constructor
-  ExprOrStmt (::std::unique_ptr<AST::Stmt> stmt) : stmt (::std::move (stmt)) {}
+  ExprOrStmt (std::unique_ptr<AST::Stmt> stmt) : stmt (std::move (stmt)) {}
 
   // Returns whether this object is in an error state.
-  inline bool is_error () const
+  bool is_error () const
   {
-    return (expr == NULL && stmt == NULL) || (expr != NULL && stmt != NULL);
+    return (expr == nullptr && stmt == nullptr) || (expr != nullptr && stmt != nullptr);
   }
 
   // Returns an error state object.
-  static ExprOrStmt create_error () { return ExprOrStmt (NULL, NULL); }
+  static ExprOrStmt create_error () { return ExprOrStmt (nullptr, nullptr); }
 
   ~ExprOrStmt () = default;
 
-  // no copy constructors/assignment copy as simple object like this shouldn't
-  // require it
+  /* no copy constructors/assignment as simple object like this shouldn't
+   * require it */
 
   // move constructors
   ExprOrStmt (ExprOrStmt &&other) = default;
@@ -58,7 +58,7 @@ private:
 };
 
 /* Restrictions on parsing used to signal that certain ambiguous grammar
- * features should be parsed in a certain way.*/
+ * features should be parsed in a certain way. */
 struct ParseRestrictions
 {
   bool can_be_struct_expr = true;
@@ -68,6 +68,8 @@ struct ParseRestrictions
 };
 
 // Parser implementation for gccrs.
+// TODO: if updated to C++20, ManagedTokenSource would be useful as a concept
+template <typename ManagedTokenSource> 
 class Parser
 {
 private:
@@ -85,18 +87,18 @@ private:
   void parse_statement_seq (bool (Parser::*done) ());
 
   // AST-related stuff - maybe move or something?
-  ::std::vector<AST::Attribute> parse_inner_attributes ();
+  std::vector<AST::Attribute> parse_inner_attributes ();
   AST::Attribute parse_inner_attribute ();
-  ::std::vector<AST::Attribute> parse_outer_attributes ();
+  std::vector<AST::Attribute> parse_outer_attributes ();
   AST::Attribute parse_outer_attribute ();
   AST::Attribute parse_attribute_body ();
-  ::std::unique_ptr<AST::AttrInput> parse_attr_input ();
+  std::unique_ptr<AST::AttrInput> parse_attr_input ();
 
   // Path-related
   AST::SimplePath parse_simple_path ();
   AST::SimplePathSegment parse_simple_path_segment ();
   AST::TypePath parse_type_path ();
-  ::std::unique_ptr<AST::TypePathSegment> parse_type_path_segment ();
+  std::unique_ptr<AST::TypePathSegment> parse_type_path_segment ();
   AST::PathIdentSegment parse_path_ident_segment ();
   AST::GenericArgs parse_path_generic_args ();
   AST::GenericArgsBinding parse_generic_args_binding ();
@@ -110,436 +112,436 @@ private:
 
   // Token tree or macro related
   AST::DelimTokenTree parse_delim_token_tree ();
-  ::std::unique_ptr<AST::TokenTree> parse_token_tree ();
-  ::std::unique_ptr<AST::MacroRulesDefinition>
-  parse_macro_rules_def (::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::MacroInvocationSemi>
-  parse_macro_invocation_semi (::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::MacroInvocation>
-  parse_macro_invocation (::std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::TokenTree> parse_token_tree ();
+  std::unique_ptr<AST::MacroRulesDefinition>
+  parse_macro_rules_def (std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::MacroInvocationSemi>
+  parse_macro_invocation_semi (std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::MacroInvocation>
+  parse_macro_invocation (std::vector<AST::Attribute> outer_attrs);
   AST::MacroRule parse_macro_rule ();
   AST::MacroMatcher parse_macro_matcher ();
-  ::std::unique_ptr<AST::MacroMatch> parse_macro_match ();
-  ::std::unique_ptr<AST::MacroMatchFragment> parse_macro_match_fragment ();
-  ::std::unique_ptr<AST::MacroMatchRepetition> parse_macro_match_repetition ();
+  std::unique_ptr<AST::MacroMatch> parse_macro_match ();
+  std::unique_ptr<AST::MacroMatchFragment> parse_macro_match_fragment ();
+  std::unique_ptr<AST::MacroMatchRepetition> parse_macro_match_repetition ();
 
   // Top-level item-related
-  ::std::vector< ::std::unique_ptr<AST::Item> > parse_items ();
-  ::std::unique_ptr<AST::Item> parse_item (bool called_from_statement);
-  ::std::unique_ptr<AST::VisItem>
-  parse_vis_item (::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::MacroItem>
-  parse_macro_item (::std::vector<AST::Attribute> outer_attrs);
+  std::vector< std::unique_ptr<AST::Item> > parse_items ();
+  std::unique_ptr<AST::Item> parse_item (bool called_from_statement);
+  std::unique_ptr<AST::VisItem>
+  parse_vis_item (std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::MacroItem>
+  parse_macro_item (std::vector<AST::Attribute> outer_attrs);
   AST::Visibility parse_visibility ();
 
   // VisItem subclass-related
-  ::std::unique_ptr<AST::Module>
-  parse_module (AST::Visibility vis, ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::ExternCrate>
+  std::unique_ptr<AST::Module>
+  parse_module (AST::Visibility vis, std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::ExternCrate>
   parse_extern_crate (AST::Visibility vis,
-		      ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::UseDeclaration>
+		      std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::UseDeclaration>
   parse_use_decl (AST::Visibility vis,
-		  ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::UseTree> parse_use_tree ();
-  ::std::unique_ptr<AST::Function>
+		  std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::UseTree> parse_use_tree ();
+  std::unique_ptr<AST::Function>
   parse_function (AST::Visibility vis,
-		  ::std::vector<AST::Attribute> outer_attrs);
+		  std::vector<AST::Attribute> outer_attrs);
   AST::FunctionQualifiers parse_function_qualifiers ();
-  ::std::vector< ::std::unique_ptr<AST::GenericParam> >
+  std::vector< std::unique_ptr<AST::GenericParam> >
   parse_generic_params_in_angles ();
-  ::std::vector< ::std::unique_ptr<AST::GenericParam> > parse_generic_params ();
-  ::std::vector< ::std::unique_ptr<AST::LifetimeParam> >
+  std::vector< std::unique_ptr<AST::GenericParam> > parse_generic_params ();
+  std::vector< std::unique_ptr<AST::LifetimeParam> >
   parse_lifetime_params ();
-  ::std::vector<AST::LifetimeParam> parse_lifetime_params_objs ();
+  std::vector<AST::LifetimeParam> parse_lifetime_params_objs ();
   AST::LifetimeParam parse_lifetime_param ();
-  ::std::vector< ::std::unique_ptr<AST::TypeParam> > parse_type_params ();
-  ::std::unique_ptr<AST::TypeParam> parse_type_param ();
-  ::std::vector<AST::FunctionParam> parse_function_params ();
+  std::vector< std::unique_ptr<AST::TypeParam> > parse_type_params ();
+  std::unique_ptr<AST::TypeParam> parse_type_param ();
+  std::vector<AST::FunctionParam> parse_function_params ();
   AST::FunctionParam parse_function_param ();
-  ::std::unique_ptr<AST::Type> parse_function_return_type ();
+  std::unique_ptr<AST::Type> parse_function_return_type ();
   AST::WhereClause parse_where_clause ();
-  ::std::unique_ptr<AST::WhereClauseItem> parse_where_clause_item ();
-  ::std::unique_ptr<AST::LifetimeWhereClauseItem>
+  std::unique_ptr<AST::WhereClauseItem> parse_where_clause_item ();
+  std::unique_ptr<AST::LifetimeWhereClauseItem>
   parse_lifetime_where_clause_item ();
-  ::std::unique_ptr<AST::TypeBoundWhereClauseItem>
+  std::unique_ptr<AST::TypeBoundWhereClauseItem>
   parse_type_bound_where_clause_item ();
-  ::std::vector<AST::LifetimeParam> parse_for_lifetimes ();
-  ::std::vector< ::std::unique_ptr<AST::TypeParamBound> >
+  std::vector<AST::LifetimeParam> parse_for_lifetimes ();
+  std::vector< std::unique_ptr<AST::TypeParamBound> >
   parse_type_param_bounds ();
-  ::std::unique_ptr<AST::TypeParamBound> parse_type_param_bound ();
-  ::std::unique_ptr<AST::TraitBound> parse_trait_bound ();
-  ::std::vector<AST::Lifetime> parse_lifetime_bounds ();
+  std::unique_ptr<AST::TypeParamBound> parse_type_param_bound ();
+  std::unique_ptr<AST::TraitBound> parse_trait_bound ();
+  std::vector<AST::Lifetime> parse_lifetime_bounds ();
   AST::Lifetime parse_lifetime ();
-  ::std::unique_ptr<AST::TypeAlias>
+  std::unique_ptr<AST::TypeAlias>
   parse_type_alias (AST::Visibility vis,
-		    ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::Struct>
-  parse_struct (AST::Visibility vis, ::std::vector<AST::Attribute> outer_attrs);
-  ::std::vector<AST::StructField> parse_struct_fields ();
+		    std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::Struct>
+  parse_struct (AST::Visibility vis, std::vector<AST::Attribute> outer_attrs);
+  std::vector<AST::StructField> parse_struct_fields ();
   AST::StructField parse_struct_field ();
-  ::std::vector<AST::TupleField> parse_tuple_fields ();
+  std::vector<AST::TupleField> parse_tuple_fields ();
   AST::TupleField parse_tuple_field ();
-  ::std::unique_ptr<AST::Enum>
-  parse_enum (AST::Visibility vis, ::std::vector<AST::Attribute> outer_attrs);
-  ::std::vector< ::std::unique_ptr<AST::EnumItem> > parse_enum_items ();
-  ::std::unique_ptr<AST::EnumItem> parse_enum_item ();
-  ::std::unique_ptr<AST::Union>
-  parse_union (AST::Visibility vis, ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::ConstantItem>
+  std::unique_ptr<AST::Enum>
+  parse_enum (AST::Visibility vis, std::vector<AST::Attribute> outer_attrs);
+  std::vector< std::unique_ptr<AST::EnumItem> > parse_enum_items ();
+  std::unique_ptr<AST::EnumItem> parse_enum_item ();
+  std::unique_ptr<AST::Union>
+  parse_union (AST::Visibility vis, std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::ConstantItem>
   parse_const_item (AST::Visibility vis,
-		    ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::StaticItem>
+		    std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::StaticItem>
   parse_static_item (AST::Visibility vis,
-		     ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::Trait>
-  parse_trait (AST::Visibility vis, ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::TraitItem> parse_trait_item ();
-  ::std::unique_ptr<AST::TraitItemType>
-  parse_trait_type (::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::TraitItemConst>
-  parse_trait_const (::std::vector<AST::Attribute> outer_attrs);
+		     std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::Trait>
+  parse_trait (AST::Visibility vis, std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::TraitItem> parse_trait_item ();
+  std::unique_ptr<AST::TraitItemType>
+  parse_trait_type (std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::TraitItemConst>
+  parse_trait_const (std::vector<AST::Attribute> outer_attrs);
   AST::SelfParam parse_self_param ();
-  ::std::unique_ptr<AST::Impl>
-  parse_impl (AST::Visibility vis, ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::InherentImplItem> parse_inherent_impl_item ();
-  ::std::unique_ptr<AST::InherentImplItem>
+  std::unique_ptr<AST::Impl>
+  parse_impl (AST::Visibility vis, std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::InherentImplItem> parse_inherent_impl_item ();
+  std::unique_ptr<AST::InherentImplItem>
   parse_inherent_impl_function_or_method (
-    AST::Visibility vis, ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::TraitImplItem> parse_trait_impl_item ();
-  ::std::unique_ptr<AST::TraitImplItem> parse_trait_impl_function_or_method (
-    AST::Visibility vis, ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::ExternBlock>
+    AST::Visibility vis, std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::TraitImplItem> parse_trait_impl_item ();
+  std::unique_ptr<AST::TraitImplItem> parse_trait_impl_function_or_method (
+    AST::Visibility vis, std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::ExternBlock>
   parse_extern_block (AST::Visibility vis,
-		      ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::ExternalItem> parse_external_item ();
+		      std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::ExternalItem> parse_external_item ();
   AST::NamedFunctionParam parse_named_function_param ();
   AST::Method parse_method ();
 
   // Expression-related (Pratt parsed)
-  ::std::unique_ptr<AST::Expr>
-  parse_expr (::std::vector<AST::Attribute> outer_attrs
-	      = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::Expr>
+  parse_expr (std::vector<AST::Attribute> outer_attrs
+	      = std::vector<AST::Attribute> (),
 	      ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::Expr>
+  std::unique_ptr<AST::Expr>
   parse_expr (int right_binding_power,
-	      ::std::vector<AST::Attribute> outer_attrs
-	      = ::std::vector<AST::Attribute> (),
+	      std::vector<AST::Attribute> outer_attrs
+	      = std::vector<AST::Attribute> (),
 	      ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::Expr>
-  null_denotation_NEW (const_TokenPtr t,
-		       ::std::vector<AST::Attribute> outer_attrs
-		       = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::Expr>
+  null_denotation (const_TokenPtr t,
+		       std::vector<AST::Attribute> outer_attrs
+		       = std::vector<AST::Attribute> (),
 		       ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::Expr>
-  left_denotation (const_TokenPtr t, ::std::unique_ptr<AST::Expr> left,
-		   ::std::vector<AST::Attribute> outer_attrs
-		   = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::Expr>
+  left_denotation (const_TokenPtr t, std::unique_ptr<AST::Expr> left,
+		   std::vector<AST::Attribute> outer_attrs
+		   = std::vector<AST::Attribute> (),
 		   ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArithmeticOrLogicalExpr>
-  parse_binary_plus_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			  ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArithmeticOrLogicalExpr>
+  parse_binary_plus_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			  std::vector<AST::Attribute> outer_attrs,
 			  ParseRestrictions restrictions
 			  = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArithmeticOrLogicalExpr> parse_binary_minus_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArithmeticOrLogicalExpr> parse_binary_minus_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArithmeticOrLogicalExpr>
-  parse_binary_mult_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			  ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArithmeticOrLogicalExpr>
+  parse_binary_mult_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			  std::vector<AST::Attribute> outer_attrs,
 			  ParseRestrictions restrictions
 			  = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArithmeticOrLogicalExpr>
-  parse_binary_div_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			 ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArithmeticOrLogicalExpr>
+  parse_binary_div_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			 std::vector<AST::Attribute> outer_attrs,
 			 ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArithmeticOrLogicalExpr>
-  parse_binary_mod_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			 ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArithmeticOrLogicalExpr>
+  parse_binary_mod_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			 std::vector<AST::Attribute> outer_attrs,
 			 ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArithmeticOrLogicalExpr>
-  parse_bitwise_and_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			  ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArithmeticOrLogicalExpr>
+  parse_bitwise_and_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			  std::vector<AST::Attribute> outer_attrs,
 			  ParseRestrictions restrictions
 			  = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArithmeticOrLogicalExpr>
-  parse_bitwise_or_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			 ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArithmeticOrLogicalExpr>
+  parse_bitwise_or_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			 std::vector<AST::Attribute> outer_attrs,
 			 ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArithmeticOrLogicalExpr>
-  parse_bitwise_xor_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			  ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArithmeticOrLogicalExpr>
+  parse_bitwise_xor_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			  std::vector<AST::Attribute> outer_attrs,
 			  ParseRestrictions restrictions
 			  = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArithmeticOrLogicalExpr>
-  parse_left_shift_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			 ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArithmeticOrLogicalExpr>
+  parse_left_shift_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			 std::vector<AST::Attribute> outer_attrs,
 			 ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArithmeticOrLogicalExpr>
-  parse_right_shift_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			  ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArithmeticOrLogicalExpr>
+  parse_right_shift_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			  std::vector<AST::Attribute> outer_attrs,
 			  ParseRestrictions restrictions
 			  = ParseRestrictions ());
-  ::std::unique_ptr<AST::ComparisonExpr> parse_binary_equal_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ComparisonExpr> parse_binary_equal_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ComparisonExpr> parse_binary_not_equal_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ComparisonExpr> parse_binary_not_equal_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ComparisonExpr> parse_binary_greater_than_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ComparisonExpr> parse_binary_greater_than_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ComparisonExpr> parse_binary_less_than_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ComparisonExpr> parse_binary_less_than_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ComparisonExpr> parse_binary_greater_equal_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ComparisonExpr> parse_binary_greater_equal_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ComparisonExpr> parse_binary_less_equal_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ComparisonExpr> parse_binary_less_equal_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::LazyBooleanExpr>
-  parse_lazy_or_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-		      ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::LazyBooleanExpr>
+  parse_lazy_or_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+		      std::vector<AST::Attribute> outer_attrs,
 		      ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::LazyBooleanExpr>
-  parse_lazy_and_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-		       ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::LazyBooleanExpr>
+  parse_lazy_and_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+		       std::vector<AST::Attribute> outer_attrs,
 		       ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::TypeCastExpr>
+  std::unique_ptr<AST::TypeCastExpr>
   parse_type_cast_expr (const_TokenPtr tok,
-			::std::unique_ptr<AST::Expr> expr_to_cast,
-			::std::vector<AST::Attribute> outer_attrs,
+			std::unique_ptr<AST::Expr> expr_to_cast,
+			std::vector<AST::Attribute> outer_attrs,
 			ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::AssignmentExpr>
-  parse_assig_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-		    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::AssignmentExpr>
+  parse_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+		    std::vector<AST::Attribute> outer_attrs,
 		    ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::CompoundAssignmentExpr>
-  parse_plus_assig_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			 ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CompoundAssignmentExpr>
+  parse_plus_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			 std::vector<AST::Attribute> outer_attrs,
 			 ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::CompoundAssignmentExpr>
-  parse_minus_assig_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			  ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CompoundAssignmentExpr>
+  parse_minus_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			  std::vector<AST::Attribute> outer_attrs,
 			  ParseRestrictions restrictions
 			  = ParseRestrictions ());
-  ::std::unique_ptr<AST::CompoundAssignmentExpr>
-  parse_mult_assig_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			 ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CompoundAssignmentExpr>
+  parse_mult_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			 std::vector<AST::Attribute> outer_attrs,
 			 ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::CompoundAssignmentExpr>
-  parse_div_assig_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CompoundAssignmentExpr>
+  parse_div_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			std::vector<AST::Attribute> outer_attrs,
 			ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::CompoundAssignmentExpr>
-  parse_mod_assig_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CompoundAssignmentExpr>
+  parse_mod_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			std::vector<AST::Attribute> outer_attrs,
 			ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::CompoundAssignmentExpr>
-  parse_and_assig_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CompoundAssignmentExpr>
+  parse_and_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			std::vector<AST::Attribute> outer_attrs,
 			ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::CompoundAssignmentExpr>
-  parse_or_assig_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-		       ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CompoundAssignmentExpr>
+  parse_or_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+		       std::vector<AST::Attribute> outer_attrs,
 		       ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::CompoundAssignmentExpr>
-  parse_xor_assig_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-			::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CompoundAssignmentExpr>
+  parse_xor_assig_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+			std::vector<AST::Attribute> outer_attrs,
 			ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::CompoundAssignmentExpr> parse_left_shift_assig_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CompoundAssignmentExpr> parse_left_shift_assig_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::CompoundAssignmentExpr> parse_right_shift_assig_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CompoundAssignmentExpr> parse_right_shift_assig_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::AwaitExpr>
+  std::unique_ptr<AST::AwaitExpr>
   parse_await_expr (const_TokenPtr tok,
-		    ::std::unique_ptr<AST::Expr> expr_to_await,
-		    ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::MethodCallExpr> parse_method_call_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> receiver_expr,
-    ::std::vector<AST::Attribute> outer_attrs,
+		    std::unique_ptr<AST::Expr> expr_to_await,
+		    std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::MethodCallExpr> parse_method_call_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> receiver_expr,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::CallExpr> parse_function_call_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> function_expr,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::CallExpr> parse_function_call_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> function_expr,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::RangeExpr> parse_led_range_exclusive_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::RangeExpr> parse_led_range_exclusive_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::RangeExpr>
+  std::unique_ptr<AST::RangeExpr>
   parse_nud_range_exclusive_expr (const_TokenPtr tok,
-				  ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::RangeFromToInclExpr> parse_range_inclusive_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> left,
-    ::std::vector<AST::Attribute> outer_attrs,
+				  std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::RangeFromToInclExpr> parse_range_inclusive_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> left,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::RangeToInclExpr>
+  std::unique_ptr<AST::RangeToInclExpr>
   parse_range_to_inclusive_expr (const_TokenPtr tok,
-				 ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::TupleIndexExpr> parse_tuple_index_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> tuple_expr,
-    ::std::vector<AST::Attribute> outer_attrs,
+				 std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::TupleIndexExpr> parse_tuple_index_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> tuple_expr,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::FieldAccessExpr> parse_field_access_expr (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> struct_expr,
-    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::FieldAccessExpr> parse_field_access_expr (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> struct_expr,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::ArrayIndexExpr>
-  parse_index_expr (const_TokenPtr tok, ::std::unique_ptr<AST::Expr> array_expr,
-		    ::std::vector<AST::Attribute> outer_attrs,
+  std::unique_ptr<AST::ArrayIndexExpr>
+  parse_index_expr (const_TokenPtr tok, std::unique_ptr<AST::Expr> array_expr,
+		    std::vector<AST::Attribute> outer_attrs,
 		    ParseRestrictions restrictions = ParseRestrictions ());
-  ::std::unique_ptr<AST::MacroInvocation>
+  std::unique_ptr<AST::MacroInvocation>
   parse_macro_invocation_partial (AST::PathInExpression path,
-				  ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::StructExprStruct>
+				  std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::StructExprStruct>
   parse_struct_expr_struct_partial (AST::PathInExpression path,
-				    ::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::CallExpr>
+				    std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::CallExpr>
   parse_struct_expr_tuple_partial (AST::PathInExpression path,
-				   ::std::vector<AST::Attribute> outer_attrs);
+				   std::vector<AST::Attribute> outer_attrs);
   AST::PathInExpression parse_path_in_expression_pratt (const_TokenPtr tok);
-  ::std::unique_ptr<AST::ClosureExpr>
+  std::unique_ptr<AST::ClosureExpr>
   parse_closure_expr_pratt (const_TokenPtr tok,
-			    ::std::vector<AST::Attribute> outer_attrs
-			    = ::std::vector<AST::Attribute> ());
-  ::std::unique_ptr<AST::TupleIndexExpr> parse_tuple_index_expr_float (
-    const_TokenPtr tok, ::std::unique_ptr<AST::Expr> tuple_expr,
-    ::std::vector<AST::Attribute> outer_attrs,
+			    std::vector<AST::Attribute> outer_attrs
+			    = std::vector<AST::Attribute> ());
+  std::unique_ptr<AST::TupleIndexExpr> parse_tuple_index_expr_float (
+    const_TokenPtr tok, std::unique_ptr<AST::Expr> tuple_expr,
+    std::vector<AST::Attribute> outer_attrs,
     ParseRestrictions restrictions = ParseRestrictions ());
 
   // Expression-related (non-Pratt parsed)
-  ::std::unique_ptr<AST::ExprWithoutBlock>
-  parse_expr_without_block (::std::vector<AST::Attribute> outer_attrs
-			    = ::std::vector<AST::Attribute> ());
-  ::std::unique_ptr<AST::BlockExpr>
-  parse_block_expr (::std::vector<AST::Attribute> outer_attrs
-		    = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::ExprWithoutBlock>
+  parse_expr_without_block (std::vector<AST::Attribute> outer_attrs
+			    = std::vector<AST::Attribute> ());
+  std::unique_ptr<AST::BlockExpr>
+  parse_block_expr (std::vector<AST::Attribute> outer_attrs
+		    = std::vector<AST::Attribute> (),
 		    bool pratt_parse = false);
-  ::std::unique_ptr<AST::IfExpr>
-  parse_if_expr (::std::vector<AST::Attribute> outer_attrs
-		 = ::std::vector<AST::Attribute> ());
-  ::std::unique_ptr<AST::IfLetExpr>
-  parse_if_let_expr (::std::vector<AST::Attribute> outer_attrs
-		     = ::std::vector<AST::Attribute> ());
-  ::std::unique_ptr<AST::LoopExpr>
-  parse_loop_expr (::std::vector<AST::Attribute> outer_attrs
-		   = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::IfExpr>
+  parse_if_expr (std::vector<AST::Attribute> outer_attrs
+		 = std::vector<AST::Attribute> ());
+  std::unique_ptr<AST::IfLetExpr>
+  parse_if_let_expr (std::vector<AST::Attribute> outer_attrs
+		     = std::vector<AST::Attribute> ());
+  std::unique_ptr<AST::LoopExpr>
+  parse_loop_expr (std::vector<AST::Attribute> outer_attrs
+		   = std::vector<AST::Attribute> (),
 		   AST::LoopLabel label = AST::LoopLabel::error ());
-  ::std::unique_ptr<AST::WhileLoopExpr>
-  parse_while_loop_expr (::std::vector<AST::Attribute> outer_attrs
-			 = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::WhileLoopExpr>
+  parse_while_loop_expr (std::vector<AST::Attribute> outer_attrs
+			 = std::vector<AST::Attribute> (),
 			 AST::LoopLabel label = AST::LoopLabel::error ());
-  ::std::unique_ptr<AST::WhileLetLoopExpr>
-  parse_while_let_loop_expr (::std::vector<AST::Attribute> outer_attrs
-			     = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::WhileLetLoopExpr>
+  parse_while_let_loop_expr (std::vector<AST::Attribute> outer_attrs
+			     = std::vector<AST::Attribute> (),
 			     AST::LoopLabel label = AST::LoopLabel::error ());
-  ::std::unique_ptr<AST::ForLoopExpr>
-  parse_for_loop_expr (::std::vector<AST::Attribute> outer_attrs
-		       = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::ForLoopExpr>
+  parse_for_loop_expr (std::vector<AST::Attribute> outer_attrs
+		       = std::vector<AST::Attribute> (),
 		       AST::LoopLabel label = AST::LoopLabel::error ());
-  ::std::unique_ptr<AST::MatchExpr>
-  parse_match_expr (::std::vector<AST::Attribute> outer_attrs
-		    = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::MatchExpr>
+  parse_match_expr (std::vector<AST::Attribute> outer_attrs
+		    = std::vector<AST::Attribute> (),
 		    bool pratt_parse = false);
   AST::MatchArm parse_match_arm ();
-  ::std::vector< ::std::unique_ptr<AST::Pattern> >
+  std::vector< std::unique_ptr<AST::Pattern> >
   parse_match_arm_patterns (TokenId end_token_id);
-  ::std::unique_ptr<AST::BaseLoopExpr>
-  parse_labelled_loop_expr (::std::vector<AST::Attribute> outer_attrs
-			    = ::std::vector<AST::Attribute> ());
+  std::unique_ptr<AST::BaseLoopExpr>
+  parse_labelled_loop_expr (std::vector<AST::Attribute> outer_attrs
+			    = std::vector<AST::Attribute> ());
   AST::LoopLabel parse_loop_label ();
-  ::std::unique_ptr<AST::AsyncBlockExpr>
-  parse_async_block_expr (::std::vector<AST::Attribute> outer_attrs
-			  = ::std::vector<AST::Attribute> ());
-  ::std::unique_ptr<AST::UnsafeBlockExpr>
-  parse_unsafe_block_expr (::std::vector<AST::Attribute> outer_attrs
-			   = ::std::vector<AST::Attribute> ());
-  ::std::unique_ptr<AST::GroupedExpr>
-  parse_grouped_expr (::std::vector<AST::Attribute> outer_attrs
-		      = ::std::vector<AST::Attribute> ());
-  ::std::unique_ptr<AST::ClosureExpr>
-  parse_closure_expr (::std::vector<AST::Attribute> outer_attrs
-		      = ::std::vector<AST::Attribute> ());
+  std::unique_ptr<AST::AsyncBlockExpr>
+  parse_async_block_expr (std::vector<AST::Attribute> outer_attrs
+			  = std::vector<AST::Attribute> ());
+  std::unique_ptr<AST::UnsafeBlockExpr>
+  parse_unsafe_block_expr (std::vector<AST::Attribute> outer_attrs
+			   = std::vector<AST::Attribute> ());
+  std::unique_ptr<AST::GroupedExpr>
+  parse_grouped_expr (std::vector<AST::Attribute> outer_attrs
+		      = std::vector<AST::Attribute> ());
+  std::unique_ptr<AST::ClosureExpr>
+  parse_closure_expr (std::vector<AST::Attribute> outer_attrs
+		      = std::vector<AST::Attribute> ());
   AST::ClosureParam parse_closure_param ();
-  ::std::unique_ptr<AST::LiteralExpr>
-  parse_literal_expr (::std::vector<AST::Attribute> outer_attrs
-		      = ::std::vector<AST::Attribute> ());
-  ::std::unique_ptr<AST::ReturnExpr>
-  parse_return_expr (::std::vector<AST::Attribute> outer_attrs
-		     = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::LiteralExpr>
+  parse_literal_expr (std::vector<AST::Attribute> outer_attrs
+		      = std::vector<AST::Attribute> ());
+  std::unique_ptr<AST::ReturnExpr>
+  parse_return_expr (std::vector<AST::Attribute> outer_attrs
+		     = std::vector<AST::Attribute> (),
 		     bool pratt_parse = false);
-  ::std::unique_ptr<AST::BreakExpr>
-  parse_break_expr (::std::vector<AST::Attribute> outer_attrs
-		    = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::BreakExpr>
+  parse_break_expr (std::vector<AST::Attribute> outer_attrs
+		    = std::vector<AST::Attribute> (),
 		    bool pratt_parse = false);
-  ::std::unique_ptr<AST::ContinueExpr>
-  parse_continue_expr (::std::vector<AST::Attribute> outer_attrs
-		       = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::ContinueExpr>
+  parse_continue_expr (std::vector<AST::Attribute> outer_attrs
+		       = std::vector<AST::Attribute> (),
 		       bool pratt_parse = false);
-  ::std::unique_ptr<AST::ArrayExpr>
-  parse_array_expr (::std::vector<AST::Attribute> outer_attrs
-		    = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::ArrayExpr>
+  parse_array_expr (std::vector<AST::Attribute> outer_attrs
+		    = std::vector<AST::Attribute> (),
 		    bool pratt_parse = false);
-  ::std::unique_ptr<AST::ExprWithoutBlock>
-  parse_grouped_or_tuple_expr (::std::vector<AST::Attribute> outer_attrs
-			       = ::std::vector<AST::Attribute> (),
+  std::unique_ptr<AST::ExprWithoutBlock>
+  parse_grouped_or_tuple_expr (std::vector<AST::Attribute> outer_attrs
+			       = std::vector<AST::Attribute> (),
 			       bool pratt_parse = false);
-  ::std::unique_ptr<AST::StructExprField> parse_struct_expr_field ();
+  std::unique_ptr<AST::StructExprField> parse_struct_expr_field ();
 
   // Type-related
-  ::std::unique_ptr<AST::Type> parse_type ();
-  ::std::unique_ptr<AST::TypeNoBounds> parse_type_no_bounds ();
-  ::std::unique_ptr<AST::TypeNoBounds> parse_slice_or_array_type ();
-  ::std::unique_ptr<AST::RawPointerType> parse_raw_pointer_type ();
-  ::std::unique_ptr<AST::ReferenceType> parse_reference_type ();
-  ::std::unique_ptr<AST::BareFunctionType>
-  parse_bare_function_type (::std::vector<AST::LifetimeParam> for_lifetimes);
-  ::std::unique_ptr<AST::Type> parse_paren_prefixed_type ();
-  ::std::unique_ptr<AST::TypeNoBounds> parse_paren_prefixed_type_no_bounds ();
-  ::std::unique_ptr<AST::Type> parse_for_prefixed_type ();
+  std::unique_ptr<AST::Type> parse_type ();
+  std::unique_ptr<AST::TypeNoBounds> parse_type_no_bounds ();
+  std::unique_ptr<AST::TypeNoBounds> parse_slice_or_array_type ();
+  std::unique_ptr<AST::RawPointerType> parse_raw_pointer_type ();
+  std::unique_ptr<AST::ReferenceType> parse_reference_type ();
+  std::unique_ptr<AST::BareFunctionType>
+  parse_bare_function_type (std::vector<AST::LifetimeParam> for_lifetimes);
+  std::unique_ptr<AST::Type> parse_paren_prefixed_type ();
+  std::unique_ptr<AST::TypeNoBounds> parse_paren_prefixed_type_no_bounds ();
+  std::unique_ptr<AST::Type> parse_for_prefixed_type ();
   AST::MaybeNamedParam parse_maybe_named_param ();
 
   // Statement-related
-  ::std::unique_ptr<AST::Stmt> parse_stmt ();
-  ::std::unique_ptr<AST::LetStmt>
-  parse_let_stmt (::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::ExprStmt>
-  parse_expr_stmt (::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::ExprStmtWithBlock>
-  parse_expr_stmt_with_block (::std::vector<AST::Attribute> outer_attrs);
-  ::std::unique_ptr<AST::ExprStmtWithoutBlock>
-  parse_expr_stmt_without_block (::std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::Stmt> parse_stmt ();
+  std::unique_ptr<AST::LetStmt>
+  parse_let_stmt (std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::ExprStmt>
+  parse_expr_stmt (std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::ExprStmtWithBlock>
+  parse_expr_stmt_with_block (std::vector<AST::Attribute> outer_attrs);
+  std::unique_ptr<AST::ExprStmtWithoutBlock>
+  parse_expr_stmt_without_block (std::vector<AST::Attribute> outer_attrs);
   ExprOrStmt parse_stmt_or_expr_without_block ();
   ExprOrStmt
-  parse_macro_invocation_maybe_semi (::std::vector<AST::Attribute> outer_attrs);
+  parse_macro_invocation_maybe_semi (std::vector<AST::Attribute> outer_attrs);
   ExprOrStmt
-  parse_path_based_stmt_or_expr (::std::vector<AST::Attribute> outer_attrs);
+  parse_path_based_stmt_or_expr (std::vector<AST::Attribute> outer_attrs);
 
   // Pattern-related
-  ::std::unique_ptr<AST::Pattern> parse_pattern ();
-  ::std::unique_ptr<AST::Pattern> parse_literal_or_range_pattern ();
-  ::std::unique_ptr<AST::RangePatternBound> parse_range_pattern_bound ();
-  ::std::unique_ptr<AST::ReferencePattern> parse_reference_pattern ();
-  ::std::unique_ptr<AST::Pattern> parse_grouped_or_tuple_pattern ();
-  ::std::unique_ptr<AST::SlicePattern> parse_slice_pattern ();
-  ::std::unique_ptr<AST::IdentifierPattern> parse_identifier_pattern ();
-  ::std::unique_ptr<AST::Pattern> parse_ident_leading_pattern ();
-  ::std::unique_ptr<AST::TupleStructItems> parse_tuple_struct_items ();
+  std::unique_ptr<AST::Pattern> parse_pattern ();
+  std::unique_ptr<AST::Pattern> parse_literal_or_range_pattern ();
+  std::unique_ptr<AST::RangePatternBound> parse_range_pattern_bound ();
+  std::unique_ptr<AST::ReferencePattern> parse_reference_pattern ();
+  std::unique_ptr<AST::Pattern> parse_grouped_or_tuple_pattern ();
+  std::unique_ptr<AST::SlicePattern> parse_slice_pattern ();
+  std::unique_ptr<AST::IdentifierPattern> parse_identifier_pattern ();
+  std::unique_ptr<AST::Pattern> parse_ident_leading_pattern ();
+  std::unique_ptr<AST::TupleStructItems> parse_tuple_struct_items ();
   AST::StructPatternElements parse_struct_pattern_elems ();
-  ::std::unique_ptr<AST::StructPatternField> parse_struct_pattern_field ();
+  std::unique_ptr<AST::StructPatternField> parse_struct_pattern_field ();
 
   int left_binding_power (const_TokenPtr token);
 
@@ -548,8 +550,8 @@ private:
   bool done_end_of_file ();
 
 public:
-  // Construct parser with specified lexer reference.
-  Parser (Lexer &parLexer) : lexer (parLexer) {}
+  // Construct parser with specified "managed" token source.
+  Parser (ManagedTokenSource tokenSource) : lexer (std::move(tokenSource)) {}
 
   // Main entry point for parser.
   AST::Crate parse_crate ();
@@ -559,9 +561,12 @@ public:
   void debug_dump_ast_output (AST::Crate &crate);
 
 private:
-  // The lexer associated with the parser.
-  Lexer &lexer;
+  // The token source (usually lexer) associated with the parser.
+  ManagedTokenSource lexer;
 };
 } // namespace Rust
 
+// as now template, include implementations of all methods
+#include "rust-parse-impl.h"
+
 #endif // RUST_PARSE_H